armfrontdoor

package module
v0.2.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 21, 2022 License: MIT Imports: 14 Imported by: 7

README

Azure Front Door Module for Go

PkgGoDev

The armfrontdoor module provides operations for working with Azure Front Door.

Source code

Getting started

Prerequisites

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Front Door module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Front Door. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Clients

Azure Front Door modules consist of one or more clients. A client groups a set of related APIs, providing access to its functionality within the specified subscription. Create one or more clients to access the APIs you require using your credential.

client := armfrontdoor.NewFrontDoorsClient(<subscription ID>, cred, nil)

You can use ClientOptions in package github.com/Azure/azure-sdk-for-go/sdk/azcore/arm to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for azcore at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore.

options = arm.ClientOptions{
    Host: arm.AzureChina,
}
client := armfrontdoor.NewFrontDoorsClient(<subscription ID>, cred, &options)

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Front Door label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ActionType 

type ActionType string

ActionType - Defines the action to take on rule match. 

const (
	ActionTypeAllow    ActionType = "Allow"
	ActionTypeBlock    ActionType = "Block"
	ActionTypeLog      ActionType = "Log"
	ActionTypeRedirect ActionType = "Redirect"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

func (ActionType) ToPtr 

func (c ActionType) ToPtr() *ActionType

ToPtr returns a *ActionType pointing to the current value.

type AggregationInterval 

type AggregationInterval string

AggregationInterval - The aggregation interval of the Timeseries 

const (
	AggregationIntervalDaily  AggregationInterval = "Daily"
	AggregationIntervalHourly AggregationInterval = "Hourly"
)

func PossibleAggregationIntervalValues 

func PossibleAggregationIntervalValues() []AggregationInterval

PossibleAggregationIntervalValues returns the possible values for the AggregationInterval const type.

func (AggregationInterval) ToPtr 

func (c AggregationInterval) ToPtr() *AggregationInterval

ToPtr returns a *AggregationInterval pointing to the current value.

type Availability 

type Availability string

Availability - Indicates whether the name is available. 

const (
	AvailabilityAvailable   Availability = "Available"
	AvailabilityUnavailable Availability = "Unavailable"
)

func PossibleAvailabilityValues 

func PossibleAvailabilityValues() []Availability

PossibleAvailabilityValues returns the possible values for the Availability const type.

func (Availability) ToPtr 

func (c Availability) ToPtr() *Availability

ToPtr returns a *Availability pointing to the current value.

type AzureAsyncOperationResult 

type AzureAsyncOperationResult struct {
	Error *Error `json:"error,omitempty"`

	// Status of the Azure async operation. Possible values are: 'InProgress', 'Succeeded', and 'Failed'.
	Status *NetworkOperationStatus `json:"status,omitempty"`
}

AzureAsyncOperationResult - The response body contains the status of the specified asynchronous operation, indicating whether it has succeeded, is in progress, or has failed. Note that this status is distinct from the HTTP status code returned for the Get Operation Status operation itself. If the asynchronous operation succeeded, the response body includes the HTTP status code for the successful request. If the asynchronous operation failed, the response body includes the HTTP status code for the failed request and error information regarding the failure.

type Backend 

type Backend struct {
	// Location of the backend (IP address or FQDN)
	Address *string `json:"address,omitempty"`

	// The value to use as the host header sent to the backend. If blank or unspecified, this defaults to the incoming host.
	BackendHostHeader *string `json:"backendHostHeader,omitempty"`

	// Whether to enable use of this backend. Permitted values are 'Enabled' or 'Disabled'
	EnabledState *BackendEnabledState `json:"enabledState,omitempty"`

	// The HTTP TCP port number. Must be between 1 and 65535.
	HTTPPort *int32 `json:"httpPort,omitempty"`

	// The HTTPS TCP port number. Must be between 1 and 65535.
	HTTPSPort *int32 `json:"httpsPort,omitempty"`

	// Priority to use for load balancing. Higher priorities will not be used for load balancing if any lower priority backend
	// is healthy.
	Priority *int32 `json:"priority,omitempty"`

	// The Alias of the Private Link resource. Populating this optional field indicates that this backend is 'Private'
	PrivateLinkAlias *string `json:"privateLinkAlias,omitempty"`

	// A custom message to be included in the approval request to connect to the Private Link
	PrivateLinkApprovalMessage *string `json:"privateLinkApprovalMessage,omitempty"`

	// The location of the Private Link resource. Required only if 'privateLinkResourceId' is populated
	PrivateLinkLocation *string `json:"privateLinkLocation,omitempty"`

	// The Resource Id of the Private Link resource. Populating this optional field indicates that this backend is 'Private'
	PrivateLinkResourceID *string `json:"privateLinkResourceId,omitempty"`

	// Weight of this endpoint for load balancing purposes.
	Weight *int32 `json:"weight,omitempty"`

	// READ-ONLY; The Approval status for the connection to the Private Link
	PrivateEndpointStatus *PrivateEndpointStatus `json:"privateEndpointStatus,omitempty" azure:"ro"`
}

Backend address of a frontDoor load balancer.

type BackendEnabledState 

type BackendEnabledState string

BackendEnabledState - Whether to enable use of this backend. Permitted values are 'Enabled' or 'Disabled' 

const (
	BackendEnabledStateDisabled BackendEnabledState = "Disabled"
	BackendEnabledStateEnabled  BackendEnabledState = "Enabled"
)

func PossibleBackendEnabledStateValues 

func PossibleBackendEnabledStateValues() []BackendEnabledState

PossibleBackendEnabledStateValues returns the possible values for the BackendEnabledState const type.

func (BackendEnabledState) ToPtr 

func (c BackendEnabledState) ToPtr() *BackendEnabledState

ToPtr returns a *BackendEnabledState pointing to the current value.

type BackendPool 

type BackendPool struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`

	// Resource name.
	Name *string `json:"name,omitempty"`

	// Properties of the Front Door Backend Pool
	Properties *BackendPoolProperties `json:"properties,omitempty"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

BackendPool - A backend pool is a collection of backends that can be routed to.

type BackendPoolListResult 

type BackendPoolListResult struct {
	// URL to get the next set of BackendPool objects if there are any.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of Backend Pools within a Front Door.
	Value []*BackendPool `json:"value,omitempty" azure:"ro"`
}

BackendPoolListResult - Result of the request to list Backend Pools. It contains a list of Backend Pools objects and a URL link to get the next set of results.

func (BackendPoolListResult) MarshalJSON 

func (b BackendPoolListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BackendPoolListResult.

type BackendPoolProperties 

type BackendPoolProperties struct {
	// The set of backends for this pool
	Backends []*Backend `json:"backends,omitempty"`

	// L7 health probe settings for a backend pool
	HealthProbeSettings *SubResource `json:"healthProbeSettings,omitempty"`

	// Load balancing settings for a backend pool
	LoadBalancingSettings *SubResource `json:"loadBalancingSettings,omitempty"`

	// READ-ONLY; Resource status.
	ResourceState *FrontDoorResourceState `json:"resourceState,omitempty" azure:"ro"`
}

BackendPoolProperties - The JSON object that contains the properties required to create a Backend Pool.

func (BackendPoolProperties) MarshalJSON 

func (b BackendPoolProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BackendPoolProperties.

type BackendPoolUpdateParameters 

type BackendPoolUpdateParameters struct {
	// The set of backends for this pool
	Backends []*Backend `json:"backends,omitempty"`

	// L7 health probe settings for a backend pool
	HealthProbeSettings *SubResource `json:"healthProbeSettings,omitempty"`

	// Load balancing settings for a backend pool
	LoadBalancingSettings *SubResource `json:"loadBalancingSettings,omitempty"`
}

BackendPoolUpdateParameters - A collection of backends that can be routed to.

func (BackendPoolUpdateParameters) MarshalJSON 

func (b BackendPoolUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BackendPoolUpdateParameters.

type BackendPoolsSettings 

type BackendPoolsSettings struct {
	// Whether to enforce certificate name check on HTTPS requests to all backend pools. No effect on non-HTTPS requests.
	EnforceCertificateNameCheck *EnforceCertificateNameCheckEnabledState `json:"enforceCertificateNameCheck,omitempty"`

	// Send and receive timeout on forwarding request to the backend. When timeout is reached, the request fails and returns.
	SendRecvTimeoutSeconds *int32 `json:"sendRecvTimeoutSeconds,omitempty"`
}

BackendPoolsSettings - Settings that apply to all backend pools.

type CacheConfiguration 

type CacheConfiguration struct {
	// The duration for which the content needs to be cached. Allowed format is in ISO 8601 format (http://en.wikipedia.org/wiki/ISO_8601#Durations).
	// HTTP requires the value to be no more than a year
	CacheDuration *string `json:"cacheDuration,omitempty"`

	// Whether to use dynamic compression for cached content
	DynamicCompression *DynamicCompressionEnabled `json:"dynamicCompression,omitempty"`

	// Treatment of URL query terms when forming the cache key.
	QueryParameterStripDirective *FrontDoorQuery `json:"queryParameterStripDirective,omitempty"`

	// query parameters to include or exclude (comma separated).
	QueryParameters *string `json:"queryParameters,omitempty"`
}

CacheConfiguration - Caching settings for a caching-type route. To disable caching, do not provide a cacheConfiguration object.

type CertificateSourceParameters added in v0.2.0 

type CertificateSourceParameters struct {
	// Defines the type of the certificate used for secure connections to a frontendEndpoint
	CertificateType *FrontDoorCertificateType `json:"certificateType,omitempty"`
}

CertificateSourceParameters - Parameters required for enabling SSL with Front Door-managed certificates

type CheckNameAvailabilityInput 

type CheckNameAvailabilityInput struct {
	// REQUIRED; The resource name to validate.
	Name *string `json:"name,omitempty"`

	// REQUIRED; The type of the resource whose name is to be validated.
	Type *ResourceType `json:"type,omitempty"`
}

CheckNameAvailabilityInput - Input of CheckNameAvailability API.

type CheckNameAvailabilityOutput 

type CheckNameAvailabilityOutput struct {
	// READ-ONLY; The detailed error message describing why the name is not available.
	Message *string `json:"message,omitempty" azure:"ro"`

	// READ-ONLY; Indicates whether the name is available.
	NameAvailability *Availability `json:"nameAvailability,omitempty" azure:"ro"`

	// READ-ONLY; The reason why the name is not available.
	Reason *string `json:"reason,omitempty" azure:"ro"`
}

CheckNameAvailabilityOutput - Output of check name availability API.

type CustomHTTPSConfiguration 

type CustomHTTPSConfiguration struct {
	// REQUIRED; Defines the source of the SSL certificate
	CertificateSource *FrontDoorCertificateSource `json:"certificateSource,omitempty"`

	// REQUIRED; The minimum TLS version required from the clients to establish an SSL handshake with Front Door.
	MinimumTLSVersion *MinimumTLSVersion `json:"minimumTlsVersion,omitempty"`

	// REQUIRED; Defines the TLS extension protocol that is used for secure delivery
	ProtocolType *FrontDoorTLSProtocolType `json:"protocolType,omitempty"`

	// Parameters required for enabling SSL with Front Door-managed certificates (if certificateSource=FrontDoor)
	FrontDoorCertificateSourceParameters *CertificateSourceParameters `json:"frontDoorCertificateSourceParameters,omitempty"`

	// KeyVault certificate source parameters (if certificateSource=AzureKeyVault)
	KeyVaultCertificateSourceParameters *KeyVaultCertificateSourceParameters `json:"keyVaultCertificateSourceParameters,omitempty"`
}

CustomHTTPSConfiguration - Https settings for a domain

type CustomHTTPSProvisioningState 

type CustomHTTPSProvisioningState string

CustomHTTPSProvisioningState - Provisioning status of Custom Https of the frontendEndpoint. 

const (
	CustomHTTPSProvisioningStateDisabled  CustomHTTPSProvisioningState = "Disabled"
	CustomHTTPSProvisioningStateDisabling CustomHTTPSProvisioningState = "Disabling"
	CustomHTTPSProvisioningStateEnabled   CustomHTTPSProvisioningState = "Enabled"
	CustomHTTPSProvisioningStateEnabling  CustomHTTPSProvisioningState = "Enabling"
	CustomHTTPSProvisioningStateFailed    CustomHTTPSProvisioningState = "Failed"
)

func PossibleCustomHTTPSProvisioningStateValues 

func PossibleCustomHTTPSProvisioningStateValues() []CustomHTTPSProvisioningState

PossibleCustomHTTPSProvisioningStateValues returns the possible values for the CustomHTTPSProvisioningState const type.

func (CustomHTTPSProvisioningState) ToPtr 

func (c CustomHTTPSProvisioningState) ToPtr() *CustomHTTPSProvisioningState

ToPtr returns a *CustomHTTPSProvisioningState pointing to the current value.

type CustomHTTPSProvisioningSubstate 

type CustomHTTPSProvisioningSubstate string

CustomHTTPSProvisioningSubstate - Provisioning substate shows the progress of custom HTTPS enabling/disabling process step by step. 

const (
	CustomHTTPSProvisioningSubstateCertificateDeleted                            CustomHTTPSProvisioningSubstate = "CertificateDeleted"
	CustomHTTPSProvisioningSubstateCertificateDeployed                           CustomHTTPSProvisioningSubstate = "CertificateDeployed"
	CustomHTTPSProvisioningSubstateDeletingCertificate                           CustomHTTPSProvisioningSubstate = "DeletingCertificate"
	CustomHTTPSProvisioningSubstateDeployingCertificate                          CustomHTTPSProvisioningSubstate = "DeployingCertificate"
	CustomHTTPSProvisioningSubstateDomainControlValidationRequestApproved        CustomHTTPSProvisioningSubstate = "DomainControlValidationRequestApproved"
	CustomHTTPSProvisioningSubstateDomainControlValidationRequestRejected        CustomHTTPSProvisioningSubstate = "DomainControlValidationRequestRejected"
	CustomHTTPSProvisioningSubstateDomainControlValidationRequestTimedOut        CustomHTTPSProvisioningSubstate = "DomainControlValidationRequestTimedOut"
	CustomHTTPSProvisioningSubstateIssuingCertificate                            CustomHTTPSProvisioningSubstate = "IssuingCertificate"
	CustomHTTPSProvisioningSubstatePendingDomainControlValidationREquestApproval CustomHTTPSProvisioningSubstate = "PendingDomainControlValidationREquestApproval"
	CustomHTTPSProvisioningSubstateSubmittingDomainControlValidationRequest      CustomHTTPSProvisioningSubstate = "SubmittingDomainControlValidationRequest"
)

func PossibleCustomHTTPSProvisioningSubstateValues 

func PossibleCustomHTTPSProvisioningSubstateValues() []CustomHTTPSProvisioningSubstate

PossibleCustomHTTPSProvisioningSubstateValues returns the possible values for the CustomHTTPSProvisioningSubstate const type.

func (CustomHTTPSProvisioningSubstate) ToPtr 

func (c CustomHTTPSProvisioningSubstate) ToPtr() *CustomHTTPSProvisioningSubstate

ToPtr returns a *CustomHTTPSProvisioningSubstate pointing to the current value.

type CustomRule 

type CustomRule struct {
	// REQUIRED; Describes what action to be applied when rule matches.
	Action *ActionType `json:"action,omitempty"`

	// REQUIRED; List of match conditions.
	MatchConditions []*MatchCondition `json:"matchConditions,omitempty"`

	// REQUIRED; Describes priority of the rule. Rules with a lower value will be evaluated before rules with a higher value.
	Priority *int32 `json:"priority,omitempty"`

	// REQUIRED; Describes type of rule.
	RuleType *RuleType `json:"ruleType,omitempty"`

	// Describes if the custom rule is in enabled or disabled state. Defaults to Enabled if not specified.
	EnabledState *CustomRuleEnabledState `json:"enabledState,omitempty"`

	// Describes the name of the rule.
	Name *string `json:"name,omitempty"`

	// Time window for resetting the rate limit count. Default is 1 minute.
	RateLimitDurationInMinutes *int32 `json:"rateLimitDurationInMinutes,omitempty"`

	// Number of allowed requests per client within the time window.
	RateLimitThreshold *int32 `json:"rateLimitThreshold,omitempty"`
}

CustomRule - Defines contents of a web application rule

func (CustomRule) MarshalJSON 

func (c CustomRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CustomRule.

type CustomRuleEnabledState 

type CustomRuleEnabledState string

CustomRuleEnabledState - Describes if the custom rule is in enabled or disabled state. Defaults to Enabled if not specified. 

const (
	CustomRuleEnabledStateDisabled CustomRuleEnabledState = "Disabled"
	CustomRuleEnabledStateEnabled  CustomRuleEnabledState = "Enabled"
)

func PossibleCustomRuleEnabledStateValues 

func PossibleCustomRuleEnabledStateValues() []CustomRuleEnabledState

PossibleCustomRuleEnabledStateValues returns the possible values for the CustomRuleEnabledState const type.

func (CustomRuleEnabledState) ToPtr 

func (c CustomRuleEnabledState) ToPtr() *CustomRuleEnabledState

ToPtr returns a *CustomRuleEnabledState pointing to the current value.

type CustomRuleList 

type CustomRuleList struct {
	// List of rules
	Rules []*CustomRule `json:"rules,omitempty"`
}

CustomRuleList - Defines contents of custom rules

func (CustomRuleList) MarshalJSON 

func (c CustomRuleList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CustomRuleList.

type DynamicCompressionEnabled 

type DynamicCompressionEnabled string

DynamicCompressionEnabled - Whether to use dynamic compression for cached content 

const (
	DynamicCompressionEnabledDisabled DynamicCompressionEnabled = "Disabled"
	DynamicCompressionEnabledEnabled  DynamicCompressionEnabled = "Enabled"
)

func PossibleDynamicCompressionEnabledValues 

func PossibleDynamicCompressionEnabledValues() []DynamicCompressionEnabled

PossibleDynamicCompressionEnabledValues returns the possible values for the DynamicCompressionEnabled const type.

func (DynamicCompressionEnabled) ToPtr 

func (c DynamicCompressionEnabled) ToPtr() *DynamicCompressionEnabled

ToPtr returns a *DynamicCompressionEnabled pointing to the current value.

type Endpoint 

type Endpoint struct {
	// The endpoint URL
	Endpoint *string `json:"endpoint,omitempty"`

	// The name of the endpoint
	Name *string `json:"name,omitempty"`
}

Endpoint - Defines the endpoint properties

type EndpointType 

type EndpointType string

EndpointType - The type of endpoint 

const (
	EndpointTypeAFD         EndpointType = "AFD"
	EndpointTypeATM         EndpointType = "ATM"
	EndpointTypeAzureRegion EndpointType = "AzureRegion"
	EndpointTypeCDN         EndpointType = "CDN"
)

func PossibleEndpointTypeValues 

func PossibleEndpointTypeValues() []EndpointType

PossibleEndpointTypeValues returns the possible values for the EndpointType const type.

func (EndpointType) ToPtr 

func (c EndpointType) ToPtr() *EndpointType

ToPtr returns a *EndpointType pointing to the current value.

type EndpointsClient 

type EndpointsClient struct {
	// contains filtered or unexported fields
}

EndpointsClient contains the methods for the Endpoints group. Don't use this type directly, use NewEndpointsClient() instead.

func NewEndpointsClient 

func NewEndpointsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *EndpointsClient

NewEndpointsClient creates a new instance of EndpointsClient with the specified values. subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*EndpointsClient) BeginPurgeContent 

func (client *EndpointsClient) BeginPurgeContent(ctx context.Context, resourceGroupName string, frontDoorName string, contentFilePaths PurgeParameters, options *EndpointsClientBeginPurgeContentOptions) (EndpointsClientPurgeContentPollerResponse, error)

BeginPurgeContent - Removes a content from Front Door. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. contentFilePaths - The path to the content to be purged. Path can be a full URL, e.g. '/pictures/city.png' which removes a single file, or a directory with a wildcard, e.g. '/pictures/*' which removes all folders and files in the directory. options - EndpointsClientBeginPurgeContentOptions contains the optional parameters for the EndpointsClient.BeginPurgeContent method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorPurgeContent.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewEndpointsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginPurgeContent(ctx,
		"<resource-group-name>",
		"<front-door-name>",
		armfrontdoor.PurgeParameters{
			ContentPaths: []*string{
				to.StringPtr("/pictures.aspx"),
				to.StringPtr("/pictures/*")},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

type EndpointsClientBeginPurgeContentOptions added in v0.2.0 

type EndpointsClientBeginPurgeContentOptions struct {
}

EndpointsClientBeginPurgeContentOptions contains the optional parameters for the EndpointsClient.BeginPurgeContent method.

type EndpointsClientPurgeContentPoller added in v0.2.0 

type EndpointsClientPurgeContentPoller struct {
	// contains filtered or unexported fields
}

EndpointsClientPurgeContentPoller provides polling facilities until the operation reaches a terminal state.

func (*EndpointsClientPurgeContentPoller) Done added in v0.2.0 

func (p *EndpointsClientPurgeContentPoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*EndpointsClientPurgeContentPoller) FinalResponse added in v0.2.0 

func (p *EndpointsClientPurgeContentPoller) FinalResponse(ctx context.Context) (EndpointsClientPurgeContentResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final EndpointsClientPurgeContentResponse will be returned.

func (*EndpointsClientPurgeContentPoller) Poll added in v0.2.0 

func (p *EndpointsClientPurgeContentPoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*EndpointsClientPurgeContentPoller) ResumeToken added in v0.2.0 

func (p *EndpointsClientPurgeContentPoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type EndpointsClientPurgeContentPollerResponse added in v0.2.0 

type EndpointsClientPurgeContentPollerResponse struct {
	// Poller contains an initialized poller.
	Poller *EndpointsClientPurgeContentPoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

EndpointsClientPurgeContentPollerResponse contains the response from method EndpointsClient.PurgeContent.

func (EndpointsClientPurgeContentPollerResponse) PollUntilDone added in v0.2.0 

func (l EndpointsClientPurgeContentPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (EndpointsClientPurgeContentResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*EndpointsClientPurgeContentPollerResponse) Resume added in v0.2.0 

func (l *EndpointsClientPurgeContentPollerResponse) Resume(ctx context.Context, client *EndpointsClient, token string) error

Resume rehydrates a EndpointsClientPurgeContentPollerResponse from the provided client and resume token.

type EndpointsClientPurgeContentResponse added in v0.2.0 

type EndpointsClientPurgeContentResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

EndpointsClientPurgeContentResponse contains the response from method EndpointsClient.PurgeContent.

type EnforceCertificateNameCheckEnabledState 

type EnforceCertificateNameCheckEnabledState string

EnforceCertificateNameCheckEnabledState - Whether to enforce certificate name check on HTTPS requests to all backend pools. No effect on non-HTTPS requests. 

const (
	EnforceCertificateNameCheckEnabledStateDisabled EnforceCertificateNameCheckEnabledState = "Disabled"
	EnforceCertificateNameCheckEnabledStateEnabled  EnforceCertificateNameCheckEnabledState = "Enabled"
)

func PossibleEnforceCertificateNameCheckEnabledStateValues 

func PossibleEnforceCertificateNameCheckEnabledStateValues() []EnforceCertificateNameCheckEnabledState

PossibleEnforceCertificateNameCheckEnabledStateValues returns the possible values for the EnforceCertificateNameCheckEnabledState const type.

func (EnforceCertificateNameCheckEnabledState) ToPtr 

func (c EnforceCertificateNameCheckEnabledState) ToPtr() *EnforceCertificateNameCheckEnabledState

ToPtr returns a *EnforceCertificateNameCheckEnabledState pointing to the current value.

type Error 

type Error struct {
	Code       *string         `json:"code,omitempty"`
	Details    []*ErrorDetails `json:"details,omitempty"`
	InnerError *string         `json:"innerError,omitempty"`
	Message    *string         `json:"message,omitempty"`
	Target     *string         `json:"target,omitempty"`
}

func (Error) MarshalJSON 

func (e Error) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Error.

type ErrorDetails 

type ErrorDetails struct {
	Code    *string `json:"code,omitempty"`
	Message *string `json:"message,omitempty"`
	Target  *string `json:"target,omitempty"`
}

type ErrorResponse 

type ErrorResponse struct {
	// READ-ONLY; Error code.
	Code *string `json:"code,omitempty" azure:"ro"`

	// READ-ONLY; Error message indicating why the operation failed.
	Message *string `json:"message,omitempty" azure:"ro"`
}

ErrorResponse - Error response indicates Front Door service is not able to process the incoming request. The reason is provided in the error message.

type Experiment 

type Experiment struct {
	// Resource location.
	Location *string `json:"location,omitempty"`

	// The properties of an Experiment
	Properties *ExperimentProperties `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

Experiment - Defines the properties of an Experiment

func (Experiment) MarshalJSON 

func (e Experiment) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Experiment.

type ExperimentList 

type ExperimentList struct {
	// URL to get the next set of Experiment objects if there are any.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of Experiments within a resource group.
	Value []*Experiment `json:"value,omitempty" azure:"ro"`
}

ExperimentList - Defines a list of Experiments. It contains a list of Experiment objects and a URL link to get the next set of results.

func (ExperimentList) MarshalJSON 

func (e ExperimentList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExperimentList.

type ExperimentProperties 

type ExperimentProperties struct {
	// The description of the details or intents of the Experiment
	Description *string `json:"description,omitempty"`

	// The state of the Experiment
	EnabledState *State `json:"enabledState,omitempty"`

	// The endpoint A of an experiment
	EndpointA *Endpoint `json:"endpointA,omitempty"`

	// The endpoint B of an experiment
	EndpointB *Endpoint `json:"endpointB,omitempty"`

	// READ-ONLY; Resource status.
	ResourceState *NetworkExperimentResourceState `json:"resourceState,omitempty" azure:"ro"`

	// READ-ONLY; The uri to the Script used in the Experiment
	ScriptFileURI *string `json:"scriptFileUri,omitempty" azure:"ro"`

	// READ-ONLY; The description of Experiment status from the server side
	Status *string `json:"status,omitempty" azure:"ro"`
}

ExperimentProperties - Defines the properties of an experiment

type ExperimentUpdateModel 

type ExperimentUpdateModel struct {
	// The properties of a Profile
	Properties *ExperimentUpdateProperties `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`
}

ExperimentUpdateModel - Defines modifiable attributes of an Experiment

func (ExperimentUpdateModel) MarshalJSON 

func (e ExperimentUpdateModel) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExperimentUpdateModel.

type ExperimentUpdateProperties 

type ExperimentUpdateProperties struct {
	// The description of the intent or details of the Experiment
	Description *string `json:"description,omitempty"`

	// The state of the Experiment
	EnabledState *State `json:"enabledState,omitempty"`
}

ExperimentUpdateProperties - Defines the properties of an experiment

type ExperimentsClient 

type ExperimentsClient struct {
	// contains filtered or unexported fields
}

ExperimentsClient contains the methods for the Experiments group. Don't use this type directly, use NewExperimentsClient() instead.

func NewExperimentsClient 

func NewExperimentsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *ExperimentsClient

NewExperimentsClient creates a new instance of ExperimentsClient with the specified values. subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*ExperimentsClient) BeginCreateOrUpdate 

func (client *ExperimentsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, profileName string, experimentName string, parameters Experiment, options *ExperimentsClientBeginCreateOrUpdateOptions) (ExperimentsClientCreateOrUpdatePollerResponse, error)

BeginCreateOrUpdate - Creates or updates an Experiment If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. profileName - The Profile identifier associated with the Tenant and Partner experimentName - The Experiment identifier associated with the Experiment parameters - The Experiment resource options - ExperimentsClientBeginCreateOrUpdateOptions contains the optional parameters for the ExperimentsClient.BeginCreateOrUpdate method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentCreateExperiment.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewExperimentsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreateOrUpdate(ctx,
		"<resource-group-name>",
		"<profile-name>",
		"<experiment-name>",
		armfrontdoor.Experiment{
			Properties: &armfrontdoor.ExperimentProperties{
				Description:  to.StringPtr("<description>"),
				EnabledState: armfrontdoor.State("Enabled").ToPtr(),
				EndpointA: &armfrontdoor.Endpoint{
					Name:     to.StringPtr("<name>"),
					Endpoint: to.StringPtr("<endpoint>"),
				},
				EndpointB: &armfrontdoor.Endpoint{
					Name:     to.StringPtr("<name>"),
					Endpoint: to.StringPtr("<endpoint>"),
				},
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.ExperimentsClientCreateOrUpdateResult)
}

Output:

func (*ExperimentsClient) BeginDelete 

func (client *ExperimentsClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, experimentName string, options *ExperimentsClientBeginDeleteOptions) (ExperimentsClientDeletePollerResponse, error)

BeginDelete - Deletes an Experiment If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. profileName - The Profile identifier associated with the Tenant and Partner experimentName - The Experiment identifier associated with the Experiment options - ExperimentsClientBeginDeleteOptions contains the optional parameters for the ExperimentsClient.BeginDelete method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentDeleteExperiment.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewExperimentsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<profile-name>",
		"<experiment-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*ExperimentsClient) BeginUpdate 

func (client *ExperimentsClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, experimentName string, parameters ExperimentUpdateModel, options *ExperimentsClientBeginUpdateOptions) (ExperimentsClientUpdatePollerResponse, error)

BeginUpdate - Updates an Experiment If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. profileName - The Profile identifier associated with the Tenant and Partner experimentName - The Experiment identifier associated with the Experiment parameters - The Experiment Update Model options - ExperimentsClientBeginUpdateOptions contains the optional parameters for the ExperimentsClient.BeginUpdate method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentUpdateExperiment.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewExperimentsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginUpdate(ctx,
		"<resource-group-name>",
		"<profile-name>",
		"<experiment-name>",
		armfrontdoor.ExperimentUpdateModel{
			Properties: &armfrontdoor.ExperimentUpdateProperties{
				Description:  to.StringPtr("<description>"),
				EnabledState: armfrontdoor.State("Enabled").ToPtr(),
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.ExperimentsClientUpdateResult)
}

Output:

func (*ExperimentsClient) Get 

func (client *ExperimentsClient) Get(ctx context.Context, resourceGroupName string, profileName string, experimentName string, options *ExperimentsClientGetOptions) (ExperimentsClientGetResponse, error)

Get - Gets an Experiment by ExperimentName If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. profileName - The Profile identifier associated with the Tenant and Partner experimentName - The Experiment identifier associated with the Experiment options - ExperimentsClientGetOptions contains the optional parameters for the ExperimentsClient.Get method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentGetExperiment.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewExperimentsClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<profile-name>",
		"<experiment-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.ExperimentsClientGetResult)
}

Output:

func (*ExperimentsClient) ListByProfile 

func (client *ExperimentsClient) ListByProfile(resourceGroupName string, profileName string, options *ExperimentsClientListByProfileOptions) *ExperimentsClientListByProfilePager

ListByProfile - Gets a list of Experiments If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. profileName - The Profile identifier associated with the Tenant and Partner options - ExperimentsClientListByProfileOptions contains the optional parameters for the ExperimentsClient.ListByProfile method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentListExperiments.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewExperimentsClient("<subscription-id>", cred, nil)
	pager := client.ListByProfile("<resource-group-name>",
		"<profile-name>",
		nil)
	for {
		nextResult := pager.NextPage(ctx)
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		if !nextResult {
			break
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("Pager result: %#v\n", v)
		}
	}
}

Output:

type ExperimentsClientBeginCreateOrUpdateOptions added in v0.2.0 

type ExperimentsClientBeginCreateOrUpdateOptions struct {
}

ExperimentsClientBeginCreateOrUpdateOptions contains the optional parameters for the ExperimentsClient.BeginCreateOrUpdate method.

type ExperimentsClientBeginDeleteOptions added in v0.2.0 

type ExperimentsClientBeginDeleteOptions struct {
}

ExperimentsClientBeginDeleteOptions contains the optional parameters for the ExperimentsClient.BeginDelete method.

type ExperimentsClientBeginUpdateOptions added in v0.2.0 

type ExperimentsClientBeginUpdateOptions struct {
}

ExperimentsClientBeginUpdateOptions contains the optional parameters for the ExperimentsClient.BeginUpdate method.

type ExperimentsClientCreateOrUpdatePoller added in v0.2.0 

type ExperimentsClientCreateOrUpdatePoller struct {
	// contains filtered or unexported fields
}

ExperimentsClientCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*ExperimentsClientCreateOrUpdatePoller) Done added in v0.2.0 

func (p *ExperimentsClientCreateOrUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*ExperimentsClientCreateOrUpdatePoller) FinalResponse added in v0.2.0 

func (p *ExperimentsClientCreateOrUpdatePoller) FinalResponse(ctx context.Context) (ExperimentsClientCreateOrUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final ExperimentsClientCreateOrUpdateResponse will be returned.

func (*ExperimentsClientCreateOrUpdatePoller) Poll added in v0.2.0 

func (p *ExperimentsClientCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*ExperimentsClientCreateOrUpdatePoller) ResumeToken added in v0.2.0 

func (p *ExperimentsClientCreateOrUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type ExperimentsClientCreateOrUpdatePollerResponse added in v0.2.0 

type ExperimentsClientCreateOrUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *ExperimentsClientCreateOrUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

ExperimentsClientCreateOrUpdatePollerResponse contains the response from method ExperimentsClient.CreateOrUpdate.

func (ExperimentsClientCreateOrUpdatePollerResponse) PollUntilDone added in v0.2.0 

func (l ExperimentsClientCreateOrUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (ExperimentsClientCreateOrUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*ExperimentsClientCreateOrUpdatePollerResponse) Resume added in v0.2.0 

func (l *ExperimentsClientCreateOrUpdatePollerResponse) Resume(ctx context.Context, client *ExperimentsClient, token string) error

Resume rehydrates a ExperimentsClientCreateOrUpdatePollerResponse from the provided client and resume token.

type ExperimentsClientCreateOrUpdateResponse added in v0.2.0 

type ExperimentsClientCreateOrUpdateResponse struct {
	ExperimentsClientCreateOrUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

ExperimentsClientCreateOrUpdateResponse contains the response from method ExperimentsClient.CreateOrUpdate.

type ExperimentsClientCreateOrUpdateResult added in v0.2.0 

type ExperimentsClientCreateOrUpdateResult struct {
	Experiment
}

ExperimentsClientCreateOrUpdateResult contains the result from method ExperimentsClient.CreateOrUpdate.

type ExperimentsClientDeletePoller added in v0.2.0 

type ExperimentsClientDeletePoller struct {
	// contains filtered or unexported fields
}

ExperimentsClientDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*ExperimentsClientDeletePoller) Done added in v0.2.0 

func (p *ExperimentsClientDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*ExperimentsClientDeletePoller) FinalResponse added in v0.2.0 

func (p *ExperimentsClientDeletePoller) FinalResponse(ctx context.Context) (ExperimentsClientDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final ExperimentsClientDeleteResponse will be returned.

func (*ExperimentsClientDeletePoller) Poll added in v0.2.0 

func (p *ExperimentsClientDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*ExperimentsClientDeletePoller) ResumeToken added in v0.2.0 

func (p *ExperimentsClientDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type ExperimentsClientDeletePollerResponse added in v0.2.0 

type ExperimentsClientDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *ExperimentsClientDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

ExperimentsClientDeletePollerResponse contains the response from method ExperimentsClient.Delete.

func (ExperimentsClientDeletePollerResponse) PollUntilDone added in v0.2.0 

func (l ExperimentsClientDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (ExperimentsClientDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*ExperimentsClientDeletePollerResponse) Resume added in v0.2.0 

func (l *ExperimentsClientDeletePollerResponse) Resume(ctx context.Context, client *ExperimentsClient, token string) error

Resume rehydrates a ExperimentsClientDeletePollerResponse from the provided client and resume token.

type ExperimentsClientDeleteResponse added in v0.2.0 

type ExperimentsClientDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

ExperimentsClientDeleteResponse contains the response from method ExperimentsClient.Delete.

type ExperimentsClientGetOptions added in v0.2.0 

type ExperimentsClientGetOptions struct {
}

ExperimentsClientGetOptions contains the optional parameters for the ExperimentsClient.Get method.

type ExperimentsClientGetResponse added in v0.2.0 

type ExperimentsClientGetResponse struct {
	ExperimentsClientGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

ExperimentsClientGetResponse contains the response from method ExperimentsClient.Get.

type ExperimentsClientGetResult added in v0.2.0 

type ExperimentsClientGetResult struct {
	Experiment
}

ExperimentsClientGetResult contains the result from method ExperimentsClient.Get.

type ExperimentsClientListByProfileOptions added in v0.2.0 

type ExperimentsClientListByProfileOptions struct {
}

ExperimentsClientListByProfileOptions contains the optional parameters for the ExperimentsClient.ListByProfile method.

type ExperimentsClientListByProfilePager added in v0.2.0 

type ExperimentsClientListByProfilePager struct {
	// contains filtered or unexported fields
}

ExperimentsClientListByProfilePager provides operations for iterating over paged responses.

func (*ExperimentsClientListByProfilePager) Err added in v0.2.0 

func (p *ExperimentsClientListByProfilePager) Err() error

Err returns the last error encountered while paging.

func (*ExperimentsClientListByProfilePager) NextPage added in v0.2.0 

func (p *ExperimentsClientListByProfilePager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*ExperimentsClientListByProfilePager) PageResponse added in v0.2.0 

func (p *ExperimentsClientListByProfilePager) PageResponse() ExperimentsClientListByProfileResponse

PageResponse returns the current ExperimentsClientListByProfileResponse page.

type ExperimentsClientListByProfileResponse added in v0.2.0 

type ExperimentsClientListByProfileResponse struct {
	ExperimentsClientListByProfileResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

ExperimentsClientListByProfileResponse contains the response from method ExperimentsClient.ListByProfile.

type ExperimentsClientListByProfileResult added in v0.2.0 

type ExperimentsClientListByProfileResult struct {
	ExperimentList
}

ExperimentsClientListByProfileResult contains the result from method ExperimentsClient.ListByProfile.

type ExperimentsClientUpdatePoller added in v0.2.0 

type ExperimentsClientUpdatePoller struct {
	// contains filtered or unexported fields
}

ExperimentsClientUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*ExperimentsClientUpdatePoller) Done added in v0.2.0 

func (p *ExperimentsClientUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*ExperimentsClientUpdatePoller) FinalResponse added in v0.2.0 

func (p *ExperimentsClientUpdatePoller) FinalResponse(ctx context.Context) (ExperimentsClientUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final ExperimentsClientUpdateResponse will be returned.

func (*ExperimentsClientUpdatePoller) Poll added in v0.2.0 

func (p *ExperimentsClientUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*ExperimentsClientUpdatePoller) ResumeToken added in v0.2.0 

func (p *ExperimentsClientUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type ExperimentsClientUpdatePollerResponse added in v0.2.0 

type ExperimentsClientUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *ExperimentsClientUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

ExperimentsClientUpdatePollerResponse contains the response from method ExperimentsClient.Update.

func (ExperimentsClientUpdatePollerResponse) PollUntilDone added in v0.2.0 

func (l ExperimentsClientUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (ExperimentsClientUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*ExperimentsClientUpdatePollerResponse) Resume added in v0.2.0 

func (l *ExperimentsClientUpdatePollerResponse) Resume(ctx context.Context, client *ExperimentsClient, token string) error

Resume rehydrates a ExperimentsClientUpdatePollerResponse from the provided client and resume token.

type ExperimentsClientUpdateResponse added in v0.2.0 

type ExperimentsClientUpdateResponse struct {
	ExperimentsClientUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

ExperimentsClientUpdateResponse contains the response from method ExperimentsClient.Update.

type ExperimentsClientUpdateResult added in v0.2.0 

type ExperimentsClientUpdateResult struct {
	Experiment
}

ExperimentsClientUpdateResult contains the result from method ExperimentsClient.Update.

type ForwardingConfiguration 

type ForwardingConfiguration struct {
	// REQUIRED
	ODataType *string `json:"@odata.type,omitempty"`

	// A reference to the BackendPool which this rule routes to.
	BackendPool *SubResource `json:"backendPool,omitempty"`

	// The caching configuration associated with this rule.
	CacheConfiguration *CacheConfiguration `json:"cacheConfiguration,omitempty"`

	// A custom path used to rewrite resource paths matched by this rule. Leave empty to use incoming path.
	CustomForwardingPath *string `json:"customForwardingPath,omitempty"`

	// Protocol this rule will use when forwarding traffic to backends.
	ForwardingProtocol *FrontDoorForwardingProtocol `json:"forwardingProtocol,omitempty"`
}

ForwardingConfiguration - Describes Forwarding Route.

func (*ForwardingConfiguration) GetRouteConfiguration added in v0.2.0 

func (f *ForwardingConfiguration) GetRouteConfiguration() *RouteConfiguration

GetRouteConfiguration implements the RouteConfigurationClassification interface for type ForwardingConfiguration.

func (ForwardingConfiguration) MarshalJSON 

func (f ForwardingConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ForwardingConfiguration.

func (*ForwardingConfiguration) UnmarshalJSON 

func (f *ForwardingConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ForwardingConfiguration.

type FrontDoor 

type FrontDoor struct {
	// Resource location.
	Location *string `json:"location,omitempty"`

	// Properties of the Front Door Load Balancer
	Properties *Properties `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

FrontDoor - Front Door represents a collection of backend endpoints to route traffic to along with rules that specify how traffic is sent there.

func (FrontDoor) MarshalJSON 

func (f FrontDoor) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FrontDoor.

type FrontDoorCertificateSource 

type FrontDoorCertificateSource string

FrontDoorCertificateSource - Defines the source of the SSL certificate 

const (
	FrontDoorCertificateSourceAzureKeyVault FrontDoorCertificateSource = "AzureKeyVault"
	FrontDoorCertificateSourceFrontDoor     FrontDoorCertificateSource = "FrontDoor"
)

func PossibleFrontDoorCertificateSourceValues 

func PossibleFrontDoorCertificateSourceValues() []FrontDoorCertificateSource

PossibleFrontDoorCertificateSourceValues returns the possible values for the FrontDoorCertificateSource const type.

func (FrontDoorCertificateSource) ToPtr 

func (c FrontDoorCertificateSource) ToPtr() *FrontDoorCertificateSource

ToPtr returns a *FrontDoorCertificateSource pointing to the current value.

type FrontDoorCertificateType 

type FrontDoorCertificateType string

FrontDoorCertificateType - Defines the type of the certificate used for secure connections to a frontendEndpoint 

const (
	FrontDoorCertificateTypeDedicated FrontDoorCertificateType = "Dedicated"
)

func PossibleFrontDoorCertificateTypeValues 

func PossibleFrontDoorCertificateTypeValues() []FrontDoorCertificateType

PossibleFrontDoorCertificateTypeValues returns the possible values for the FrontDoorCertificateType const type.

func (FrontDoorCertificateType) ToPtr 

func (c FrontDoorCertificateType) ToPtr() *FrontDoorCertificateType

ToPtr returns a *FrontDoorCertificateType pointing to the current value.

type FrontDoorEnabledState 

type FrontDoorEnabledState string

FrontDoorEnabledState - Operational status of the Front Door load balancer. Permitted values are 'Enabled' or 'Disabled' 

const (
	FrontDoorEnabledStateDisabled FrontDoorEnabledState = "Disabled"
	FrontDoorEnabledStateEnabled  FrontDoorEnabledState = "Enabled"
)

func PossibleFrontDoorEnabledStateValues 

func PossibleFrontDoorEnabledStateValues() []FrontDoorEnabledState

PossibleFrontDoorEnabledStateValues returns the possible values for the FrontDoorEnabledState const type.

func (FrontDoorEnabledState) ToPtr 

func (c FrontDoorEnabledState) ToPtr() *FrontDoorEnabledState

ToPtr returns a *FrontDoorEnabledState pointing to the current value.

type FrontDoorForwardingProtocol 

type FrontDoorForwardingProtocol string

FrontDoorForwardingProtocol - Protocol this rule will use when forwarding traffic to backends. 

const (
	FrontDoorForwardingProtocolHTTPOnly     FrontDoorForwardingProtocol = "HttpOnly"
	FrontDoorForwardingProtocolHTTPSOnly    FrontDoorForwardingProtocol = "HttpsOnly"
	FrontDoorForwardingProtocolMatchRequest FrontDoorForwardingProtocol = "MatchRequest"
)

func PossibleFrontDoorForwardingProtocolValues 

func PossibleFrontDoorForwardingProtocolValues() []FrontDoorForwardingProtocol

PossibleFrontDoorForwardingProtocolValues returns the possible values for the FrontDoorForwardingProtocol const type.

func (FrontDoorForwardingProtocol) ToPtr 

func (c FrontDoorForwardingProtocol) ToPtr() *FrontDoorForwardingProtocol

ToPtr returns a *FrontDoorForwardingProtocol pointing to the current value.

type FrontDoorHealthProbeMethod 

type FrontDoorHealthProbeMethod string

FrontDoorHealthProbeMethod - Configures which HTTP method to use to probe the backends defined under backendPools. 

const (
	FrontDoorHealthProbeMethodGET  FrontDoorHealthProbeMethod = "GET"
	FrontDoorHealthProbeMethodHEAD FrontDoorHealthProbeMethod = "HEAD"
)

func PossibleFrontDoorHealthProbeMethodValues 

func PossibleFrontDoorHealthProbeMethodValues() []FrontDoorHealthProbeMethod

PossibleFrontDoorHealthProbeMethodValues returns the possible values for the FrontDoorHealthProbeMethod const type.

func (FrontDoorHealthProbeMethod) ToPtr 

func (c FrontDoorHealthProbeMethod) ToPtr() *FrontDoorHealthProbeMethod

ToPtr returns a *FrontDoorHealthProbeMethod pointing to the current value.

type FrontDoorProtocol 

type FrontDoorProtocol string

FrontDoorProtocol - Accepted protocol schemes. 

const (
	FrontDoorProtocolHTTP  FrontDoorProtocol = "Http"
	FrontDoorProtocolHTTPS FrontDoorProtocol = "Https"
)

func PossibleFrontDoorProtocolValues 

func PossibleFrontDoorProtocolValues() []FrontDoorProtocol

PossibleFrontDoorProtocolValues returns the possible values for the FrontDoorProtocol const type.

func (FrontDoorProtocol) ToPtr 

func (c FrontDoorProtocol) ToPtr() *FrontDoorProtocol

ToPtr returns a *FrontDoorProtocol pointing to the current value.

type FrontDoorQuery 

type FrontDoorQuery string

FrontDoorQuery - Treatment of URL query terms when forming the cache key. 

const (
	FrontDoorQueryStripAll       FrontDoorQuery = "StripAll"
	FrontDoorQueryStripAllExcept FrontDoorQuery = "StripAllExcept"
	FrontDoorQueryStripNone      FrontDoorQuery = "StripNone"
	FrontDoorQueryStripOnly      FrontDoorQuery = "StripOnly"
)

func PossibleFrontDoorQueryValues 

func PossibleFrontDoorQueryValues() []FrontDoorQuery

PossibleFrontDoorQueryValues returns the possible values for the FrontDoorQuery const type.

func (FrontDoorQuery) ToPtr 

func (c FrontDoorQuery) ToPtr() *FrontDoorQuery

ToPtr returns a *FrontDoorQuery pointing to the current value.

type FrontDoorRedirectProtocol 

type FrontDoorRedirectProtocol string

FrontDoorRedirectProtocol - The protocol of the destination to where the traffic is redirected 

const (
	FrontDoorRedirectProtocolHTTPOnly     FrontDoorRedirectProtocol = "HttpOnly"
	FrontDoorRedirectProtocolHTTPSOnly    FrontDoorRedirectProtocol = "HttpsOnly"
	FrontDoorRedirectProtocolMatchRequest FrontDoorRedirectProtocol = "MatchRequest"
)

func PossibleFrontDoorRedirectProtocolValues 

func PossibleFrontDoorRedirectProtocolValues() []FrontDoorRedirectProtocol

PossibleFrontDoorRedirectProtocolValues returns the possible values for the FrontDoorRedirectProtocol const type.

func (FrontDoorRedirectProtocol) ToPtr 

func (c FrontDoorRedirectProtocol) ToPtr() *FrontDoorRedirectProtocol

ToPtr returns a *FrontDoorRedirectProtocol pointing to the current value.

type FrontDoorRedirectType 

type FrontDoorRedirectType string

FrontDoorRedirectType - The redirect type the rule will use when redirecting traffic. 

const (
	FrontDoorRedirectTypeFound             FrontDoorRedirectType = "Found"
	FrontDoorRedirectTypeMoved             FrontDoorRedirectType = "Moved"
	FrontDoorRedirectTypePermanentRedirect FrontDoorRedirectType = "PermanentRedirect"
	FrontDoorRedirectTypeTemporaryRedirect FrontDoorRedirectType = "TemporaryRedirect"
)

func PossibleFrontDoorRedirectTypeValues 

func PossibleFrontDoorRedirectTypeValues() []FrontDoorRedirectType

PossibleFrontDoorRedirectTypeValues returns the possible values for the FrontDoorRedirectType const type.

func (FrontDoorRedirectType) ToPtr 

func (c FrontDoorRedirectType) ToPtr() *FrontDoorRedirectType

ToPtr returns a *FrontDoorRedirectType pointing to the current value.

type FrontDoorResourceState 

type FrontDoorResourceState string

FrontDoorResourceState - Resource status of the Front Door or Front Door SubResource. 

const (
	FrontDoorResourceStateCreating  FrontDoorResourceState = "Creating"
	FrontDoorResourceStateDeleting  FrontDoorResourceState = "Deleting"
	FrontDoorResourceStateDisabled  FrontDoorResourceState = "Disabled"
	FrontDoorResourceStateDisabling FrontDoorResourceState = "Disabling"
	FrontDoorResourceStateEnabled   FrontDoorResourceState = "Enabled"
	FrontDoorResourceStateEnabling  FrontDoorResourceState = "Enabling"
)

func PossibleFrontDoorResourceStateValues 

func PossibleFrontDoorResourceStateValues() []FrontDoorResourceState

PossibleFrontDoorResourceStateValues returns the possible values for the FrontDoorResourceState const type.

func (FrontDoorResourceState) ToPtr 

func (c FrontDoorResourceState) ToPtr() *FrontDoorResourceState

ToPtr returns a *FrontDoorResourceState pointing to the current value.

type FrontDoorTLSProtocolType 

type FrontDoorTLSProtocolType string

FrontDoorTLSProtocolType - Defines the TLS extension protocol that is used for secure delivery 

const (
	FrontDoorTLSProtocolTypeServerNameIndication FrontDoorTLSProtocolType = "ServerNameIndication"
)

func PossibleFrontDoorTLSProtocolTypeValues 

func PossibleFrontDoorTLSProtocolTypeValues() []FrontDoorTLSProtocolType

PossibleFrontDoorTLSProtocolTypeValues returns the possible values for the FrontDoorTLSProtocolType const type.

func (FrontDoorTLSProtocolType) ToPtr 

func (c FrontDoorTLSProtocolType) ToPtr() *FrontDoorTLSProtocolType

ToPtr returns a *FrontDoorTLSProtocolType pointing to the current value.

type FrontDoorsClient 

type FrontDoorsClient struct {
	// contains filtered or unexported fields
}

FrontDoorsClient contains the methods for the FrontDoors group. Don't use this type directly, use NewFrontDoorsClient() instead.

func NewFrontDoorsClient 

func NewFrontDoorsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *FrontDoorsClient

NewFrontDoorsClient creates a new instance of FrontDoorsClient with the specified values. subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*FrontDoorsClient) BeginCreateOrUpdate 

func (client *FrontDoorsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, frontDoorName string, frontDoorParameters FrontDoor, options *FrontDoorsClientBeginCreateOrUpdateOptions) (FrontDoorsClientCreateOrUpdatePollerResponse, error)

BeginCreateOrUpdate - Creates a new Front Door with a Front Door name under the specified subscription and resource group. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. frontDoorParameters - Front Door properties needed to create a new Front Door. options - FrontDoorsClientBeginCreateOrUpdateOptions contains the optional parameters for the FrontDoorsClient.BeginCreateOrUpdate method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorCreate.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewFrontDoorsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreateOrUpdate(ctx,
		"<resource-group-name>",
		"<front-door-name>",
		armfrontdoor.FrontDoor{
			Location: to.StringPtr("<location>"),
			Tags: map[string]*string{
				"tag1": to.StringPtr("value1"),
				"tag2": to.StringPtr("value2"),
			},
			Properties: &armfrontdoor.Properties{
				BackendPools: []*armfrontdoor.BackendPool{
					{
						Name: to.StringPtr("<name>"),
						Properties: &armfrontdoor.BackendPoolProperties{
							Backends: []*armfrontdoor.Backend{
								{
									Address:   to.StringPtr("<address>"),
									HTTPPort:  to.Int32Ptr(80),
									HTTPSPort: to.Int32Ptr(443),
									Priority:  to.Int32Ptr(2),
									Weight:    to.Int32Ptr(1),
								},
								{
									Address:                    to.StringPtr("<address>"),
									HTTPPort:                   to.Int32Ptr(80),
									HTTPSPort:                  to.Int32Ptr(443),
									Priority:                   to.Int32Ptr(1),
									PrivateLinkApprovalMessage: to.StringPtr("<private-link-approval-message>"),
									PrivateLinkLocation:        to.StringPtr("<private-link-location>"),
									PrivateLinkResourceID:      to.StringPtr("<private-link-resource-id>"),
									Weight:                     to.Int32Ptr(2),
								},
								{
									Address:                    to.StringPtr("<address>"),
									HTTPPort:                   to.Int32Ptr(80),
									HTTPSPort:                  to.Int32Ptr(443),
									Priority:                   to.Int32Ptr(1),
									PrivateLinkAlias:           to.StringPtr("<private-link-alias>"),
									PrivateLinkApprovalMessage: to.StringPtr("<private-link-approval-message>"),
									Weight:                     to.Int32Ptr(1),
								}},
							HealthProbeSettings: &armfrontdoor.SubResource{
								ID: to.StringPtr("<id>"),
							},
							LoadBalancingSettings: &armfrontdoor.SubResource{
								ID: to.StringPtr("<id>"),
							},
						},
					}},
				BackendPoolsSettings: &armfrontdoor.BackendPoolsSettings{
					EnforceCertificateNameCheck: armfrontdoor.EnforceCertificateNameCheckEnabledState("Enabled").ToPtr(),
					SendRecvTimeoutSeconds:      to.Int32Ptr(60),
				},
				EnabledState: armfrontdoor.FrontDoorEnabledState("Enabled").ToPtr(),
				FrontendEndpoints: []*armfrontdoor.FrontendEndpoint{
					{
						Name: to.StringPtr("<name>"),
						Properties: &armfrontdoor.FrontendEndpointProperties{
							HostName:                    to.StringPtr("<host-name>"),
							SessionAffinityEnabledState: armfrontdoor.SessionAffinityEnabledState("Enabled").ToPtr(),
							SessionAffinityTTLSeconds:   to.Int32Ptr(60),
							WebApplicationFirewallPolicyLink: &armfrontdoor.FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink{
								ID: to.StringPtr("<id>"),
							},
						},
					},
					{
						Name: to.StringPtr("<name>"),
						Properties: &armfrontdoor.FrontendEndpointProperties{
							HostName: to.StringPtr("<host-name>"),
						},
					}},
				HealthProbeSettings: []*armfrontdoor.HealthProbeSettingsModel{
					{
						Name: to.StringPtr("<name>"),
						Properties: &armfrontdoor.HealthProbeSettingsProperties{
							Path:              to.StringPtr("<path>"),
							EnabledState:      armfrontdoor.HealthProbeEnabled("Enabled").ToPtr(),
							HealthProbeMethod: armfrontdoor.FrontDoorHealthProbeMethod("HEAD").ToPtr(),
							IntervalInSeconds: to.Int32Ptr(120),
							Protocol:          armfrontdoor.FrontDoorProtocol("Http").ToPtr(),
						},
					}},
				LoadBalancingSettings: []*armfrontdoor.LoadBalancingSettingsModel{
					{
						Name: to.StringPtr("<name>"),
						Properties: &armfrontdoor.LoadBalancingSettingsProperties{
							SampleSize:                to.Int32Ptr(4),
							SuccessfulSamplesRequired: to.Int32Ptr(2),
						},
					}},
				RoutingRules: []*armfrontdoor.RoutingRule{
					{
						Name: to.StringPtr("<name>"),
						Properties: &armfrontdoor.RoutingRuleProperties{
							AcceptedProtocols: []*armfrontdoor.FrontDoorProtocol{
								armfrontdoor.FrontDoorProtocol("Http").ToPtr()},
							EnabledState: armfrontdoor.RoutingRuleEnabledState("Enabled").ToPtr(),
							FrontendEndpoints: []*armfrontdoor.SubResource{
								{
									ID: to.StringPtr("<id>"),
								},
								{
									ID: to.StringPtr("<id>"),
								}},
							PatternsToMatch: []*string{
								to.StringPtr("/*")},
							RouteConfiguration: &armfrontdoor.ForwardingConfiguration{
								ODataType: to.StringPtr("<odata-type>"),
								BackendPool: &armfrontdoor.SubResource{
									ID: to.StringPtr("<id>"),
								},
							},
							RulesEngine: &armfrontdoor.SubResource{
								ID: to.StringPtr("<id>"),
							},
							WebApplicationFirewallPolicyLink: &armfrontdoor.RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink{
								ID: to.StringPtr("<id>"),
							},
						},
					}},
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.FrontDoorsClientCreateOrUpdateResult)
}

Output:

func (*FrontDoorsClient) BeginDelete 

func (client *FrontDoorsClient) BeginDelete(ctx context.Context, resourceGroupName string, frontDoorName string, options *FrontDoorsClientBeginDeleteOptions) (FrontDoorsClientDeletePollerResponse, error)

BeginDelete - Deletes an existing Front Door with the specified parameters. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. options - FrontDoorsClientBeginDeleteOptions contains the optional parameters for the FrontDoorsClient.BeginDelete method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorDelete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewFrontDoorsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<front-door-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*FrontDoorsClient) Get 

func (client *FrontDoorsClient) Get(ctx context.Context, resourceGroupName string, frontDoorName string, options *FrontDoorsClientGetOptions) (FrontDoorsClientGetResponse, error)

Get - Gets a Front Door with the specified Front Door name under the specified subscription and resource group. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. options - FrontDoorsClientGetOptions contains the optional parameters for the FrontDoorsClient.Get method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewFrontDoorsClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<front-door-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.FrontDoorsClientGetResult)
}

Output:

func (*FrontDoorsClient) List 

func (client *FrontDoorsClient) List(options *FrontDoorsClientListOptions) *FrontDoorsClientListPager

List - Lists all of the Front Doors within an Azure subscription. If the operation fails it returns an *azcore.ResponseError type. options - FrontDoorsClientListOptions contains the optional parameters for the FrontDoorsClient.List method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorListAll.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewFrontDoorsClient("<subscription-id>", cred, nil)
	pager := client.List(nil)
	for {
		nextResult := pager.NextPage(ctx)
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		if !nextResult {
			break
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("Pager result: %#v\n", v)
		}
	}
}

Output:

func (*FrontDoorsClient) ListByResourceGroup 

func (client *FrontDoorsClient) ListByResourceGroup(resourceGroupName string, options *FrontDoorsClientListByResourceGroupOptions) *FrontDoorsClientListByResourceGroupPager

ListByResourceGroup - Lists all of the Front Doors within a resource group under a subscription. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. options - FrontDoorsClientListByResourceGroupOptions contains the optional parameters for the FrontDoorsClient.ListByResourceGroup method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewFrontDoorsClient("<subscription-id>", cred, nil)
	pager := client.ListByResourceGroup("<resource-group-name>",
		nil)
	for {
		nextResult := pager.NextPage(ctx)
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		if !nextResult {
			break
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("Pager result: %#v\n", v)
		}
	}
}

Output:

func (*FrontDoorsClient) ValidateCustomDomain 

func (client *FrontDoorsClient) ValidateCustomDomain(ctx context.Context, resourceGroupName string, frontDoorName string, customDomainProperties ValidateCustomDomainInput, options *FrontDoorsClientValidateCustomDomainOptions) (FrontDoorsClientValidateCustomDomainResponse, error)

ValidateCustomDomain - Validates the custom domain mapping to ensure it maps to the correct Front Door endpoint in DNS. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. customDomainProperties - Custom domain to be validated. options - FrontDoorsClientValidateCustomDomainOptions contains the optional parameters for the FrontDoorsClient.ValidateCustomDomain method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorValidateCustomDomain.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewFrontDoorsClient("<subscription-id>", cred, nil)
	res, err := client.ValidateCustomDomain(ctx,
		"<resource-group-name>",
		"<front-door-name>",
		armfrontdoor.ValidateCustomDomainInput{
			HostName: to.StringPtr("<host-name>"),
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.FrontDoorsClientValidateCustomDomainResult)
}

Output:

type FrontDoorsClientBeginCreateOrUpdateOptions added in v0.2.0 

type FrontDoorsClientBeginCreateOrUpdateOptions struct {
}

FrontDoorsClientBeginCreateOrUpdateOptions contains the optional parameters for the FrontDoorsClient.BeginCreateOrUpdate method.

type FrontDoorsClientBeginDeleteOptions added in v0.2.0 

type FrontDoorsClientBeginDeleteOptions struct {
}

FrontDoorsClientBeginDeleteOptions contains the optional parameters for the FrontDoorsClient.BeginDelete method.

type FrontDoorsClientCreateOrUpdatePoller added in v0.2.0 

type FrontDoorsClientCreateOrUpdatePoller struct {
	// contains filtered or unexported fields
}

FrontDoorsClientCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*FrontDoorsClientCreateOrUpdatePoller) Done added in v0.2.0 

func (p *FrontDoorsClientCreateOrUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*FrontDoorsClientCreateOrUpdatePoller) FinalResponse added in v0.2.0 

func (p *FrontDoorsClientCreateOrUpdatePoller) FinalResponse(ctx context.Context) (FrontDoorsClientCreateOrUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final FrontDoorsClientCreateOrUpdateResponse will be returned.

func (*FrontDoorsClientCreateOrUpdatePoller) Poll added in v0.2.0 

func (p *FrontDoorsClientCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*FrontDoorsClientCreateOrUpdatePoller) ResumeToken added in v0.2.0 

func (p *FrontDoorsClientCreateOrUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type FrontDoorsClientCreateOrUpdatePollerResponse added in v0.2.0 

type FrontDoorsClientCreateOrUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *FrontDoorsClientCreateOrUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontDoorsClientCreateOrUpdatePollerResponse contains the response from method FrontDoorsClient.CreateOrUpdate.

func (FrontDoorsClientCreateOrUpdatePollerResponse) PollUntilDone added in v0.2.0 

func (l FrontDoorsClientCreateOrUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (FrontDoorsClientCreateOrUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*FrontDoorsClientCreateOrUpdatePollerResponse) Resume added in v0.2.0 

func (l *FrontDoorsClientCreateOrUpdatePollerResponse) Resume(ctx context.Context, client *FrontDoorsClient, token string) error

Resume rehydrates a FrontDoorsClientCreateOrUpdatePollerResponse from the provided client and resume token.

type FrontDoorsClientCreateOrUpdateResponse added in v0.2.0 

type FrontDoorsClientCreateOrUpdateResponse struct {
	FrontDoorsClientCreateOrUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontDoorsClientCreateOrUpdateResponse contains the response from method FrontDoorsClient.CreateOrUpdate.

type FrontDoorsClientCreateOrUpdateResult added in v0.2.0 

type FrontDoorsClientCreateOrUpdateResult struct {
	FrontDoor
}

FrontDoorsClientCreateOrUpdateResult contains the result from method FrontDoorsClient.CreateOrUpdate.

type FrontDoorsClientDeletePoller added in v0.2.0 

type FrontDoorsClientDeletePoller struct {
	// contains filtered or unexported fields
}

FrontDoorsClientDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*FrontDoorsClientDeletePoller) Done added in v0.2.0 

func (p *FrontDoorsClientDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*FrontDoorsClientDeletePoller) FinalResponse added in v0.2.0 

func (p *FrontDoorsClientDeletePoller) FinalResponse(ctx context.Context) (FrontDoorsClientDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final FrontDoorsClientDeleteResponse will be returned.

func (*FrontDoorsClientDeletePoller) Poll added in v0.2.0 

func (p *FrontDoorsClientDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*FrontDoorsClientDeletePoller) ResumeToken added in v0.2.0 

func (p *FrontDoorsClientDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type FrontDoorsClientDeletePollerResponse added in v0.2.0 

type FrontDoorsClientDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *FrontDoorsClientDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontDoorsClientDeletePollerResponse contains the response from method FrontDoorsClient.Delete.

func (FrontDoorsClientDeletePollerResponse) PollUntilDone added in v0.2.0 

func (l FrontDoorsClientDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (FrontDoorsClientDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*FrontDoorsClientDeletePollerResponse) Resume added in v0.2.0 

func (l *FrontDoorsClientDeletePollerResponse) Resume(ctx context.Context, client *FrontDoorsClient, token string) error

Resume rehydrates a FrontDoorsClientDeletePollerResponse from the provided client and resume token.

type FrontDoorsClientDeleteResponse added in v0.2.0 

type FrontDoorsClientDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontDoorsClientDeleteResponse contains the response from method FrontDoorsClient.Delete.

type FrontDoorsClientGetOptions added in v0.2.0 

type FrontDoorsClientGetOptions struct {
}

FrontDoorsClientGetOptions contains the optional parameters for the FrontDoorsClient.Get method.

type FrontDoorsClientGetResponse added in v0.2.0 

type FrontDoorsClientGetResponse struct {
	FrontDoorsClientGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontDoorsClientGetResponse contains the response from method FrontDoorsClient.Get.

type FrontDoorsClientGetResult added in v0.2.0 

type FrontDoorsClientGetResult struct {
	FrontDoor
}

FrontDoorsClientGetResult contains the result from method FrontDoorsClient.Get.

type FrontDoorsClientListByResourceGroupOptions added in v0.2.0 

type FrontDoorsClientListByResourceGroupOptions struct {
}

FrontDoorsClientListByResourceGroupOptions contains the optional parameters for the FrontDoorsClient.ListByResourceGroup method.

type FrontDoorsClientListByResourceGroupPager added in v0.2.0 

type FrontDoorsClientListByResourceGroupPager struct {
	// contains filtered or unexported fields
}

FrontDoorsClientListByResourceGroupPager provides operations for iterating over paged responses.

func (*FrontDoorsClientListByResourceGroupPager) Err added in v0.2.0 

func (p *FrontDoorsClientListByResourceGroupPager) Err() error

Err returns the last error encountered while paging.

func (*FrontDoorsClientListByResourceGroupPager) NextPage added in v0.2.0 

func (p *FrontDoorsClientListByResourceGroupPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*FrontDoorsClientListByResourceGroupPager) PageResponse added in v0.2.0 

func (p *FrontDoorsClientListByResourceGroupPager) PageResponse() FrontDoorsClientListByResourceGroupResponse

PageResponse returns the current FrontDoorsClientListByResourceGroupResponse page.

type FrontDoorsClientListByResourceGroupResponse added in v0.2.0 

type FrontDoorsClientListByResourceGroupResponse struct {
	FrontDoorsClientListByResourceGroupResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontDoorsClientListByResourceGroupResponse contains the response from method FrontDoorsClient.ListByResourceGroup.

type FrontDoorsClientListByResourceGroupResult added in v0.2.0 

type FrontDoorsClientListByResourceGroupResult struct {
	ListResult
}

FrontDoorsClientListByResourceGroupResult contains the result from method FrontDoorsClient.ListByResourceGroup.

type FrontDoorsClientListOptions added in v0.2.0 

type FrontDoorsClientListOptions struct {
}

FrontDoorsClientListOptions contains the optional parameters for the FrontDoorsClient.List method.

type FrontDoorsClientListPager added in v0.2.0 

type FrontDoorsClientListPager struct {
	// contains filtered or unexported fields
}

FrontDoorsClientListPager provides operations for iterating over paged responses.

func (*FrontDoorsClientListPager) Err added in v0.2.0 

func (p *FrontDoorsClientListPager) Err() error

Err returns the last error encountered while paging.

func (*FrontDoorsClientListPager) NextPage added in v0.2.0 

func (p *FrontDoorsClientListPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*FrontDoorsClientListPager) PageResponse added in v0.2.0 

func (p *FrontDoorsClientListPager) PageResponse() FrontDoorsClientListResponse

PageResponse returns the current FrontDoorsClientListResponse page.

type FrontDoorsClientListResponse added in v0.2.0 

type FrontDoorsClientListResponse struct {
	FrontDoorsClientListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontDoorsClientListResponse contains the response from method FrontDoorsClient.List.

type FrontDoorsClientListResult added in v0.2.0 

type FrontDoorsClientListResult struct {
	ListResult
}

FrontDoorsClientListResult contains the result from method FrontDoorsClient.List.

type FrontDoorsClientValidateCustomDomainOptions added in v0.2.0 

type FrontDoorsClientValidateCustomDomainOptions struct {
}

FrontDoorsClientValidateCustomDomainOptions contains the optional parameters for the FrontDoorsClient.ValidateCustomDomain method.

type FrontDoorsClientValidateCustomDomainResponse added in v0.2.0 

type FrontDoorsClientValidateCustomDomainResponse struct {
	FrontDoorsClientValidateCustomDomainResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontDoorsClientValidateCustomDomainResponse contains the response from method FrontDoorsClient.ValidateCustomDomain.

type FrontDoorsClientValidateCustomDomainResult added in v0.2.0 

type FrontDoorsClientValidateCustomDomainResult struct {
	ValidateCustomDomainOutput
}

FrontDoorsClientValidateCustomDomainResult contains the result from method FrontDoorsClient.ValidateCustomDomain.

type FrontendEndpoint 

type FrontendEndpoint struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`

	// Resource name.
	Name *string `json:"name,omitempty"`

	// Properties of the Frontend endpoint
	Properties *FrontendEndpointProperties `json:"properties,omitempty"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

FrontendEndpoint - A frontend endpoint used for routing. 

type FrontendEndpointLink struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`
}

FrontendEndpointLink - Defines the Resource ID for a Frontend Endpoint.

type FrontendEndpointProperties 

type FrontendEndpointProperties struct {
	// The host name of the frontendEndpoint. Must be a domain name.
	HostName *string `json:"hostName,omitempty"`

	// Whether to allow session affinity on this host. Valid options are 'Enabled' or 'Disabled'
	SessionAffinityEnabledState *SessionAffinityEnabledState `json:"sessionAffinityEnabledState,omitempty"`

	// UNUSED. This field will be ignored. The TTL to use in seconds for session affinity, if applicable.
	SessionAffinityTTLSeconds *int32 `json:"sessionAffinityTtlSeconds,omitempty"`

	// Defines the Web Application Firewall policy for each host (if applicable)
	WebApplicationFirewallPolicyLink *FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink `json:"webApplicationFirewallPolicyLink,omitempty"`

	// READ-ONLY; The configuration specifying how to enable HTTPS
	CustomHTTPSConfiguration *CustomHTTPSConfiguration `json:"customHttpsConfiguration,omitempty" azure:"ro"`

	// READ-ONLY; Provisioning status of Custom Https of the frontendEndpoint.
	CustomHTTPSProvisioningState *CustomHTTPSProvisioningState `json:"customHttpsProvisioningState,omitempty" azure:"ro"`

	// READ-ONLY; Provisioning substate shows the progress of custom HTTPS enabling/disabling process step by step.
	CustomHTTPSProvisioningSubstate *CustomHTTPSProvisioningSubstate `json:"customHttpsProvisioningSubstate,omitempty" azure:"ro"`

	// READ-ONLY; Resource status.
	ResourceState *FrontDoorResourceState `json:"resourceState,omitempty" azure:"ro"`
}

FrontendEndpointProperties - The JSON object that contains the properties required to create a frontend endpoint.

type FrontendEndpointUpdateParameters 

type FrontendEndpointUpdateParameters struct {
	// The host name of the frontendEndpoint. Must be a domain name.
	HostName *string `json:"hostName,omitempty"`

	// Whether to allow session affinity on this host. Valid options are 'Enabled' or 'Disabled'
	SessionAffinityEnabledState *SessionAffinityEnabledState `json:"sessionAffinityEnabledState,omitempty"`

	// UNUSED. This field will be ignored. The TTL to use in seconds for session affinity, if applicable.
	SessionAffinityTTLSeconds *int32 `json:"sessionAffinityTtlSeconds,omitempty"`

	// Defines the Web Application Firewall policy for each host (if applicable)
	WebApplicationFirewallPolicyLink *FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink `json:"webApplicationFirewallPolicyLink,omitempty"`
}

FrontendEndpointUpdateParameters - Frontend endpoint used in routing rule 

type FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`
}

FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink - Defines the Web Application Firewall policy for each host (if applicable)

type FrontendEndpointsClient 

type FrontendEndpointsClient struct {
	// contains filtered or unexported fields
}

FrontendEndpointsClient contains the methods for the FrontendEndpoints group. Don't use this type directly, use NewFrontendEndpointsClient() instead.

func NewFrontendEndpointsClient 

func NewFrontendEndpointsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *FrontendEndpointsClient

NewFrontendEndpointsClient creates a new instance of FrontendEndpointsClient with the specified values. subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*FrontendEndpointsClient) BeginDisableHTTPS 

func (client *FrontendEndpointsClient) BeginDisableHTTPS(ctx context.Context, resourceGroupName string, frontDoorName string, frontendEndpointName string, options *FrontendEndpointsClientBeginDisableHTTPSOptions) (FrontendEndpointsClientDisableHTTPSPollerResponse, error)

BeginDisableHTTPS - Disables a frontendEndpoint for HTTPS traffic If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. frontendEndpointName - Name of the Frontend endpoint which is unique within the Front Door. options - FrontendEndpointsClientBeginDisableHTTPSOptions contains the optional parameters for the FrontendEndpointsClient.BeginDisableHTTPS method.

func (*FrontendEndpointsClient) BeginEnableHTTPS 

func (client *FrontendEndpointsClient) BeginEnableHTTPS(ctx context.Context, resourceGroupName string, frontDoorName string, frontendEndpointName string, customHTTPSConfiguration CustomHTTPSConfiguration, options *FrontendEndpointsClientBeginEnableHTTPSOptions) (FrontendEndpointsClientEnableHTTPSPollerResponse, error)

BeginEnableHTTPS - Enables a frontendEndpoint for HTTPS traffic If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. frontendEndpointName - Name of the Frontend endpoint which is unique within the Front Door. customHTTPSConfiguration - The configuration specifying how to enable HTTPS options - FrontendEndpointsClientBeginEnableHTTPSOptions contains the optional parameters for the FrontendEndpointsClient.BeginEnableHTTPS method.

func (*FrontendEndpointsClient) Get 

func (client *FrontendEndpointsClient) Get(ctx context.Context, resourceGroupName string, frontDoorName string, frontendEndpointName string, options *FrontendEndpointsClientGetOptions) (FrontendEndpointsClientGetResponse, error)

Get - Gets a Frontend endpoint with the specified name within the specified Front Door. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. frontendEndpointName - Name of the Frontend endpoint which is unique within the Front Door. options - FrontendEndpointsClientGetOptions contains the optional parameters for the FrontendEndpointsClient.Get method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorFrontendEndpointGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewFrontendEndpointsClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<front-door-name>",
		"<frontend-endpoint-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.FrontendEndpointsClientGetResult)
}

Output:

func (*FrontendEndpointsClient) ListByFrontDoor 

func (client *FrontendEndpointsClient) ListByFrontDoor(resourceGroupName string, frontDoorName string, options *FrontendEndpointsClientListByFrontDoorOptions) *FrontendEndpointsClientListByFrontDoorPager

ListByFrontDoor - Lists all of the frontend endpoints within a Front Door. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. options - FrontendEndpointsClientListByFrontDoorOptions contains the optional parameters for the FrontendEndpointsClient.ListByFrontDoor method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorFrontendEndpointList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewFrontendEndpointsClient("<subscription-id>", cred, nil)
	pager := client.ListByFrontDoor("<resource-group-name>",
		"<front-door-name>",
		nil)
	for {
		nextResult := pager.NextPage(ctx)
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		if !nextResult {
			break
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("Pager result: %#v\n", v)
		}
	}
}

Output:

type FrontendEndpointsClientBeginDisableHTTPSOptions added in v0.2.0 

type FrontendEndpointsClientBeginDisableHTTPSOptions struct {
}

FrontendEndpointsClientBeginDisableHTTPSOptions contains the optional parameters for the FrontendEndpointsClient.BeginDisableHTTPS method.

type FrontendEndpointsClientBeginEnableHTTPSOptions added in v0.2.0 

type FrontendEndpointsClientBeginEnableHTTPSOptions struct {
}

FrontendEndpointsClientBeginEnableHTTPSOptions contains the optional parameters for the FrontendEndpointsClient.BeginEnableHTTPS method.

type FrontendEndpointsClientDisableHTTPSPoller added in v0.2.0 

type FrontendEndpointsClientDisableHTTPSPoller struct {
	// contains filtered or unexported fields
}

FrontendEndpointsClientDisableHTTPSPoller provides polling facilities until the operation reaches a terminal state.

func (*FrontendEndpointsClientDisableHTTPSPoller) Done added in v0.2.0 

func (p *FrontendEndpointsClientDisableHTTPSPoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*FrontendEndpointsClientDisableHTTPSPoller) FinalResponse added in v0.2.0 

func (p *FrontendEndpointsClientDisableHTTPSPoller) FinalResponse(ctx context.Context) (FrontendEndpointsClientDisableHTTPSResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final FrontendEndpointsClientDisableHTTPSResponse will be returned.

func (*FrontendEndpointsClientDisableHTTPSPoller) Poll added in v0.2.0 

func (p *FrontendEndpointsClientDisableHTTPSPoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*FrontendEndpointsClientDisableHTTPSPoller) ResumeToken added in v0.2.0 

func (p *FrontendEndpointsClientDisableHTTPSPoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type FrontendEndpointsClientDisableHTTPSPollerResponse added in v0.2.0 

type FrontendEndpointsClientDisableHTTPSPollerResponse struct {
	// Poller contains an initialized poller.
	Poller *FrontendEndpointsClientDisableHTTPSPoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontendEndpointsClientDisableHTTPSPollerResponse contains the response from method FrontendEndpointsClient.DisableHTTPS.

func (FrontendEndpointsClientDisableHTTPSPollerResponse) PollUntilDone added in v0.2.0 

func (l FrontendEndpointsClientDisableHTTPSPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (FrontendEndpointsClientDisableHTTPSResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*FrontendEndpointsClientDisableHTTPSPollerResponse) Resume added in v0.2.0 

func (l *FrontendEndpointsClientDisableHTTPSPollerResponse) Resume(ctx context.Context, client *FrontendEndpointsClient, token string) error

Resume rehydrates a FrontendEndpointsClientDisableHTTPSPollerResponse from the provided client and resume token.

type FrontendEndpointsClientDisableHTTPSResponse added in v0.2.0 

type FrontendEndpointsClientDisableHTTPSResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontendEndpointsClientDisableHTTPSResponse contains the response from method FrontendEndpointsClient.DisableHTTPS.

type FrontendEndpointsClientEnableHTTPSPoller added in v0.2.0 

type FrontendEndpointsClientEnableHTTPSPoller struct {
	// contains filtered or unexported fields
}

FrontendEndpointsClientEnableHTTPSPoller provides polling facilities until the operation reaches a terminal state.

func (*FrontendEndpointsClientEnableHTTPSPoller) Done added in v0.2.0 

func (p *FrontendEndpointsClientEnableHTTPSPoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*FrontendEndpointsClientEnableHTTPSPoller) FinalResponse added in v0.2.0 

func (p *FrontendEndpointsClientEnableHTTPSPoller) FinalResponse(ctx context.Context) (FrontendEndpointsClientEnableHTTPSResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final FrontendEndpointsClientEnableHTTPSResponse will be returned.

func (*FrontendEndpointsClientEnableHTTPSPoller) Poll added in v0.2.0 

func (p *FrontendEndpointsClientEnableHTTPSPoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*FrontendEndpointsClientEnableHTTPSPoller) ResumeToken added in v0.2.0 

func (p *FrontendEndpointsClientEnableHTTPSPoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type FrontendEndpointsClientEnableHTTPSPollerResponse added in v0.2.0 

type FrontendEndpointsClientEnableHTTPSPollerResponse struct {
	// Poller contains an initialized poller.
	Poller *FrontendEndpointsClientEnableHTTPSPoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontendEndpointsClientEnableHTTPSPollerResponse contains the response from method FrontendEndpointsClient.EnableHTTPS.

func (FrontendEndpointsClientEnableHTTPSPollerResponse) PollUntilDone added in v0.2.0 

func (l FrontendEndpointsClientEnableHTTPSPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (FrontendEndpointsClientEnableHTTPSResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*FrontendEndpointsClientEnableHTTPSPollerResponse) Resume added in v0.2.0 

func (l *FrontendEndpointsClientEnableHTTPSPollerResponse) Resume(ctx context.Context, client *FrontendEndpointsClient, token string) error

Resume rehydrates a FrontendEndpointsClientEnableHTTPSPollerResponse from the provided client and resume token.

type FrontendEndpointsClientEnableHTTPSResponse added in v0.2.0 

type FrontendEndpointsClientEnableHTTPSResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontendEndpointsClientEnableHTTPSResponse contains the response from method FrontendEndpointsClient.EnableHTTPS.

type FrontendEndpointsClientGetOptions added in v0.2.0 

type FrontendEndpointsClientGetOptions struct {
}

FrontendEndpointsClientGetOptions contains the optional parameters for the FrontendEndpointsClient.Get method.

type FrontendEndpointsClientGetResponse added in v0.2.0 

type FrontendEndpointsClientGetResponse struct {
	FrontendEndpointsClientGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontendEndpointsClientGetResponse contains the response from method FrontendEndpointsClient.Get.

type FrontendEndpointsClientGetResult added in v0.2.0 

type FrontendEndpointsClientGetResult struct {
	FrontendEndpoint
}

FrontendEndpointsClientGetResult contains the result from method FrontendEndpointsClient.Get.

type FrontendEndpointsClientListByFrontDoorOptions added in v0.2.0 

type FrontendEndpointsClientListByFrontDoorOptions struct {
}

FrontendEndpointsClientListByFrontDoorOptions contains the optional parameters for the FrontendEndpointsClient.ListByFrontDoor method.

type FrontendEndpointsClientListByFrontDoorPager added in v0.2.0 

type FrontendEndpointsClientListByFrontDoorPager struct {
	// contains filtered or unexported fields
}

FrontendEndpointsClientListByFrontDoorPager provides operations for iterating over paged responses.

func (*FrontendEndpointsClientListByFrontDoorPager) Err added in v0.2.0 

func (p *FrontendEndpointsClientListByFrontDoorPager) Err() error

Err returns the last error encountered while paging.

func (*FrontendEndpointsClientListByFrontDoorPager) NextPage added in v0.2.0 

func (p *FrontendEndpointsClientListByFrontDoorPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*FrontendEndpointsClientListByFrontDoorPager) PageResponse added in v0.2.0 

func (p *FrontendEndpointsClientListByFrontDoorPager) PageResponse() FrontendEndpointsClientListByFrontDoorResponse

PageResponse returns the current FrontendEndpointsClientListByFrontDoorResponse page.

type FrontendEndpointsClientListByFrontDoorResponse added in v0.2.0 

type FrontendEndpointsClientListByFrontDoorResponse struct {
	FrontendEndpointsClientListByFrontDoorResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

FrontendEndpointsClientListByFrontDoorResponse contains the response from method FrontendEndpointsClient.ListByFrontDoor.

type FrontendEndpointsClientListByFrontDoorResult added in v0.2.0 

type FrontendEndpointsClientListByFrontDoorResult struct {
	FrontendEndpointsListResult
}

FrontendEndpointsClientListByFrontDoorResult contains the result from method FrontendEndpointsClient.ListByFrontDoor.

type FrontendEndpointsListResult 

type FrontendEndpointsListResult struct {
	// URL to get the next set of frontend endpoints if there are any.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of Frontend endpoints within a Front Door.
	Value []*FrontendEndpoint `json:"value,omitempty" azure:"ro"`
}

FrontendEndpointsListResult - Result of the request to list frontend endpoints. It contains a list of Frontend endpoint objects and a URL link to get the next set of results.

func (FrontendEndpointsListResult) MarshalJSON 

func (f FrontendEndpointsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FrontendEndpointsListResult.

type HeaderAction 

type HeaderAction struct {
	// REQUIRED; Which type of manipulation to apply to the header.
	HeaderActionType *HeaderActionType `json:"headerActionType,omitempty"`

	// REQUIRED; The name of the header this action will apply to.
	HeaderName *string `json:"headerName,omitempty"`

	// The value to update the given header name with. This value is not used if the actionType is Delete.
	Value *string `json:"value,omitempty"`
}

HeaderAction - An action that can manipulate an http header.

type HeaderActionType 

type HeaderActionType string

HeaderActionType - Which type of manipulation to apply to the header. 

const (
	HeaderActionTypeAppend    HeaderActionType = "Append"
	HeaderActionTypeDelete    HeaderActionType = "Delete"
	HeaderActionTypeOverwrite HeaderActionType = "Overwrite"
)

func PossibleHeaderActionTypeValues 

func PossibleHeaderActionTypeValues() []HeaderActionType

PossibleHeaderActionTypeValues returns the possible values for the HeaderActionType const type.

func (HeaderActionType) ToPtr 

func (c HeaderActionType) ToPtr() *HeaderActionType

ToPtr returns a *HeaderActionType pointing to the current value.

type HealthProbeEnabled 

type HealthProbeEnabled string

HealthProbeEnabled - Whether to enable health probes to be made against backends defined under backendPools. Health probes can only be disabled if there is a single enabled backend in single enabled backend pool. 

const (
	HealthProbeEnabledDisabled HealthProbeEnabled = "Disabled"
	HealthProbeEnabledEnabled  HealthProbeEnabled = "Enabled"
)

func PossibleHealthProbeEnabledValues 

func PossibleHealthProbeEnabledValues() []HealthProbeEnabled

PossibleHealthProbeEnabledValues returns the possible values for the HealthProbeEnabled const type.

func (HealthProbeEnabled) ToPtr 

func (c HealthProbeEnabled) ToPtr() *HealthProbeEnabled

ToPtr returns a *HealthProbeEnabled pointing to the current value.

type HealthProbeSettingsListResult 

type HealthProbeSettingsListResult struct {
	// URL to get the next set of HealthProbeSettings objects if there are any.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of HealthProbeSettings within a Front Door.
	Value []*HealthProbeSettingsModel `json:"value,omitempty" azure:"ro"`
}

HealthProbeSettingsListResult - Result of the request to list HealthProbeSettings. It contains a list of HealthProbeSettings objects and a URL link to get the next set of results.

func (HealthProbeSettingsListResult) MarshalJSON 

func (h HealthProbeSettingsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HealthProbeSettingsListResult.

type HealthProbeSettingsModel 

type HealthProbeSettingsModel struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`

	// Resource name.
	Name *string `json:"name,omitempty"`

	// Properties of the health probe settings
	Properties *HealthProbeSettingsProperties `json:"properties,omitempty"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

HealthProbeSettingsModel - Load balancing settings for a backend pool

type HealthProbeSettingsProperties 

type HealthProbeSettingsProperties struct {
	// Whether to enable health probes to be made against backends defined under backendPools. Health probes can only be disabled
	// if there is a single enabled backend in single enabled backend pool.
	EnabledState *HealthProbeEnabled `json:"enabledState,omitempty"`

	// Configures which HTTP method to use to probe the backends defined under backendPools.
	HealthProbeMethod *FrontDoorHealthProbeMethod `json:"healthProbeMethod,omitempty"`

	// The number of seconds between health probes.
	IntervalInSeconds *int32 `json:"intervalInSeconds,omitempty"`

	// The path to use for the health probe. Default is /
	Path *string `json:"path,omitempty"`

	// Protocol scheme to use for this probe
	Protocol *FrontDoorProtocol `json:"protocol,omitempty"`

	// READ-ONLY; Resource status.
	ResourceState *FrontDoorResourceState `json:"resourceState,omitempty" azure:"ro"`
}

HealthProbeSettingsProperties - The JSON object that contains the properties required to create a health probe settings.

type HealthProbeSettingsUpdateParameters 

type HealthProbeSettingsUpdateParameters struct {
	// Whether to enable health probes to be made against backends defined under backendPools. Health probes can only be disabled
	// if there is a single enabled backend in single enabled backend pool.
	EnabledState *HealthProbeEnabled `json:"enabledState,omitempty"`

	// Configures which HTTP method to use to probe the backends defined under backendPools.
	HealthProbeMethod *FrontDoorHealthProbeMethod `json:"healthProbeMethod,omitempty"`

	// The number of seconds between health probes.
	IntervalInSeconds *int32 `json:"intervalInSeconds,omitempty"`

	// The path to use for the health probe. Default is /
	Path *string `json:"path,omitempty"`

	// Protocol scheme to use for this probe
	Protocol *FrontDoorProtocol `json:"protocol,omitempty"`
}

HealthProbeSettingsUpdateParameters - L7 health probe settings for a backend pool

type KeyVaultCertificateSourceParameters 

type KeyVaultCertificateSourceParameters struct {
	// The name of the Key Vault secret representing the full certificate PFX
	SecretName *string `json:"secretName,omitempty"`

	// The version of the Key Vault secret representing the full certificate PFX
	SecretVersion *string `json:"secretVersion,omitempty"`

	// The Key Vault containing the SSL certificate
	Vault *KeyVaultCertificateSourceParametersVault `json:"vault,omitempty"`
}

KeyVaultCertificateSourceParameters - Parameters required for bring-your-own-certification via Key Vault

type KeyVaultCertificateSourceParametersVault 

type KeyVaultCertificateSourceParametersVault struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`
}

KeyVaultCertificateSourceParametersVault - The Key Vault containing the SSL certificate

type LatencyMetric 

type LatencyMetric struct {
	// READ-ONLY; The lower end of the 95% confidence interval for endpoint A
	ACLower95CI *float32 `json:"aCLower95CI,omitempty" azure:"ro"`

	// READ-ONLY; The upper end of the 95% confidence interval for endpoint A
	AHUpper95CI *float32 `json:"aHUpper95CI,omitempty" azure:"ro"`

	// READ-ONLY; The metric value of the A endpoint
	AValue *float32 `json:"aValue,omitempty" azure:"ro"`

	// READ-ONLY; The lower end of the 95% confidence interval for endpoint B
	BCLower95CI *float32 `json:"bCLower95CI,omitempty" azure:"ro"`

	// READ-ONLY; The upper end of the 95% confidence interval for endpoint B
	BUpper95CI *float32 `json:"bUpper95CI,omitempty" azure:"ro"`

	// READ-ONLY; The metric value of the B endpoint
	BValue *float32 `json:"bValue,omitempty" azure:"ro"`

	// READ-ONLY; The difference in value between endpoint A and B
	Delta *float32 `json:"delta,omitempty" azure:"ro"`

	// READ-ONLY; The percent difference between endpoint A and B
	DeltaPercent *float32 `json:"deltaPercent,omitempty" azure:"ro"`

	// READ-ONLY; The end time of the Latency Scorecard in UTC
	EndDateTimeUTC *string `json:"endDateTimeUTC,omitempty" azure:"ro"`

	// READ-ONLY; The name of the Latency Metric
	Name *string `json:"name,omitempty" azure:"ro"`
}

LatencyMetric - Defines the properties of a latency metric used in the latency scorecard

type LatencyScorecard 

type LatencyScorecard struct {
	// Resource location.
	Location *string `json:"location,omitempty"`

	// The properties of a latency scorecard
	Properties *LatencyScorecardProperties `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

LatencyScorecard - Defines the LatencyScorecard

func (LatencyScorecard) MarshalJSON 

func (l LatencyScorecard) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LatencyScorecard.

type LatencyScorecardAggregationInterval 

type LatencyScorecardAggregationInterval string
const (
	LatencyScorecardAggregationIntervalDaily   LatencyScorecardAggregationInterval = "Daily"
	LatencyScorecardAggregationIntervalMonthly LatencyScorecardAggregationInterval = "Monthly"
	LatencyScorecardAggregationIntervalWeekly  LatencyScorecardAggregationInterval = "Weekly"
)

func PossibleLatencyScorecardAggregationIntervalValues 

func PossibleLatencyScorecardAggregationIntervalValues() []LatencyScorecardAggregationInterval

PossibleLatencyScorecardAggregationIntervalValues returns the possible values for the LatencyScorecardAggregationInterval const type.

func (LatencyScorecardAggregationInterval) ToPtr 

func (c LatencyScorecardAggregationInterval) ToPtr() *LatencyScorecardAggregationInterval

ToPtr returns a *LatencyScorecardAggregationInterval pointing to the current value.

type LatencyScorecardProperties 

type LatencyScorecardProperties struct {
	// The latency metrics of the Latency Scorecard
	LatencyMetrics []*LatencyMetric `json:"latencyMetrics,omitempty"`

	// READ-ONLY; The country associated with the Latency Scorecard. Values are country ISO codes as specified here- https://www.iso.org/iso-3166-country-codes.html
	Country *string `json:"country,omitempty" azure:"ro"`

	// READ-ONLY; The description of the Latency Scorecard
	Description *string `json:"description,omitempty" azure:"ro"`

	// READ-ONLY; The end time of the Latency Scorecard in UTC
	EndDateTimeUTC *time.Time `json:"endDateTimeUTC,omitempty" azure:"ro"`

	// READ-ONLY; The A endpoint in the scorecard
	EndpointA *string `json:"endpointA,omitempty" azure:"ro"`

	// READ-ONLY; The B endpoint in the scorecard
	EndpointB *string `json:"endpointB,omitempty" azure:"ro"`

	// READ-ONLY; The unique identifier of the Latency Scorecard
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the Latency Scorecard
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The start time of the Latency Scorecard in UTC
	StartDateTimeUTC *time.Time `json:"startDateTimeUTC,omitempty" azure:"ro"`
}

LatencyScorecardProperties - Defines a the properties of a Latency Scorecard

func (LatencyScorecardProperties) MarshalJSON 

func (l LatencyScorecardProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LatencyScorecardProperties.

func (*LatencyScorecardProperties) UnmarshalJSON 

func (l *LatencyScorecardProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LatencyScorecardProperties.

type ListResult added in v0.2.0 

type ListResult struct {
	// URL to get the next set of Front Door objects if there are any.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of Front Doors within a resource group.
	Value []*FrontDoor `json:"value,omitempty" azure:"ro"`
}

ListResult - Result of the request to list Front Doors. It contains a list of Front Door objects and a URL link to get the next set of results.

func (ListResult) MarshalJSON added in v0.2.0 

func (l ListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ListResult.

type LoadBalancingSettingsListResult 

type LoadBalancingSettingsListResult struct {
	// URL to get the next set of LoadBalancingSettings objects if there are any.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of Backend Pools within a Front Door.
	Value []*LoadBalancingSettingsModel `json:"value,omitempty" azure:"ro"`
}

LoadBalancingSettingsListResult - Result of the request to list load balancing settings. It contains a list of load balancing settings objects and a URL link to get the next set of results.

func (LoadBalancingSettingsListResult) MarshalJSON 

func (l LoadBalancingSettingsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LoadBalancingSettingsListResult.

type LoadBalancingSettingsModel 

type LoadBalancingSettingsModel struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`

	// Resource name.
	Name *string `json:"name,omitempty"`

	// Properties of the load balancing settings
	Properties *LoadBalancingSettingsProperties `json:"properties,omitempty"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

LoadBalancingSettingsModel - Load balancing settings for a backend pool

type LoadBalancingSettingsProperties 

type LoadBalancingSettingsProperties struct {
	// The additional latency in milliseconds for probes to fall into the lowest latency bucket
	AdditionalLatencyMilliseconds *int32 `json:"additionalLatencyMilliseconds,omitempty"`

	// The number of samples to consider for load balancing decisions
	SampleSize *int32 `json:"sampleSize,omitempty"`

	// The number of samples within the sample period that must succeed
	SuccessfulSamplesRequired *int32 `json:"successfulSamplesRequired,omitempty"`

	// READ-ONLY; Resource status.
	ResourceState *FrontDoorResourceState `json:"resourceState,omitempty" azure:"ro"`
}

LoadBalancingSettingsProperties - The JSON object that contains the properties required to create load balancing settings

type LoadBalancingSettingsUpdateParameters 

type LoadBalancingSettingsUpdateParameters struct {
	// The additional latency in milliseconds for probes to fall into the lowest latency bucket
	AdditionalLatencyMilliseconds *int32 `json:"additionalLatencyMilliseconds,omitempty"`

	// The number of samples to consider for load balancing decisions
	SampleSize *int32 `json:"sampleSize,omitempty"`

	// The number of samples within the sample period that must succeed
	SuccessfulSamplesRequired *int32 `json:"successfulSamplesRequired,omitempty"`
}

LoadBalancingSettingsUpdateParameters - Round-Robin load balancing settings for a backend pool

type ManagedRuleDefinition 

type ManagedRuleDefinition struct {
	// READ-ONLY; Describes the default action to be applied when the managed rule matches.
	DefaultAction *ActionType `json:"defaultAction,omitempty" azure:"ro"`

	// READ-ONLY; Describes the default state for the managed rule.
	DefaultState *ManagedRuleEnabledState `json:"defaultState,omitempty" azure:"ro"`

	// READ-ONLY; Describes the functionality of the managed rule.
	Description *string `json:"description,omitempty" azure:"ro"`

	// READ-ONLY; Identifier for the managed rule.
	RuleID *string `json:"ruleId,omitempty" azure:"ro"`
}

ManagedRuleDefinition - Describes a managed rule definition.

type ManagedRuleEnabledState 

type ManagedRuleEnabledState string

ManagedRuleEnabledState - Describes if the managed rule is in enabled or disabled state. 

const (
	ManagedRuleEnabledStateDisabled ManagedRuleEnabledState = "Disabled"
	ManagedRuleEnabledStateEnabled  ManagedRuleEnabledState = "Enabled"
)

func PossibleManagedRuleEnabledStateValues 

func PossibleManagedRuleEnabledStateValues() []ManagedRuleEnabledState

PossibleManagedRuleEnabledStateValues returns the possible values for the ManagedRuleEnabledState const type.

func (ManagedRuleEnabledState) ToPtr 

func (c ManagedRuleEnabledState) ToPtr() *ManagedRuleEnabledState

ToPtr returns a *ManagedRuleEnabledState pointing to the current value.

type ManagedRuleExclusion 

type ManagedRuleExclusion struct {
	// REQUIRED; The variable type to be excluded.
	MatchVariable *ManagedRuleExclusionMatchVariable `json:"matchVariable,omitempty"`

	// REQUIRED; Selector value for which elements in the collection this exclusion applies to.
	Selector *string `json:"selector,omitempty"`

	// REQUIRED; Comparison operator to apply to the selector when specifying which elements in the collection this exclusion
	// applies to.
	SelectorMatchOperator *ManagedRuleExclusionSelectorMatchOperator `json:"selectorMatchOperator,omitempty"`
}

ManagedRuleExclusion - Exclude variables from managed rule evaluation.

type ManagedRuleExclusionMatchVariable 

type ManagedRuleExclusionMatchVariable string

ManagedRuleExclusionMatchVariable - The variable type to be excluded. 

const (
	ManagedRuleExclusionMatchVariableQueryStringArgNames     ManagedRuleExclusionMatchVariable = "QueryStringArgNames"
	ManagedRuleExclusionMatchVariableRequestBodyJSONArgNames ManagedRuleExclusionMatchVariable = "RequestBodyJsonArgNames"
	ManagedRuleExclusionMatchVariableRequestBodyPostArgNames ManagedRuleExclusionMatchVariable = "RequestBodyPostArgNames"
	ManagedRuleExclusionMatchVariableRequestCookieNames      ManagedRuleExclusionMatchVariable = "RequestCookieNames"
	ManagedRuleExclusionMatchVariableRequestHeaderNames      ManagedRuleExclusionMatchVariable = "RequestHeaderNames"
)

func PossibleManagedRuleExclusionMatchVariableValues 

func PossibleManagedRuleExclusionMatchVariableValues() []ManagedRuleExclusionMatchVariable

PossibleManagedRuleExclusionMatchVariableValues returns the possible values for the ManagedRuleExclusionMatchVariable const type.

func (ManagedRuleExclusionMatchVariable) ToPtr 

func (c ManagedRuleExclusionMatchVariable) ToPtr() *ManagedRuleExclusionMatchVariable

ToPtr returns a *ManagedRuleExclusionMatchVariable pointing to the current value.

type ManagedRuleExclusionSelectorMatchOperator 

type ManagedRuleExclusionSelectorMatchOperator string

ManagedRuleExclusionSelectorMatchOperator - Comparison operator to apply to the selector when specifying which elements in the collection this exclusion applies to. 

const (
	ManagedRuleExclusionSelectorMatchOperatorContains   ManagedRuleExclusionSelectorMatchOperator = "Contains"
	ManagedRuleExclusionSelectorMatchOperatorEndsWith   ManagedRuleExclusionSelectorMatchOperator = "EndsWith"
	ManagedRuleExclusionSelectorMatchOperatorEquals     ManagedRuleExclusionSelectorMatchOperator = "Equals"
	ManagedRuleExclusionSelectorMatchOperatorEqualsAny  ManagedRuleExclusionSelectorMatchOperator = "EqualsAny"
	ManagedRuleExclusionSelectorMatchOperatorStartsWith ManagedRuleExclusionSelectorMatchOperator = "StartsWith"
)

func PossibleManagedRuleExclusionSelectorMatchOperatorValues 

func PossibleManagedRuleExclusionSelectorMatchOperatorValues() []ManagedRuleExclusionSelectorMatchOperator

PossibleManagedRuleExclusionSelectorMatchOperatorValues returns the possible values for the ManagedRuleExclusionSelectorMatchOperator const type.

func (ManagedRuleExclusionSelectorMatchOperator) ToPtr 

func (c ManagedRuleExclusionSelectorMatchOperator) ToPtr() *ManagedRuleExclusionSelectorMatchOperator

ToPtr returns a *ManagedRuleExclusionSelectorMatchOperator pointing to the current value.

type ManagedRuleGroupDefinition 

type ManagedRuleGroupDefinition struct {
	// READ-ONLY; Description of the managed rule group.
	Description *string `json:"description,omitempty" azure:"ro"`

	// READ-ONLY; Name of the managed rule group.
	RuleGroupName *string `json:"ruleGroupName,omitempty" azure:"ro"`

	// READ-ONLY; List of rules within the managed rule group.
	Rules []*ManagedRuleDefinition `json:"rules,omitempty" azure:"ro"`
}

ManagedRuleGroupDefinition - Describes a managed rule group.

func (ManagedRuleGroupDefinition) MarshalJSON 

func (m ManagedRuleGroupDefinition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleGroupDefinition.

type ManagedRuleGroupOverride 

type ManagedRuleGroupOverride struct {
	// REQUIRED; Describes the managed rule group to override.
	RuleGroupName *string `json:"ruleGroupName,omitempty"`

	// Describes the exclusions that are applied to all rules in the group.
	Exclusions []*ManagedRuleExclusion `json:"exclusions,omitempty"`

	// List of rules that will be disabled. If none specified, all rules in the group will be disabled.
	Rules []*ManagedRuleOverride `json:"rules,omitempty"`
}

ManagedRuleGroupOverride - Defines a managed rule group override setting.

func (ManagedRuleGroupOverride) MarshalJSON 

func (m ManagedRuleGroupOverride) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleGroupOverride.

type ManagedRuleOverride 

type ManagedRuleOverride struct {
	// REQUIRED; Identifier for the managed rule.
	RuleID *string `json:"ruleId,omitempty"`

	// Describes the override action to be applied when rule matches.
	Action *ActionType `json:"action,omitempty"`

	// Describes if the managed rule is in enabled or disabled state. Defaults to Disabled if not specified.
	EnabledState *ManagedRuleEnabledState `json:"enabledState,omitempty"`

	// Describes the exclusions that are applied to this specific rule.
	Exclusions []*ManagedRuleExclusion `json:"exclusions,omitempty"`
}

ManagedRuleOverride - Defines a managed rule group override setting.

func (ManagedRuleOverride) MarshalJSON 

func (m ManagedRuleOverride) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleOverride.

type ManagedRuleSet 

type ManagedRuleSet struct {
	// REQUIRED; Defines the rule set type to use.
	RuleSetType *string `json:"ruleSetType,omitempty"`

	// REQUIRED; Defines the version of the rule set to use.
	RuleSetVersion *string `json:"ruleSetVersion,omitempty"`

	// Describes the exclusions that are applied to all rules in the set.
	Exclusions []*ManagedRuleExclusion `json:"exclusions,omitempty"`

	// Defines the rule group overrides to apply to the rule set.
	RuleGroupOverrides []*ManagedRuleGroupOverride `json:"ruleGroupOverrides,omitempty"`

	// Defines the action to take when a managed rule set score threshold is met.
	RuleSetAction *ManagedRuleSetActionType `json:"ruleSetAction,omitempty"`
}

ManagedRuleSet - Defines a managed rule set.

func (ManagedRuleSet) MarshalJSON 

func (m ManagedRuleSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleSet.

type ManagedRuleSetActionType 

type ManagedRuleSetActionType string

ManagedRuleSetActionType - Defines the action to take when a managed rule set score threshold is met. 

const (
	ManagedRuleSetActionTypeBlock    ManagedRuleSetActionType = "Block"
	ManagedRuleSetActionTypeLog      ManagedRuleSetActionType = "Log"
	ManagedRuleSetActionTypeRedirect ManagedRuleSetActionType = "Redirect"
)

func PossibleManagedRuleSetActionTypeValues 

func PossibleManagedRuleSetActionTypeValues() []ManagedRuleSetActionType

PossibleManagedRuleSetActionTypeValues returns the possible values for the ManagedRuleSetActionType const type.

func (ManagedRuleSetActionType) ToPtr 

func (c ManagedRuleSetActionType) ToPtr() *ManagedRuleSetActionType

ToPtr returns a *ManagedRuleSetActionType pointing to the current value.

type ManagedRuleSetDefinition 

type ManagedRuleSetDefinition struct {
	// Resource location.
	Location *string `json:"location,omitempty"`

	// Properties for a managed rule set definition.
	Properties *ManagedRuleSetDefinitionProperties `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

ManagedRuleSetDefinition - Describes the a managed rule set definition.

func (ManagedRuleSetDefinition) MarshalJSON 

func (m ManagedRuleSetDefinition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleSetDefinition.

type ManagedRuleSetDefinitionList 

type ManagedRuleSetDefinitionList struct {
	// URL to retrieve next set of managed rule set definitions.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of managed rule set definitions.
	Value []*ManagedRuleSetDefinition `json:"value,omitempty" azure:"ro"`
}

ManagedRuleSetDefinitionList - List of managed rule set definitions available for use in a policy.

func (ManagedRuleSetDefinitionList) MarshalJSON 

func (m ManagedRuleSetDefinitionList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleSetDefinitionList.

type ManagedRuleSetDefinitionProperties 

type ManagedRuleSetDefinitionProperties struct {
	// READ-ONLY; Provisioning state of the managed rule set.
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; Rule groups of the managed rule set.
	RuleGroups []*ManagedRuleGroupDefinition `json:"ruleGroups,omitempty" azure:"ro"`

	// READ-ONLY; Id of the managed rule set.
	RuleSetID *string `json:"ruleSetId,omitempty" azure:"ro"`

	// READ-ONLY; Type of the managed rule set.
	RuleSetType *string `json:"ruleSetType,omitempty" azure:"ro"`

	// READ-ONLY; Version of the managed rule set type.
	RuleSetVersion *string `json:"ruleSetVersion,omitempty" azure:"ro"`
}

ManagedRuleSetDefinitionProperties - Properties for a managed rule set definition.

func (ManagedRuleSetDefinitionProperties) MarshalJSON 

func (m ManagedRuleSetDefinitionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleSetDefinitionProperties.

type ManagedRuleSetList 

type ManagedRuleSetList struct {
	// List of rule sets.
	ManagedRuleSets []*ManagedRuleSet `json:"managedRuleSets,omitempty"`
}

ManagedRuleSetList - Defines the list of managed rule sets for the policy.

func (ManagedRuleSetList) MarshalJSON 

func (m ManagedRuleSetList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleSetList.

type ManagedRuleSetsClient 

type ManagedRuleSetsClient struct {
	// contains filtered or unexported fields
}

ManagedRuleSetsClient contains the methods for the ManagedRuleSets group. Don't use this type directly, use NewManagedRuleSetsClient() instead.

func NewManagedRuleSetsClient 

func NewManagedRuleSetsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *ManagedRuleSetsClient

NewManagedRuleSetsClient creates a new instance of ManagedRuleSetsClient with the specified values. subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*ManagedRuleSetsClient) List 

func (client *ManagedRuleSetsClient) List(options *ManagedRuleSetsClientListOptions) *ManagedRuleSetsClientListPager

List - Lists all available managed rule sets. If the operation fails it returns an *azcore.ResponseError type. options - ManagedRuleSetsClientListOptions contains the optional parameters for the ManagedRuleSetsClient.List method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-11-01/examples/WafListManagedRuleSets.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewManagedRuleSetsClient("<subscription-id>", cred, nil)
	pager := client.List(nil)
	for {
		nextResult := pager.NextPage(ctx)
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		if !nextResult {
			break
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("Pager result: %#v\n", v)
		}
	}
}

Output:

type ManagedRuleSetsClientListOptions added in v0.2.0 

type ManagedRuleSetsClientListOptions struct {
}

ManagedRuleSetsClientListOptions contains the optional parameters for the ManagedRuleSetsClient.List method.

type ManagedRuleSetsClientListPager added in v0.2.0 

type ManagedRuleSetsClientListPager struct {
	// contains filtered or unexported fields
}

ManagedRuleSetsClientListPager provides operations for iterating over paged responses.

func (*ManagedRuleSetsClientListPager) Err added in v0.2.0 

func (p *ManagedRuleSetsClientListPager) Err() error

Err returns the last error encountered while paging.

func (*ManagedRuleSetsClientListPager) NextPage added in v0.2.0 

func (p *ManagedRuleSetsClientListPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*ManagedRuleSetsClientListPager) PageResponse added in v0.2.0 

func (p *ManagedRuleSetsClientListPager) PageResponse() ManagedRuleSetsClientListResponse

PageResponse returns the current ManagedRuleSetsClientListResponse page.

type ManagedRuleSetsClientListResponse added in v0.2.0 

type ManagedRuleSetsClientListResponse struct {
	ManagedRuleSetsClientListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

ManagedRuleSetsClientListResponse contains the response from method ManagedRuleSetsClient.List.

type ManagedRuleSetsClientListResult added in v0.2.0 

type ManagedRuleSetsClientListResult struct {
	ManagedRuleSetDefinitionList
}

ManagedRuleSetsClientListResult contains the result from method ManagedRuleSetsClient.List.

type MatchCondition 

type MatchCondition struct {
	// REQUIRED; List of possible match values.
	MatchValue []*string `json:"matchValue,omitempty"`

	// REQUIRED; Request variable to compare with.
	MatchVariable *MatchVariable `json:"matchVariable,omitempty"`

	// REQUIRED; Comparison type to use for matching with the variable value.
	Operator *Operator `json:"operator,omitempty"`

	// Describes if the result of this condition should be negated.
	NegateCondition *bool `json:"negateCondition,omitempty"`

	// Match against a specific key from the QueryString, PostArgs, RequestHeader or Cookies variables. Default is null.
	Selector *string `json:"selector,omitempty"`

	// List of transforms.
	Transforms []*TransformType `json:"transforms,omitempty"`
}

MatchCondition - Define a match condition.

func (MatchCondition) MarshalJSON 

func (m MatchCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MatchCondition.

type MatchProcessingBehavior 

type MatchProcessingBehavior string

MatchProcessingBehavior - If this rule is a match should the rules engine continue running the remaining rules or stop. If not present, defaults to Continue. 

const (
	MatchProcessingBehaviorContinue MatchProcessingBehavior = "Continue"
	MatchProcessingBehaviorStop     MatchProcessingBehavior = "Stop"
)

func PossibleMatchProcessingBehaviorValues 

func PossibleMatchProcessingBehaviorValues() []MatchProcessingBehavior

PossibleMatchProcessingBehaviorValues returns the possible values for the MatchProcessingBehavior const type.

func (MatchProcessingBehavior) ToPtr 

func (c MatchProcessingBehavior) ToPtr() *MatchProcessingBehavior

ToPtr returns a *MatchProcessingBehavior pointing to the current value.

type MatchVariable 

type MatchVariable string

MatchVariable - Request variable to compare with. 

const (
	MatchVariableCookies       MatchVariable = "Cookies"
	MatchVariablePostArgs      MatchVariable = "PostArgs"
	MatchVariableQueryString   MatchVariable = "QueryString"
	MatchVariableRemoteAddr    MatchVariable = "RemoteAddr"
	MatchVariableRequestBody   MatchVariable = "RequestBody"
	MatchVariableRequestHeader MatchVariable = "RequestHeader"
	MatchVariableRequestMethod MatchVariable = "RequestMethod"
	MatchVariableRequestURI    MatchVariable = "RequestUri"
	MatchVariableSocketAddr    MatchVariable = "SocketAddr"
)

func PossibleMatchVariableValues 

func PossibleMatchVariableValues() []MatchVariable

PossibleMatchVariableValues returns the possible values for the MatchVariable const type.

func (MatchVariable) ToPtr 

func (c MatchVariable) ToPtr() *MatchVariable

ToPtr returns a *MatchVariable pointing to the current value.

type MinimumTLSVersion 

type MinimumTLSVersion string

MinimumTLSVersion - The minimum TLS version required from the clients to establish an SSL handshake with Front Door. 

const (
	MinimumTLSVersionOne0 MinimumTLSVersion = "1.0"
	MinimumTLSVersionOne2 MinimumTLSVersion = "1.2"
)

func PossibleMinimumTLSVersionValues 

func PossibleMinimumTLSVersionValues() []MinimumTLSVersion

PossibleMinimumTLSVersionValues returns the possible values for the MinimumTLSVersion const type.

func (MinimumTLSVersion) ToPtr 

func (c MinimumTLSVersion) ToPtr() *MinimumTLSVersion

ToPtr returns a *MinimumTLSVersion pointing to the current value.

type NameAvailabilityClient added in v0.2.0 

type NameAvailabilityClient struct {
	// contains filtered or unexported fields
}

NameAvailabilityClient contains the methods for the FrontDoorNameAvailability group. Don't use this type directly, use NewNameAvailabilityClient() instead.

func NewNameAvailabilityClient added in v0.2.0 

func NewNameAvailabilityClient(credential azcore.TokenCredential, options *arm.ClientOptions) *NameAvailabilityClient

NewNameAvailabilityClient creates a new instance of NameAvailabilityClient with the specified values. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*NameAvailabilityClient) Check added in v0.2.0 

func (client *NameAvailabilityClient) Check(ctx context.Context, checkFrontDoorNameAvailabilityInput CheckNameAvailabilityInput, options *NameAvailabilityClientCheckOptions) (NameAvailabilityClientCheckResponse, error)

Check - Check the availability of a Front Door resource name. If the operation fails it returns an *azcore.ResponseError type. checkFrontDoorNameAvailabilityInput - Input to check. options - NameAvailabilityClientCheckOptions contains the optional parameters for the NameAvailabilityClient.Check method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/CheckFrontdoorNameAvailability.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewNameAvailabilityClient(cred, nil)
	res, err := client.Check(ctx,
		armfrontdoor.CheckNameAvailabilityInput{
			Name: to.StringPtr("<name>"),
			Type: armfrontdoor.ResourceTypeMicrosoftNetworkFrontDoors.ToPtr(),
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.NameAvailabilityClientCheckResult)
}

Output:

type NameAvailabilityClientCheckOptions added in v0.2.0 

type NameAvailabilityClientCheckOptions struct {
}

NameAvailabilityClientCheckOptions contains the optional parameters for the NameAvailabilityClient.Check method.

type NameAvailabilityClientCheckResponse added in v0.2.0 

type NameAvailabilityClientCheckResponse struct {
	NameAvailabilityClientCheckResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NameAvailabilityClientCheckResponse contains the response from method NameAvailabilityClient.Check.

type NameAvailabilityClientCheckResult added in v0.2.0 

type NameAvailabilityClientCheckResult struct {
	CheckNameAvailabilityOutput
}

NameAvailabilityClientCheckResult contains the result from method NameAvailabilityClient.Check.

type NameAvailabilityWithSubscriptionClient added in v0.2.0 

type NameAvailabilityWithSubscriptionClient struct {
	// contains filtered or unexported fields
}

NameAvailabilityWithSubscriptionClient contains the methods for the FrontDoorNameAvailabilityWithSubscription group. Don't use this type directly, use NewNameAvailabilityWithSubscriptionClient() instead.

func NewNameAvailabilityWithSubscriptionClient added in v0.2.0 

func NewNameAvailabilityWithSubscriptionClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *NameAvailabilityWithSubscriptionClient

NewNameAvailabilityWithSubscriptionClient creates a new instance of NameAvailabilityWithSubscriptionClient with the specified values. subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*NameAvailabilityWithSubscriptionClient) Check added in v0.2.0 

func (client *NameAvailabilityWithSubscriptionClient) Check(ctx context.Context, checkFrontDoorNameAvailabilityInput CheckNameAvailabilityInput, options *NameAvailabilityWithSubscriptionClientCheckOptions) (NameAvailabilityWithSubscriptionClientCheckResponse, error)

Check - Check the availability of a Front Door subdomain. If the operation fails it returns an *azcore.ResponseError type. checkFrontDoorNameAvailabilityInput - Input to check. options - NameAvailabilityWithSubscriptionClientCheckOptions contains the optional parameters for the NameAvailabilityWithSubscriptionClient.Check method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/CheckFrontdoorNameAvailabilityWithSubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewNameAvailabilityWithSubscriptionClient("<subscription-id>", cred, nil)
	res, err := client.Check(ctx,
		armfrontdoor.CheckNameAvailabilityInput{
			Name: to.StringPtr("<name>"),
			Type: armfrontdoor.ResourceTypeMicrosoftNetworkFrontDoorsFrontendEndpoints.ToPtr(),
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.NameAvailabilityWithSubscriptionClientCheckResult)
}

Output:

type NameAvailabilityWithSubscriptionClientCheckOptions added in v0.2.0 

type NameAvailabilityWithSubscriptionClientCheckOptions struct {
}

NameAvailabilityWithSubscriptionClientCheckOptions contains the optional parameters for the NameAvailabilityWithSubscriptionClient.Check method.

type NameAvailabilityWithSubscriptionClientCheckResponse added in v0.2.0 

type NameAvailabilityWithSubscriptionClientCheckResponse struct {
	NameAvailabilityWithSubscriptionClientCheckResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NameAvailabilityWithSubscriptionClientCheckResponse contains the response from method NameAvailabilityWithSubscriptionClient.Check.

type NameAvailabilityWithSubscriptionClientCheckResult added in v0.2.0 

type NameAvailabilityWithSubscriptionClientCheckResult struct {
	CheckNameAvailabilityOutput
}

NameAvailabilityWithSubscriptionClientCheckResult contains the result from method NameAvailabilityWithSubscriptionClient.Check.

type NetworkExperimentProfilesClient 

type NetworkExperimentProfilesClient struct {
	// contains filtered or unexported fields
}

NetworkExperimentProfilesClient contains the methods for the NetworkExperimentProfiles group. Don't use this type directly, use NewNetworkExperimentProfilesClient() instead.

func NewNetworkExperimentProfilesClient 

func NewNetworkExperimentProfilesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *NetworkExperimentProfilesClient

NewNetworkExperimentProfilesClient creates a new instance of NetworkExperimentProfilesClient with the specified values. subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*NetworkExperimentProfilesClient) BeginCreateOrUpdate 

func (client *NetworkExperimentProfilesClient) BeginCreateOrUpdate(ctx context.Context, profileName string, resourceGroupName string, parameters Profile, options *NetworkExperimentProfilesClientBeginCreateOrUpdateOptions) (NetworkExperimentProfilesClientCreateOrUpdatePollerResponse, error)

BeginCreateOrUpdate - Creates an NetworkExperiment Profile If the operation fails it returns an *azcore.ResponseError type. profileName - The Profile identifier associated with the Tenant and Partner resourceGroupName - Name of the Resource group within the Azure subscription. parameters - An Network Experiment Profile options - NetworkExperimentProfilesClientBeginCreateOrUpdateOptions contains the optional parameters for the NetworkExperimentProfilesClient.BeginCreateOrUpdate method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentCreateProfile.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewNetworkExperimentProfilesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreateOrUpdate(ctx,
		"<profile-name>",
		"<resource-group-name>",
		armfrontdoor.Profile{
			Location: to.StringPtr("<location>"),
			Properties: &armfrontdoor.ProfileProperties{
				EnabledState: armfrontdoor.State("Enabled").ToPtr(),
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.NetworkExperimentProfilesClientCreateOrUpdateResult)
}

Output:

func (*NetworkExperimentProfilesClient) BeginDelete 

func (client *NetworkExperimentProfilesClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, options *NetworkExperimentProfilesClientBeginDeleteOptions) (NetworkExperimentProfilesClientDeletePollerResponse, error)

BeginDelete - Deletes an NetworkExperiment Profile by ProfileName If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. profileName - The Profile identifier associated with the Tenant and Partner options - NetworkExperimentProfilesClientBeginDeleteOptions contains the optional parameters for the NetworkExperimentProfilesClient.BeginDelete method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentDeleteProfile.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewNetworkExperimentProfilesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<profile-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*NetworkExperimentProfilesClient) BeginUpdate 

func (client *NetworkExperimentProfilesClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, parameters ProfileUpdateModel, options *NetworkExperimentProfilesClientBeginUpdateOptions) (NetworkExperimentProfilesClientUpdatePollerResponse, error)

BeginUpdate - Updates an NetworkExperimentProfiles If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. profileName - The Profile identifier associated with the Tenant and Partner parameters - The Profile Update Model options - NetworkExperimentProfilesClientBeginUpdateOptions contains the optional parameters for the NetworkExperimentProfilesClient.BeginUpdate method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentUpdateProfile.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewNetworkExperimentProfilesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginUpdate(ctx,
		"<resource-group-name>",
		"<profile-name>",
		armfrontdoor.ProfileUpdateModel{
			Properties: &armfrontdoor.ProfileUpdateProperties{
				EnabledState: armfrontdoor.State("Enabled").ToPtr(),
			},
			Tags: map[string]*string{
				"key1": to.StringPtr("value1"),
				"key2": to.StringPtr("value2"),
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.NetworkExperimentProfilesClientUpdateResult)
}

Output:

func (*NetworkExperimentProfilesClient) Get 

func (client *NetworkExperimentProfilesClient) Get(ctx context.Context, resourceGroupName string, profileName string, options *NetworkExperimentProfilesClientGetOptions) (NetworkExperimentProfilesClientGetResponse, error)

Get - Gets an NetworkExperiment Profile by ProfileName If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. profileName - The Profile identifier associated with the Tenant and Partner options - NetworkExperimentProfilesClientGetOptions contains the optional parameters for the NetworkExperimentProfilesClient.Get method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentGetProfile.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewNetworkExperimentProfilesClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<profile-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.NetworkExperimentProfilesClientGetResult)
}

Output:

func (*NetworkExperimentProfilesClient) List 

func (client *NetworkExperimentProfilesClient) List(options *NetworkExperimentProfilesClientListOptions) *NetworkExperimentProfilesClientListPager

List - Gets a list of Network Experiment Profiles under a subscription If the operation fails it returns an *azcore.ResponseError type. options - NetworkExperimentProfilesClientListOptions contains the optional parameters for the NetworkExperimentProfilesClient.List method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentListProfiles.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewNetworkExperimentProfilesClient("<subscription-id>", cred, nil)
	pager := client.List(nil)
	for {
		nextResult := pager.NextPage(ctx)
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		if !nextResult {
			break
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("Pager result: %#v\n", v)
		}
	}
}

Output:

func (*NetworkExperimentProfilesClient) ListByResourceGroup 

func (client *NetworkExperimentProfilesClient) ListByResourceGroup(resourceGroupName string, options *NetworkExperimentProfilesClientListByResourceGroupOptions) *NetworkExperimentProfilesClientListByResourceGroupPager

ListByResourceGroup - Gets a list of Network Experiment Profiles within a resource group under a subscription If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. options - NetworkExperimentProfilesClientListByResourceGroupOptions contains the optional parameters for the NetworkExperimentProfilesClient.ListByResourceGroup method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentListProfiles.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewNetworkExperimentProfilesClient("<subscription-id>", cred, nil)
	pager := client.ListByResourceGroup("<resource-group-name>",
		nil)
	for {
		nextResult := pager.NextPage(ctx)
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		if !nextResult {
			break
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("Pager result: %#v\n", v)
		}
	}
}

Output:

type NetworkExperimentProfilesClientBeginCreateOrUpdateOptions added in v0.2.0 

type NetworkExperimentProfilesClientBeginCreateOrUpdateOptions struct {
}

NetworkExperimentProfilesClientBeginCreateOrUpdateOptions contains the optional parameters for the NetworkExperimentProfilesClient.BeginCreateOrUpdate method.

type NetworkExperimentProfilesClientBeginDeleteOptions added in v0.2.0 

type NetworkExperimentProfilesClientBeginDeleteOptions struct {
}

NetworkExperimentProfilesClientBeginDeleteOptions contains the optional parameters for the NetworkExperimentProfilesClient.BeginDelete method.

type NetworkExperimentProfilesClientBeginUpdateOptions added in v0.2.0 

type NetworkExperimentProfilesClientBeginUpdateOptions struct {
}

NetworkExperimentProfilesClientBeginUpdateOptions contains the optional parameters for the NetworkExperimentProfilesClient.BeginUpdate method.

type NetworkExperimentProfilesClientCreateOrUpdatePoller added in v0.2.0 

type NetworkExperimentProfilesClientCreateOrUpdatePoller struct {
	// contains filtered or unexported fields
}

NetworkExperimentProfilesClientCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*NetworkExperimentProfilesClientCreateOrUpdatePoller) Done added in v0.2.0 

func (p *NetworkExperimentProfilesClientCreateOrUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*NetworkExperimentProfilesClientCreateOrUpdatePoller) FinalResponse added in v0.2.0 

func (p *NetworkExperimentProfilesClientCreateOrUpdatePoller) FinalResponse(ctx context.Context) (NetworkExperimentProfilesClientCreateOrUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final NetworkExperimentProfilesClientCreateOrUpdateResponse will be returned.

func (*NetworkExperimentProfilesClientCreateOrUpdatePoller) Poll added in v0.2.0 

func (p *NetworkExperimentProfilesClientCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*NetworkExperimentProfilesClientCreateOrUpdatePoller) ResumeToken added in v0.2.0 

func (p *NetworkExperimentProfilesClientCreateOrUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type NetworkExperimentProfilesClientCreateOrUpdatePollerResponse added in v0.2.0 

type NetworkExperimentProfilesClientCreateOrUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *NetworkExperimentProfilesClientCreateOrUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetworkExperimentProfilesClientCreateOrUpdatePollerResponse contains the response from method NetworkExperimentProfilesClient.CreateOrUpdate.

func (NetworkExperimentProfilesClientCreateOrUpdatePollerResponse) PollUntilDone added in v0.2.0 

func (l NetworkExperimentProfilesClientCreateOrUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (NetworkExperimentProfilesClientCreateOrUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*NetworkExperimentProfilesClientCreateOrUpdatePollerResponse) Resume added in v0.2.0 

func (l *NetworkExperimentProfilesClientCreateOrUpdatePollerResponse) Resume(ctx context.Context, client *NetworkExperimentProfilesClient, token string) error

Resume rehydrates a NetworkExperimentProfilesClientCreateOrUpdatePollerResponse from the provided client and resume token.

type NetworkExperimentProfilesClientCreateOrUpdateResponse added in v0.2.0 

type NetworkExperimentProfilesClientCreateOrUpdateResponse struct {
	NetworkExperimentProfilesClientCreateOrUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetworkExperimentProfilesClientCreateOrUpdateResponse contains the response from method NetworkExperimentProfilesClient.CreateOrUpdate.

type NetworkExperimentProfilesClientCreateOrUpdateResult added in v0.2.0 

type NetworkExperimentProfilesClientCreateOrUpdateResult struct {
	Profile
}

NetworkExperimentProfilesClientCreateOrUpdateResult contains the result from method NetworkExperimentProfilesClient.CreateOrUpdate.

type NetworkExperimentProfilesClientDeletePoller added in v0.2.0 

type NetworkExperimentProfilesClientDeletePoller struct {
	// contains filtered or unexported fields
}

NetworkExperimentProfilesClientDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*NetworkExperimentProfilesClientDeletePoller) Done added in v0.2.0 

func (p *NetworkExperimentProfilesClientDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*NetworkExperimentProfilesClientDeletePoller) FinalResponse added in v0.2.0 

func (p *NetworkExperimentProfilesClientDeletePoller) FinalResponse(ctx context.Context) (NetworkExperimentProfilesClientDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final NetworkExperimentProfilesClientDeleteResponse will be returned.

func (*NetworkExperimentProfilesClientDeletePoller) Poll added in v0.2.0 

func (p *NetworkExperimentProfilesClientDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*NetworkExperimentProfilesClientDeletePoller) ResumeToken added in v0.2.0 

func (p *NetworkExperimentProfilesClientDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type NetworkExperimentProfilesClientDeletePollerResponse added in v0.2.0 

type NetworkExperimentProfilesClientDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *NetworkExperimentProfilesClientDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetworkExperimentProfilesClientDeletePollerResponse contains the response from method NetworkExperimentProfilesClient.Delete.

func (NetworkExperimentProfilesClientDeletePollerResponse) PollUntilDone added in v0.2.0 

func (l NetworkExperimentProfilesClientDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (NetworkExperimentProfilesClientDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*NetworkExperimentProfilesClientDeletePollerResponse) Resume added in v0.2.0 

func (l *NetworkExperimentProfilesClientDeletePollerResponse) Resume(ctx context.Context, client *NetworkExperimentProfilesClient, token string) error

Resume rehydrates a NetworkExperimentProfilesClientDeletePollerResponse from the provided client and resume token.

type NetworkExperimentProfilesClientDeleteResponse added in v0.2.0 

type NetworkExperimentProfilesClientDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetworkExperimentProfilesClientDeleteResponse contains the response from method NetworkExperimentProfilesClient.Delete.

type NetworkExperimentProfilesClientGetOptions added in v0.2.0 

type NetworkExperimentProfilesClientGetOptions struct {
}

NetworkExperimentProfilesClientGetOptions contains the optional parameters for the NetworkExperimentProfilesClient.Get method.

type NetworkExperimentProfilesClientGetResponse added in v0.2.0 

type NetworkExperimentProfilesClientGetResponse struct {
	NetworkExperimentProfilesClientGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetworkExperimentProfilesClientGetResponse contains the response from method NetworkExperimentProfilesClient.Get.

type NetworkExperimentProfilesClientGetResult added in v0.2.0 

type NetworkExperimentProfilesClientGetResult struct {
	Profile
}

NetworkExperimentProfilesClientGetResult contains the result from method NetworkExperimentProfilesClient.Get.

type NetworkExperimentProfilesClientListByResourceGroupOptions added in v0.2.0 

type NetworkExperimentProfilesClientListByResourceGroupOptions struct {
}

NetworkExperimentProfilesClientListByResourceGroupOptions contains the optional parameters for the NetworkExperimentProfilesClient.ListByResourceGroup method.

type NetworkExperimentProfilesClientListByResourceGroupPager added in v0.2.0 

type NetworkExperimentProfilesClientListByResourceGroupPager struct {
	// contains filtered or unexported fields
}

NetworkExperimentProfilesClientListByResourceGroupPager provides operations for iterating over paged responses.

func (*NetworkExperimentProfilesClientListByResourceGroupPager) Err added in v0.2.0 

func (p *NetworkExperimentProfilesClientListByResourceGroupPager) Err() error

Err returns the last error encountered while paging.

func (*NetworkExperimentProfilesClientListByResourceGroupPager) NextPage added in v0.2.0 

func (p *NetworkExperimentProfilesClientListByResourceGroupPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*NetworkExperimentProfilesClientListByResourceGroupPager) PageResponse added in v0.2.0 

func (p *NetworkExperimentProfilesClientListByResourceGroupPager) PageResponse() NetworkExperimentProfilesClientListByResourceGroupResponse

PageResponse returns the current NetworkExperimentProfilesClientListByResourceGroupResponse page.

type NetworkExperimentProfilesClientListByResourceGroupResponse added in v0.2.0 

type NetworkExperimentProfilesClientListByResourceGroupResponse struct {
	NetworkExperimentProfilesClientListByResourceGroupResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetworkExperimentProfilesClientListByResourceGroupResponse contains the response from method NetworkExperimentProfilesClient.ListByResourceGroup.

type NetworkExperimentProfilesClientListByResourceGroupResult added in v0.2.0 

type NetworkExperimentProfilesClientListByResourceGroupResult struct {
	ProfileList
}

NetworkExperimentProfilesClientListByResourceGroupResult contains the result from method NetworkExperimentProfilesClient.ListByResourceGroup.

type NetworkExperimentProfilesClientListOptions added in v0.2.0 

type NetworkExperimentProfilesClientListOptions struct {
}

NetworkExperimentProfilesClientListOptions contains the optional parameters for the NetworkExperimentProfilesClient.List method.

type NetworkExperimentProfilesClientListPager added in v0.2.0 

type NetworkExperimentProfilesClientListPager struct {
	// contains filtered or unexported fields
}

NetworkExperimentProfilesClientListPager provides operations for iterating over paged responses.

func (*NetworkExperimentProfilesClientListPager) Err added in v0.2.0 

func (p *NetworkExperimentProfilesClientListPager) Err() error

Err returns the last error encountered while paging.

func (*NetworkExperimentProfilesClientListPager) NextPage added in v0.2.0 

func (p *NetworkExperimentProfilesClientListPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*NetworkExperimentProfilesClientListPager) PageResponse added in v0.2.0 

func (p *NetworkExperimentProfilesClientListPager) PageResponse() NetworkExperimentProfilesClientListResponse

PageResponse returns the current NetworkExperimentProfilesClientListResponse page.

type NetworkExperimentProfilesClientListResponse added in v0.2.0 

type NetworkExperimentProfilesClientListResponse struct {
	NetworkExperimentProfilesClientListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetworkExperimentProfilesClientListResponse contains the response from method NetworkExperimentProfilesClient.List.

type NetworkExperimentProfilesClientListResult added in v0.2.0 

type NetworkExperimentProfilesClientListResult struct {
	ProfileList
}

NetworkExperimentProfilesClientListResult contains the result from method NetworkExperimentProfilesClient.List.

type NetworkExperimentProfilesClientUpdatePoller added in v0.2.0 

type NetworkExperimentProfilesClientUpdatePoller struct {
	// contains filtered or unexported fields
}

NetworkExperimentProfilesClientUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*NetworkExperimentProfilesClientUpdatePoller) Done added in v0.2.0 

func (p *NetworkExperimentProfilesClientUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*NetworkExperimentProfilesClientUpdatePoller) FinalResponse added in v0.2.0 

func (p *NetworkExperimentProfilesClientUpdatePoller) FinalResponse(ctx context.Context) (NetworkExperimentProfilesClientUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final NetworkExperimentProfilesClientUpdateResponse will be returned.

func (*NetworkExperimentProfilesClientUpdatePoller) Poll added in v0.2.0 

func (p *NetworkExperimentProfilesClientUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*NetworkExperimentProfilesClientUpdatePoller) ResumeToken added in v0.2.0 

func (p *NetworkExperimentProfilesClientUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type NetworkExperimentProfilesClientUpdatePollerResponse added in v0.2.0 

type NetworkExperimentProfilesClientUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *NetworkExperimentProfilesClientUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetworkExperimentProfilesClientUpdatePollerResponse contains the response from method NetworkExperimentProfilesClient.Update.

func (NetworkExperimentProfilesClientUpdatePollerResponse) PollUntilDone added in v0.2.0 

func (l NetworkExperimentProfilesClientUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (NetworkExperimentProfilesClientUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*NetworkExperimentProfilesClientUpdatePollerResponse) Resume added in v0.2.0 

func (l *NetworkExperimentProfilesClientUpdatePollerResponse) Resume(ctx context.Context, client *NetworkExperimentProfilesClient, token string) error

Resume rehydrates a NetworkExperimentProfilesClientUpdatePollerResponse from the provided client and resume token.

type NetworkExperimentProfilesClientUpdateResponse added in v0.2.0 

type NetworkExperimentProfilesClientUpdateResponse struct {
	NetworkExperimentProfilesClientUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetworkExperimentProfilesClientUpdateResponse contains the response from method NetworkExperimentProfilesClient.Update.

type NetworkExperimentProfilesClientUpdateResult added in v0.2.0 

type NetworkExperimentProfilesClientUpdateResult struct {
	Profile
}

NetworkExperimentProfilesClientUpdateResult contains the result from method NetworkExperimentProfilesClient.Update.

type NetworkExperimentResourceState 

type NetworkExperimentResourceState string

NetworkExperimentResourceState - Defines the server side resource status 

const (
	NetworkExperimentResourceStateCreating  NetworkExperimentResourceState = "Creating"
	NetworkExperimentResourceStateDeleting  NetworkExperimentResourceState = "Deleting"
	NetworkExperimentResourceStateDisabled  NetworkExperimentResourceState = "Disabled"
	NetworkExperimentResourceStateDisabling NetworkExperimentResourceState = "Disabling"
	NetworkExperimentResourceStateEnabled   NetworkExperimentResourceState = "Enabled"
	NetworkExperimentResourceStateEnabling  NetworkExperimentResourceState = "Enabling"
)

func PossibleNetworkExperimentResourceStateValues 

func PossibleNetworkExperimentResourceStateValues() []NetworkExperimentResourceState

PossibleNetworkExperimentResourceStateValues returns the possible values for the NetworkExperimentResourceState const type.

func (NetworkExperimentResourceState) ToPtr 

func (c NetworkExperimentResourceState) ToPtr() *NetworkExperimentResourceState

ToPtr returns a *NetworkExperimentResourceState pointing to the current value.

type NetworkOperationStatus 

type NetworkOperationStatus string

NetworkOperationStatus - Status of the Azure async operation. Possible values are: 'InProgress', 'Succeeded', and 'Failed'. 

const (
	NetworkOperationStatusFailed     NetworkOperationStatus = "Failed"
	NetworkOperationStatusInProgress NetworkOperationStatus = "InProgress"
	NetworkOperationStatusSucceeded  NetworkOperationStatus = "Succeeded"
)

func PossibleNetworkOperationStatusValues 

func PossibleNetworkOperationStatusValues() []NetworkOperationStatus

PossibleNetworkOperationStatusValues returns the possible values for the NetworkOperationStatus const type.

func (NetworkOperationStatus) ToPtr 

func (c NetworkOperationStatus) ToPtr() *NetworkOperationStatus

ToPtr returns a *NetworkOperationStatus pointing to the current value.

type Operator 

type Operator string

Operator - Comparison type to use for matching with the variable value. 

const (
	OperatorAny                Operator = "Any"
	OperatorBeginsWith         Operator = "BeginsWith"
	OperatorContains           Operator = "Contains"
	OperatorEndsWith           Operator = "EndsWith"
	OperatorEqual              Operator = "Equal"
	OperatorGeoMatch           Operator = "GeoMatch"
	OperatorGreaterThan        Operator = "GreaterThan"
	OperatorGreaterThanOrEqual Operator = "GreaterThanOrEqual"
	OperatorIPMatch            Operator = "IPMatch"
	OperatorLessThan           Operator = "LessThan"
	OperatorLessThanOrEqual    Operator = "LessThanOrEqual"
	OperatorRegEx              Operator = "RegEx"
)

func PossibleOperatorValues 

func PossibleOperatorValues() []Operator

PossibleOperatorValues returns the possible values for the Operator const type.

func (Operator) ToPtr 

func (c Operator) ToPtr() *Operator

ToPtr returns a *Operator pointing to the current value.

type PoliciesClient 

type PoliciesClient struct {
	// contains filtered or unexported fields
}

PoliciesClient contains the methods for the Policies group. Don't use this type directly, use NewPoliciesClient() instead.

func NewPoliciesClient 

func NewPoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *PoliciesClient

NewPoliciesClient creates a new instance of PoliciesClient with the specified values. subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*PoliciesClient) BeginCreateOrUpdate 

func (client *PoliciesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, policyName string, parameters WebApplicationFirewallPolicy, options *PoliciesClientBeginCreateOrUpdateOptions) (PoliciesClientCreateOrUpdatePollerResponse, error)

BeginCreateOrUpdate - Create or update policy with specified rule set name within a resource group. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. policyName - The name of the Web Application Firewall Policy. parameters - Policy to be created. options - PoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the PoliciesClient.BeginCreateOrUpdate method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-11-01/examples/WafPolicyCreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewPoliciesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreateOrUpdate(ctx,
		"<resource-group-name>",
		"<policy-name>",
		armfrontdoor.WebApplicationFirewallPolicy{
			Properties: &armfrontdoor.WebApplicationFirewallPolicyProperties{
				CustomRules: &armfrontdoor.CustomRuleList{
					Rules: []*armfrontdoor.CustomRule{
						{
							Name:   to.StringPtr("<name>"),
							Action: armfrontdoor.ActionType("Block").ToPtr(),
							MatchConditions: []*armfrontdoor.MatchCondition{
								{
									MatchValue: []*string{
										to.StringPtr("192.168.1.0/24"),
										to.StringPtr("10.0.0.0/24")},
									MatchVariable: armfrontdoor.MatchVariable("RemoteAddr").ToPtr(),
									Operator:      armfrontdoor.Operator("IPMatch").ToPtr(),
								}},
							Priority:           to.Int32Ptr(1),
							RateLimitThreshold: to.Int32Ptr(1000),
							RuleType:           armfrontdoor.RuleType("RateLimitRule").ToPtr(),
						},
						{
							Name:   to.StringPtr("<name>"),
							Action: armfrontdoor.ActionType("Block").ToPtr(),
							MatchConditions: []*armfrontdoor.MatchCondition{
								{
									MatchValue: []*string{
										to.StringPtr("CH")},
									MatchVariable: armfrontdoor.MatchVariable("RemoteAddr").ToPtr(),
									Operator:      armfrontdoor.Operator("GeoMatch").ToPtr(),
								},
								{
									MatchValue: []*string{
										to.StringPtr("windows")},
									MatchVariable: armfrontdoor.MatchVariable("RequestHeader").ToPtr(),
									Operator:      armfrontdoor.Operator("Contains").ToPtr(),
									Selector:      to.StringPtr("<selector>"),
									Transforms: []*armfrontdoor.TransformType{
										armfrontdoor.TransformType("Lowercase").ToPtr()},
								}},
							Priority: to.Int32Ptr(2),
							RuleType: armfrontdoor.RuleType("MatchRule").ToPtr(),
						}},
				},
				ManagedRules: &armfrontdoor.ManagedRuleSetList{
					ManagedRuleSets: []*armfrontdoor.ManagedRuleSet{
						{
							Exclusions: []*armfrontdoor.ManagedRuleExclusion{
								{
									MatchVariable:         armfrontdoor.ManagedRuleExclusionMatchVariable("RequestHeaderNames").ToPtr(),
									Selector:              to.StringPtr("<selector>"),
									SelectorMatchOperator: armfrontdoor.ManagedRuleExclusionSelectorMatchOperator("Equals").ToPtr(),
								}},
							RuleGroupOverrides: []*armfrontdoor.ManagedRuleGroupOverride{
								{
									Exclusions: []*armfrontdoor.ManagedRuleExclusion{
										{
											MatchVariable:         armfrontdoor.ManagedRuleExclusionMatchVariable("RequestCookieNames").ToPtr(),
											Selector:              to.StringPtr("<selector>"),
											SelectorMatchOperator: armfrontdoor.ManagedRuleExclusionSelectorMatchOperator("StartsWith").ToPtr(),
										}},
									RuleGroupName: to.StringPtr("<rule-group-name>"),
									Rules: []*armfrontdoor.ManagedRuleOverride{
										{
											Action:       armfrontdoor.ActionType("Redirect").ToPtr(),
											EnabledState: armfrontdoor.ManagedRuleEnabledState("Enabled").ToPtr(),
											Exclusions: []*armfrontdoor.ManagedRuleExclusion{
												{
													MatchVariable:         armfrontdoor.ManagedRuleExclusionMatchVariable("QueryStringArgNames").ToPtr(),
													Selector:              to.StringPtr("<selector>"),
													SelectorMatchOperator: armfrontdoor.ManagedRuleExclusionSelectorMatchOperator("Equals").ToPtr(),
												}},
											RuleID: to.StringPtr("<rule-id>"),
										},
										{
											EnabledState: armfrontdoor.ManagedRuleEnabledState("Disabled").ToPtr(),
											RuleID:       to.StringPtr("<rule-id>"),
										}},
								}},
							RuleSetAction:  armfrontdoor.ManagedRuleSetActionType("Block").ToPtr(),
							RuleSetType:    to.StringPtr("<rule-set-type>"),
							RuleSetVersion: to.StringPtr("<rule-set-version>"),
						}},
				},
				PolicySettings: &armfrontdoor.PolicySettings{
					CustomBlockResponseBody:       to.StringPtr("<custom-block-response-body>"),
					CustomBlockResponseStatusCode: to.Int32Ptr(499),
					EnabledState:                  armfrontdoor.PolicyEnabledState("Enabled").ToPtr(),
					Mode:                          armfrontdoor.PolicyMode("Prevention").ToPtr(),
					RedirectURL:                   to.StringPtr("<redirect-url>"),
					RequestBodyCheck:              armfrontdoor.PolicyRequestBodyCheck("Disabled").ToPtr(),
				},
			},
			SKU: &armfrontdoor.SKU{
				Name: armfrontdoor.SKUName("Classic_AzureFrontDoor").ToPtr(),
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.PoliciesClientCreateOrUpdateResult)
}

Output:

func (*PoliciesClient) BeginDelete 

func (client *PoliciesClient) BeginDelete(ctx context.Context, resourceGroupName string, policyName string, options *PoliciesClientBeginDeleteOptions) (PoliciesClientDeletePollerResponse, error)

BeginDelete - Deletes Policy If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. policyName - The name of the Web Application Firewall Policy. options - PoliciesClientBeginDeleteOptions contains the optional parameters for the PoliciesClient.BeginDelete method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-11-01/examples/WafPolicyDelete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewPoliciesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<policy-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*PoliciesClient) Get 

func (client *PoliciesClient) Get(ctx context.Context, resourceGroupName string, policyName string, options *PoliciesClientGetOptions) (PoliciesClientGetResponse, error)

Get - Retrieve protection policy with specified name within a resource group. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. policyName - The name of the Web Application Firewall Policy. options - PoliciesClientGetOptions contains the optional parameters for the PoliciesClient.Get method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-11-01/examples/WafPolicyGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewPoliciesClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<policy-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.PoliciesClientGetResult)
}

Output:

func (*PoliciesClient) List 

func (client *PoliciesClient) List(resourceGroupName string, options *PoliciesClientListOptions) *PoliciesClientListPager

List - Lists all of the protection policies within a resource group. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. options - PoliciesClientListOptions contains the optional parameters for the PoliciesClient.List method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-11-01/examples/WafListPolicies.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewPoliciesClient("<subscription-id>", cred, nil)
	pager := client.List("<resource-group-name>",
		nil)
	for {
		nextResult := pager.NextPage(ctx)
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		if !nextResult {
			break
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("Pager result: %#v\n", v)
		}
	}
}

Output:

type PoliciesClientBeginCreateOrUpdateOptions added in v0.2.0 

type PoliciesClientBeginCreateOrUpdateOptions struct {
}

PoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the PoliciesClient.BeginCreateOrUpdate method.

type PoliciesClientBeginDeleteOptions added in v0.2.0 

type PoliciesClientBeginDeleteOptions struct {
}

PoliciesClientBeginDeleteOptions contains the optional parameters for the PoliciesClient.BeginDelete method.

type PoliciesClientCreateOrUpdatePoller added in v0.2.0 

type PoliciesClientCreateOrUpdatePoller struct {
	// contains filtered or unexported fields
}

PoliciesClientCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*PoliciesClientCreateOrUpdatePoller) Done added in v0.2.0 

func (p *PoliciesClientCreateOrUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*PoliciesClientCreateOrUpdatePoller) FinalResponse added in v0.2.0 

func (p *PoliciesClientCreateOrUpdatePoller) FinalResponse(ctx context.Context) (PoliciesClientCreateOrUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final PoliciesClientCreateOrUpdateResponse will be returned.

func (*PoliciesClientCreateOrUpdatePoller) Poll added in v0.2.0 

func (p *PoliciesClientCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*PoliciesClientCreateOrUpdatePoller) ResumeToken added in v0.2.0 

func (p *PoliciesClientCreateOrUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type PoliciesClientCreateOrUpdatePollerResponse added in v0.2.0 

type PoliciesClientCreateOrUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *PoliciesClientCreateOrUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoliciesClientCreateOrUpdatePollerResponse contains the response from method PoliciesClient.CreateOrUpdate.

func (PoliciesClientCreateOrUpdatePollerResponse) PollUntilDone added in v0.2.0 

func (l PoliciesClientCreateOrUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (PoliciesClientCreateOrUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*PoliciesClientCreateOrUpdatePollerResponse) Resume added in v0.2.0 

func (l *PoliciesClientCreateOrUpdatePollerResponse) Resume(ctx context.Context, client *PoliciesClient, token string) error

Resume rehydrates a PoliciesClientCreateOrUpdatePollerResponse from the provided client and resume token.

type PoliciesClientCreateOrUpdateResponse added in v0.2.0 

type PoliciesClientCreateOrUpdateResponse struct {
	PoliciesClientCreateOrUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoliciesClientCreateOrUpdateResponse contains the response from method PoliciesClient.CreateOrUpdate.

type PoliciesClientCreateOrUpdateResult added in v0.2.0 

type PoliciesClientCreateOrUpdateResult struct {
	WebApplicationFirewallPolicy
}

PoliciesClientCreateOrUpdateResult contains the result from method PoliciesClient.CreateOrUpdate.

type PoliciesClientDeletePoller added in v0.2.0 

type PoliciesClientDeletePoller struct {
	// contains filtered or unexported fields
}

PoliciesClientDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*PoliciesClientDeletePoller) Done added in v0.2.0 

func (p *PoliciesClientDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*PoliciesClientDeletePoller) FinalResponse added in v0.2.0 

func (p *PoliciesClientDeletePoller) FinalResponse(ctx context.Context) (PoliciesClientDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final PoliciesClientDeleteResponse will be returned.

func (*PoliciesClientDeletePoller) Poll added in v0.2.0 

func (p *PoliciesClientDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*PoliciesClientDeletePoller) ResumeToken added in v0.2.0 

func (p *PoliciesClientDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type PoliciesClientDeletePollerResponse added in v0.2.0 

type PoliciesClientDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *PoliciesClientDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoliciesClientDeletePollerResponse contains the response from method PoliciesClient.Delete.

func (PoliciesClientDeletePollerResponse) PollUntilDone added in v0.2.0 

func (l PoliciesClientDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (PoliciesClientDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*PoliciesClientDeletePollerResponse) Resume added in v0.2.0 

func (l *PoliciesClientDeletePollerResponse) Resume(ctx context.Context, client *PoliciesClient, token string) error

Resume rehydrates a PoliciesClientDeletePollerResponse from the provided client and resume token.

type PoliciesClientDeleteResponse added in v0.2.0 

type PoliciesClientDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoliciesClientDeleteResponse contains the response from method PoliciesClient.Delete.

type PoliciesClientGetOptions added in v0.2.0 

type PoliciesClientGetOptions struct {
}

PoliciesClientGetOptions contains the optional parameters for the PoliciesClient.Get method.

type PoliciesClientGetResponse added in v0.2.0 

type PoliciesClientGetResponse struct {
	PoliciesClientGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoliciesClientGetResponse contains the response from method PoliciesClient.Get.

type PoliciesClientGetResult added in v0.2.0 

type PoliciesClientGetResult struct {
	WebApplicationFirewallPolicy
}

PoliciesClientGetResult contains the result from method PoliciesClient.Get.

type PoliciesClientListOptions added in v0.2.0 

type PoliciesClientListOptions struct {
}

PoliciesClientListOptions contains the optional parameters for the PoliciesClient.List method.

type PoliciesClientListPager added in v0.2.0 

type PoliciesClientListPager struct {
	// contains filtered or unexported fields
}

PoliciesClientListPager provides operations for iterating over paged responses.

func (*PoliciesClientListPager) Err added in v0.2.0 

func (p *PoliciesClientListPager) Err() error

Err returns the last error encountered while paging.

func (*PoliciesClientListPager) NextPage added in v0.2.0 

func (p *PoliciesClientListPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*PoliciesClientListPager) PageResponse added in v0.2.0 

func (p *PoliciesClientListPager) PageResponse() PoliciesClientListResponse

PageResponse returns the current PoliciesClientListResponse page.

type PoliciesClientListResponse added in v0.2.0 

type PoliciesClientListResponse struct {
	PoliciesClientListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoliciesClientListResponse contains the response from method PoliciesClient.List.

type PoliciesClientListResult added in v0.2.0 

type PoliciesClientListResult struct {
	WebApplicationFirewallPolicyList
}

PoliciesClientListResult contains the result from method PoliciesClient.List.

type PolicyEnabledState 

type PolicyEnabledState string

PolicyEnabledState - Describes if the policy is in enabled or disabled state. Defaults to Enabled if not specified. 

const (
	PolicyEnabledStateDisabled PolicyEnabledState = "Disabled"
	PolicyEnabledStateEnabled  PolicyEnabledState = "Enabled"
)

func PossiblePolicyEnabledStateValues 

func PossiblePolicyEnabledStateValues() []PolicyEnabledState

PossiblePolicyEnabledStateValues returns the possible values for the PolicyEnabledState const type.

func (PolicyEnabledState) ToPtr 

func (c PolicyEnabledState) ToPtr() *PolicyEnabledState

ToPtr returns a *PolicyEnabledState pointing to the current value.

type PolicyMode 

type PolicyMode string

PolicyMode - Describes if it is in detection mode or prevention mode at policy level. 

const (
	PolicyModeDetection  PolicyMode = "Detection"
	PolicyModePrevention PolicyMode = "Prevention"
)

func PossiblePolicyModeValues 

func PossiblePolicyModeValues() []PolicyMode

PossiblePolicyModeValues returns the possible values for the PolicyMode const type.

func (PolicyMode) ToPtr 

func (c PolicyMode) ToPtr() *PolicyMode

ToPtr returns a *PolicyMode pointing to the current value.

type PolicyRequestBodyCheck 

type PolicyRequestBodyCheck string

PolicyRequestBodyCheck - Describes if policy managed rules will inspect the request body content. 

const (
	PolicyRequestBodyCheckDisabled PolicyRequestBodyCheck = "Disabled"
	PolicyRequestBodyCheckEnabled  PolicyRequestBodyCheck = "Enabled"
)

func PossiblePolicyRequestBodyCheckValues 

func PossiblePolicyRequestBodyCheckValues() []PolicyRequestBodyCheck

PossiblePolicyRequestBodyCheckValues returns the possible values for the PolicyRequestBodyCheck const type.

func (PolicyRequestBodyCheck) ToPtr 

func (c PolicyRequestBodyCheck) ToPtr() *PolicyRequestBodyCheck

ToPtr returns a *PolicyRequestBodyCheck pointing to the current value.

type PolicyResourceState 

type PolicyResourceState string

PolicyResourceState - Resource status of the policy. 

const (
	PolicyResourceStateCreating  PolicyResourceState = "Creating"
	PolicyResourceStateDeleting  PolicyResourceState = "Deleting"
	PolicyResourceStateDisabled  PolicyResourceState = "Disabled"
	PolicyResourceStateDisabling PolicyResourceState = "Disabling"
	PolicyResourceStateEnabled   PolicyResourceState = "Enabled"
	PolicyResourceStateEnabling  PolicyResourceState = "Enabling"
)

func PossiblePolicyResourceStateValues 

func PossiblePolicyResourceStateValues() []PolicyResourceState

PossiblePolicyResourceStateValues returns the possible values for the PolicyResourceState const type.

func (PolicyResourceState) ToPtr 

func (c PolicyResourceState) ToPtr() *PolicyResourceState

ToPtr returns a *PolicyResourceState pointing to the current value.

type PolicySettings 

type PolicySettings struct {
	// If the action type is block, customer can override the response body. The body must be specified in base64 encoding.
	CustomBlockResponseBody *string `json:"customBlockResponseBody,omitempty"`

	// If the action type is block, customer can override the response status code.
	CustomBlockResponseStatusCode *int32 `json:"customBlockResponseStatusCode,omitempty"`

	// Describes if the policy is in enabled or disabled state. Defaults to Enabled if not specified.
	EnabledState *PolicyEnabledState `json:"enabledState,omitempty"`

	// Describes if it is in detection mode or prevention mode at policy level.
	Mode *PolicyMode `json:"mode,omitempty"`

	// If action type is redirect, this field represents redirect URL for the client.
	RedirectURL *string `json:"redirectUrl,omitempty"`

	// Describes if policy managed rules will inspect the request body content.
	RequestBodyCheck *PolicyRequestBodyCheck `json:"requestBodyCheck,omitempty"`
}

PolicySettings - Defines top-level WebApplicationFirewallPolicy configuration settings.

type PreconfiguredEndpoint 

type PreconfiguredEndpoint struct {
	// Resource location.
	Location *string `json:"location,omitempty"`

	// The properties of a preconfiguredEndpoint
	Properties *PreconfiguredEndpointProperties `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

PreconfiguredEndpoint - Defines the properties of a preconfigured endpoint

func (PreconfiguredEndpoint) MarshalJSON 

func (p PreconfiguredEndpoint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PreconfiguredEndpoint.

type PreconfiguredEndpointList 

type PreconfiguredEndpointList struct {
	// URL to get the next set of PreconfiguredEndpoints if there are any.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of PreconfiguredEndpoints supported by NetworkExperiment.
	Value []*PreconfiguredEndpoint `json:"value,omitempty" azure:"ro"`
}

PreconfiguredEndpointList - Defines a list of preconfigured endpoints.

func (PreconfiguredEndpointList) MarshalJSON 

func (p PreconfiguredEndpointList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PreconfiguredEndpointList.

type PreconfiguredEndpointProperties 

type PreconfiguredEndpointProperties struct {
	// The preconfigured endpoint backend
	Backend *string `json:"backend,omitempty"`

	// The description of the endpoint
	Description *string `json:"description,omitempty"`

	// The endpoint that is preconfigured
	Endpoint *string `json:"endpoint,omitempty"`

	// The type of endpoint
	EndpointType *EndpointType `json:"endpointType,omitempty"`
}

PreconfiguredEndpointProperties - Defines the properties of a preconfigured endpoint

type PreconfiguredEndpointsClient 

type PreconfiguredEndpointsClient struct {
	// contains filtered or unexported fields
}

PreconfiguredEndpointsClient contains the methods for the PreconfiguredEndpoints group. Don't use this type directly, use NewPreconfiguredEndpointsClient() instead.

func NewPreconfiguredEndpointsClient 

func NewPreconfiguredEndpointsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *PreconfiguredEndpointsClient

NewPreconfiguredEndpointsClient creates a new instance of PreconfiguredEndpointsClient with the specified values. subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*PreconfiguredEndpointsClient) List 

func (client *PreconfiguredEndpointsClient) List(resourceGroupName string, profileName string, options *PreconfiguredEndpointsClientListOptions) *PreconfiguredEndpointsClientListPager

List - Gets a list of Preconfigured Endpoints If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. profileName - The Profile identifier associated with the Tenant and Partner options - PreconfiguredEndpointsClientListOptions contains the optional parameters for the PreconfiguredEndpointsClient.List method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentGetPreconfiguredEndpoints.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewPreconfiguredEndpointsClient("<subscription-id>", cred, nil)
	pager := client.List("<resource-group-name>",
		"<profile-name>",
		nil)
	for {
		nextResult := pager.NextPage(ctx)
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		if !nextResult {
			break
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("Pager result: %#v\n", v)
		}
	}
}

Output:

type PreconfiguredEndpointsClientListOptions added in v0.2.0 

type PreconfiguredEndpointsClientListOptions struct {
}

PreconfiguredEndpointsClientListOptions contains the optional parameters for the PreconfiguredEndpointsClient.List method.

type PreconfiguredEndpointsClientListPager added in v0.2.0 

type PreconfiguredEndpointsClientListPager struct {
	// contains filtered or unexported fields
}

PreconfiguredEndpointsClientListPager provides operations for iterating over paged responses.

func (*PreconfiguredEndpointsClientListPager) Err added in v0.2.0 

func (p *PreconfiguredEndpointsClientListPager) Err() error

Err returns the last error encountered while paging.

func (*PreconfiguredEndpointsClientListPager) NextPage added in v0.2.0 

func (p *PreconfiguredEndpointsClientListPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*PreconfiguredEndpointsClientListPager) PageResponse added in v0.2.0 

func (p *PreconfiguredEndpointsClientListPager) PageResponse() PreconfiguredEndpointsClientListResponse

PageResponse returns the current PreconfiguredEndpointsClientListResponse page.

type PreconfiguredEndpointsClientListResponse added in v0.2.0 

type PreconfiguredEndpointsClientListResponse struct {
	PreconfiguredEndpointsClientListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PreconfiguredEndpointsClientListResponse contains the response from method PreconfiguredEndpointsClient.List.

type PreconfiguredEndpointsClientListResult added in v0.2.0 

type PreconfiguredEndpointsClientListResult struct {
	PreconfiguredEndpointList
}

PreconfiguredEndpointsClientListResult contains the result from method PreconfiguredEndpointsClient.List.

type PrivateEndpointStatus 

type PrivateEndpointStatus string

PrivateEndpointStatus - The Approval status for the connection to the Private Link 

const (
	PrivateEndpointStatusApproved     PrivateEndpointStatus = "Approved"
	PrivateEndpointStatusDisconnected PrivateEndpointStatus = "Disconnected"
	PrivateEndpointStatusPending      PrivateEndpointStatus = "Pending"
	PrivateEndpointStatusRejected     PrivateEndpointStatus = "Rejected"
	PrivateEndpointStatusTimeout      PrivateEndpointStatus = "Timeout"
)

func PossiblePrivateEndpointStatusValues 

func PossiblePrivateEndpointStatusValues() []PrivateEndpointStatus

PossiblePrivateEndpointStatusValues returns the possible values for the PrivateEndpointStatus const type.

func (PrivateEndpointStatus) ToPtr 

func (c PrivateEndpointStatus) ToPtr() *PrivateEndpointStatus

ToPtr returns a *PrivateEndpointStatus pointing to the current value.

type Profile 

type Profile struct {
	// Gets a unique read-only string that changes whenever the resource is updated.
	Etag *string `json:"etag,omitempty"`

	// Resource location.
	Location *string `json:"location,omitempty"`

	// The properties of a Profile
	Properties *ProfileProperties `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

Profile - Defines an Network Experiment Profile and lists of Experiments

func (Profile) MarshalJSON 

func (p Profile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Profile.

type ProfileList 

type ProfileList struct {
	// URL to get the next set of Profile objects if there are any.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of Profiles within a resource group.
	Value []*Profile `json:"value,omitempty" azure:"ro"`
}

ProfileList - Defines a list of Profiles. It contains a list of Profile objects and a URL link to get the next set of results.

func (ProfileList) MarshalJSON 

func (p ProfileList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProfileList.

type ProfileProperties 

type ProfileProperties struct {
	// The state of the Experiment
	EnabledState *State `json:"enabledState,omitempty"`

	// READ-ONLY; Resource status.
	ResourceState *NetworkExperimentResourceState `json:"resourceState,omitempty" azure:"ro"`
}

ProfileProperties - Defines the properties of an experiment

type ProfileUpdateModel 

type ProfileUpdateModel struct {
	// The properties of a Profile
	Properties *ProfileUpdateProperties `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`
}

ProfileUpdateModel - Defines modifiable attributes of a Profile

func (ProfileUpdateModel) MarshalJSON 

func (p ProfileUpdateModel) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProfileUpdateModel.

type ProfileUpdateProperties 

type ProfileUpdateProperties struct {
	// The enabled state of the Profile
	EnabledState *State `json:"enabledState,omitempty"`
}

ProfileUpdateProperties - Defines the properties of an experiment

type Properties added in v0.2.0 

type Properties struct {
	// Backend pools available to routing rules.
	BackendPools []*BackendPool `json:"backendPools,omitempty"`

	// Settings for all backendPools
	BackendPoolsSettings *BackendPoolsSettings `json:"backendPoolsSettings,omitempty"`

	// Operational status of the Front Door load balancer. Permitted values are 'Enabled' or 'Disabled'
	EnabledState *FrontDoorEnabledState `json:"enabledState,omitempty"`

	// A friendly name for the frontDoor
	FriendlyName *string `json:"friendlyName,omitempty"`

	// Frontend endpoints available to routing rules.
	FrontendEndpoints []*FrontendEndpoint `json:"frontendEndpoints,omitempty"`

	// Health probe settings associated with this Front Door instance.
	HealthProbeSettings []*HealthProbeSettingsModel `json:"healthProbeSettings,omitempty"`

	// Load balancing settings associated with this Front Door instance.
	LoadBalancingSettings []*LoadBalancingSettingsModel `json:"loadBalancingSettings,omitempty"`

	// Routing rules associated with this Front Door.
	RoutingRules []*RoutingRule `json:"routingRules,omitempty"`

	// READ-ONLY; The host that each frontendEndpoint must CNAME to.
	Cname *string `json:"cname,omitempty" azure:"ro"`

	// READ-ONLY; The Id of the frontdoor.
	FrontdoorID *string `json:"frontdoorId,omitempty" azure:"ro"`

	// READ-ONLY; Provisioning state of the Front Door.
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; Resource status of the Front Door.
	ResourceState *FrontDoorResourceState `json:"resourceState,omitempty" azure:"ro"`

	// READ-ONLY; Rules Engine Configurations available to routing rules.
	RulesEngines []*RulesEngine `json:"rulesEngines,omitempty" azure:"ro"`
}

Properties - The JSON object that contains the properties required to create an endpoint.

func (Properties) MarshalJSON added in v0.2.0 

func (p Properties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Properties.

type PurgeParameters 

type PurgeParameters struct {
	// REQUIRED; The path to the content to be purged. Can describe a file path or a wild card directory.
	ContentPaths []*string `json:"contentPaths,omitempty"`
}

PurgeParameters - Parameters required for content purge.

func (PurgeParameters) MarshalJSON 

func (p PurgeParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PurgeParameters.

type RedirectConfiguration 

type RedirectConfiguration struct {
	// REQUIRED
	ODataType *string `json:"@odata.type,omitempty"`

	// Fragment to add to the redirect URL. Fragment is the part of the URL that comes after #. Do not include the #.
	CustomFragment *string `json:"customFragment,omitempty"`

	// Host to redirect. Leave empty to use the incoming host as the destination host.
	CustomHost *string `json:"customHost,omitempty"`

	// The full path to redirect. Path cannot be empty and must start with /. Leave empty to use the incoming path as destination
	// path.
	CustomPath *string `json:"customPath,omitempty"`

	// The set of query strings to be placed in the redirect URL. Setting this value would replace any existing query string;
	// leave empty to preserve the incoming query string. Query string must be in =
	// format. The first ? and & will be added automatically so do not include them in the front, but do separate multiple query
	// strings with &.
	CustomQueryString *string `json:"customQueryString,omitempty"`

	// The protocol of the destination to where the traffic is redirected
	RedirectProtocol *FrontDoorRedirectProtocol `json:"redirectProtocol,omitempty"`

	// The redirect type the rule will use when redirecting traffic.
	RedirectType *FrontDoorRedirectType `json:"redirectType,omitempty"`
}

RedirectConfiguration - Describes Redirect Route.

func (*RedirectConfiguration) GetRouteConfiguration added in v0.2.0 

func (r *RedirectConfiguration) GetRouteConfiguration() *RouteConfiguration

GetRouteConfiguration implements the RouteConfigurationClassification interface for type RedirectConfiguration.

func (RedirectConfiguration) MarshalJSON 

func (r RedirectConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RedirectConfiguration.

func (*RedirectConfiguration) UnmarshalJSON 

func (r *RedirectConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RedirectConfiguration.

type ReportsClient 

type ReportsClient struct {
	// contains filtered or unexported fields
}

ReportsClient contains the methods for the Reports group. Don't use this type directly, use NewReportsClient() instead.

func NewReportsClient 

func NewReportsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *ReportsClient

NewReportsClient creates a new instance of ReportsClient with the specified values. subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*ReportsClient) GetLatencyScorecards 

func (client *ReportsClient) GetLatencyScorecards(ctx context.Context, resourceGroupName string, profileName string, experimentName string, aggregationInterval LatencyScorecardAggregationInterval, options *ReportsClientGetLatencyScorecardsOptions) (ReportsClientGetLatencyScorecardsResponse, error)

GetLatencyScorecards - Gets a Latency Scorecard for a given Experiment If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. profileName - The Profile identifier associated with the Tenant and Partner experimentName - The Experiment identifier associated with the Experiment aggregationInterval - The aggregation interval of the Latency Scorecard options - ReportsClientGetLatencyScorecardsOptions contains the optional parameters for the ReportsClient.GetLatencyScorecards method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentGetLatencyScorecard.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewReportsClient("<subscription-id>", cred, nil)
	res, err := client.GetLatencyScorecards(ctx,
		"<resource-group-name>",
		"<profile-name>",
		"<experiment-name>",
		armfrontdoor.LatencyScorecardAggregationInterval("Daily"),
		&armfrontdoor.ReportsClientGetLatencyScorecardsOptions{EndDateTimeUTC: nil,
			Country: nil,
		})
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.ReportsClientGetLatencyScorecardsResult)
}

Output:

func (*ReportsClient) GetTimeseries 

func (client *ReportsClient) GetTimeseries(ctx context.Context, resourceGroupName string, profileName string, experimentName string, startDateTimeUTC time.Time, endDateTimeUTC time.Time, aggregationInterval TimeseriesAggregationInterval, timeseriesType TimeseriesType, options *ReportsClientGetTimeseriesOptions) (ReportsClientGetTimeseriesResponse, error)

GetTimeseries - Gets a Timeseries for a given Experiment If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. profileName - The Profile identifier associated with the Tenant and Partner experimentName - The Experiment identifier associated with the Experiment startDateTimeUTC - The start DateTime of the Timeseries in UTC endDateTimeUTC - The end DateTime of the Timeseries in UTC aggregationInterval - The aggregation interval of the Timeseries timeseriesType - The type of Timeseries options - ReportsClientGetTimeseriesOptions contains the optional parameters for the ReportsClient.GetTimeseries method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2019-11-01/examples/NetworkExperimentGetTimeseries.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewReportsClient("<subscription-id>", cred, nil)
	res, err := client.GetTimeseries(ctx,
		"<resource-group-name>",
		"<profile-name>",
		"<experiment-name>",
		func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-07-21T17:32:28Z"); return t }(),
		func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-09-21T17:32:28Z"); return t }(),
		armfrontdoor.TimeseriesAggregationInterval("Hourly"),
		armfrontdoor.TimeseriesType("MeasurementCounts"),
		&armfrontdoor.ReportsClientGetTimeseriesOptions{Endpoint: nil,
			Country: nil,
		})
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.ReportsClientGetTimeseriesResult)
}

Output:

type ReportsClientGetLatencyScorecardsOptions added in v0.2.0 

type ReportsClientGetLatencyScorecardsOptions struct {
	// The country associated with the Latency Scorecard. Values are country ISO codes as specified here- https://www.iso.org/iso-3166-country-codes.html
	Country *string
	// The end DateTime of the Latency Scorecard in UTC
	EndDateTimeUTC *string
}

ReportsClientGetLatencyScorecardsOptions contains the optional parameters for the ReportsClient.GetLatencyScorecards method.

type ReportsClientGetLatencyScorecardsResponse added in v0.2.0 

type ReportsClientGetLatencyScorecardsResponse struct {
	ReportsClientGetLatencyScorecardsResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

ReportsClientGetLatencyScorecardsResponse contains the response from method ReportsClient.GetLatencyScorecards.

type ReportsClientGetLatencyScorecardsResult added in v0.2.0 

type ReportsClientGetLatencyScorecardsResult struct {
	LatencyScorecard
}

ReportsClientGetLatencyScorecardsResult contains the result from method ReportsClient.GetLatencyScorecards.

type ReportsClientGetTimeseriesOptions added in v0.2.0 

type ReportsClientGetTimeseriesOptions struct {
	// The country associated with the Timeseries. Values are country ISO codes as specified here- https://www.iso.org/iso-3166-country-codes.html
	Country *string
	// The specific endpoint
	Endpoint *string
}

ReportsClientGetTimeseriesOptions contains the optional parameters for the ReportsClient.GetTimeseries method.

type ReportsClientGetTimeseriesResponse added in v0.2.0 

type ReportsClientGetTimeseriesResponse struct {
	ReportsClientGetTimeseriesResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

ReportsClientGetTimeseriesResponse contains the response from method ReportsClient.GetTimeseries.

type ReportsClientGetTimeseriesResult added in v0.2.0 

type ReportsClientGetTimeseriesResult struct {
	Timeseries
}

ReportsClientGetTimeseriesResult contains the result from method ReportsClient.GetTimeseries.

type Resource 

type Resource struct {
	// Resource location.
	Location *string `json:"location,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

Resource - Common resource representation.

func (Resource) MarshalJSON 

func (r Resource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Resource.

type ResourceType 

type ResourceType string

ResourceType - Type of Front Door resource used in CheckNameAvailability. 

const (
	ResourceTypeMicrosoftNetworkFrontDoors                  ResourceType = "Microsoft.Network/frontDoors"
	ResourceTypeMicrosoftNetworkFrontDoorsFrontendEndpoints ResourceType = "Microsoft.Network/frontDoors/frontendEndpoints"
)

func PossibleResourceTypeValues 

func PossibleResourceTypeValues() []ResourceType

PossibleResourceTypeValues returns the possible values for the ResourceType const type.

func (ResourceType) ToPtr 

func (c ResourceType) ToPtr() *ResourceType

ToPtr returns a *ResourceType pointing to the current value.

type RouteConfiguration 

type RouteConfiguration struct {
	// REQUIRED
	ODataType *string `json:"@odata.type,omitempty"`
}

RouteConfiguration - Base class for all types of Route.

func (*RouteConfiguration) GetRouteConfiguration 

func (r *RouteConfiguration) GetRouteConfiguration() *RouteConfiguration

GetRouteConfiguration implements the RouteConfigurationClassification interface for type RouteConfiguration.

type RouteConfigurationClassification 

type RouteConfigurationClassification interface {
	// GetRouteConfiguration returns the RouteConfiguration content of the underlying type.
	GetRouteConfiguration() *RouteConfiguration
}

RouteConfigurationClassification provides polymorphic access to related types. Call the interface's GetRouteConfiguration() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *ForwardingConfiguration, *RedirectConfiguration, *RouteConfiguration

type RoutingRule 

type RoutingRule struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`

	// Resource name.
	Name *string `json:"name,omitempty"`

	// Properties of the Front Door Routing Rule
	Properties *RoutingRuleProperties `json:"properties,omitempty"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

RoutingRule - A routing rule represents a specification for traffic to treat and where to send it, along with health probe information.

type RoutingRuleEnabledState 

type RoutingRuleEnabledState string

RoutingRuleEnabledState - Whether to enable use of this rule. Permitted values are 'Enabled' or 'Disabled' 

const (
	RoutingRuleEnabledStateDisabled RoutingRuleEnabledState = "Disabled"
	RoutingRuleEnabledStateEnabled  RoutingRuleEnabledState = "Enabled"
)

func PossibleRoutingRuleEnabledStateValues 

func PossibleRoutingRuleEnabledStateValues() []RoutingRuleEnabledState

PossibleRoutingRuleEnabledStateValues returns the possible values for the RoutingRuleEnabledState const type.

func (RoutingRuleEnabledState) ToPtr 

func (c RoutingRuleEnabledState) ToPtr() *RoutingRuleEnabledState

ToPtr returns a *RoutingRuleEnabledState pointing to the current value. 

type RoutingRuleLink struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`
}

RoutingRuleLink - Defines the Resource ID for a Routing Rule.

type RoutingRuleListResult 

type RoutingRuleListResult struct {
	// URL to get the next set of RoutingRule objects if there are any.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of Routing Rules within a Front Door.
	Value []*RoutingRule `json:"value,omitempty" azure:"ro"`
}

RoutingRuleListResult - Result of the request to list Routing Rules. It contains a list of Routing Rule objects and a URL link to get the next set of results.

func (RoutingRuleListResult) MarshalJSON 

func (r RoutingRuleListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RoutingRuleListResult.

type RoutingRuleProperties 

type RoutingRuleProperties struct {
	// Protocol schemes to match for this rule
	AcceptedProtocols []*FrontDoorProtocol `json:"acceptedProtocols,omitempty"`

	// Whether to enable use of this rule. Permitted values are 'Enabled' or 'Disabled'
	EnabledState *RoutingRuleEnabledState `json:"enabledState,omitempty"`

	// Frontend endpoints associated with this rule
	FrontendEndpoints []*SubResource `json:"frontendEndpoints,omitempty"`

	// The route patterns of the rule.
	PatternsToMatch []*string `json:"patternsToMatch,omitempty"`

	// A reference to the routing configuration.
	RouteConfiguration RouteConfigurationClassification `json:"routeConfiguration,omitempty"`

	// A reference to a specific Rules Engine Configuration to apply to this route.
	RulesEngine *SubResource `json:"rulesEngine,omitempty"`

	// Defines the Web Application Firewall policy for each routing rule (if applicable)
	WebApplicationFirewallPolicyLink *RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink `json:"webApplicationFirewallPolicyLink,omitempty"`

	// READ-ONLY; Resource status.
	ResourceState *FrontDoorResourceState `json:"resourceState,omitempty" azure:"ro"`
}

RoutingRuleProperties - The JSON object that contains the properties required to create a routing rule.

func (RoutingRuleProperties) MarshalJSON 

func (r RoutingRuleProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RoutingRuleProperties.

func (*RoutingRuleProperties) UnmarshalJSON 

func (r *RoutingRuleProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RoutingRuleProperties.

type RoutingRuleUpdateParameters 

type RoutingRuleUpdateParameters struct {
	// Protocol schemes to match for this rule
	AcceptedProtocols []*FrontDoorProtocol `json:"acceptedProtocols,omitempty"`

	// Whether to enable use of this rule. Permitted values are 'Enabled' or 'Disabled'
	EnabledState *RoutingRuleEnabledState `json:"enabledState,omitempty"`

	// Frontend endpoints associated with this rule
	FrontendEndpoints []*SubResource `json:"frontendEndpoints,omitempty"`

	// The route patterns of the rule.
	PatternsToMatch []*string `json:"patternsToMatch,omitempty"`

	// A reference to the routing configuration.
	RouteConfiguration RouteConfigurationClassification `json:"routeConfiguration,omitempty"`

	// A reference to a specific Rules Engine Configuration to apply to this route.
	RulesEngine *SubResource `json:"rulesEngine,omitempty"`

	// Defines the Web Application Firewall policy for each routing rule (if applicable)
	WebApplicationFirewallPolicyLink *RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink `json:"webApplicationFirewallPolicyLink,omitempty"`
}

RoutingRuleUpdateParameters - Routing rules to apply to an endpoint

func (RoutingRuleUpdateParameters) MarshalJSON 

func (r RoutingRuleUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RoutingRuleUpdateParameters.

func (*RoutingRuleUpdateParameters) UnmarshalJSON 

func (r *RoutingRuleUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RoutingRuleUpdateParameters. 

type RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`
}

RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink - Defines the Web Application Firewall policy for each routing rule (if applicable)

type RuleType 

type RuleType string

RuleType - Describes type of rule. 

const (
	RuleTypeMatchRule     RuleType = "MatchRule"
	RuleTypeRateLimitRule RuleType = "RateLimitRule"
)

func PossibleRuleTypeValues 

func PossibleRuleTypeValues() []RuleType

PossibleRuleTypeValues returns the possible values for the RuleType const type.

func (RuleType) ToPtr 

func (c RuleType) ToPtr() *RuleType

ToPtr returns a *RuleType pointing to the current value.

type RulesEngine 

type RulesEngine struct {
	// Properties of the Rules Engine Configuration.
	Properties *RulesEngineProperties `json:"properties,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

RulesEngine - A rules engine configuration containing a list of rules that will run to modify the runtime behavior of the request and response.

type RulesEngineAction 

type RulesEngineAction struct {
	// A list of header actions to apply from the request from AFD to the origin.
	RequestHeaderActions []*HeaderAction `json:"requestHeaderActions,omitempty"`

	// A list of header actions to apply from the response from AFD to the client.
	ResponseHeaderActions []*HeaderAction `json:"responseHeaderActions,omitempty"`

	// Override the route configuration.
	RouteConfigurationOverride RouteConfigurationClassification `json:"routeConfigurationOverride,omitempty"`
}

RulesEngineAction - One or more actions that will execute, modifying the request and/or response.

func (RulesEngineAction) MarshalJSON 

func (r RulesEngineAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RulesEngineAction.

func (*RulesEngineAction) UnmarshalJSON 

func (r *RulesEngineAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RulesEngineAction.

type RulesEngineListResult 

type RulesEngineListResult struct {
	// URL to get the next set of RulesEngine objects if there are any.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of rulesEngines within a Front Door.
	Value []*RulesEngine `json:"value,omitempty" azure:"ro"`
}

RulesEngineListResult - Result of the request to list Rules Engine Configurations. It contains a list of RulesEngine objects and a URL link to get the next set of results.

func (RulesEngineListResult) MarshalJSON 

func (r RulesEngineListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RulesEngineListResult.

type RulesEngineMatchCondition 

type RulesEngineMatchCondition struct {
	// REQUIRED; Match values to match against. The operator will apply to each value in here with OR semantics. If any of them
	// match the variable with the given operator this match condition is considered a match.
	RulesEngineMatchValue []*string `json:"rulesEngineMatchValue,omitempty"`

	// REQUIRED; Match Variable
	RulesEngineMatchVariable *RulesEngineMatchVariable `json:"rulesEngineMatchVariable,omitempty"`

	// REQUIRED; Describes operator to apply to the match condition.
	RulesEngineOperator *RulesEngineOperator `json:"rulesEngineOperator,omitempty"`

	// Describes if this is negate condition or not
	NegateCondition *bool `json:"negateCondition,omitempty"`

	// Name of selector in RequestHeader or RequestBody to be matched
	Selector *string `json:"selector,omitempty"`

	// List of transforms
	Transforms []*Transform `json:"transforms,omitempty"`
}

RulesEngineMatchCondition - Define a match condition

func (RulesEngineMatchCondition) MarshalJSON 

func (r RulesEngineMatchCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RulesEngineMatchCondition.

type RulesEngineMatchVariable 

type RulesEngineMatchVariable string

RulesEngineMatchVariable - Match Variable 

const (
	RulesEngineMatchVariableIsMobile                 RulesEngineMatchVariable = "IsMobile"
	RulesEngineMatchVariablePostArgs                 RulesEngineMatchVariable = "PostArgs"
	RulesEngineMatchVariableQueryString              RulesEngineMatchVariable = "QueryString"
	RulesEngineMatchVariableRemoteAddr               RulesEngineMatchVariable = "RemoteAddr"
	RulesEngineMatchVariableRequestBody              RulesEngineMatchVariable = "RequestBody"
	RulesEngineMatchVariableRequestFilename          RulesEngineMatchVariable = "RequestFilename"
	RulesEngineMatchVariableRequestFilenameExtension RulesEngineMatchVariable = "RequestFilenameExtension"
	RulesEngineMatchVariableRequestHeader            RulesEngineMatchVariable = "RequestHeader"
	RulesEngineMatchVariableRequestMethod            RulesEngineMatchVariable = "RequestMethod"
	RulesEngineMatchVariableRequestPath              RulesEngineMatchVariable = "RequestPath"
	RulesEngineMatchVariableRequestScheme            RulesEngineMatchVariable = "RequestScheme"
	RulesEngineMatchVariableRequestURI               RulesEngineMatchVariable = "RequestUri"
)

func PossibleRulesEngineMatchVariableValues 

func PossibleRulesEngineMatchVariableValues() []RulesEngineMatchVariable

PossibleRulesEngineMatchVariableValues returns the possible values for the RulesEngineMatchVariable const type.

func (RulesEngineMatchVariable) ToPtr 

func (c RulesEngineMatchVariable) ToPtr() *RulesEngineMatchVariable

ToPtr returns a *RulesEngineMatchVariable pointing to the current value.

type RulesEngineOperator 

type RulesEngineOperator string

RulesEngineOperator - Describes operator to apply to the match condition. 

const (
	RulesEngineOperatorAny                RulesEngineOperator = "Any"
	RulesEngineOperatorBeginsWith         RulesEngineOperator = "BeginsWith"
	RulesEngineOperatorContains           RulesEngineOperator = "Contains"
	RulesEngineOperatorEndsWith           RulesEngineOperator = "EndsWith"
	RulesEngineOperatorEqual              RulesEngineOperator = "Equal"
	RulesEngineOperatorGeoMatch           RulesEngineOperator = "GeoMatch"
	RulesEngineOperatorGreaterThan        RulesEngineOperator = "GreaterThan"
	RulesEngineOperatorGreaterThanOrEqual RulesEngineOperator = "GreaterThanOrEqual"
	RulesEngineOperatorIPMatch            RulesEngineOperator = "IPMatch"
	RulesEngineOperatorLessThan           RulesEngineOperator = "LessThan"
	RulesEngineOperatorLessThanOrEqual    RulesEngineOperator = "LessThanOrEqual"
)

func PossibleRulesEngineOperatorValues 

func PossibleRulesEngineOperatorValues() []RulesEngineOperator

PossibleRulesEngineOperatorValues returns the possible values for the RulesEngineOperator const type.

func (RulesEngineOperator) ToPtr 

func (c RulesEngineOperator) ToPtr() *RulesEngineOperator

ToPtr returns a *RulesEngineOperator pointing to the current value.

type RulesEngineProperties 

type RulesEngineProperties struct {
	// A list of rules that define a particular Rules Engine Configuration.
	Rules []*RulesEngineRule `json:"rules,omitempty"`

	// READ-ONLY; Resource status.
	ResourceState *FrontDoorResourceState `json:"resourceState,omitempty" azure:"ro"`
}

RulesEngineProperties - The JSON object that contains the properties required to create a Rules Engine Configuration.

func (RulesEngineProperties) MarshalJSON 

func (r RulesEngineProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RulesEngineProperties.

type RulesEngineRule 

type RulesEngineRule struct {
	// REQUIRED; Actions to perform on the request and response if all of the match conditions are met.
	Action *RulesEngineAction `json:"action,omitempty"`

	// REQUIRED; A name to refer to this specific rule.
	Name *string `json:"name,omitempty"`

	// REQUIRED; A priority assigned to this rule.
	Priority *int32 `json:"priority,omitempty"`

	// A list of match conditions that must meet in order for the actions of this rule to run. Having no match conditions means
	// the actions will always run.
	MatchConditions []*RulesEngineMatchCondition `json:"matchConditions,omitempty"`

	// If this rule is a match should the rules engine continue running the remaining rules or stop. If not present, defaults
	// to Continue.
	MatchProcessingBehavior *MatchProcessingBehavior `json:"matchProcessingBehavior,omitempty"`
}

RulesEngineRule - Contains a list of match conditions, and an action on how to modify the request/response. If multiple rules match, the actions from one rule that conflict with a previous rule overwrite for a singular action, or append in the case of headers manipulation.

func (RulesEngineRule) MarshalJSON 

func (r RulesEngineRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RulesEngineRule.

type RulesEngineUpdateParameters 

type RulesEngineUpdateParameters struct {
	// A list of rules that define a particular Rules Engine Configuration.
	Rules []*RulesEngineRule `json:"rules,omitempty"`
}

RulesEngineUpdateParameters - Rules Engine Configuration to apply to a Routing Rule.

func (RulesEngineUpdateParameters) MarshalJSON 

func (r RulesEngineUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RulesEngineUpdateParameters.

type RulesEnginesClient 

type RulesEnginesClient struct {
	// contains filtered or unexported fields
}

RulesEnginesClient contains the methods for the RulesEngines group. Don't use this type directly, use NewRulesEnginesClient() instead.

func NewRulesEnginesClient 

func NewRulesEnginesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *RulesEnginesClient

NewRulesEnginesClient creates a new instance of RulesEnginesClient with the specified values. subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*RulesEnginesClient) BeginCreateOrUpdate 

func (client *RulesEnginesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, frontDoorName string, rulesEngineName string, rulesEngineParameters RulesEngine, options *RulesEnginesClientBeginCreateOrUpdateOptions) (RulesEnginesClientCreateOrUpdatePollerResponse, error)

BeginCreateOrUpdate - Creates a new Rules Engine Configuration with the specified name within the specified Front Door. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. rulesEngineName - Name of the Rules Engine which is unique within the Front Door. rulesEngineParameters - Rules Engine Configuration properties needed to create a new Rules Engine Configuration. options - RulesEnginesClientBeginCreateOrUpdateOptions contains the optional parameters for the RulesEnginesClient.BeginCreateOrUpdate method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorRulesEngineCreate.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewRulesEnginesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreateOrUpdate(ctx,
		"<resource-group-name>",
		"<front-door-name>",
		"<rules-engine-name>",
		armfrontdoor.RulesEngine{
			Properties: &armfrontdoor.RulesEngineProperties{
				Rules: []*armfrontdoor.RulesEngineRule{
					{
						Name: to.StringPtr("<name>"),
						Action: &armfrontdoor.RulesEngineAction{
							RouteConfigurationOverride: &armfrontdoor.RedirectConfiguration{
								ODataType:         to.StringPtr("<odata-type>"),
								CustomFragment:    to.StringPtr("<custom-fragment>"),
								CustomHost:        to.StringPtr("<custom-host>"),
								CustomPath:        to.StringPtr("<custom-path>"),
								CustomQueryString: to.StringPtr("<custom-query-string>"),
								RedirectProtocol:  armfrontdoor.FrontDoorRedirectProtocol("HttpsOnly").ToPtr(),
								RedirectType:      armfrontdoor.FrontDoorRedirectType("Moved").ToPtr(),
							},
						},
						MatchConditions: []*armfrontdoor.RulesEngineMatchCondition{
							{
								RulesEngineMatchValue: []*string{
									to.StringPtr("CH")},
								RulesEngineMatchVariable: armfrontdoor.RulesEngineMatchVariable("RemoteAddr").ToPtr(),
								RulesEngineOperator:      armfrontdoor.RulesEngineOperator("GeoMatch").ToPtr(),
							}},
						MatchProcessingBehavior: armfrontdoor.MatchProcessingBehavior("Stop").ToPtr(),
						Priority:                to.Int32Ptr(1),
					},
					{
						Name: to.StringPtr("<name>"),
						Action: &armfrontdoor.RulesEngineAction{
							ResponseHeaderActions: []*armfrontdoor.HeaderAction{
								{
									HeaderActionType: armfrontdoor.HeaderActionType("Overwrite").ToPtr(),
									HeaderName:       to.StringPtr("<header-name>"),
									Value:            to.StringPtr("<value>"),
								}},
						},
						MatchConditions: []*armfrontdoor.RulesEngineMatchCondition{
							{
								RulesEngineMatchValue: []*string{
									to.StringPtr("jpg")},
								RulesEngineMatchVariable: armfrontdoor.RulesEngineMatchVariable("RequestFilenameExtension").ToPtr(),
								RulesEngineOperator:      armfrontdoor.RulesEngineOperator("Equal").ToPtr(),
								Transforms: []*armfrontdoor.Transform{
									armfrontdoor.Transform("Lowercase").ToPtr()},
							}},
						Priority: to.Int32Ptr(2),
					},
					{
						Name: to.StringPtr("<name>"),
						Action: &armfrontdoor.RulesEngineAction{
							RouteConfigurationOverride: &armfrontdoor.ForwardingConfiguration{
								ODataType: to.StringPtr("<odata-type>"),
								BackendPool: &armfrontdoor.SubResource{
									ID: to.StringPtr("<id>"),
								},
								CacheConfiguration: &armfrontdoor.CacheConfiguration{
									CacheDuration:                to.StringPtr("<cache-duration>"),
									DynamicCompression:           armfrontdoor.DynamicCompressionEnabled("Disabled").ToPtr(),
									QueryParameterStripDirective: armfrontdoor.FrontDoorQuery("StripOnly").ToPtr(),
									QueryParameters:              to.StringPtr("<query-parameters>"),
								},
								ForwardingProtocol: armfrontdoor.FrontDoorForwardingProtocol("HttpsOnly").ToPtr(),
							},
						},
						MatchConditions: []*armfrontdoor.RulesEngineMatchCondition{
							{
								NegateCondition: to.BoolPtr(false),
								RulesEngineMatchValue: []*string{
									to.StringPtr("allowoverride")},
								RulesEngineMatchVariable: armfrontdoor.RulesEngineMatchVariable("RequestHeader").ToPtr(),
								RulesEngineOperator:      armfrontdoor.RulesEngineOperator("Equal").ToPtr(),
								Selector:                 to.StringPtr("<selector>"),
								Transforms: []*armfrontdoor.Transform{
									armfrontdoor.Transform("Lowercase").ToPtr()},
							}},
						Priority: to.Int32Ptr(3),
					}},
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.RulesEnginesClientCreateOrUpdateResult)
}

Output:

func (*RulesEnginesClient) BeginDelete 

func (client *RulesEnginesClient) BeginDelete(ctx context.Context, resourceGroupName string, frontDoorName string, rulesEngineName string, options *RulesEnginesClientBeginDeleteOptions) (RulesEnginesClientDeletePollerResponse, error)

BeginDelete - Deletes an existing Rules Engine Configuration with the specified parameters. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. rulesEngineName - Name of the Rules Engine which is unique within the Front Door. options - RulesEnginesClientBeginDeleteOptions contains the optional parameters for the RulesEnginesClient.BeginDelete method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorRulesEngineDelete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewRulesEnginesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<front-door-name>",
		"<rules-engine-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*RulesEnginesClient) Get 

func (client *RulesEnginesClient) Get(ctx context.Context, resourceGroupName string, frontDoorName string, rulesEngineName string, options *RulesEnginesClientGetOptions) (RulesEnginesClientGetResponse, error)

Get - Gets a Rules Engine Configuration with the specified name within the specified Front Door. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. rulesEngineName - Name of the Rules Engine which is unique within the Front Door. options - RulesEnginesClientGetOptions contains the optional parameters for the RulesEnginesClient.Get method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorRulesEngineGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewRulesEnginesClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<front-door-name>",
		"<rules-engine-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Response result: %#v\n", res.RulesEnginesClientGetResult)
}

Output:

func (*RulesEnginesClient) ListByFrontDoor 

func (client *RulesEnginesClient) ListByFrontDoor(resourceGroupName string, frontDoorName string, options *RulesEnginesClientListByFrontDoorOptions) *RulesEnginesClientListByFrontDoorPager

ListByFrontDoor - Lists all of the Rules Engine Configurations within a Front Door. If the operation fails it returns an *azcore.ResponseError type. resourceGroupName - Name of the Resource group within the Azure subscription. frontDoorName - Name of the Front Door which is globally unique. options - RulesEnginesClientListByFrontDoorOptions contains the optional parameters for the RulesEnginesClient.ListByFrontDoor method.

Example

x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2020-05-01/examples/FrontdoorRulesEngineList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armfrontdoor.NewRulesEnginesClient("<subscription-id>", cred, nil)
	pager := client.ListByFrontDoor("<resource-group-name>",
		"<front-door-name>",
		nil)
	for {
		nextResult := pager.NextPage(ctx)
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		if !nextResult {
			break
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("Pager result: %#v\n", v)
		}
	}
}

Output:

type RulesEnginesClientBeginCreateOrUpdateOptions added in v0.2.0 

type RulesEnginesClientBeginCreateOrUpdateOptions struct {
}

RulesEnginesClientBeginCreateOrUpdateOptions contains the optional parameters for the RulesEnginesClient.BeginCreateOrUpdate method.

type RulesEnginesClientBeginDeleteOptions added in v0.2.0 

type RulesEnginesClientBeginDeleteOptions struct {
}

RulesEnginesClientBeginDeleteOptions contains the optional parameters for the RulesEnginesClient.BeginDelete method.

type RulesEnginesClientCreateOrUpdatePoller added in v0.2.0 

type RulesEnginesClientCreateOrUpdatePoller struct {
	// contains filtered or unexported fields
}

RulesEnginesClientCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*RulesEnginesClientCreateOrUpdatePoller) Done added in v0.2.0 

func (p *RulesEnginesClientCreateOrUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*RulesEnginesClientCreateOrUpdatePoller) FinalResponse added in v0.2.0 

func (p *RulesEnginesClientCreateOrUpdatePoller) FinalResponse(ctx context.Context) (RulesEnginesClientCreateOrUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final RulesEnginesClientCreateOrUpdateResponse will be returned.

func (*RulesEnginesClientCreateOrUpdatePoller) Poll added in v0.2.0 

func (p *RulesEnginesClientCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*RulesEnginesClientCreateOrUpdatePoller) ResumeToken added in v0.2.0 

func (p *RulesEnginesClientCreateOrUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type RulesEnginesClientCreateOrUpdatePollerResponse added in v0.2.0 

type RulesEnginesClientCreateOrUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *RulesEnginesClientCreateOrUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

RulesEnginesClientCreateOrUpdatePollerResponse contains the response from method RulesEnginesClient.CreateOrUpdate.

func (RulesEnginesClientCreateOrUpdatePollerResponse) PollUntilDone added in v0.2.0 

func (l RulesEnginesClientCreateOrUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (RulesEnginesClientCreateOrUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*RulesEnginesClientCreateOrUpdatePollerResponse) Resume added in v0.2.0 

func (l *RulesEnginesClientCreateOrUpdatePollerResponse) Resume(ctx context.Context, client *RulesEnginesClient, token string) error

Resume rehydrates a RulesEnginesClientCreateOrUpdatePollerResponse from the provided client and resume token.

type RulesEnginesClientCreateOrUpdateResponse added in v0.2.0 

type RulesEnginesClientCreateOrUpdateResponse struct {
	RulesEnginesClientCreateOrUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

RulesEnginesClientCreateOrUpdateResponse contains the response from method RulesEnginesClient.CreateOrUpdate.

type RulesEnginesClientCreateOrUpdateResult added in v0.2.0 

type RulesEnginesClientCreateOrUpdateResult struct {
	RulesEngine
}

RulesEnginesClientCreateOrUpdateResult contains the result from method RulesEnginesClient.CreateOrUpdate.

type RulesEnginesClientDeletePoller added in v0.2.0 

type RulesEnginesClientDeletePoller struct {
	// contains filtered or unexported fields
}

RulesEnginesClientDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*RulesEnginesClientDeletePoller) Done added in v0.2.0 

func (p *RulesEnginesClientDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*RulesEnginesClientDeletePoller) FinalResponse added in v0.2.0 

func (p *RulesEnginesClientDeletePoller) FinalResponse(ctx context.Context) (RulesEnginesClientDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final RulesEnginesClientDeleteResponse will be returned.

func (*RulesEnginesClientDeletePoller) Poll added in v0.2.0 

func (p *RulesEnginesClientDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*RulesEnginesClientDeletePoller) ResumeToken added in v0.2.0 

func (p *RulesEnginesClientDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type RulesEnginesClientDeletePollerResponse added in v0.2.0 

type RulesEnginesClientDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *RulesEnginesClientDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

RulesEnginesClientDeletePollerResponse contains the response from method RulesEnginesClient.Delete.

func (RulesEnginesClientDeletePollerResponse) PollUntilDone added in v0.2.0 

func (l RulesEnginesClientDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (RulesEnginesClientDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*RulesEnginesClientDeletePollerResponse) Resume added in v0.2.0 

func (l *RulesEnginesClientDeletePollerResponse) Resume(ctx context.Context, client *RulesEnginesClient, token string) error

Resume rehydrates a RulesEnginesClientDeletePollerResponse from the provided client and resume token.

type RulesEnginesClientDeleteResponse added in v0.2.0 

type RulesEnginesClientDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

RulesEnginesClientDeleteResponse contains the response from method RulesEnginesClient.Delete.

type RulesEnginesClientGetOptions added in v0.2.0 

type RulesEnginesClientGetOptions struct {
}

RulesEnginesClientGetOptions contains the optional parameters for the RulesEnginesClient.Get method.

type RulesEnginesClientGetResponse added in v0.2.0 

type RulesEnginesClientGetResponse struct {
	RulesEnginesClientGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

RulesEnginesClientGetResponse contains the response from method RulesEnginesClient.Get.

type RulesEnginesClientGetResult added in v0.2.0 

type RulesEnginesClientGetResult struct {
	RulesEngine
}

RulesEnginesClientGetResult contains the result from method RulesEnginesClient.Get.

type RulesEnginesClientListByFrontDoorOptions added in v0.2.0 

type RulesEnginesClientListByFrontDoorOptions struct {
}

RulesEnginesClientListByFrontDoorOptions contains the optional parameters for the RulesEnginesClient.ListByFrontDoor method.

type RulesEnginesClientListByFrontDoorPager added in v0.2.0 

type RulesEnginesClientListByFrontDoorPager struct {
	// contains filtered or unexported fields
}

RulesEnginesClientListByFrontDoorPager provides operations for iterating over paged responses.

func (*RulesEnginesClientListByFrontDoorPager) Err added in v0.2.0 

func (p *RulesEnginesClientListByFrontDoorPager) Err() error

Err returns the last error encountered while paging.

func (*RulesEnginesClientListByFrontDoorPager) NextPage added in v0.2.0 

func (p *RulesEnginesClientListByFrontDoorPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*RulesEnginesClientListByFrontDoorPager) PageResponse added in v0.2.0 

func (p *RulesEnginesClientListByFrontDoorPager) PageResponse() RulesEnginesClientListByFrontDoorResponse

PageResponse returns the current RulesEnginesClientListByFrontDoorResponse page.

type RulesEnginesClientListByFrontDoorResponse added in v0.2.0 

type RulesEnginesClientListByFrontDoorResponse struct {
	RulesEnginesClientListByFrontDoorResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

RulesEnginesClientListByFrontDoorResponse contains the response from method RulesEnginesClient.ListByFrontDoor.

type RulesEnginesClientListByFrontDoorResult added in v0.2.0 

type RulesEnginesClientListByFrontDoorResult struct {
	RulesEngineListResult
}

RulesEnginesClientListByFrontDoorResult contains the result from method RulesEnginesClient.ListByFrontDoor.

type SKU 

type SKU struct {
	// Name of the pricing tier.
	Name *SKUName `json:"name,omitempty"`
}

SKU - The pricing tier of the web application firewall policy.

type SKUName 

type SKUName string

SKUName - Name of the pricing tier. 

const (
	SKUNameClassicAzureFrontDoor  SKUName = "Classic_AzureFrontDoor"
	SKUNamePremiumAzureFrontDoor  SKUName = "Premium_AzureFrontDoor"
	SKUNameStandardAzureFrontDoor SKUName = "Standard_AzureFrontDoor"
)

func PossibleSKUNameValues 

func PossibleSKUNameValues() []SKUName

PossibleSKUNameValues returns the possible values for the SKUName const type.

func (SKUName) ToPtr 

func (c SKUName) ToPtr() *SKUName

ToPtr returns a *SKUName pointing to the current value. 

type SecurityPolicyLink struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`
}

SecurityPolicyLink - Defines the Resource ID for a Security Policy.

type SessionAffinityEnabledState 

type SessionAffinityEnabledState string

SessionAffinityEnabledState - Whether to allow session affinity on this host. Valid options are 'Enabled' or 'Disabled' 

const (
	SessionAffinityEnabledStateDisabled SessionAffinityEnabledState = "Disabled"
	SessionAffinityEnabledStateEnabled  SessionAffinityEnabledState = "Enabled"
)

func PossibleSessionAffinityEnabledStateValues 

func PossibleSessionAffinityEnabledStateValues() []SessionAffinityEnabledState

PossibleSessionAffinityEnabledStateValues returns the possible values for the SessionAffinityEnabledState const type.

func (SessionAffinityEnabledState) ToPtr 

func (c SessionAffinityEnabledState) ToPtr() *SessionAffinityEnabledState

ToPtr returns a *SessionAffinityEnabledState pointing to the current value.

type State 

type State string

State - The state of the Experiment 

const (
	StateDisabled State = "Disabled"
	StateEnabled  State = "Enabled"
)

func PossibleStateValues 

func PossibleStateValues() []State

PossibleStateValues returns the possible values for the State const type.

func (State) ToPtr 

func (c State) ToPtr() *State

ToPtr returns a *State pointing to the current value.

type SubResource 

type SubResource struct {
	// Resource ID.
	ID *string `json:"id,omitempty"`
}

SubResource - Reference to another subresource.

type TagsObject 

type TagsObject struct {
	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`
}

TagsObject - Tags object for patch operations.

func (TagsObject) MarshalJSON 

func (t TagsObject) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TagsObject.

type Timeseries 

type Timeseries struct {
	// Resource location.
	Location *string `json:"location,omitempty"`

	// The properties of a Timeseries
	Properties *TimeseriesProperties `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

Timeseries - Defines the Timeseries

func (Timeseries) MarshalJSON 

func (t Timeseries) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Timeseries.

type TimeseriesAggregationInterval 

type TimeseriesAggregationInterval string
const (
	TimeseriesAggregationIntervalDaily  TimeseriesAggregationInterval = "Daily"
	TimeseriesAggregationIntervalHourly TimeseriesAggregationInterval = "Hourly"
)

func PossibleTimeseriesAggregationIntervalValues 

func PossibleTimeseriesAggregationIntervalValues() []TimeseriesAggregationInterval

PossibleTimeseriesAggregationIntervalValues returns the possible values for the TimeseriesAggregationInterval const type.

func (TimeseriesAggregationInterval) ToPtr 

func (c TimeseriesAggregationInterval) ToPtr() *TimeseriesAggregationInterval

ToPtr returns a *TimeseriesAggregationInterval pointing to the current value.

type TimeseriesDataPoint 

type TimeseriesDataPoint struct {
	// The DateTime of the Timeseries data point in UTC
	DateTimeUTC *string `json:"dateTimeUTC,omitempty"`

	// The Value of the Timeseries data point
	Value *float32 `json:"value,omitempty"`
}

TimeseriesDataPoint - Defines a timeseries datapoint used in a timeseries

type TimeseriesProperties 

type TimeseriesProperties struct {
	// The aggregation interval of the Timeseries
	AggregationInterval *AggregationInterval `json:"aggregationInterval,omitempty"`

	// The country associated with the Timeseries. Values are country ISO codes as specified here- https://www.iso.org/iso-3166-country-codes.html
	Country *string `json:"country,omitempty"`

	// The end DateTime of the Timeseries in UTC
	EndDateTimeUTC *string `json:"endDateTimeUTC,omitempty"`

	// The endpoint associated with the Timeseries data point
	Endpoint *string `json:"endpoint,omitempty"`

	// The start DateTime of the Timeseries in UTC
	StartDateTimeUTC *string `json:"startDateTimeUTC,omitempty"`

	// The set of data points for the timeseries
	TimeseriesData []*TimeseriesDataPoint `json:"timeseriesData,omitempty"`

	// The type of Timeseries
	TimeseriesType *TimeseriesType `json:"timeseriesType,omitempty"`
}

TimeseriesProperties - Defines the properties of a timeseries

func (TimeseriesProperties) MarshalJSON 

func (t TimeseriesProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TimeseriesProperties.

type TimeseriesType 

type TimeseriesType string

TimeseriesType - The type of Timeseries 

const (
	TimeseriesTypeLatencyP50        TimeseriesType = "LatencyP50"
	TimeseriesTypeLatencyP75        TimeseriesType = "LatencyP75"
	TimeseriesTypeLatencyP95        TimeseriesType = "LatencyP95"
	TimeseriesTypeMeasurementCounts TimeseriesType = "MeasurementCounts"
)

func PossibleTimeseriesTypeValues 

func PossibleTimeseriesTypeValues() []TimeseriesType

PossibleTimeseriesTypeValues returns the possible values for the TimeseriesType const type.

func (TimeseriesType) ToPtr 

func (c TimeseriesType) ToPtr() *TimeseriesType

ToPtr returns a *TimeseriesType pointing to the current value.

type Transform 

type Transform string

Transform - Describes what transforms are applied before matching 

const (
	TransformLowercase   Transform = "Lowercase"
	TransformRemoveNulls Transform = "RemoveNulls"
	TransformTrim        Transform = "Trim"
	TransformURLDecode   Transform = "UrlDecode"
	TransformURLEncode   Transform = "UrlEncode"
	TransformUppercase   Transform = "Uppercase"
)

func PossibleTransformValues 

func PossibleTransformValues() []Transform

PossibleTransformValues returns the possible values for the Transform const type.

func (Transform) ToPtr 

func (c Transform) ToPtr() *Transform

ToPtr returns a *Transform pointing to the current value.

type TransformType 

type TransformType string

TransformType - Describes what transforms applied before matching. 

const (
	TransformTypeLowercase   TransformType = "Lowercase"
	TransformTypeRemoveNulls TransformType = "RemoveNulls"
	TransformTypeTrim        TransformType = "Trim"
	TransformTypeURLDecode   TransformType = "UrlDecode"
	TransformTypeURLEncode   TransformType = "UrlEncode"
	TransformTypeUppercase   TransformType = "Uppercase"
)

func PossibleTransformTypeValues 

func PossibleTransformTypeValues() []TransformType

PossibleTransformTypeValues returns the possible values for the TransformType const type.

func (TransformType) ToPtr 

func (c TransformType) ToPtr() *TransformType

ToPtr returns a *TransformType pointing to the current value.

type UpdateParameters added in v0.2.0 

type UpdateParameters struct {
	// Backend pools available to routing rules.
	BackendPools []*BackendPool `json:"backendPools,omitempty"`

	// Settings for all backendPools
	BackendPoolsSettings *BackendPoolsSettings `json:"backendPoolsSettings,omitempty"`

	// Operational status of the Front Door load balancer. Permitted values are 'Enabled' or 'Disabled'
	EnabledState *FrontDoorEnabledState `json:"enabledState,omitempty"`

	// A friendly name for the frontDoor
	FriendlyName *string `json:"friendlyName,omitempty"`

	// Frontend endpoints available to routing rules.
	FrontendEndpoints []*FrontendEndpoint `json:"frontendEndpoints,omitempty"`

	// Health probe settings associated with this Front Door instance.
	HealthProbeSettings []*HealthProbeSettingsModel `json:"healthProbeSettings,omitempty"`

	// Load balancing settings associated with this Front Door instance.
	LoadBalancingSettings []*LoadBalancingSettingsModel `json:"loadBalancingSettings,omitempty"`

	// Routing rules associated with this Front Door.
	RoutingRules []*RoutingRule `json:"routingRules,omitempty"`
}

UpdateParameters - The properties needed to update a Front Door

func (UpdateParameters) MarshalJSON added in v0.2.0 

func (u UpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UpdateParameters.

type ValidateCustomDomainInput 

type ValidateCustomDomainInput struct {
	// REQUIRED; The host name of the custom domain. Must be a domain name.
	HostName *string `json:"hostName,omitempty"`
}

ValidateCustomDomainInput - Input of the custom domain to be validated for DNS mapping.

type ValidateCustomDomainOutput 

type ValidateCustomDomainOutput struct {
	// READ-ONLY; Indicates whether the custom domain is valid or not.
	CustomDomainValidated *bool `json:"customDomainValidated,omitempty" azure:"ro"`

	// READ-ONLY; Error message describing why the custom domain is not valid.
	Message *string `json:"message,omitempty" azure:"ro"`

	// READ-ONLY; The reason why the custom domain is not valid.
	Reason *string `json:"reason,omitempty" azure:"ro"`
}

ValidateCustomDomainOutput - Output of custom domain validation.

type WebApplicationFirewallPolicy 

type WebApplicationFirewallPolicy struct {
	// Gets a unique read-only string that changes whenever the resource is updated.
	Etag *string `json:"etag,omitempty"`

	// Resource location.
	Location *string `json:"location,omitempty"`

	// Properties of the web application firewall policy.
	Properties *WebApplicationFirewallPolicyProperties `json:"properties,omitempty"`

	// The pricing tier of web application firewall policy. Defaults to Classic_AzureFrontDoor if not specified.
	SKU *SKU `json:"sku,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

WebApplicationFirewallPolicy - Defines web application firewall policy.

func (WebApplicationFirewallPolicy) MarshalJSON 

func (w WebApplicationFirewallPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WebApplicationFirewallPolicy.

type WebApplicationFirewallPolicyList 

type WebApplicationFirewallPolicyList struct {
	// URL to get the next set of WebApplicationFirewallPolicy objects if there are any.
	NextLink *string `json:"nextLink,omitempty"`

	// READ-ONLY; List of WebApplicationFirewallPolicies within a resource group.
	Value []*WebApplicationFirewallPolicy `json:"value,omitempty" azure:"ro"`
}

WebApplicationFirewallPolicyList - Defines a list of WebApplicationFirewallPolicies. It contains a list of WebApplicationFirewallPolicy objects and a URL link to get the next set of results.

func (WebApplicationFirewallPolicyList) MarshalJSON 

func (w WebApplicationFirewallPolicyList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WebApplicationFirewallPolicyList.

type WebApplicationFirewallPolicyProperties 

type WebApplicationFirewallPolicyProperties struct {
	// Describes custom rules inside the policy.
	CustomRules *CustomRuleList `json:"customRules,omitempty"`

	// Describes managed rules inside the policy.
	ManagedRules *ManagedRuleSetList `json:"managedRules,omitempty"`

	// Describes settings for the policy.
	PolicySettings *PolicySettings `json:"policySettings,omitempty"`

	// READ-ONLY; Describes Frontend Endpoints associated with this Web Application Firewall policy.
	FrontendEndpointLinks []*FrontendEndpointLink `json:"frontendEndpointLinks,omitempty" azure:"ro"`

	// READ-ONLY; Provisioning state of the policy.
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; Resource status of the policy.
	ResourceState *PolicyResourceState `json:"resourceState,omitempty" azure:"ro"`

	// READ-ONLY; Describes Routing Rules associated with this Web Application Firewall policy.
	RoutingRuleLinks []*RoutingRuleLink `json:"routingRuleLinks,omitempty" azure:"ro"`

	// READ-ONLY; Describes Security Policy associated with this Web Application Firewall policy.
	SecurityPolicyLinks []*SecurityPolicyLink `json:"securityPolicyLinks,omitempty" azure:"ro"`
}

WebApplicationFirewallPolicyProperties - Defines web application firewall policy properties.

func (WebApplicationFirewallPolicyProperties) MarshalJSON 

func (w WebApplicationFirewallPolicyProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WebApplicationFirewallPolicyProperties.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.