armdomainservices

package module
v1.2.0 Latest Latest
Warning

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

 Go to latest Published: Nov 23, 2023 License: MIT Imports: 14 Imported by: 1

README

Azure Domain Services Module for Go

PkgGoDev

The armdomainservices module provides operations for working with Azure Domain Services.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Go 1.18 or above (You could download and install the latest version of Go from here. It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this doc.)

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Domain Services module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/domainservices/armdomainservices

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Domain Services. 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.

Client Factory

Azure Domain Services module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armdomainservices.NewClientFactory(<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 {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armdomainservices.NewClientFactory(<subscription ID>, cred, &options)

Clients

A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory.

client := clientFactory.NewDomainServiceOperationsClient()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Domain Services 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 Client added in v0.2.0 

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

Client contains the methods for the DomainServices group. Don't use this type directly, use NewClient() instead.

func NewClient added in v0.2.0 

func NewClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*Client, error)

NewClient creates a new instance of Client with the specified values.

  • subscriptionID - Gets 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 (*Client) BeginCreateOrUpdate added in v0.2.0 

func (client *Client) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, domainServiceName string, domainService DomainService, options *ClientBeginCreateOrUpdateOptions) (*runtime.Poller[ClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - The Create Domain Service operation creates a new domain service with the specified parameters. If the specific service already exists, then any patchable properties will be updated and any immutable properties will remain unchanged. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-05-01

  • resourceGroupName - The name of the resource group within the user's subscription. The name is case insensitive.
  • domainServiceName - The name of the domain service.
  • domainService - Properties supplied to the Create or Update a Domain Service operation.
  • options - ClientBeginCreateOrUpdateOptions contains the optional parameters for the Client.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/CreateDomainService.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/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewClient().BeginCreateOrUpdate(ctx, "TestResourceGroup", "TestDomainService.com", armdomainservices.DomainService{
		Properties: &armdomainservices.DomainServiceProperties{
			DomainName: to.Ptr("TestDomainService.com"),
			DomainSecuritySettings: &armdomainservices.DomainSecuritySettings{
				NtlmV1:            to.Ptr(armdomainservices.NtlmV1Enabled),
				SyncNtlmPasswords: to.Ptr(armdomainservices.SyncNtlmPasswordsEnabled),
				TLSV1:             to.Ptr(armdomainservices.TLSV1Disabled),
			},
			FilteredSync: to.Ptr(armdomainservices.FilteredSyncEnabled),
			LdapsSettings: &armdomainservices.LdapsSettings{
				ExternalAccess:         to.Ptr(armdomainservices.ExternalAccessEnabled),
				Ldaps:                  to.Ptr(armdomainservices.LdapsEnabled),
				PfxCertificate:         to.Ptr("MIIDPDCCAiSgAwIBAgIQQUI9P6tq2p9OFIJa7DLNvTANBgkqhkiG9w0BAQsFADAgMR4w..."),
				PfxCertificatePassword: to.Ptr("<pfxCertificatePassword>"),
			},
			NotificationSettings: &armdomainservices.NotificationSettings{
				AdditionalRecipients: []*string{
					to.Ptr("jicha@microsoft.com"),
					to.Ptr("caalmont@microsoft.com")},
				NotifyDcAdmins:     to.Ptr(armdomainservices.NotifyDcAdminsEnabled),
				NotifyGlobalAdmins: to.Ptr(armdomainservices.NotifyGlobalAdminsEnabled),
			},
			ReplicaSets: []*armdomainservices.ReplicaSet{
				{
					Location: to.Ptr("West US"),
					SubnetID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestNetworkResourceGroup/providers/Microsoft.Network/virtualNetworks/TestVnetWUS/subnets/TestSubnetWUS"),
				}},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.DomainService = armdomainservices.DomainService{
	// 	Name: to.Ptr("TestDomainService.com"),
	// 	Type: to.Ptr("Microsoft.AAD/DomainServices"),
	// 	ID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestResourceGroup/providers/Microsoft.AAD/DomainServices/TestDomainService.com"),
	// 	Properties: &armdomainservices.DomainServiceProperties{
	// 		DeploymentID: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
	// 		DomainName: to.Ptr("TestDomainService.com"),
	// 		DomainSecuritySettings: &armdomainservices.DomainSecuritySettings{
	// 			NtlmV1: to.Ptr(armdomainservices.NtlmV1Enabled),
	// 			SyncNtlmPasswords: to.Ptr(armdomainservices.SyncNtlmPasswordsEnabled),
	// 			TLSV1: to.Ptr(armdomainservices.TLSV1Disabled),
	// 		},
	// 		FilteredSync: to.Ptr(armdomainservices.FilteredSyncEnabled),
	// 		LdapsSettings: &armdomainservices.LdapsSettings{
	// 			CertificateNotAfter: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-02-15T21:43:21.000Z"); return t}()),
	// 			CertificateThumbprint: to.Ptr("9154A390F0C387D679E0DD040701745CDFED67F3"),
	// 			ExternalAccess: to.Ptr(armdomainservices.ExternalAccessEnabled),
	// 			Ldaps: to.Ptr(armdomainservices.LdapsEnabled),
	// 			PublicCertificate: to.Ptr("MIIDPDCCAiSgAwIBAgIQQUI9P6tq2p9OFIJa7DLNvTANBgkqhkiG9w0BAQsFADAgMR4w..."),
	// 		},
	// 		NotificationSettings: &armdomainservices.NotificationSettings{
	// 			AdditionalRecipients: []*string{
	// 				to.Ptr("jicha@microsoft.com"),
	// 				to.Ptr("caalmont@microsoft.com")},
	// 				NotifyDcAdmins: to.Ptr(armdomainservices.NotifyDcAdminsEnabled),
	// 				NotifyGlobalAdmins: to.Ptr(armdomainservices.NotifyGlobalAdminsEnabled),
	// 			},
	// 			ProvisioningState: to.Ptr("Succeeded"),
	// 			ReplicaSets: []*armdomainservices.ReplicaSet{
	// 				{
	// 					DomainControllerIPAddress: []*string{
	// 						to.Ptr("10.0.0.1"),
	// 						to.Ptr("10.0.0.2")},
	// 						ExternalAccessIPAddress: to.Ptr("13.64.148.151"),
	// 						Location: to.Ptr("West US"),
	// 						ReplicaSetID: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
	// 						ServiceStatus: to.Ptr("Running"),
	// 						SubnetID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestNetworkResourceGroup/providers/Microsoft.Network/virtualNetworks/TestVnetWUS/subnets/TestSubnetWUS"),
	// 						VnetSiteID: to.Ptr("99083198-a39c-469f-972d-59017e7f078c"),
	// 				}},
	// 				SyncOwner: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
	// 				TenantID: to.Ptr("3f8cd22c-7b32-48aa-a01c-f533133b1def"),
	// 				Version: to.Ptr[int32](2),
	// 			},
	// 		}
}

Output:

func (*Client) BeginDelete added in v0.2.0 

func (client *Client) BeginDelete(ctx context.Context, resourceGroupName string, domainServiceName string, options *ClientBeginDeleteOptions) (*runtime.Poller[ClientDeleteResponse], error)

BeginDelete - The Delete Domain Service operation deletes an existing Domain Service. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-05-01

  • resourceGroupName - The name of the resource group within the user's subscription. The name is case insensitive.
  • domainServiceName - The name of the domain service.
  • options - ClientBeginDeleteOptions contains the optional parameters for the Client.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/DeleteDomainService.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewClient().BeginDelete(ctx, "TestResourceGroup", "TestDomainService.com", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

Output:

func (*Client) BeginUpdate added in v0.2.0 

func (client *Client) BeginUpdate(ctx context.Context, resourceGroupName string, domainServiceName string, domainService DomainService, options *ClientBeginUpdateOptions) (*runtime.Poller[ClientUpdateResponse], error)

BeginUpdate - The Update Domain Service operation can be used to update the existing deployment. The update call only supports the properties listed in the PATCH body. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-05-01

  • resourceGroupName - The name of the resource group within the user's subscription. The name is case insensitive.
  • domainServiceName - The name of the domain service.
  • domainService - Properties supplied to the Update a Domain Service operation.
  • options - ClientBeginUpdateOptions contains the optional parameters for the Client.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/UpdateDomainService.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/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewClient().BeginUpdate(ctx, "TestResourceGroup", "TestDomainService.com", armdomainservices.DomainService{
		Properties: &armdomainservices.DomainServiceProperties{
			ConfigDiagnostics: &armdomainservices.ConfigDiagnostics{
				LastExecuted: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC1123, "NaN-NaN-NaNTNaN:NaN:NaN.NaNZ"); return t }()),
				ValidatorResults: []*armdomainservices.ConfigDiagnosticsValidatorResult{
					{
						Issues: []*armdomainservices.ConfigDiagnosticsValidatorResultIssue{
							{
								DescriptionParams: []*string{},
								ID:                to.Ptr("AADDS-CFG-DIAG-I20"),
							}},
						ReplicaSetSubnetDisplayName: to.Ptr("West US/aadds-subnet"),
						Status:                      to.Ptr(armdomainservices.StatusWarning),
						ValidatorID:                 to.Ptr("AADDS-CFG-DIAG-V06"),
					}},
			},
			DomainSecuritySettings: &armdomainservices.DomainSecuritySettings{
				NtlmV1:            to.Ptr(armdomainservices.NtlmV1Enabled),
				SyncNtlmPasswords: to.Ptr(armdomainservices.SyncNtlmPasswordsEnabled),
				TLSV1:             to.Ptr(armdomainservices.TLSV1Disabled),
			},
			FilteredSync: to.Ptr(armdomainservices.FilteredSyncEnabled),
			LdapsSettings: &armdomainservices.LdapsSettings{
				ExternalAccess:         to.Ptr(armdomainservices.ExternalAccessEnabled),
				Ldaps:                  to.Ptr(armdomainservices.LdapsEnabled),
				PfxCertificate:         to.Ptr("MIIDPDCCAiSgAwIBAgIQQUI9P6tq2p9OFIJa7DLNvTANBgkqhkiG9w0BAQsFADAgMR4w..."),
				PfxCertificatePassword: to.Ptr("<pfxCertificatePassword>"),
			},
			NotificationSettings: &armdomainservices.NotificationSettings{
				AdditionalRecipients: []*string{
					to.Ptr("jicha@microsoft.com"),
					to.Ptr("caalmont@microsoft.com")},
				NotifyDcAdmins:     to.Ptr(armdomainservices.NotifyDcAdminsEnabled),
				NotifyGlobalAdmins: to.Ptr(armdomainservices.NotifyGlobalAdminsEnabled),
			},
			ReplicaSets: []*armdomainservices.ReplicaSet{
				{
					Location: to.Ptr("West US"),
					SubnetID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestNetworkResourceGroup/providers/Microsoft.Network/virtualNetworks/TestVnetWUS/subnets/TestSubnetWUS"),
				},
				{
					Location: to.Ptr("East US"),
					SubnetID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestNetworkResourceGroup/providers/Microsoft.Network/virtualNetworks/TestVnetEUS/subnets/TestSubnetEUS"),
				}},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.DomainService = armdomainservices.DomainService{
	// 	Name: to.Ptr("TestDomainService.com"),
	// 	Type: to.Ptr("Microsoft.AAD/DomainServices"),
	// 	ID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestResourceGroup/providers/Microsoft.AAD/DomainServices/TestDomainService.com"),
	// 	Properties: &armdomainservices.DomainServiceProperties{
	// 		DeploymentID: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
	// 		DomainName: to.Ptr("TestDomainService.com"),
	// 		DomainSecuritySettings: &armdomainservices.DomainSecuritySettings{
	// 			NtlmV1: to.Ptr(armdomainservices.NtlmV1Enabled),
	// 			SyncNtlmPasswords: to.Ptr(armdomainservices.SyncNtlmPasswordsEnabled),
	// 			TLSV1: to.Ptr(armdomainservices.TLSV1Disabled),
	// 		},
	// 		FilteredSync: to.Ptr(armdomainservices.FilteredSyncEnabled),
	// 		LdapsSettings: &armdomainservices.LdapsSettings{
	// 			CertificateNotAfter: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-02-15T21:43:21.000Z"); return t}()),
	// 			CertificateThumbprint: to.Ptr("9154A390F0C387D679E0DD040701745CDFED67F3"),
	// 			ExternalAccess: to.Ptr(armdomainservices.ExternalAccessEnabled),
	// 			Ldaps: to.Ptr(armdomainservices.LdapsEnabled),
	// 			PublicCertificate: to.Ptr("MIIDPDCCAiSgAwIBAgIQQUI9P6tq2p9OFIJa7DLNvTANBgkqhkiG9w0BAQsFADAgMR4w..."),
	// 		},
	// 		NotificationSettings: &armdomainservices.NotificationSettings{
	// 			AdditionalRecipients: []*string{
	// 				to.Ptr("jicha@microsoft.com"),
	// 				to.Ptr("caalmont@microsoft.com")},
	// 				NotifyDcAdmins: to.Ptr(armdomainservices.NotifyDcAdminsEnabled),
	// 				NotifyGlobalAdmins: to.Ptr(armdomainservices.NotifyGlobalAdminsEnabled),
	// 			},
	// 			ProvisioningState: to.Ptr("Succeeded"),
	// 			ReplicaSets: []*armdomainservices.ReplicaSet{
	// 				{
	// 					DomainControllerIPAddress: []*string{
	// 						to.Ptr("10.0.0.1"),
	// 						to.Ptr("10.0.0.2")},
	// 						ExternalAccessIPAddress: to.Ptr("13.64.148.151"),
	// 						Location: to.Ptr("West US"),
	// 						ReplicaSetID: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
	// 						ServiceStatus: to.Ptr("Running"),
	// 						SubnetID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestNetworkResourceGroup/providers/Microsoft.Network/virtualNetworks/TestVnetWUS/subnets/TestSubnetWUS"),
	// 						VnetSiteID: to.Ptr("99083198-a39c-469f-972d-59017e7f078c"),
	// 					},
	// 					{
	// 						DomainControllerIPAddress: []*string{
	// 							to.Ptr("10.0.0.3"),
	// 							to.Ptr("10.0.0.4")},
	// 							ExternalAccessIPAddress: to.Ptr("13.64.148.152"),
	// 							Location: to.Ptr("East US"),
	// 							ReplicaSetID: to.Ptr("5057347d-cad1-4ec8-8db6-66cf7eedf4b8"),
	// 							ServiceStatus: to.Ptr("Running"),
	// 							SubnetID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestNetworkResourceGroup/providers/Microsoft.Network/virtualNetworks/TestVnetEUS/subnets/TestSubnetEUS"),
	// 					}},
	// 					SyncOwner: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
	// 					TenantID: to.Ptr("3f8cd22c-7b32-48aa-a01c-f533133b1def"),
	// 					Version: to.Ptr[int32](2),
	// 				},
	// 			}
}

Output:

func (*Client) Get added in v0.2.0 

func (client *Client) Get(ctx context.Context, resourceGroupName string, domainServiceName string, options *ClientGetOptions) (ClientGetResponse, error)

Get - The Get Domain Service operation retrieves a json representation of the Domain Service. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-05-01

  • resourceGroupName - The name of the resource group within the user's subscription. The name is case insensitive.
  • domainServiceName - The name of the domain service.
  • options - ClientGetOptions contains the optional parameters for the Client.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/GetDomainService.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().Get(ctx, "TestResourceGroup", "TestDomainService.com", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.DomainService = armdomainservices.DomainService{
	// 	Name: to.Ptr("TestDomainService.com"),
	// 	Type: to.Ptr("Microsoft.AAD/DomainServices"),
	// 	ID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestResourceGroup/providers/Microsoft.AAD/DomainServices/TestDomainService.com"),
	// 	Properties: &armdomainservices.DomainServiceProperties{
	// 		DeploymentID: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
	// 		DomainName: to.Ptr("TestDomainService.com"),
	// 		DomainSecuritySettings: &armdomainservices.DomainSecuritySettings{
	// 			NtlmV1: to.Ptr(armdomainservices.NtlmV1Enabled),
	// 			SyncNtlmPasswords: to.Ptr(armdomainservices.SyncNtlmPasswordsEnabled),
	// 			TLSV1: to.Ptr(armdomainservices.TLSV1Disabled),
	// 		},
	// 		FilteredSync: to.Ptr(armdomainservices.FilteredSyncEnabled),
	// 		LdapsSettings: &armdomainservices.LdapsSettings{
	// 			CertificateNotAfter: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-02-15T21:43:21.000Z"); return t}()),
	// 			CertificateThumbprint: to.Ptr("9154A390F0C387D679E0DD040701745CDFED67F3"),
	// 			ExternalAccess: to.Ptr(armdomainservices.ExternalAccessEnabled),
	// 			Ldaps: to.Ptr(armdomainservices.LdapsEnabled),
	// 			PublicCertificate: to.Ptr("MIIDPDCCAiSgAwIBAgIQQUI9P6tq2p9OFIJa7DLNvTANBgkqhkiG9w0BAQsFADAgMR4w..."),
	// 		},
	// 		NotificationSettings: &armdomainservices.NotificationSettings{
	// 			AdditionalRecipients: []*string{
	// 				to.Ptr("jicha@microsoft.com"),
	// 				to.Ptr("caalmont@microsoft.com")},
	// 				NotifyDcAdmins: to.Ptr(armdomainservices.NotifyDcAdminsEnabled),
	// 				NotifyGlobalAdmins: to.Ptr(armdomainservices.NotifyGlobalAdminsEnabled),
	// 			},
	// 			ProvisioningState: to.Ptr("Succeeded"),
	// 			ReplicaSets: []*armdomainservices.ReplicaSet{
	// 				{
	// 					DomainControllerIPAddress: []*string{
	// 						to.Ptr("10.0.0.1"),
	// 						to.Ptr("10.0.0.2")},
	// 						ExternalAccessIPAddress: to.Ptr("13.64.148.151"),
	// 						HealthAlerts: []*armdomainservices.HealthAlert{
	// 							{
	// 								Name: to.Ptr("The managed domain is experiencing a network error"),
	// 								ID: to.Ptr("AADDS104"),
	// 								Issue: to.Ptr("Microsoft is unable to reach the domain controllers for this managed domain. This may happen if a network security group (NSG) configured on your virtual network blocks access to the managed domain. Another possible reason is if there is a user defined route that blocks incoming traffic from the internet."),
	// 								LastDetected: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-09-18T17:46:39.269Z"); return t}()),
	// 								Raised: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-09-18T01:55:40.783Z"); return t}()),
	// 								ResolutionURI: to.Ptr("https://aka.ms/aadds-neterr"),
	// 								Severity: to.Ptr("2"),
	// 						}},
	// 						HealthLastEvaluated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC1123, "2018-02-15T21:43:21.000Z"); return t}()),
	// 						HealthMonitors: []*armdomainservices.HealthMonitor{
	// 							{
	// 								Name: to.Ptr("Backup"),
	// 								ID: to.Ptr("AADDS501"),
	// 								Details: to.Ptr("Last backed up on Tue, 18 Sep 2018 03:37:04 GMT"),
	// 							},
	// 							{
	// 								Name: to.Ptr("Synchronization with Azure AD"),
	// 								ID: to.Ptr("AADDS500"),
	// 								Details: to.Ptr("Synchronized on Tue, 18 Sep 2018 16:47:57 GMT."),
	// 						}},
	// 						Location: to.Ptr("West US"),
	// 						ReplicaSetID: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
	// 						ServiceStatus: to.Ptr("Running"),
	// 						SubnetID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestNetworkResourceGroup/providers/Microsoft.Network/virtualNetworks/TestVnetWUS/subnets/TestSubnetWUS"),
	// 						VnetSiteID: to.Ptr("99083198-a39c-469f-972d-59017e7f078c"),
	// 				}},
	// 				SyncOwner: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
	// 				TenantID: to.Ptr("3f8cd22c-7b32-48aa-a01c-f533133b1def"),
	// 				Version: to.Ptr[int32](2),
	// 			},
	// 		}
}

Output:

func (*Client) NewListByResourceGroupPager added in v0.4.0 

func (client *Client) NewListByResourceGroupPager(resourceGroupName string, options *ClientListByResourceGroupOptions) *runtime.Pager[ClientListByResourceGroupResponse]

NewListByResourceGroupPager - The List Domain Services in Resource Group operation lists all the domain services available under the given resource group.

Generated from API version 2021-05-01

  • resourceGroupName - The name of the resource group within the user's subscription. The name is case insensitive.
  • options - ClientListByResourceGroupOptions contains the optional parameters for the Client.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/ListDomainServicesByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewClient().NewListByResourceGroupPager("TestResourceGroup", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.DomainServiceListResult = armdomainservices.DomainServiceListResult{
		// 	Value: []*armdomainservices.DomainService{
		// 		{
		// 			Name: to.Ptr("TestDomainService.com"),
		// 			Type: to.Ptr("Microsoft.AAD/DomainServices"),
		// 			ID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestResourceGroup/providers/Microsoft.AAD/DomainServices/TestDomainService.com"),
		// 			Properties: &armdomainservices.DomainServiceProperties{
		// 				DeploymentID: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
		// 				DomainName: to.Ptr("TestDomainService.com"),
		// 				DomainSecuritySettings: &armdomainservices.DomainSecuritySettings{
		// 					NtlmV1: to.Ptr(armdomainservices.NtlmV1Enabled),
		// 					SyncNtlmPasswords: to.Ptr(armdomainservices.SyncNtlmPasswordsEnabled),
		// 					TLSV1: to.Ptr(armdomainservices.TLSV1Disabled),
		// 				},
		// 				FilteredSync: to.Ptr(armdomainservices.FilteredSyncEnabled),
		// 				LdapsSettings: &armdomainservices.LdapsSettings{
		// 					CertificateNotAfter: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-02-15T21:43:21.000Z"); return t}()),
		// 					CertificateThumbprint: to.Ptr("9154A390F0C387D679E0DD040701745CDFED67F3"),
		// 					ExternalAccess: to.Ptr(armdomainservices.ExternalAccessEnabled),
		// 					Ldaps: to.Ptr(armdomainservices.LdapsEnabled),
		// 					PublicCertificate: to.Ptr("MIIDPDCCAiSgAwIBAgIQQUI9P6tq2p9OFIJa7DLNvTANBgkqhkiG9w0BAQsFADAgMR4w..."),
		// 				},
		// 				NotificationSettings: &armdomainservices.NotificationSettings{
		// 					AdditionalRecipients: []*string{
		// 						to.Ptr("jicha@microsoft.com"),
		// 						to.Ptr("caalmont@microsoft.com")},
		// 						NotifyDcAdmins: to.Ptr(armdomainservices.NotifyDcAdminsEnabled),
		// 						NotifyGlobalAdmins: to.Ptr(armdomainservices.NotifyGlobalAdminsEnabled),
		// 					},
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ReplicaSets: []*armdomainservices.ReplicaSet{
		// 						{
		// 							DomainControllerIPAddress: []*string{
		// 								to.Ptr("10.0.0.1"),
		// 								to.Ptr("10.0.0.2")},
		// 								ExternalAccessIPAddress: to.Ptr("13.64.148.151"),
		// 								HealthAlerts: []*armdomainservices.HealthAlert{
		// 									{
		// 										Name: to.Ptr("The managed domain is experiencing a network error"),
		// 										ID: to.Ptr("AADDS104"),
		// 										Issue: to.Ptr("Microsoft is unable to reach the domain controllers for this managed domain. This may happen if a network security group (NSG) configured on your virtual network blocks access to the managed domain. Another possible reason is if there is a user defined route that blocks incoming traffic from the internet."),
		// 										LastDetected: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-09-18T17:46:39.269Z"); return t}()),
		// 										Raised: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-09-18T01:55:40.783Z"); return t}()),
		// 										ResolutionURI: to.Ptr("https://aka.ms/aadds-neterr"),
		// 										Severity: to.Ptr("2"),
		// 								}},
		// 								HealthLastEvaluated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC1123, "2018-02-15T21:43:21.000Z"); return t}()),
		// 								HealthMonitors: []*armdomainservices.HealthMonitor{
		// 									{
		// 										Name: to.Ptr("Backup"),
		// 										ID: to.Ptr("AADDS501"),
		// 										Details: to.Ptr("Last backed up on Tue, 18 Sep 2018 03:37:04 GMT"),
		// 									},
		// 									{
		// 										Name: to.Ptr("Synchronization with Azure AD"),
		// 										ID: to.Ptr("AADDS500"),
		// 										Details: to.Ptr("Synchronized on Tue, 18 Sep 2018 16:47:57 GMT."),
		// 								}},
		// 								Location: to.Ptr("West US"),
		// 								ReplicaSetID: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
		// 								ServiceStatus: to.Ptr("Running"),
		// 								SubnetID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestNetworkResourceGroup/providers/Microsoft.Network/virtualNetworks/TestVnetWUS/subnets/TestSubnetWUS"),
		// 								VnetSiteID: to.Ptr("99083198-a39c-469f-972d-59017e7f078c"),
		// 						}},
		// 						SyncOwner: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
		// 						TenantID: to.Ptr("3f8cd22c-7b32-48aa-a01c-f533133b1def"),
		// 						Version: to.Ptr[int32](2),
		// 					},
		// 			}},
		// 		}
	}
}

Output:

func (*Client) NewListPager added in v0.4.0 

func (client *Client) NewListPager(options *ClientListOptions) *runtime.Pager[ClientListResponse]

NewListPager - The List Domain Services in Subscription operation lists all the domain services available under the given subscription (and across all resource groups within that subscription).

Generated from API version 2021-05-01

  • options - ClientListOptions contains the optional parameters for the Client.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/ListDomainServicesBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewClient().NewListPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.DomainServiceListResult = armdomainservices.DomainServiceListResult{
		// 	Value: []*armdomainservices.DomainService{
		// 		{
		// 			Name: to.Ptr("TestDomainService.com"),
		// 			Type: to.Ptr("Microsoft.AAD/DomainServices"),
		// 			ID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestResourceGroup/providers/Microsoft.AAD/DomainServices/TestDomainService.com"),
		// 			Properties: &armdomainservices.DomainServiceProperties{
		// 				DeploymentID: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
		// 				DomainName: to.Ptr("TestDomainService.com"),
		// 				DomainSecuritySettings: &armdomainservices.DomainSecuritySettings{
		// 					NtlmV1: to.Ptr(armdomainservices.NtlmV1Enabled),
		// 					SyncNtlmPasswords: to.Ptr(armdomainservices.SyncNtlmPasswordsEnabled),
		// 					TLSV1: to.Ptr(armdomainservices.TLSV1Disabled),
		// 				},
		// 				FilteredSync: to.Ptr(armdomainservices.FilteredSyncEnabled),
		// 				LdapsSettings: &armdomainservices.LdapsSettings{
		// 					CertificateNotAfter: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-02-15T21:43:21.000Z"); return t}()),
		// 					CertificateThumbprint: to.Ptr("9154A390F0C387D679E0DD040701745CDFED67F3"),
		// 					ExternalAccess: to.Ptr(armdomainservices.ExternalAccessEnabled),
		// 					Ldaps: to.Ptr(armdomainservices.LdapsEnabled),
		// 					PublicCertificate: to.Ptr("MIIDPDCCAiSgAwIBAgIQQUI9P6tq2p9OFIJa7DLNvTANBgkqhkiG9w0BAQsFADAgMR4w..."),
		// 				},
		// 				NotificationSettings: &armdomainservices.NotificationSettings{
		// 					AdditionalRecipients: []*string{
		// 						to.Ptr("jicha@microsoft.com"),
		// 						to.Ptr("caalmont@microsoft.com")},
		// 						NotifyDcAdmins: to.Ptr(armdomainservices.NotifyDcAdminsEnabled),
		// 						NotifyGlobalAdmins: to.Ptr(armdomainservices.NotifyGlobalAdminsEnabled),
		// 					},
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ReplicaSets: []*armdomainservices.ReplicaSet{
		// 						{
		// 							DomainControllerIPAddress: []*string{
		// 								to.Ptr("10.0.0.1"),
		// 								to.Ptr("10.0.0.2")},
		// 								ExternalAccessIPAddress: to.Ptr("13.64.148.151"),
		// 								HealthAlerts: []*armdomainservices.HealthAlert{
		// 									{
		// 										Name: to.Ptr("The managed domain is experiencing a network error"),
		// 										ID: to.Ptr("AADDS104"),
		// 										Issue: to.Ptr("Microsoft is unable to reach the domain controllers for this managed domain. This may happen if a network security group (NSG) configured on your virtual network blocks access to the managed domain. Another possible reason is if there is a user defined route that blocks incoming traffic from the internet."),
		// 										LastDetected: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-09-18T17:46:39.269Z"); return t}()),
		// 										Raised: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-09-18T01:55:40.783Z"); return t}()),
		// 										ResolutionURI: to.Ptr("https://aka.ms/aadds-neterr"),
		// 										Severity: to.Ptr("2"),
		// 								}},
		// 								HealthLastEvaluated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC1123, "2018-02-15T21:43:21.000Z"); return t}()),
		// 								HealthMonitors: []*armdomainservices.HealthMonitor{
		// 									{
		// 										Name: to.Ptr("Backup"),
		// 										ID: to.Ptr("AADDS501"),
		// 										Details: to.Ptr("Last backed up on Tue, 18 Sep 2018 03:37:04 GMT"),
		// 									},
		// 									{
		// 										Name: to.Ptr("Synchronization with Azure AD"),
		// 										ID: to.Ptr("AADDS500"),
		// 										Details: to.Ptr("Synchronized on Tue, 18 Sep 2018 16:47:57 GMT."),
		// 								}},
		// 								Location: to.Ptr("West US"),
		// 								ReplicaSetID: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
		// 								ServiceStatus: to.Ptr("Running"),
		// 								SubnetID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/TestNetworkResourceGroup/providers/Microsoft.Network/virtualNetworks/TestVnetWUS/subnets/TestSubnetWUS"),
		// 								VnetSiteID: to.Ptr("99083198-a39c-469f-972d-59017e7f078c"),
		// 						}},
		// 						SyncOwner: to.Ptr("4a619871-0150-41c4-aeb4-0b10deb7940a"),
		// 						TenantID: to.Ptr("3f8cd22c-7b32-48aa-a01c-f533133b1def"),
		// 						Version: to.Ptr[int32](2),
		// 					},
		// 			}},
		// 		}
	}
}

Output:

type ClientBeginCreateOrUpdateOptions added in v0.2.0 

type ClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ClientBeginCreateOrUpdateOptions contains the optional parameters for the Client.BeginCreateOrUpdate method.

type ClientBeginDeleteOptions added in v0.2.0 

type ClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ClientBeginDeleteOptions contains the optional parameters for the Client.BeginDelete method.

type ClientBeginUpdateOptions added in v0.2.0 

type ClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ClientBeginUpdateOptions contains the optional parameters for the Client.BeginUpdate method.

type ClientCreateOrUpdateResponse added in v0.2.0 

type ClientCreateOrUpdateResponse struct {
	// Domain service.
	DomainService
}

ClientCreateOrUpdateResponse contains the response from method Client.BeginCreateOrUpdate.

type ClientDeleteResponse added in v0.2.0 

type ClientDeleteResponse struct {
}

ClientDeleteResponse contains the response from method Client.BeginDelete.

type ClientFactory added in v1.1.0 

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

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory added in v1.1.0 

func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

  • subscriptionID - Gets 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 (*ClientFactory) NewClient added in v1.1.0 

func (c *ClientFactory) NewClient() *Client

NewClient creates a new instance of Client.

func (*ClientFactory) NewDomainServiceOperationsClient added in v1.1.0 

func (c *ClientFactory) NewDomainServiceOperationsClient() *DomainServiceOperationsClient

NewDomainServiceOperationsClient creates a new instance of DomainServiceOperationsClient.

func (*ClientFactory) NewOuContainerClient added in v1.1.0 

func (c *ClientFactory) NewOuContainerClient() *OuContainerClient

NewOuContainerClient creates a new instance of OuContainerClient.

func (*ClientFactory) NewOuContainerOperationsClient added in v1.1.0 

func (c *ClientFactory) NewOuContainerOperationsClient() *OuContainerOperationsClient

NewOuContainerOperationsClient creates a new instance of OuContainerOperationsClient.

type ClientGetOptions added in v0.2.0 

type ClientGetOptions struct {
}

ClientGetOptions contains the optional parameters for the Client.Get method.

type ClientGetResponse added in v0.2.0 

type ClientGetResponse struct {
	// Domain service.
	DomainService
}

ClientGetResponse contains the response from method Client.Get.

type ClientListByResourceGroupOptions added in v0.2.0 

type ClientListByResourceGroupOptions struct {
}

ClientListByResourceGroupOptions contains the optional parameters for the Client.NewListByResourceGroupPager method.

type ClientListByResourceGroupResponse added in v0.2.0 

type ClientListByResourceGroupResponse struct {
	// The response from the List Domain Services operation.
	DomainServiceListResult
}

ClientListByResourceGroupResponse contains the response from method Client.NewListByResourceGroupPager.

type ClientListOptions added in v0.2.0 

type ClientListOptions struct {
}

ClientListOptions contains the optional parameters for the Client.NewListPager method.

type ClientListResponse added in v0.2.0 

type ClientListResponse struct {
	// The response from the List Domain Services operation.
	DomainServiceListResult
}

ClientListResponse contains the response from method Client.NewListPager.

type ClientUpdateResponse added in v0.2.0 

type ClientUpdateResponse struct {
	// Domain service.
	DomainService
}

ClientUpdateResponse contains the response from method Client.BeginUpdate.

type ConfigDiagnostics 

type ConfigDiagnostics struct {
	// Last domain configuration diagnostics DateTime
	LastExecuted *time.Time

	// List of Configuration Diagnostics validator results.
	ValidatorResults []*ConfigDiagnosticsValidatorResult
}

ConfigDiagnostics - Configuration Diagnostics

func (ConfigDiagnostics) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConfigDiagnostics.

func (*ConfigDiagnostics) UnmarshalJSON 

func (c *ConfigDiagnostics) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigDiagnostics.

type ConfigDiagnosticsValidatorResult 

type ConfigDiagnosticsValidatorResult struct {
	// List of resource config validation issues.
	Issues []*ConfigDiagnosticsValidatorResultIssue

	// Replica set location and subnet name
	ReplicaSetSubnetDisplayName *string

	// Status for individual validator after running diagnostics.
	Status *Status

	// Validator identifier
	ValidatorID *string
}

ConfigDiagnosticsValidatorResult - Config Diagnostics validator result data

func (ConfigDiagnosticsValidatorResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConfigDiagnosticsValidatorResult.

func (*ConfigDiagnosticsValidatorResult) UnmarshalJSON added in v1.1.0 

func (c *ConfigDiagnosticsValidatorResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigDiagnosticsValidatorResult.

type ConfigDiagnosticsValidatorResultIssue 

type ConfigDiagnosticsValidatorResultIssue struct {
	// List of domain resource property name or values used to compose a rich description.
	DescriptionParams []*string

	// Validation issue identifier.
	ID *string
}

ConfigDiagnosticsValidatorResultIssue - Specific issue for a particular config diagnostics validator

func (ConfigDiagnosticsValidatorResultIssue) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConfigDiagnosticsValidatorResultIssue.

func (*ConfigDiagnosticsValidatorResultIssue) UnmarshalJSON added in v1.1.0 

func (c *ConfigDiagnosticsValidatorResultIssue) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigDiagnosticsValidatorResultIssue.

type ContainerAccount 

type ContainerAccount struct {
	// The account name
	AccountName *string

	// The account password
	Password *string

	// The account spn
	Spn *string
}

ContainerAccount - Container Account Description

func (ContainerAccount) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ContainerAccount.

func (*ContainerAccount) UnmarshalJSON added in v1.1.0 

func (c *ContainerAccount) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ContainerAccount.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type DomainSecuritySettings 

type DomainSecuritySettings struct {
	// A flag to determine whether or not KerberosArmoring is enabled or disabled.
	KerberosArmoring *KerberosArmoring

	// A flag to determine whether or not KerberosRc4Encryption is enabled or disabled.
	KerberosRc4Encryption *KerberosRc4Encryption

	// A flag to determine whether or not NtlmV1 is enabled or disabled.
	NtlmV1 *NtlmV1

	// A flag to determine whether or not SyncKerberosPasswords is enabled or disabled.
	SyncKerberosPasswords *SyncKerberosPasswords

	// A flag to determine whether or not SyncNtlmPasswords is enabled or disabled.
	SyncNtlmPasswords *SyncNtlmPasswords

	// A flag to determine whether or not SyncOnPremPasswords is enabled or disabled.
	SyncOnPremPasswords *SyncOnPremPasswords

	// A flag to determine whether or not TlsV1 is enabled or disabled.
	TLSV1 *TLSV1
}

DomainSecuritySettings - Domain Security Settings

func (DomainSecuritySettings) MarshalJSON added in v1.1.0 

func (d DomainSecuritySettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DomainSecuritySettings.

func (*DomainSecuritySettings) UnmarshalJSON added in v1.1.0 

func (d *DomainSecuritySettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DomainSecuritySettings.

type DomainService 

type DomainService struct {
	// Resource etag
	Etag *string

	// Resource location
	Location *string

	// Domain service properties
	Properties *DomainServiceProperties

	// Resource tags
	Tags map[string]*string

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource name
	Name *string

	// READ-ONLY; The system meta data relating to this resource.
	SystemData *SystemData

	// READ-ONLY; Resource type
	Type *string
}

DomainService - Domain service.

func (DomainService) MarshalJSON 

func (d DomainService) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DomainService.

func (*DomainService) UnmarshalJSON added in v1.1.0 

func (d *DomainService) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DomainService.

type DomainServiceListResult 

type DomainServiceListResult struct {
	// the list of domain services.
	Value []*DomainService

	// READ-ONLY; The continuation token for the next page of results.
	NextLink *string
}

DomainServiceListResult - The response from the List Domain Services operation.

func (DomainServiceListResult) MarshalJSON 

func (d DomainServiceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DomainServiceListResult.

func (*DomainServiceListResult) UnmarshalJSON added in v1.1.0 

func (d *DomainServiceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DomainServiceListResult.

type DomainServiceOperationsClient 

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

DomainServiceOperationsClient contains the methods for the DomainServiceOperations group. Don't use this type directly, use NewDomainServiceOperationsClient() instead.

func NewDomainServiceOperationsClient 

func NewDomainServiceOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*DomainServiceOperationsClient, error)

NewDomainServiceOperationsClient creates a new instance of DomainServiceOperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*DomainServiceOperationsClient) NewListPager added in v0.4.0 

func (client *DomainServiceOperationsClient) NewListPager(options *DomainServiceOperationsClientListOptions) *runtime.Pager[DomainServiceOperationsClientListResponse]

NewListPager - Lists all the available Domain Services operations.

Generated from API version 2021-05-01

  • options - DomainServiceOperationsClientListOptions contains the optional parameters for the DomainServiceOperationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/GetOperations.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDomainServiceOperationsClient().NewListPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.OperationEntityListResult = armdomainservices.OperationEntityListResult{
		// 	Value: []*armdomainservices.OperationEntity{
		// 		{
		// 			Name: to.Ptr("Microsoft.AAD/unregister/action"),
		// 			Display: &armdomainservices.OperationDisplayInfo{
		// 				Description: to.Ptr("Unregisters Domain Services"),
		// 				Operation: to.Ptr("Unregister Domain Service"),
		// 				Provider: to.Ptr("Domain Services Resource Provider"),
		// 				Resource: to.Ptr("Domain Service Type"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.AAD/register/action"),
		// 			Display: &armdomainservices.OperationDisplayInfo{
		// 				Description: to.Ptr("Registers Domain Services"),
		// 				Operation: to.Ptr("Register Domain Service"),
		// 				Provider: to.Ptr("Domain Services Resource Provider"),
		// 				Resource: to.Ptr("Domain Service Type"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.AAD/domainServices/read"),
		// 			Display: &armdomainservices.OperationDisplayInfo{
		// 				Description: to.Ptr("Reads Domain Services"),
		// 				Operation: to.Ptr("Read Domain Service"),
		// 				Provider: to.Ptr("Domain Services Resource Provider"),
		// 				Resource: to.Ptr("Domain Service Type"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.AAD/domainServices/write"),
		// 			Display: &armdomainservices.OperationDisplayInfo{
		// 				Description: to.Ptr("Writes Domain Services"),
		// 				Operation: to.Ptr("Write Domain Service"),
		// 				Provider: to.Ptr("Domain Services Resource Provider"),
		// 				Resource: to.Ptr("Domain Service Type"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.AAD/domainServices/delete"),
		// 			Display: &armdomainservices.OperationDisplayInfo{
		// 				Description: to.Ptr("Deletes Domain Services"),
		// 				Operation: to.Ptr("Delete Domain Service"),
		// 				Provider: to.Ptr("Domain Services Resource Provider"),
		// 				Resource: to.Ptr("Domain Service Type"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 	}},
		// }
	}
}

Output:

type DomainServiceOperationsClientListOptions added in v0.2.0 

type DomainServiceOperationsClientListOptions struct {
}

DomainServiceOperationsClientListOptions contains the optional parameters for the DomainServiceOperationsClient.NewListPager method.

type DomainServiceOperationsClientListResponse added in v0.2.0 

type DomainServiceOperationsClientListResponse struct {
	// The list of domain service operation response.
	OperationEntityListResult
}

DomainServiceOperationsClientListResponse contains the response from method DomainServiceOperationsClient.NewListPager.

type DomainServiceProperties 

type DomainServiceProperties struct {
	// Configuration diagnostics data containing latest execution from client.
	ConfigDiagnostics *ConfigDiagnostics

	// Domain Configuration Type
	DomainConfigurationType *string

	// The name of the Azure domain that the user would like to deploy Domain Services to.
	DomainName *string

	// DomainSecurity Settings
	DomainSecuritySettings *DomainSecuritySettings

	// Enabled or Disabled flag to turn on Group-based filtered sync
	FilteredSync *FilteredSync

	// Secure LDAP Settings
	LdapsSettings *LdapsSettings

	// Notification Settings
	NotificationSettings *NotificationSettings

	// List of ReplicaSets
	ReplicaSets []*ReplicaSet

	// Resource Forest Settings
	ResourceForestSettings *ResourceForestSettings

	// Sku Type
	SKU *string

	// READ-ONLY; Deployment Id
	DeploymentID *string

	// READ-ONLY; Migration Properties
	MigrationProperties *MigrationProperties

	// READ-ONLY; the current deployment or provisioning state, which only appears in the response.
	ProvisioningState *string

	// READ-ONLY; SyncOwner ReplicaSet Id
	SyncOwner *string

	// READ-ONLY; Azure Active Directory Tenant Id
	TenantID *string

	// READ-ONLY; Data Model Version
	Version *int32
}

DomainServiceProperties - Properties of the Domain Service.

func (DomainServiceProperties) MarshalJSON 

func (d DomainServiceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DomainServiceProperties.

func (*DomainServiceProperties) UnmarshalJSON added in v1.1.0 

func (d *DomainServiceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DomainServiceProperties.

type ExternalAccess 

type ExternalAccess string

ExternalAccess - A flag to determine whether or not Secure LDAP access over the internet is enabled or disabled. 

const (
	ExternalAccessDisabled ExternalAccess = "Disabled"
	ExternalAccessEnabled  ExternalAccess = "Enabled"
)

func PossibleExternalAccessValues 

func PossibleExternalAccessValues() []ExternalAccess

PossibleExternalAccessValues returns the possible values for the ExternalAccess const type.

type FilteredSync 

type FilteredSync string

FilteredSync - Enabled or Disabled flag to turn on Group-based filtered sync 

const (
	FilteredSyncDisabled FilteredSync = "Disabled"
	FilteredSyncEnabled  FilteredSync = "Enabled"
)

func PossibleFilteredSyncValues 

func PossibleFilteredSyncValues() []FilteredSync

PossibleFilteredSyncValues returns the possible values for the FilteredSync const type.

type ForestTrust 

type ForestTrust struct {
	// Friendly Name
	FriendlyName *string

	// Remote Dns ips
	RemoteDNSIPs *string

	// Trust Direction
	TrustDirection *string

	// Trust Password
	TrustPassword *string

	// Trusted Domain FQDN
	TrustedDomainFqdn *string
}

ForestTrust - Forest Trust Setting

func (ForestTrust) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type ForestTrust.

func (*ForestTrust) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ForestTrust.

type HealthAlert 

type HealthAlert struct {
	// READ-ONLY; Health Alert Id
	ID *string

	// READ-ONLY; Health Alert Issue
	Issue *string

	// READ-ONLY; Health Alert Last Detected DateTime
	LastDetected *time.Time

	// READ-ONLY; Health Alert Name
	Name *string

	// READ-ONLY; Health Alert Raised DateTime
	Raised *time.Time

	// READ-ONLY; Health Alert TSG Link
	ResolutionURI *string

	// READ-ONLY; Health Alert Severity
	Severity *string
}

HealthAlert - Health Alert Description

func (HealthAlert) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type HealthAlert.

func (*HealthAlert) UnmarshalJSON 

func (h *HealthAlert) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HealthAlert.

type HealthMonitor 

type HealthMonitor struct {
	// READ-ONLY; Health Monitor Details
	Details *string

	// READ-ONLY; Health Monitor Id
	ID *string

	// READ-ONLY; Health Monitor Name
	Name *string
}

HealthMonitor - Health Monitor Description

func (HealthMonitor) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type HealthMonitor.

func (*HealthMonitor) UnmarshalJSON added in v1.1.0 

func (h *HealthMonitor) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HealthMonitor.

type KerberosArmoring 

type KerberosArmoring string

KerberosArmoring - A flag to determine whether or not KerberosArmoring is enabled or disabled. 

const (
	KerberosArmoringDisabled KerberosArmoring = "Disabled"
	KerberosArmoringEnabled  KerberosArmoring = "Enabled"
)

func PossibleKerberosArmoringValues 

func PossibleKerberosArmoringValues() []KerberosArmoring

PossibleKerberosArmoringValues returns the possible values for the KerberosArmoring const type.

type KerberosRc4Encryption 

type KerberosRc4Encryption string

KerberosRc4Encryption - A flag to determine whether or not KerberosRc4Encryption is enabled or disabled. 

const (
	KerberosRc4EncryptionDisabled KerberosRc4Encryption = "Disabled"
	KerberosRc4EncryptionEnabled  KerberosRc4Encryption = "Enabled"
)

func PossibleKerberosRc4EncryptionValues 

func PossibleKerberosRc4EncryptionValues() []KerberosRc4Encryption

PossibleKerberosRc4EncryptionValues returns the possible values for the KerberosRc4Encryption const type.

type Ldaps 

type Ldaps string

Ldaps - A flag to determine whether or not Secure LDAP is enabled or disabled. 

const (
	LdapsDisabled Ldaps = "Disabled"
	LdapsEnabled  Ldaps = "Enabled"
)

func PossibleLdapsValues 

func PossibleLdapsValues() []Ldaps

PossibleLdapsValues returns the possible values for the Ldaps const type.

type LdapsSettings 

type LdapsSettings struct {
	// A flag to determine whether or not Secure LDAP access over the internet is enabled or disabled.
	ExternalAccess *ExternalAccess

	// A flag to determine whether or not Secure LDAP is enabled or disabled.
	Ldaps *Ldaps

	// The certificate required to configure Secure LDAP. The parameter passed here should be a base64encoded representation of
	// the certificate pfx file.
	PfxCertificate *string

	// The password to decrypt the provided Secure LDAP certificate pfx file.
	PfxCertificatePassword *string

	// READ-ONLY; NotAfter DateTime of configure ldaps certificate.
	CertificateNotAfter *time.Time

	// READ-ONLY; Thumbprint of configure ldaps certificate.
	CertificateThumbprint *string

	// READ-ONLY; Public certificate used to configure secure ldap.
	PublicCertificate *string
}

LdapsSettings - Secure LDAP Settings

func (LdapsSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LdapsSettings.

func (*LdapsSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LdapsSettings.

type MigrationProgress 

type MigrationProgress struct {
	// Completion Percentage
	CompletionPercentage *float64

	// Progress Message
	ProgressMessage *string
}

MigrationProgress - Migration Progress

func (MigrationProgress) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type MigrationProgress.

func (*MigrationProgress) UnmarshalJSON added in v1.1.0 

func (m *MigrationProgress) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationProgress.

type MigrationProperties 

type MigrationProperties struct {
	// READ-ONLY; Migration Progress
	MigrationProgress *MigrationProgress

	// READ-ONLY; Old Subnet Id
	OldSubnetID *string

	// READ-ONLY; Old Vnet Site Id
	OldVnetSiteID *string
}

MigrationProperties - Migration Properties

func (MigrationProperties) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type MigrationProperties.

func (*MigrationProperties) UnmarshalJSON added in v1.1.0 

func (m *MigrationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationProperties.

type NotificationSettings 

type NotificationSettings struct {
	// The list of additional recipients
	AdditionalRecipients []*string

	// Should domain controller admins be notified
	NotifyDcAdmins *NotifyDcAdmins

	// Should global admins be notified
	NotifyGlobalAdmins *NotifyGlobalAdmins
}

NotificationSettings - Settings for notification

func (NotificationSettings) MarshalJSON 

func (n NotificationSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NotificationSettings.

func (*NotificationSettings) UnmarshalJSON added in v1.1.0 

func (n *NotificationSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NotificationSettings.

type NotifyDcAdmins 

type NotifyDcAdmins string

NotifyDcAdmins - Should domain controller admins be notified 

const (
	NotifyDcAdminsDisabled NotifyDcAdmins = "Disabled"
	NotifyDcAdminsEnabled  NotifyDcAdmins = "Enabled"
)

func PossibleNotifyDcAdminsValues 

func PossibleNotifyDcAdminsValues() []NotifyDcAdmins

PossibleNotifyDcAdminsValues returns the possible values for the NotifyDcAdmins const type.

type NotifyGlobalAdmins 

type NotifyGlobalAdmins string

NotifyGlobalAdmins - Should global admins be notified 

const (
	NotifyGlobalAdminsDisabled NotifyGlobalAdmins = "Disabled"
	NotifyGlobalAdminsEnabled  NotifyGlobalAdmins = "Enabled"
)

func PossibleNotifyGlobalAdminsValues 

func PossibleNotifyGlobalAdminsValues() []NotifyGlobalAdmins

PossibleNotifyGlobalAdminsValues returns the possible values for the NotifyGlobalAdmins const type.

type NtlmV1 

type NtlmV1 string

NtlmV1 - A flag to determine whether or not NtlmV1 is enabled or disabled. 

const (
	NtlmV1Disabled NtlmV1 = "Disabled"
	NtlmV1Enabled  NtlmV1 = "Enabled"
)

func PossibleNtlmV1Values 

func PossibleNtlmV1Values() []NtlmV1

PossibleNtlmV1Values returns the possible values for the NtlmV1 const type.

type OperationDisplayInfo 

type OperationDisplayInfo struct {
	// The description of the operation.
	Description *string

	// The action that users can perform, based on their permission level.
	Operation *string

	// Service provider: Domain Services.
	Provider *string

	// Resource on which the operation is performed.
	Resource *string
}

OperationDisplayInfo - The operation supported by Domain Services.

func (OperationDisplayInfo) MarshalJSON added in v1.1.0 

func (o OperationDisplayInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationDisplayInfo.

func (*OperationDisplayInfo) UnmarshalJSON added in v1.1.0 

func (o *OperationDisplayInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplayInfo.

type OperationEntity 

type OperationEntity struct {
	// The operation supported by Domain Services.
	Display *OperationDisplayInfo

	// Operation name: {provider}/{resource}/{operation}.
	Name *string

	// The origin of the operation.
	Origin *string
}

OperationEntity - The operation supported by Domain Services.

func (OperationEntity) MarshalJSON added in v1.1.0 

func (o OperationEntity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationEntity.

func (*OperationEntity) UnmarshalJSON added in v1.1.0 

func (o *OperationEntity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationEntity.

type OperationEntityListResult 

type OperationEntityListResult struct {
	// The list of operations.
	Value []*OperationEntity

	// READ-ONLY; The continuation token for the next page of results.
	NextLink *string
}

OperationEntityListResult - The list of domain service operation response.

func (OperationEntityListResult) MarshalJSON 

func (o OperationEntityListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationEntityListResult.

func (*OperationEntityListResult) UnmarshalJSON added in v1.1.0 

func (o *OperationEntityListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationEntityListResult.

type OuContainer 

type OuContainer struct {
	// Resource etag
	Etag *string

	// Resource location
	Location *string

	// OuContainer properties
	Properties *OuContainerProperties

	// Resource tags
	Tags map[string]*string

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource name
	Name *string

	// READ-ONLY; The system meta data relating to this resource.
	SystemData *SystemData

	// READ-ONLY; Resource type
	Type *string
}

OuContainer - Resource for OuContainer.

func (OuContainer) MarshalJSON 

func (o OuContainer) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OuContainer.

func (*OuContainer) UnmarshalJSON added in v1.1.0 

func (o *OuContainer) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OuContainer.

type OuContainerClient 

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

OuContainerClient contains the methods for the OuContainer group. Don't use this type directly, use NewOuContainerClient() instead.

func NewOuContainerClient 

func NewOuContainerClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*OuContainerClient, error)

NewOuContainerClient creates a new instance of OuContainerClient with the specified values.

  • subscriptionID - Gets 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 (*OuContainerClient) BeginCreate 

func (client *OuContainerClient) BeginCreate(ctx context.Context, resourceGroupName string, domainServiceName string, ouContainerName string, containerAccount ContainerAccount, options *OuContainerClientBeginCreateOptions) (*runtime.Poller[OuContainerClientCreateResponse], error)

BeginCreate - The Create OuContainer operation creates a new OuContainer under the specified Domain Service instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-05-01

  • resourceGroupName - The name of the resource group within the user's subscription. The name is case insensitive.
  • domainServiceName - The name of the domain service.
  • ouContainerName - The name of the OuContainer.
  • containerAccount - Container Account Description.
  • options - OuContainerClientBeginCreateOptions contains the optional parameters for the OuContainerClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/CreateOuContainer.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/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewOuContainerClient().BeginCreate(ctx, "OuContainerResourceGroup", "OuContainer.com", "OuContainer1", armdomainservices.ContainerAccount{
		AccountName: to.Ptr("AccountName1"),
		Password:    to.Ptr("<password>"),
		Spn:         to.Ptr("Spn1"),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.OuContainer = armdomainservices.OuContainer{
	// 	Name: to.Ptr("OuContainer.com/OuContainer1"),
	// 	Type: to.Ptr("Microsoft.AAD/DomainServices/OuContainer"),
	// 	ID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/ouContainerResourceGroup/providers/Microsoft.AAD/domainServices/ouContainer.com/ouContainer/ouContainer1"),
	// 	Properties: &armdomainservices.OuContainerProperties{
	// 		Accounts: []*armdomainservices.ContainerAccount{
	// 			{
	// 				AccountName: to.Ptr("AccountName1"),
	// 				Spn: to.Ptr("Spn1"),
	// 			},
	// 			{
	// 				AccountName: to.Ptr("AccountName2"),
	// 				Spn: to.Ptr("Spn2"),
	// 		}},
	// 		ContainerID: to.Ptr("OuContainer1"),
	// 		DeploymentID: to.Ptr("0FC50BDB-AC45-48E4-BC92-F0651EA0687B"),
	// 		DomainName: to.Ptr("OuContainer.com"),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		ServiceStatus: to.Ptr("Running"),
	// 		TenantID: to.Ptr("3f8cd22c-7b32-48aa-a01c-f533133b1def"),
	// 	},
	// }
}

Output:

func (*OuContainerClient) BeginDelete 

func (client *OuContainerClient) BeginDelete(ctx context.Context, resourceGroupName string, domainServiceName string, ouContainerName string, options *OuContainerClientBeginDeleteOptions) (*runtime.Poller[OuContainerClientDeleteResponse], error)

BeginDelete - The Delete OuContainer operation deletes specified OuContainer. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-05-01

  • resourceGroupName - The name of the resource group within the user's subscription. The name is case insensitive.
  • domainServiceName - The name of the domain service.
  • ouContainerName - The name of the OuContainer.
  • options - OuContainerClientBeginDeleteOptions contains the optional parameters for the OuContainerClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/DeleteOuContainer.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewOuContainerClient().BeginDelete(ctx, "OuContainerResourceGroup", "OuContainer.com", "OuContainer1", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

Output:

func (*OuContainerClient) BeginUpdate 

func (client *OuContainerClient) BeginUpdate(ctx context.Context, resourceGroupName string, domainServiceName string, ouContainerName string, containerAccount ContainerAccount, options *OuContainerClientBeginUpdateOptions) (*runtime.Poller[OuContainerClientUpdateResponse], error)

BeginUpdate - The Update OuContainer operation can be used to update the existing OuContainers. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-05-01

  • resourceGroupName - The name of the resource group within the user's subscription. The name is case insensitive.
  • domainServiceName - The name of the domain service.
  • ouContainerName - The name of the OuContainer.
  • containerAccount - Container Account Description.
  • options - OuContainerClientBeginUpdateOptions contains the optional parameters for the OuContainerClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/UpdateOuContainer.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/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewOuContainerClient().BeginUpdate(ctx, "OuContainerResourceGroup", "OuContainer.com", "OuContainer1", armdomainservices.ContainerAccount{
		AccountName: to.Ptr("AccountName1"),
		Password:    to.Ptr("<password>"),
		Spn:         to.Ptr("Spn1"),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.OuContainer = armdomainservices.OuContainer{
	// 	Name: to.Ptr("OuContainer.com/OuContainer1"),
	// 	Type: to.Ptr("Microsoft.AAD/DomainServices/OuContainer"),
	// 	ID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/ouContainerResourceGroup/providers/Microsoft.AAD/domainServices/ouContainer.com/ouContainer/ouContainer1"),
	// 	Properties: &armdomainservices.OuContainerProperties{
	// 		Accounts: []*armdomainservices.ContainerAccount{
	// 			{
	// 				AccountName: to.Ptr("AccountName1"),
	// 				Spn: to.Ptr("Spn1"),
	// 			},
	// 			{
	// 				AccountName: to.Ptr("AccountName2"),
	// 				Spn: to.Ptr("Spn2"),
	// 		}},
	// 		ContainerID: to.Ptr("OuContainer1"),
	// 		DeploymentID: to.Ptr("0FC50BDB-AC45-48E4-BC92-F0651EA0687B"),
	// 		DomainName: to.Ptr("OuContainer.com"),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		ServiceStatus: to.Ptr("Running"),
	// 		TenantID: to.Ptr("3f8cd22c-7b32-48aa-a01c-f533133b1def"),
	// 	},
	// }
}

Output:

func (*OuContainerClient) Get 

func (client *OuContainerClient) Get(ctx context.Context, resourceGroupName string, domainServiceName string, ouContainerName string, options *OuContainerClientGetOptions) (OuContainerClientGetResponse, error)

Get - Get OuContainer in DomainService instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-05-01

  • resourceGroupName - The name of the resource group within the user's subscription. The name is case insensitive.
  • domainServiceName - The name of the domain service.
  • ouContainerName - The name of the OuContainer.
  • options - OuContainerClientGetOptions contains the optional parameters for the OuContainerClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/GetOuContainer.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOuContainerClient().Get(ctx, "OuContainerResourceGroup", "OuContainer.com", "OuContainer1", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.OuContainer = armdomainservices.OuContainer{
	// 	Name: to.Ptr("OuContainer.com/OuContainer1"),
	// 	Type: to.Ptr("Microsoft.AAD/DomainServices/OuContainer"),
	// 	ID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/ouContainerResourceGroup/providers/Microsoft.AAD/domainServices/ouContainer.com/ouContainer/ouContainer1"),
	// 	Properties: &armdomainservices.OuContainerProperties{
	// 		Accounts: []*armdomainservices.ContainerAccount{
	// 			{
	// 				AccountName: to.Ptr("AccountName1"),
	// 				Spn: to.Ptr("Spn1"),
	// 			},
	// 			{
	// 				AccountName: to.Ptr("AccountName2"),
	// 				Spn: to.Ptr("Spn2"),
	// 		}},
	// 		ContainerID: to.Ptr("OuContainer1"),
	// 		DeploymentID: to.Ptr("0FC50BDB-AC45-48E4-BC92-F0651EA0687B"),
	// 		DomainName: to.Ptr("OuContainer.com"),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		ServiceStatus: to.Ptr("Running"),
	// 		TenantID: to.Ptr("3f8cd22c-7b32-48aa-a01c-f533133b1def"),
	// 	},
	// }
}

Output:

func (*OuContainerClient) NewListPager added in v0.4.0 

func (client *OuContainerClient) NewListPager(resourceGroupName string, domainServiceName string, options *OuContainerClientListOptions) *runtime.Pager[OuContainerClientListResponse]

NewListPager - The List of OuContainers in DomainService instance.

Generated from API version 2021-05-01

  • resourceGroupName - The name of the resource group within the user's subscription. The name is case insensitive.
  • domainServiceName - The name of the domain service.
  • options - OuContainerClientListOptions contains the optional parameters for the OuContainerClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/ListOuContainers.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOuContainerClient().NewListPager("OuContainerResourceGroup", "OuContainer.com", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.OuContainerListResult = armdomainservices.OuContainerListResult{
		// 	Value: []*armdomainservices.OuContainer{
		// 		{
		// 			Name: to.Ptr("OuContainer.com/OuContainer1"),
		// 			Type: to.Ptr("Microsoft.AAD/DomainServices/OuContainer"),
		// 			ID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/ouContainerResourceGroup/providers/Microsoft.AAD/domainServices/ouContainer.com/ouContainer/ouContainer1"),
		// 			Properties: &armdomainservices.OuContainerProperties{
		// 				Accounts: []*armdomainservices.ContainerAccount{
		// 					{
		// 						AccountName: to.Ptr("AccountName1"),
		// 						Spn: to.Ptr("Spn1"),
		// 					},
		// 					{
		// 						AccountName: to.Ptr("AccountName2"),
		// 						Spn: to.Ptr("Spn2"),
		// 				}},
		// 				ContainerID: to.Ptr("OuContainer1"),
		// 				DeploymentID: to.Ptr("0FC50BDB-AC45-48E4-BC92-F0651EA0687B"),
		// 				DomainName: to.Ptr("OuContainer.com"),
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				ServiceStatus: to.Ptr("Running"),
		// 				TenantID: to.Ptr("3f8cd22c-7b32-48aa-a01c-f533133b1def"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("OuContainer.com/OuContainer2"),
		// 			Type: to.Ptr("Microsoft.AAD/DomainServices/OuContainer"),
		// 			ID: to.Ptr("/subscriptions/1639790a-76a2-4ac4-98d9-8562f5dfcb4d/resourceGroups/ouContainerResourceGroup/providers/Microsoft.AAD/domainServices/ouContainer.com/ouContainer/ouContainer2"),
		// 			Properties: &armdomainservices.OuContainerProperties{
		// 				Accounts: []*armdomainservices.ContainerAccount{
		// 					{
		// 						AccountName: to.Ptr("AccountName3"),
		// 						Spn: to.Ptr("Spn3"),
		// 					},
		// 					{
		// 						AccountName: to.Ptr("AccountName4"),
		// 						Spn: to.Ptr("Spn4"),
		// 				}},
		// 				ContainerID: to.Ptr("OuContainer2"),
		// 				DeploymentID: to.Ptr("0FC50BDB-AC45-48E4-BC92-F0651EA0687B"),
		// 				DomainName: to.Ptr("OuContainer.com"),
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				ServiceStatus: to.Ptr("Running"),
		// 				TenantID: to.Ptr("3f8cd22c-7b32-48aa-a01c-f533133b1def"),
		// 			},
		// 	}},
		// }
	}
}

Output:

type OuContainerClientBeginCreateOptions added in v0.2.0 

type OuContainerClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

OuContainerClientBeginCreateOptions contains the optional parameters for the OuContainerClient.BeginCreate method.

type OuContainerClientBeginDeleteOptions added in v0.2.0 

type OuContainerClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

OuContainerClientBeginDeleteOptions contains the optional parameters for the OuContainerClient.BeginDelete method.

type OuContainerClientBeginUpdateOptions added in v0.2.0 

type OuContainerClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

OuContainerClientBeginUpdateOptions contains the optional parameters for the OuContainerClient.BeginUpdate method.

type OuContainerClientCreateResponse added in v0.2.0 

type OuContainerClientCreateResponse struct {
	// Resource for OuContainer.
	OuContainer
}

OuContainerClientCreateResponse contains the response from method OuContainerClient.BeginCreate.

type OuContainerClientDeleteResponse added in v0.2.0 

type OuContainerClientDeleteResponse struct {
}

OuContainerClientDeleteResponse contains the response from method OuContainerClient.BeginDelete.

type OuContainerClientGetOptions added in v0.2.0 

type OuContainerClientGetOptions struct {
}

OuContainerClientGetOptions contains the optional parameters for the OuContainerClient.Get method.

type OuContainerClientGetResponse added in v0.2.0 

type OuContainerClientGetResponse struct {
	// Resource for OuContainer.
	OuContainer
}

OuContainerClientGetResponse contains the response from method OuContainerClient.Get.

type OuContainerClientListOptions added in v0.2.0 

type OuContainerClientListOptions struct {
}

OuContainerClientListOptions contains the optional parameters for the OuContainerClient.NewListPager method.

type OuContainerClientListResponse added in v0.2.0 

type OuContainerClientListResponse struct {
	// The response from the List OuContainer operation.
	OuContainerListResult
}

OuContainerClientListResponse contains the response from method OuContainerClient.NewListPager.

type OuContainerClientUpdateResponse added in v0.2.0 

type OuContainerClientUpdateResponse struct {
	// Resource for OuContainer.
	OuContainer
}

OuContainerClientUpdateResponse contains the response from method OuContainerClient.BeginUpdate.

type OuContainerListResult 

type OuContainerListResult struct {
	// The list of OuContainer.
	Value []*OuContainer

	// READ-ONLY; The continuation token for the next page of results.
	NextLink *string
}

OuContainerListResult - The response from the List OuContainer operation.

func (OuContainerListResult) MarshalJSON 

func (o OuContainerListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OuContainerListResult.

func (*OuContainerListResult) UnmarshalJSON added in v1.1.0 

func (o *OuContainerListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OuContainerListResult.

type OuContainerOperationsClient 

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

OuContainerOperationsClient contains the methods for the OuContainerOperations group. Don't use this type directly, use NewOuContainerOperationsClient() instead.

func NewOuContainerOperationsClient 

func NewOuContainerOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OuContainerOperationsClient, error)

NewOuContainerOperationsClient creates a new instance of OuContainerOperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OuContainerOperationsClient) NewListPager added in v0.4.0 

func (client *OuContainerOperationsClient) NewListPager(options *OuContainerOperationsClientListOptions) *runtime.Pager[OuContainerOperationsClientListResponse]

NewListPager - Lists all the available OuContainer operations.

Generated from API version 2021-05-01

  • options - OuContainerOperationsClientListOptions contains the optional parameters for the OuContainerOperationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/domainservices/resource-manager/Microsoft.AAD/stable/2021-05-01/examples/GetOperations.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/domainservices/armdomainservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdomainservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOuContainerOperationsClient().NewListPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.OperationEntityListResult = armdomainservices.OperationEntityListResult{
		// 	Value: []*armdomainservices.OperationEntity{
		// 		{
		// 			Name: to.Ptr("Microsoft.AAD/unregister/action"),
		// 			Display: &armdomainservices.OperationDisplayInfo{
		// 				Description: to.Ptr("Unregisters Domain Services"),
		// 				Operation: to.Ptr("Unregister Domain Service"),
		// 				Provider: to.Ptr("Domain Services Resource Provider"),
		// 				Resource: to.Ptr("Domain Service Type"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.AAD/register/action"),
		// 			Display: &armdomainservices.OperationDisplayInfo{
		// 				Description: to.Ptr("Registers Domain Services"),
		// 				Operation: to.Ptr("Register Domain Service"),
		// 				Provider: to.Ptr("Domain Services Resource Provider"),
		// 				Resource: to.Ptr("Domain Service Type"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.AAD/domainServices/read"),
		// 			Display: &armdomainservices.OperationDisplayInfo{
		// 				Description: to.Ptr("Reads Domain Services"),
		// 				Operation: to.Ptr("Read Domain Service"),
		// 				Provider: to.Ptr("Domain Services Resource Provider"),
		// 				Resource: to.Ptr("Domain Service Type"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.AAD/domainServices/write"),
		// 			Display: &armdomainservices.OperationDisplayInfo{
		// 				Description: to.Ptr("Writes Domain Services"),
		// 				Operation: to.Ptr("Write Domain Service"),
		// 				Provider: to.Ptr("Domain Services Resource Provider"),
		// 				Resource: to.Ptr("Domain Service Type"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.AAD/domainServices/delete"),
		// 			Display: &armdomainservices.OperationDisplayInfo{
		// 				Description: to.Ptr("Deletes Domain Services"),
		// 				Operation: to.Ptr("Delete Domain Service"),
		// 				Provider: to.Ptr("Domain Services Resource Provider"),
		// 				Resource: to.Ptr("Domain Service Type"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 	}},
		// }
	}
}

Output:

type OuContainerOperationsClientListOptions added in v0.2.0 

type OuContainerOperationsClientListOptions struct {
}

OuContainerOperationsClientListOptions contains the optional parameters for the OuContainerOperationsClient.NewListPager method.

type OuContainerOperationsClientListResponse added in v0.2.0 

type OuContainerOperationsClientListResponse struct {
	// The list of domain service operation response.
	OperationEntityListResult
}

OuContainerOperationsClientListResponse contains the response from method OuContainerOperationsClient.NewListPager.

type OuContainerProperties 

type OuContainerProperties struct {
	// The list of container accounts
	Accounts []*ContainerAccount

	// READ-ONLY; The OuContainer name
	ContainerID *string

	// READ-ONLY; The Deployment id
	DeploymentID *string

	// READ-ONLY; Distinguished Name of OuContainer instance
	DistinguishedName *string

	// READ-ONLY; The domain name of Domain Services.
	DomainName *string

	// READ-ONLY; The current deployment or provisioning state, which only appears in the response.
	ProvisioningState *string

	// READ-ONLY; Status of OuContainer instance
	ServiceStatus *string

	// READ-ONLY; Azure Active Directory tenant id
	TenantID *string
}

OuContainerProperties - Properties of the OuContainer.

func (OuContainerProperties) MarshalJSON 

func (o OuContainerProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OuContainerProperties.

func (*OuContainerProperties) UnmarshalJSON added in v1.1.0 

func (o *OuContainerProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OuContainerProperties.

type ReplicaSet 

type ReplicaSet struct {
	// Virtual network location
	Location *string

	// The name of the virtual network that Domain Services will be deployed on. The id of the subnet that Domain Services will
	// be deployed on. /virtualNetwork/vnetName/subnets/subnetName.
	SubnetID *string

	// READ-ONLY; List of Domain Controller IP Address
	DomainControllerIPAddress []*string

	// READ-ONLY; External access ip address.
	ExternalAccessIPAddress *string

	// READ-ONLY; List of Domain Health Alerts
	HealthAlerts []*HealthAlert

	// READ-ONLY; Last domain evaluation run DateTime
	HealthLastEvaluated *time.Time

	// READ-ONLY; List of Domain Health Monitors
	HealthMonitors []*HealthMonitor

	// READ-ONLY; ReplicaSet Id
	ReplicaSetID *string

	// READ-ONLY; Status of Domain Service instance
	ServiceStatus *string

	// READ-ONLY; Virtual network site id
	VnetSiteID *string
}

ReplicaSet - Replica Set Definition

func (ReplicaSet) MarshalJSON 

func (r ReplicaSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ReplicaSet.

func (*ReplicaSet) UnmarshalJSON 

func (r *ReplicaSet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ReplicaSet.

type Resource 

type Resource struct {
	// Resource etag
	Etag *string

	// Resource location
	Location *string

	// Resource tags
	Tags map[string]*string

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource name
	Name *string

	// READ-ONLY; The system meta data relating to this resource.
	SystemData *SystemData

	// READ-ONLY; Resource type
	Type *string
}

Resource - The Resource model definition.

func (Resource) MarshalJSON 

func (r Resource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON added in v1.1.0 

func (r *Resource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type ResourceForestSettings 

type ResourceForestSettings struct {
	// Resource Forest
	ResourceForest *string

	// List of settings for Resource Forest
	Settings []*ForestTrust
}

ResourceForestSettings - Settings for Resource Forest

func (ResourceForestSettings) MarshalJSON 

func (r ResourceForestSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceForestSettings.

func (*ResourceForestSettings) UnmarshalJSON added in v1.1.0 

func (r *ResourceForestSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceForestSettings.

type Status 

type Status string

Status - Status for individual validator after running diagnostics. 

const (
	StatusFailure Status = "Failure"
	StatusNone    Status = "None"
	StatusOK      Status = "OK"
	StatusRunning Status = "Running"
	StatusSkipped Status = "Skipped"
	StatusWarning Status = "Warning"
)

func PossibleStatusValues 

func PossibleStatusValues() []Status

PossibleStatusValues returns the possible values for the Status const type.

type SyncKerberosPasswords 

type SyncKerberosPasswords string

SyncKerberosPasswords - A flag to determine whether or not SyncKerberosPasswords is enabled or disabled. 

const (
	SyncKerberosPasswordsDisabled SyncKerberosPasswords = "Disabled"
	SyncKerberosPasswordsEnabled  SyncKerberosPasswords = "Enabled"
)

func PossibleSyncKerberosPasswordsValues 

func PossibleSyncKerberosPasswordsValues() []SyncKerberosPasswords

PossibleSyncKerberosPasswordsValues returns the possible values for the SyncKerberosPasswords const type.

type SyncNtlmPasswords 

type SyncNtlmPasswords string

SyncNtlmPasswords - A flag to determine whether or not SyncNtlmPasswords is enabled or disabled. 

const (
	SyncNtlmPasswordsDisabled SyncNtlmPasswords = "Disabled"
	SyncNtlmPasswordsEnabled  SyncNtlmPasswords = "Enabled"
)

func PossibleSyncNtlmPasswordsValues 

func PossibleSyncNtlmPasswordsValues() []SyncNtlmPasswords

PossibleSyncNtlmPasswordsValues returns the possible values for the SyncNtlmPasswords const type.

type SyncOnPremPasswords 

type SyncOnPremPasswords string

SyncOnPremPasswords - A flag to determine whether or not SyncOnPremPasswords is enabled or disabled. 

const (
	SyncOnPremPasswordsDisabled SyncOnPremPasswords = "Disabled"
	SyncOnPremPasswordsEnabled  SyncOnPremPasswords = "Enabled"
)

func PossibleSyncOnPremPasswordsValues 

func PossibleSyncOnPremPasswordsValues() []SyncOnPremPasswords

PossibleSyncOnPremPasswordsValues returns the possible values for the SyncOnPremPasswords const type.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemData - Metadata pertaining to creation and last modification of the resource.

func (SystemData) MarshalJSON 

func (s SystemData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

func (s *SystemData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TLSV1 

type TLSV1 string

TLSV1 - A flag to determine whether or not TlsV1 is enabled or disabled. 

const (
	TLSV1Disabled TLSV1 = "Disabled"
	TLSV1Enabled  TLSV1 = "Enabled"
)

func PossibleTLSV1Values 

func PossibleTLSV1Values() []TLSV1

PossibleTLSV1Values returns the possible values for the TLSV1 const type.

Source Files

View all Source files

Directories

Path Synopsis

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.