armresourceconnector

package module
v1.1.0 Latest Latest
Warning

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

 Go to latest Published: Nov 24, 2023 License: MIT Imports: 14 Imported by: 3

README

Azure Resource Connector Module for Go

PkgGoDev

The armresourceconnector module provides operations for working with Azure Resource Connector.

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 Resource Connector module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourceconnector/armresourceconnector

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Resource Connector. 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 Resource Connector 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 := armresourceconnector.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 := armresourceconnector.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.NewAppliancesClient()

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 Resource Connector 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 AccessProfileType 

type AccessProfileType string

AccessProfileType - Name which contains the role of the kubeconfig. 

const (
	AccessProfileTypeClusterCustomerUser AccessProfileType = "clusterCustomerUser"
	AccessProfileTypeClusterUser         AccessProfileType = "clusterUser"
)

func PossibleAccessProfileTypeValues 

func PossibleAccessProfileTypeValues() []AccessProfileType

PossibleAccessProfileTypeValues returns the possible values for the AccessProfileType const type.

type Appliance 

type Appliance struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// Identity for the resource.
	Identity *Identity

	// The set of properties specific to an Appliance
	Properties *ApplianceProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

Appliances definition.

func (Appliance) MarshalJSON 

func (a Appliance) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Appliance.

func (*Appliance) UnmarshalJSON added in v0.2.0 

func (a *Appliance) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Appliance.

type ApplianceCredentialKubeconfig 

type ApplianceCredentialKubeconfig struct {
	// READ-ONLY; Name which contains the role of the kubeconfig.
	Name *AccessProfileType

	// READ-ONLY; Contains the kubeconfig value.
	Value *string
}

ApplianceCredentialKubeconfig - Cluster User Credential appliance.

func (ApplianceCredentialKubeconfig) MarshalJSON added in v0.2.0 

func (a ApplianceCredentialKubeconfig) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplianceCredentialKubeconfig.

func (*ApplianceCredentialKubeconfig) UnmarshalJSON added in v0.2.0 

func (a *ApplianceCredentialKubeconfig) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplianceCredentialKubeconfig.

type ApplianceGetTelemetryConfigResult added in v0.4.0 

type ApplianceGetTelemetryConfigResult struct {
	// READ-ONLY; Telemetry instrumentation key.
	TelemetryInstrumentationKey *string
}

ApplianceGetTelemetryConfigResult - The Get Telemetry Config Result appliance.

func (ApplianceGetTelemetryConfigResult) MarshalJSON added in v0.4.0 

func (a ApplianceGetTelemetryConfigResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplianceGetTelemetryConfigResult.

func (*ApplianceGetTelemetryConfigResult) UnmarshalJSON added in v0.4.0 

func (a *ApplianceGetTelemetryConfigResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplianceGetTelemetryConfigResult.

type ApplianceListCredentialResults 

type ApplianceListCredentialResults struct {
	// READ-ONLY; Contains the REP (rendezvous endpoint) and “Listener” access token from notification service (NS).
	HybridConnectionConfig *HybridConnectionConfig

	// READ-ONLY; The list of appliance kubeconfigs.
	Kubeconfigs []*ApplianceCredentialKubeconfig
}

ApplianceListCredentialResults - The List Cluster User Credential appliance.

func (ApplianceListCredentialResults) MarshalJSON added in v0.2.0 

func (a ApplianceListCredentialResults) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplianceListCredentialResults.

func (*ApplianceListCredentialResults) UnmarshalJSON added in v0.2.0 

func (a *ApplianceListCredentialResults) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplianceListCredentialResults.

type ApplianceListKeysResults added in v0.4.0 

type ApplianceListKeysResults struct {
	// READ-ONLY; Map of artifacts that contains a list of ArtifactProfile used to upload artifacts such as logs.
	ArtifactProfiles map[string]*ArtifactProfile

	// READ-ONLY; The list of appliance kubeconfigs.
	Kubeconfigs []*ApplianceCredentialKubeconfig

	// READ-ONLY; Map of Customer User Public, Private SSH Keys and Certificate when available.
	SSHKeys map[string]*SSHKey
}

ApplianceListKeysResults - The List Cluster Keys Results appliance.

func (ApplianceListKeysResults) MarshalJSON added in v0.4.0 

func (a ApplianceListKeysResults) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplianceListKeysResults.

func (*ApplianceListKeysResults) UnmarshalJSON added in v0.4.0 

func (a *ApplianceListKeysResults) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplianceListKeysResults.

type ApplianceListResult 

type ApplianceListResult struct {
	// READ-ONLY; The URL to use for getting the next set of results.
	NextLink *string

	// READ-ONLY; The list of Appliances.
	Value []*Appliance
}

ApplianceListResult - The List Appliances operation response.

func (ApplianceListResult) MarshalJSON added in v0.2.0 

func (a ApplianceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplianceListResult.

func (*ApplianceListResult) UnmarshalJSON added in v0.2.0 

func (a *ApplianceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplianceListResult.

type ApplianceOperation 

type ApplianceOperation struct {
	// Describes the properties of an Appliances Operation Value Display.
	Display *ApplianceOperationValueDisplay

	// READ-ONLY; Is this Operation a data plane operation
	IsDataAction *bool

	// READ-ONLY; The name of the compute operation.
	Name *string

	// READ-ONLY; The origin of the compute operation.
	Origin *string
}

ApplianceOperation - Appliances operation.

func (ApplianceOperation) MarshalJSON added in v0.2.0 

func (a ApplianceOperation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplianceOperation.

func (*ApplianceOperation) UnmarshalJSON added in v0.2.0 

func (a *ApplianceOperation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplianceOperation.

type ApplianceOperationValueDisplay 

type ApplianceOperationValueDisplay struct {
	// READ-ONLY; The description of the operation.
	Description *string

	// READ-ONLY; The display name of the compute operation.
	Operation *string

	// READ-ONLY; The resource provider for the operation.
	Provider *string

	// READ-ONLY; The display name of the resource the operation applies to.
	Resource *string
}

ApplianceOperationValueDisplay - Describes the properties of an Appliances Operation Value Display.

func (ApplianceOperationValueDisplay) MarshalJSON added in v0.2.0 

func (a ApplianceOperationValueDisplay) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplianceOperationValueDisplay.

func (*ApplianceOperationValueDisplay) UnmarshalJSON added in v0.2.0 

func (a *ApplianceOperationValueDisplay) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplianceOperationValueDisplay.

type ApplianceOperationsList 

type ApplianceOperationsList struct {
	// REQUIRED; Array of applianceOperation
	Value []*ApplianceOperation

	// Next page of operations.
	NextLink *string
}

ApplianceOperationsList - Lists of Appliances operations.

func (ApplianceOperationsList) MarshalJSON added in v0.2.0 

func (a ApplianceOperationsList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplianceOperationsList.

func (*ApplianceOperationsList) UnmarshalJSON added in v0.2.0 

func (a *ApplianceOperationsList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplianceOperationsList.

type ApplianceProperties 

type ApplianceProperties struct {
	// Represents a supported Fabric/Infra. (AKSEdge etc…).
	Distro *Distro

	// Contains infrastructure information about the Appliance
	InfrastructureConfig *AppliancePropertiesInfrastructureConfig

	// Certificates pair used to download MSI certificate from HIS. Can only be set once.
	PublicKey *string

	// Version of the Appliance
	Version *string

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

	// READ-ONLY; Appliance’s health and state of connection to on-prem
	Status *Status
}

ApplianceProperties - Properties for an appliance.

func (ApplianceProperties) MarshalJSON added in v0.2.0 

func (a ApplianceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplianceProperties.

func (*ApplianceProperties) UnmarshalJSON added in v0.2.0 

func (a *ApplianceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplianceProperties.

type AppliancePropertiesInfrastructureConfig 

type AppliancePropertiesInfrastructureConfig struct {
	// Information about the connected appliance.
	Provider *Provider
}

AppliancePropertiesInfrastructureConfig - Contains infrastructure information about the Appliance

func (AppliancePropertiesInfrastructureConfig) MarshalJSON added in v0.2.0 

func (a AppliancePropertiesInfrastructureConfig) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AppliancePropertiesInfrastructureConfig.

func (*AppliancePropertiesInfrastructureConfig) UnmarshalJSON added in v0.2.0 

func (a *AppliancePropertiesInfrastructureConfig) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AppliancePropertiesInfrastructureConfig.

type AppliancesClient 

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

AppliancesClient contains the methods for the Appliances group. Don't use this type directly, use NewAppliancesClient() instead.

func NewAppliancesClient 

func NewAppliancesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AppliancesClient, error)

NewAppliancesClient creates a new instance of AppliancesClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AppliancesClient) BeginCreateOrUpdate 

func (client *AppliancesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, parameters Appliance, options *AppliancesClientBeginCreateOrUpdateOptions) (*runtime.Poller[AppliancesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates an Appliance in the specified Subscription and Resource Group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-10-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Appliances name.
  • parameters - Parameters supplied to create or update an Appliance.
  • options - AppliancesClientBeginCreateOrUpdateOptions contains the optional parameters for the AppliancesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5f700acd3d094d8eedca381932f2e7916afd2e55/specification/resourceconnector/resource-manager/Microsoft.ResourceConnector/stable/2022-10-27/examples/AppliancesCreate_Update.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/resourceconnector/armresourceconnector"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armresourceconnector.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAppliancesClient().BeginCreateOrUpdate(ctx, "testresourcegroup", "appliance01", armresourceconnector.Appliance{
		Location: to.Ptr("West US"),
		Properties: &armresourceconnector.ApplianceProperties{
			Distro: to.Ptr(armresourceconnector.DistroAKSEdge),
			InfrastructureConfig: &armresourceconnector.AppliancePropertiesInfrastructureConfig{
				Provider: to.Ptr(armresourceconnector.ProviderVMWare),
			},
		},
	}, 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.Appliance = armresourceconnector.Appliance{
	// 	Name: to.Ptr("appliance01"),
	// 	Type: to.Ptr("Microsoft.ResourceConnector/appliances"),
	// 	ID: to.Ptr("/subscriptions/11111111-2222-3333-4444-555555555555/resourceGroups/testrg/providers/Microsoft.ResourceConnector/appliances/appliance01"),
	// 	SystemData: &armresourceconnector.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
	// 		CreatedBy: to.Ptr("string"),
	// 		CreatedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("string"),
	// 		LastModifiedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
	// 	},
	// 	Location: to.Ptr("West US"),
	// 	Identity: &armresourceconnector.Identity{
	// 		Type: to.Ptr(armresourceconnector.ResourceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
	// 		TenantID: to.Ptr("111111-1111-1111-1111-111111111111"),
	// 	},
	// 	Properties: &armresourceconnector.ApplianceProperties{
	// 		Distro: to.Ptr(armresourceconnector.DistroAKSEdge),
	// 		InfrastructureConfig: &armresourceconnector.AppliancePropertiesInfrastructureConfig{
	// 			Provider: to.Ptr(armresourceconnector.ProviderVMWare),
	// 		},
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		Status: to.Ptr(armresourceconnector.StatusConnected),
	// 		Version: to.Ptr("1.0.1"),
	// 	},
	// }
}

Output:

func (*AppliancesClient) BeginDelete 

func (client *AppliancesClient) BeginDelete(ctx context.Context, resourceGroupName string, resourceName string, options *AppliancesClientBeginDeleteOptions) (*runtime.Poller[AppliancesClientDeleteResponse], error)

BeginDelete - Deletes an Appliance with the specified Resource Name, Resource Group, and Subscription Id. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-10-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Appliances name.
  • options - AppliancesClientBeginDeleteOptions contains the optional parameters for the AppliancesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5f700acd3d094d8eedca381932f2e7916afd2e55/specification/resourceconnector/resource-manager/Microsoft.ResourceConnector/stable/2022-10-27/examples/AppliancesDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourceconnector/armresourceconnector"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armresourceconnector.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAppliancesClient().BeginDelete(ctx, "testresourcegroup", "appliance01", 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 (*AppliancesClient) Get 

func (client *AppliancesClient) Get(ctx context.Context, resourceGroupName string, resourceName string, options *AppliancesClientGetOptions) (AppliancesClientGetResponse, error)

Get - Gets the details of an Appliance with a specified resource group and name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-10-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Appliances name.
  • options - AppliancesClientGetOptions contains the optional parameters for the AppliancesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5f700acd3d094d8eedca381932f2e7916afd2e55/specification/resourceconnector/resource-manager/Microsoft.ResourceConnector/stable/2022-10-27/examples/AppliancesGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourceconnector/armresourceconnector"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armresourceconnector.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAppliancesClient().Get(ctx, "testresourcegroup", "appliance01", 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.Appliance = armresourceconnector.Appliance{
	// 	Name: to.Ptr("appliance01"),
	// 	Type: to.Ptr("Microsoft.ResourceConnector/appliances"),
	// 	ID: to.Ptr("/subscriptions/11111111-2222-3333-4444-555555555555/resourceGroups/testresourcegroup/providers/Microsoft.ResourceConnector/appliances/appliance01"),
	// 	SystemData: &armresourceconnector.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
	// 		CreatedBy: to.Ptr("string"),
	// 		CreatedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("string"),
	// 		LastModifiedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
	// 	},
	// 	Location: to.Ptr("West US"),
	// 	Identity: &armresourceconnector.Identity{
	// 		Type: to.Ptr(armresourceconnector.ResourceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
	// 		TenantID: to.Ptr("111111-1111-1111-1111-111111111111"),
	// 	},
	// 	Properties: &armresourceconnector.ApplianceProperties{
	// 		Distro: to.Ptr(armresourceconnector.DistroAKSEdge),
	// 		InfrastructureConfig: &armresourceconnector.AppliancePropertiesInfrastructureConfig{
	// 			Provider: to.Ptr(armresourceconnector.ProviderVMWare),
	// 		},
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		Status: to.Ptr(armresourceconnector.StatusConnected),
	// 		Version: to.Ptr("1.0.1"),
	// 	},
	// }
}

Output:

func (*AppliancesClient) GetTelemetryConfig added in v0.4.0 

func (client *AppliancesClient) GetTelemetryConfig(ctx context.Context, options *AppliancesClientGetTelemetryConfigOptions) (AppliancesClientGetTelemetryConfigResponse, error)

GetTelemetryConfig - Gets the telemetry config. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-10-27

  • options - AppliancesClientGetTelemetryConfigOptions contains the optional parameters for the AppliancesClient.GetTelemetryConfig method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5f700acd3d094d8eedca381932f2e7916afd2e55/specification/resourceconnector/resource-manager/Microsoft.ResourceConnector/stable/2022-10-27/examples/TelemetryConfig.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourceconnector/armresourceconnector"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armresourceconnector.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAppliancesClient().GetTelemetryConfig(ctx, 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.ApplianceGetTelemetryConfigResult = armresourceconnector.ApplianceGetTelemetryConfigResult{
	// 	TelemetryInstrumentationKey: to.Ptr("xxxxxxxxxxxxxxxxxxxxxxxxxxx"),
	// }
}

Output:

func (*AppliancesClient) GetUpgradeGraph added in v0.2.0 

func (client *AppliancesClient) GetUpgradeGraph(ctx context.Context, resourceGroupName string, resourceName string, upgradeGraph string, options *AppliancesClientGetUpgradeGraphOptions) (AppliancesClientGetUpgradeGraphResponse, error)

GetUpgradeGraph - Gets the upgrade graph of an Appliance with a specified resource group and name and specific release train. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-10-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Appliances name.
  • upgradeGraph - Upgrade graph version, ex - stable
  • options - AppliancesClientGetUpgradeGraphOptions contains the optional parameters for the AppliancesClient.GetUpgradeGraph method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5f700acd3d094d8eedca381932f2e7916afd2e55/specification/resourceconnector/resource-manager/Microsoft.ResourceConnector/stable/2022-10-27/examples/UpgradeGraph.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourceconnector/armresourceconnector"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armresourceconnector.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAppliancesClient().GetUpgradeGraph(ctx, "testresourcegroup", "appliance01", "stable", 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.UpgradeGraph = armresourceconnector.UpgradeGraph{
	// 	Name: to.Ptr("stable"),
	// 	ID: to.Ptr("/subscriptions/11111111-2222-3333-4444-555555555555/resourceGroups/testresourcegroup/providers/Microsoft.ResourceConnector/appliances/appliance01"),
	// 	Properties: &armresourceconnector.UpgradeGraphProperties{
	// 		ApplianceVersion: to.Ptr("1.0.0"),
	// 		SupportedVersions: []*armresourceconnector.SupportedVersion{
	// 			{
	// 				Metadata: &armresourceconnector.SupportedVersionMetadata{
	// 					CatalogVersion: &armresourceconnector.SupportedVersionCatalogVersion{
	// 						Name: to.Ptr("cloudop-product-information"),
	// 						Data: &armresourceconnector.SupportedVersionCatalogVersionData{
	// 							Audience: to.Ptr("stable"),
	// 							Catalog: to.Ptr("arc-appliance-stable-catalogs-ext"),
	// 							Offer: to.Ptr("arcappliance"),
	// 							Version: to.Ptr("0.1.5.11115"),
	// 						},
	// 						Namespace: to.Ptr("cloudop-system"),
	// 					},
	// 				},
	// 				Version: to.Ptr("1.0.1"),
	// 		}},
	// 	},
	// }
}

Output:

func (*AppliancesClient) ListClusterUserCredential 

func (client *AppliancesClient) ListClusterUserCredential(ctx context.Context, resourceGroupName string, resourceName string, options *AppliancesClientListClusterUserCredentialOptions) (AppliancesClientListClusterUserCredentialResponse, error)

ListClusterUserCredential - Returns the cluster user credentials for the dedicated appliance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-10-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Appliances name.
  • options - AppliancesClientListClusterUserCredentialOptions contains the optional parameters for the AppliancesClient.ListClusterUserCredential method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5f700acd3d094d8eedca381932f2e7916afd2e55/specification/resourceconnector/resource-manager/Microsoft.ResourceConnector/stable/2022-10-27/examples/AppliancesListClusterUserCredential.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourceconnector/armresourceconnector"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armresourceconnector.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAppliancesClient().ListClusterUserCredential(ctx, "testresourcegroup", "appliance01", 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.ApplianceListCredentialResults = armresourceconnector.ApplianceListCredentialResults{
	// 	HybridConnectionConfig: &armresourceconnector.HybridConnectionConfig{
	// 		ExpirationTime: to.Ptr[int64](123456789),
	// 		HybridConnectionName: to.Ptr("provider/type/bc36ffcf318d5bedfc05ba8b0628dba"),
	// 		Relay: to.Ptr("relayName"),
	// 		Token: to.Ptr("mockSecretOtherprovider/type/bc36ffcf318d5bedfc05ba91c157ReceiverToken"),
	// 	},
	// 	Kubeconfigs: []*armresourceconnector.ApplianceCredentialKubeconfig{
	// 		{
	// 			Name: to.Ptr(armresourceconnector.AccessProfileType("kubeconfigName1")),
	// 			Value: to.Ptr("xxxxxxxxxxxxx"),
	// 	}},
	// }
}

Output:

func (*AppliancesClient) ListKeys added in v0.4.0 

func (client *AppliancesClient) ListKeys(ctx context.Context, resourceGroupName string, resourceName string, options *AppliancesClientListKeysOptions) (AppliancesClientListKeysResponse, error)

ListKeys - Returns the cluster customer credentials for the dedicated appliance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-10-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Appliances name.
  • options - AppliancesClientListKeysOptions contains the optional parameters for the AppliancesClient.ListKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5f700acd3d094d8eedca381932f2e7916afd2e55/specification/resourceconnector/resource-manager/Microsoft.ResourceConnector/stable/2022-10-27/examples/AppliancesListKeys.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourceconnector/armresourceconnector"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armresourceconnector.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAppliancesClient().ListKeys(ctx, "testresourcegroup", "appliance01", &armresourceconnector.AppliancesClientListKeysOptions{ArtifactType: 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.ApplianceListKeysResults = armresourceconnector.ApplianceListKeysResults{
	// 	ArtifactProfiles: map[string]*armresourceconnector.ArtifactProfile{
	// 		"LogsArtifactType": &armresourceconnector.ArtifactProfile{
	// 			Endpoint: to.Ptr("https://<storage-account-name>.blob.core.windows.net/<container-name>?<SAS-token>"),
	// 		},
	// 	},
	// 	Kubeconfigs: []*armresourceconnector.ApplianceCredentialKubeconfig{
	// 		{
	// 			Name: to.Ptr(armresourceconnector.AccessProfileType("kubeconfigName1")),
	// 			Value: to.Ptr("xxxxxxxxxxxxx"),
	// 	}},
	// 	SSHKeys: map[string]*armresourceconnector.SSHKey{
	// 		"LogsKey": &armresourceconnector.SSHKey{
	// 			Certificate: to.Ptr("<Generated Certificate>"),
	// 			CreationTimeStamp: to.Ptr[int64](1660946559),
	// 			ExpirationTimeStamp: to.Ptr[int64](1724119358),
	// 			PrivateKey: to.Ptr("<Generated Private Key>"),
	// 		},
	// 		"ManagementCAKey": &armresourceconnector.SSHKey{
	// 			PublicKey: to.Ptr("<Generated Public Key>"),
	// 		},
	// 		"SSHCustomerUser": &armresourceconnector.SSHKey{
	// 			PrivateKey: to.Ptr("xxxxxxxx"),
	// 			PublicKey: to.Ptr("xxxxxxxx"),
	// 		},
	// 		"ScopedAccessKey": &armresourceconnector.SSHKey{
	// 			Certificate: to.Ptr("<Generated Certificate>"),
	// 			CreationTimeStamp: to.Ptr[int64](1660946559),
	// 			ExpirationTimeStamp: to.Ptr[int64](1724119358),
	// 			PrivateKey: to.Ptr("<Generated Private Key>"),
	// 		},
	// 	},
	// }
}

Output:

func (*AppliancesClient) NewListByResourceGroupPager 

func (client *AppliancesClient) NewListByResourceGroupPager(resourceGroupName string, options *AppliancesClientListByResourceGroupOptions) *runtime.Pager[AppliancesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Gets a list of Appliances in the specified subscription and resource group. The operation returns properties of each Appliance.

Generated from API version 2022-10-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - AppliancesClientListByResourceGroupOptions contains the optional parameters for the AppliancesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5f700acd3d094d8eedca381932f2e7916afd2e55/specification/resourceconnector/resource-manager/Microsoft.ResourceConnector/stable/2022-10-27/examples/AppliancesListByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourceconnector/armresourceconnector"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armresourceconnector.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAppliancesClient().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.ApplianceListResult = armresourceconnector.ApplianceListResult{
		// 	Value: []*armresourceconnector.Appliance{
		// 		{
		// 			Name: to.Ptr("appliance01"),
		// 			Type: to.Ptr("Microsoft.ResourceConnector/appliances"),
		// 			ID: to.Ptr("/subscriptions/11111111-2222-3333-4444-555555555555/resourceGroups/testresourcegroup/providers/Microsoft.ResourceConnector/appliances/appliance01"),
		// 			SystemData: &armresourceconnector.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
		// 				CreatedBy: to.Ptr("string"),
		// 				CreatedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("string"),
		// 				LastModifiedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
		// 			},
		// 			Location: to.Ptr("West US"),
		// 			Properties: &armresourceconnector.ApplianceProperties{
		// 				Distro: to.Ptr(armresourceconnector.DistroAKSEdge),
		// 				InfrastructureConfig: &armresourceconnector.AppliancePropertiesInfrastructureConfig{
		// 					Provider: to.Ptr(armresourceconnector.ProviderVMWare),
		// 				},
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				Status: to.Ptr(armresourceconnector.StatusConnected),
		// 				Version: to.Ptr("1.0.1"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("appliance02"),
		// 			Type: to.Ptr("Microsoft.ResourceConnector/appliances"),
		// 			ID: to.Ptr("/subscriptions/11111111-2222-3333-4444-555555555555/resourceGroups/testresourcegroup/providers/Microsoft.ResourceConnector/appliances/appliance02"),
		// 			SystemData: &armresourceconnector.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
		// 				CreatedBy: to.Ptr("string"),
		// 				CreatedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("string"),
		// 				LastModifiedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
		// 			},
		// 			Location: to.Ptr("West US"),
		// 			Properties: &armresourceconnector.ApplianceProperties{
		// 				Distro: to.Ptr(armresourceconnector.DistroAKSEdge),
		// 				InfrastructureConfig: &armresourceconnector.AppliancePropertiesInfrastructureConfig{
		// 					Provider: to.Ptr(armresourceconnector.ProviderVMWare),
		// 				},
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				Status: to.Ptr(armresourceconnector.StatusConnected),
		// 				Version: to.Ptr("1.0.1"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AppliancesClient) NewListBySubscriptionPager 

func (client *AppliancesClient) NewListBySubscriptionPager(options *AppliancesClientListBySubscriptionOptions) *runtime.Pager[AppliancesClientListBySubscriptionResponse]

NewListBySubscriptionPager - Gets a list of Appliances in the specified subscription. The operation returns properties of each Appliance

Generated from API version 2022-10-27

  • options - AppliancesClientListBySubscriptionOptions contains the optional parameters for the AppliancesClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5f700acd3d094d8eedca381932f2e7916afd2e55/specification/resourceconnector/resource-manager/Microsoft.ResourceConnector/stable/2022-10-27/examples/AppliancesListBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourceconnector/armresourceconnector"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armresourceconnector.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAppliancesClient().NewListBySubscriptionPager(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.ApplianceListResult = armresourceconnector.ApplianceListResult{
		// 	Value: []*armresourceconnector.Appliance{
		// 		{
		// 			Name: to.Ptr("appliance01"),
		// 			Type: to.Ptr("Microsoft.ResourceConnector/appliances"),
		// 			ID: to.Ptr("/subscriptions/11111111-2222-3333-4444-555555555555/resourceGroups/testresourcegroup/providers/Microsoft.ResourceConnector/appliances/appliance01"),
		// 			SystemData: &armresourceconnector.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
		// 				CreatedBy: to.Ptr("string"),
		// 				CreatedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("string"),
		// 				LastModifiedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
		// 			},
		// 			Location: to.Ptr("West US"),
		// 			Properties: &armresourceconnector.ApplianceProperties{
		// 				Distro: to.Ptr(armresourceconnector.DistroAKSEdge),
		// 				InfrastructureConfig: &armresourceconnector.AppliancePropertiesInfrastructureConfig{
		// 					Provider: to.Ptr(armresourceconnector.ProviderVMWare),
		// 				},
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				Status: to.Ptr(armresourceconnector.StatusConnected),
		// 				Version: to.Ptr("1.0.1"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("appliance02"),
		// 			Type: to.Ptr("Microsoft.ResourceConnector/appliances"),
		// 			ID: to.Ptr("/subscriptions/11111111-2222-3333-4444-555555555555/resourceGroups/testresourcegroup/providers/Microsoft.ResourceConnector/appliances/appliance02"),
		// 			SystemData: &armresourceconnector.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
		// 				CreatedBy: to.Ptr("string"),
		// 				CreatedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T18:53:29.092Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("string"),
		// 				LastModifiedByType: to.Ptr(armresourceconnector.CreatedByTypeApplication),
		// 			},
		// 			Location: to.Ptr("West US"),
		// 			Properties: &armresourceconnector.ApplianceProperties{
		// 				Distro: to.Ptr(armresourceconnector.DistroAKSEdge),
		// 				InfrastructureConfig: &armresourceconnector.AppliancePropertiesInfrastructureConfig{
		// 					Provider: to.Ptr(armresourceconnector.ProviderVMWare),
		// 				},
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				Status: to.Ptr(armresourceconnector.StatusConnected),
		// 				Version: to.Ptr("1.0.1"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AppliancesClient) NewListOperationsPager 

func (client *AppliancesClient) NewListOperationsPager(options *AppliancesClientListOperationsOptions) *runtime.Pager[AppliancesClientListOperationsResponse]

NewListOperationsPager - Lists all available Appliances operations.

Generated from API version 2022-10-27

  • options - AppliancesClientListOperationsOptions contains the optional parameters for the AppliancesClient.NewListOperationsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5f700acd3d094d8eedca381932f2e7916afd2e55/specification/resourceconnector/resource-manager/Microsoft.ResourceConnector/stable/2022-10-27/examples/AppliancesListOperations.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourceconnector/armresourceconnector"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armresourceconnector.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAppliancesClient().NewListOperationsPager(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.ApplianceOperationsList = armresourceconnector.ApplianceOperationsList{
		// 	Value: []*armresourceconnector.ApplianceOperation{
		// 		{
		// 			Name: to.Ptr("Microsoft.ResourceConnector/operations/read"),
		// 			Display: &armresourceconnector.ApplianceOperationValueDisplay{
		// 				Description: to.Ptr("Gets list of Available Operations for Appliances"),
		// 				Operation: to.Ptr("List Available Operations for Appliances"),
		// 				Provider: to.Ptr("Microsoft ResourceConnector"),
		// 				Resource: to.Ptr("Operations"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.ResourceConnector/register/action"),
		// 			Display: &armresourceconnector.ApplianceOperationValueDisplay{
		// 				Description: to.Ptr("Registers the subscription for Appliance resource provider and enables the creation of Appliance."),
		// 				Operation: to.Ptr("Registers the Appliance Resource Provider"),
		// 				Provider: to.Ptr("Microsoft ResourceConnector"),
		// 				Resource: to.Ptr("Appliances Resource Provider"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.ResourceConnector/appliances/read"),
		// 			Display: &armresourceconnector.ApplianceOperationValueDisplay{
		// 				Description: to.Ptr("Gets an Appliance resource"),
		// 				Operation: to.Ptr("Get Appliance"),
		// 				Provider: to.Ptr("Microsoft ResourceConnector"),
		// 				Resource: to.Ptr("Appliances"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.ResourceConnector/appliances/write"),
		// 			Display: &armresourceconnector.ApplianceOperationValueDisplay{
		// 				Description: to.Ptr("Creates or Updates Appliance resource"),
		// 				Operation: to.Ptr("Create or Update Appliance"),
		// 				Provider: to.Ptr("Microsoft ResourceConnector"),
		// 				Resource: to.Ptr("Appliances"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.ResourceConnector/appliances/delete"),
		// 			Display: &armresourceconnector.ApplianceOperationValueDisplay{
		// 				Description: to.Ptr("Deletes Appliance resource"),
		// 				Operation: to.Ptr("Delete Appliance"),
		// 				Provider: to.Ptr("Microsoft ResourceConnector"),
		// 				Resource: to.Ptr("Appliances"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.ResourceConnector/appliances/listClusterUserCredential"),
		// 			Display: &armresourceconnector.ApplianceOperationValueDisplay{
		// 				Description: to.Ptr("Get an appliance cluster user credential"),
		// 				Operation: to.Ptr("List User Cluster Credential"),
		// 				Provider: to.Ptr("Microsoft ResourceConnector"),
		// 				Resource: to.Ptr("Appliances"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.ResourceConnector/locations/operationsstatus/read"),
		// 			Display: &armresourceconnector.ApplianceOperationValueDisplay{
		// 				Description: to.Ptr("Get result of Appliance operation"),
		// 				Operation: to.Ptr("Get status of Appliance operation"),
		// 				Provider: to.Ptr("Microsoft ResourceConnector"),
		// 				Resource: to.Ptr("Appliance Operation Status"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.ResourceConnector/locations/operationresults/read"),
		// 			Display: &armresourceconnector.ApplianceOperationValueDisplay{
		// 				Description: to.Ptr("Get result of Appliance operation"),
		// 				Operation: to.Ptr("Get the status of Appliance operation"),
		// 				Provider: to.Ptr("Microsoft ResourceConnector"),
		// 				Resource: to.Ptr("Appliance Operation Result"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 			Origin: to.Ptr("user,system"),
		// 	}},
		// }
	}
}

Output:

func (*AppliancesClient) Update 

func (client *AppliancesClient) Update(ctx context.Context, resourceGroupName string, resourceName string, parameters PatchableAppliance, options *AppliancesClientUpdateOptions) (AppliancesClientUpdateResponse, error)

Update - Updates an Appliance with the specified Resource Name in the specified Resource Group and Subscription. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-10-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Appliances name.
  • parameters - The updatable fields of an existing Appliance.
  • options - AppliancesClientUpdateOptions contains the optional parameters for the AppliancesClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5f700acd3d094d8eedca381932f2e7916afd2e55/specification/resourceconnector/resource-manager/Microsoft.ResourceConnector/stable/2022-10-27/examples/AppliancesPatch.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/resourceconnector/armresourceconnector"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armresourceconnector.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAppliancesClient().Update(ctx, "testresourcegroup", "appliance01", armresourceconnector.PatchableAppliance{
		Tags: map[string]*string{
			"key": to.Ptr("value"),
		},
	}, 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.Appliance = armresourceconnector.Appliance{
	// 	Name: to.Ptr("appliance01"),
	// 	Type: to.Ptr("Microsoft.ResourceConnector/appliances"),
	// 	ID: to.Ptr("/subscriptions/11111111-2222-3333-4444-555555555555/resourceGroups/testresourcegroup/providers/Microsoft.ResourceConnector/appliances/appliance01"),
	// 	Location: to.Ptr("West US"),
	// 	Tags: map[string]*string{
	// 		"key": to.Ptr("value"),
	// 	},
	// 	Identity: &armresourceconnector.Identity{
	// 		Type: to.Ptr(armresourceconnector.ResourceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
	// 		TenantID: to.Ptr("111111-1111-1111-1111-111111111111"),
	// 	},
	// 	Properties: &armresourceconnector.ApplianceProperties{
	// 		Distro: to.Ptr(armresourceconnector.DistroAKSEdge),
	// 		InfrastructureConfig: &armresourceconnector.AppliancePropertiesInfrastructureConfig{
	// 			Provider: to.Ptr(armresourceconnector.ProviderVMWare),
	// 		},
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		Status: to.Ptr(armresourceconnector.StatusValidating),
	// 		Version: to.Ptr("1.0.1"),
	// 	},
	// }
}

Output:

type AppliancesClientBeginCreateOrUpdateOptions 

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

AppliancesClientBeginCreateOrUpdateOptions contains the optional parameters for the AppliancesClient.BeginCreateOrUpdate method.

type AppliancesClientBeginDeleteOptions 

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

AppliancesClientBeginDeleteOptions contains the optional parameters for the AppliancesClient.BeginDelete method.

type AppliancesClientCreateOrUpdateResponse 

type AppliancesClientCreateOrUpdateResponse struct {
	// Appliances definition.
	Appliance
}

AppliancesClientCreateOrUpdateResponse contains the response from method AppliancesClient.BeginCreateOrUpdate.

type AppliancesClientDeleteResponse 

type AppliancesClientDeleteResponse struct {
}

AppliancesClientDeleteResponse contains the response from method AppliancesClient.BeginDelete.

type AppliancesClientGetOptions 

type AppliancesClientGetOptions struct {
}

AppliancesClientGetOptions contains the optional parameters for the AppliancesClient.Get method.

type AppliancesClientGetResponse 

type AppliancesClientGetResponse struct {
	// Appliances definition.
	Appliance
}

AppliancesClientGetResponse contains the response from method AppliancesClient.Get.

type AppliancesClientGetTelemetryConfigOptions added in v0.4.0 

type AppliancesClientGetTelemetryConfigOptions struct {
}

AppliancesClientGetTelemetryConfigOptions contains the optional parameters for the AppliancesClient.GetTelemetryConfig method.

type AppliancesClientGetTelemetryConfigResponse added in v0.4.0 

type AppliancesClientGetTelemetryConfigResponse struct {
	// The Get Telemetry Config Result appliance.
	ApplianceGetTelemetryConfigResult
}

AppliancesClientGetTelemetryConfigResponse contains the response from method AppliancesClient.GetTelemetryConfig.

type AppliancesClientGetUpgradeGraphOptions added in v0.2.0 

type AppliancesClientGetUpgradeGraphOptions struct {
}

AppliancesClientGetUpgradeGraphOptions contains the optional parameters for the AppliancesClient.GetUpgradeGraph method.

type AppliancesClientGetUpgradeGraphResponse added in v0.2.0 

type AppliancesClientGetUpgradeGraphResponse struct {
	// The Upgrade Graph for appliance.
	UpgradeGraph
}

AppliancesClientGetUpgradeGraphResponse contains the response from method AppliancesClient.GetUpgradeGraph.

type AppliancesClientListByResourceGroupOptions 

type AppliancesClientListByResourceGroupOptions struct {
}

AppliancesClientListByResourceGroupOptions contains the optional parameters for the AppliancesClient.NewListByResourceGroupPager method.

type AppliancesClientListByResourceGroupResponse 

type AppliancesClientListByResourceGroupResponse struct {
	// The List Appliances operation response.
	ApplianceListResult
}

AppliancesClientListByResourceGroupResponse contains the response from method AppliancesClient.NewListByResourceGroupPager.

type AppliancesClientListBySubscriptionOptions 

type AppliancesClientListBySubscriptionOptions struct {
}

AppliancesClientListBySubscriptionOptions contains the optional parameters for the AppliancesClient.NewListBySubscriptionPager method.

type AppliancesClientListBySubscriptionResponse 

type AppliancesClientListBySubscriptionResponse struct {
	// The List Appliances operation response.
	ApplianceListResult
}

AppliancesClientListBySubscriptionResponse contains the response from method AppliancesClient.NewListBySubscriptionPager.

type AppliancesClientListClusterUserCredentialOptions 

type AppliancesClientListClusterUserCredentialOptions struct {
}

AppliancesClientListClusterUserCredentialOptions contains the optional parameters for the AppliancesClient.ListClusterUserCredential method.

type AppliancesClientListClusterUserCredentialResponse 

type AppliancesClientListClusterUserCredentialResponse struct {
	// The List Cluster User Credential appliance.
	ApplianceListCredentialResults
}

AppliancesClientListClusterUserCredentialResponse contains the response from method AppliancesClient.ListClusterUserCredential.

type AppliancesClientListKeysOptions added in v0.4.0 

type AppliancesClientListKeysOptions struct {
	// This sets the type of artifact being returned, when empty no artifact endpoint is returned.
	ArtifactType *string
}

AppliancesClientListKeysOptions contains the optional parameters for the AppliancesClient.ListKeys method.

type AppliancesClientListKeysResponse added in v0.4.0 

type AppliancesClientListKeysResponse struct {
	// The List Cluster Keys Results appliance.
	ApplianceListKeysResults
}

AppliancesClientListKeysResponse contains the response from method AppliancesClient.ListKeys.

type AppliancesClientListOperationsOptions 

type AppliancesClientListOperationsOptions struct {
}

AppliancesClientListOperationsOptions contains the optional parameters for the AppliancesClient.NewListOperationsPager method.

type AppliancesClientListOperationsResponse 

type AppliancesClientListOperationsResponse struct {
	// Lists of Appliances operations.
	ApplianceOperationsList
}

AppliancesClientListOperationsResponse contains the response from method AppliancesClient.NewListOperationsPager.

type AppliancesClientUpdateOptions 

type AppliancesClientUpdateOptions struct {
}

AppliancesClientUpdateOptions contains the optional parameters for the AppliancesClient.Update method.

type AppliancesClientUpdateResponse 

type AppliancesClientUpdateResponse struct {
	// Appliances definition.
	Appliance
}

AppliancesClientUpdateResponse contains the response from method AppliancesClient.Update.

type ArtifactProfile added in v0.4.0 

type ArtifactProfile struct {
	// READ-ONLY; Endpoint is the URL to upload artifacts to.
	Endpoint *string
}

ArtifactProfile - Appliance ArtifactProfile definition.

func (ArtifactProfile) MarshalJSON added in v0.4.0 

func (a ArtifactProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ArtifactProfile.

func (*ArtifactProfile) UnmarshalJSON added in v0.4.0 

func (a *ArtifactProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ArtifactProfile.

type ClientFactory added in v0.3.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 v0.3.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 - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAppliancesClient added in v0.3.0 

func (c *ClientFactory) NewAppliancesClient() *AppliancesClient

NewAppliancesClient creates a new instance of AppliancesClient.

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 Distro 

type Distro string

Distro - Represents a supported Fabric/Infra. (AKSEdge etc…). 

const (
	DistroAKSEdge Distro = "AKSEdge"
)

func PossibleDistroValues 

func PossibleDistroValues() []Distro

PossibleDistroValues returns the possible values for the Distro const type.

type HybridConnectionConfig 

type HybridConnectionConfig struct {
	// READ-ONLY; Timestamp when this token will be expired.
	ExpirationTime *int64

	// READ-ONLY; Name of the connection
	HybridConnectionName *string

	// READ-ONLY; Name of the notification service.
	Relay *string

	// READ-ONLY; Listener access token
	Token *string
}

HybridConnectionConfig - Contains the REP (rendezvous endpoint) and “Listener” access token from notification service (NS).

func (HybridConnectionConfig) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type HybridConnectionConfig.

func (*HybridConnectionConfig) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HybridConnectionConfig.

type Identity 

type Identity struct {
	// The identity type.
	Type *ResourceIdentityType

	// READ-ONLY; The principal ID of resource identity.
	PrincipalID *string

	// READ-ONLY; The tenant ID of resource.
	TenantID *string
}

Identity for the resource.

func (Identity) MarshalJSON added in v0.2.0 

func (i Identity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Identity.

func (*Identity) UnmarshalJSON added in v0.2.0 

func (i *Identity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Identity.

type PatchableAppliance 

type PatchableAppliance struct {
	// Resource tags
	Tags map[string]*string
}

PatchableAppliance - The Appliances patchable resource definition.

func (PatchableAppliance) MarshalJSON 

func (p PatchableAppliance) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PatchableAppliance.

func (*PatchableAppliance) UnmarshalJSON added in v0.2.0 

func (p *PatchableAppliance) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PatchableAppliance.

type Provider 

type Provider string

Provider - Information about the connected appliance. 

const (
	ProviderHCI    Provider = "HCI"
	ProviderSCVMM  Provider = "SCVMM"
	ProviderVMWare Provider = "VMWare"
)

func PossibleProviderValues 

func PossibleProviderValues() []Provider

PossibleProviderValues returns the possible values for the Provider const type.

type ResourceIdentityType 

type ResourceIdentityType string

ResourceIdentityType - The identity type. 

const (
	ResourceIdentityTypeNone           ResourceIdentityType = "None"
	ResourceIdentityTypeSystemAssigned ResourceIdentityType = "SystemAssigned"
)

func PossibleResourceIdentityTypeValues 

func PossibleResourceIdentityTypeValues() []ResourceIdentityType

PossibleResourceIdentityTypeValues returns the possible values for the ResourceIdentityType const type.

type SSHKey added in v0.2.0 

type SSHKey struct {
	// READ-ONLY; Certificate associated with the public key if the key is signed.
	Certificate *string

	// READ-ONLY; Certificate creation timestamp (Unix).
	CreationTimeStamp *int64

	// READ-ONLY; Certificate expiration timestamp (Unix).
	ExpirationTimeStamp *int64

	// READ-ONLY; Private Key.
	PrivateKey *string

	// READ-ONLY; Public Key.
	PublicKey *string
}

SSHKey - Appliance SSHKey definition.

func (SSHKey) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type SSHKey.

func (*SSHKey) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SSHKey.

type Status 

type Status string

Status - Appliance’s health and state of connection to on-prem 

const (
	StatusConnected                             Status = "Connected"
	StatusConnecting                            Status = "Connecting"
	StatusETCDSnapshotFailed                    Status = "ETCDSnapshotFailed"
	StatusImageDeprovisioning                   Status = "ImageDeprovisioning"
	StatusImageDownloaded                       Status = "ImageDownloaded"
	StatusImageDownloading                      Status = "ImageDownloading"
	StatusImagePending                          Status = "ImagePending"
	StatusImageProvisioned                      Status = "ImageProvisioned"
	StatusImageProvisioning                     Status = "ImageProvisioning"
	StatusImageUnknown                          Status = "ImageUnknown"
	StatusNone                                  Status = "None"
	StatusOffline                               Status = "Offline"
	StatusPostUpgrade                           Status = "PostUpgrade"
	StatusPreUpgrade                            Status = "PreUpgrade"
	StatusPreparingForUpgrade                   Status = "PreparingForUpgrade"
	StatusRunning                               Status = "Running"
	StatusUpdatingCAPI                          Status = "UpdatingCAPI"
	StatusUpdatingCloudOperator                 Status = "UpdatingCloudOperator"
	StatusUpdatingCluster                       Status = "UpdatingCluster"
	StatusUpgradeClusterExtensionFailedToDelete Status = "UpgradeClusterExtensionFailedToDelete"
	StatusUpgradeComplete                       Status = "UpgradeComplete"
	StatusUpgradeFailed                         Status = "UpgradeFailed"
	StatusUpgradePrerequisitesCompleted         Status = "UpgradePrerequisitesCompleted"
	StatusUpgradingKVAIO                        Status = "UpgradingKVAIO"
	StatusValidating                            Status = "Validating"
	StatusValidatingETCDHealth                  Status = "ValidatingETCDHealth"
	StatusValidatingImageDownload               Status = "ValidatingImageDownload"
	StatusValidatingImageUpload                 Status = "ValidatingImageUpload"
	StatusValidatingSFSConnectivity             Status = "ValidatingSFSConnectivity"
	StatusWaitingForCloudOperator               Status = "WaitingForCloudOperator"
	StatusWaitingForHeartbeat                   Status = "WaitingForHeartbeat"
	StatusWaitingForKVAIO                       Status = "WaitingForKVAIO"
)

func PossibleStatusValues 

func PossibleStatusValues() []Status

PossibleStatusValues returns the possible values for the Status const type.

type SupportedVersion added in v0.2.0 

type SupportedVersion struct {
	// READ-ONLY; This is the metadata of the supported newer version.
	Metadata *SupportedVersionMetadata

	// READ-ONLY; The newer version available for upgrade.
	Version *string
}

SupportedVersion - The SupportedVersion object for appliance.

func (SupportedVersion) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type SupportedVersion.

func (*SupportedVersion) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SupportedVersion.

type SupportedVersionCatalogVersion added in v0.2.0 

type SupportedVersionCatalogVersion struct {
	// READ-ONLY; The newer supported version catalog version data.
	Data *SupportedVersionCatalogVersionData

	// READ-ONLY; The catalog version name for the version available for upgrade.
	Name *string

	// READ-ONLY; The catalog version namespace for the version available for upgrade.
	Namespace *string
}

SupportedVersionCatalogVersion - The SupportedVersionCatalogVersion object for appliance.

func (SupportedVersionCatalogVersion) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type SupportedVersionCatalogVersion.

func (*SupportedVersionCatalogVersion) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SupportedVersionCatalogVersion.

type SupportedVersionCatalogVersionData added in v0.2.0 

type SupportedVersionCatalogVersionData struct {
	// READ-ONLY; The image audience name for the version available for upgrade.
	Audience *string

	// READ-ONLY; The image catalog name for the version available for upgrade.
	Catalog *string

	// READ-ONLY; The image offer name for the version available for upgrade.
	Offer *string

	// READ-ONLY; The image version for the version available for upgrade.
	Version *string
}

SupportedVersionCatalogVersionData - The SupportedVersionCatalogVersionData object for appliance.

func (SupportedVersionCatalogVersionData) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type SupportedVersionCatalogVersionData.

func (*SupportedVersionCatalogVersionData) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SupportedVersionCatalogVersionData.

type SupportedVersionMetadata added in v0.2.0 

type SupportedVersionMetadata struct {
	// READ-ONLY; The newer supported version catalog version.
	CatalogVersion *SupportedVersionCatalogVersion
}

SupportedVersionMetadata - The SupportedVersionMetadata object for appliance.

func (SupportedVersionMetadata) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type SupportedVersionMetadata.

func (*SupportedVersionMetadata) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SupportedVersionMetadata.

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 UpgradeGraph added in v0.2.0 

type UpgradeGraph struct {
	// The properties of supported version
	Properties *UpgradeGraphProperties

	// READ-ONLY; The appliance resource path
	ID *string

	// READ-ONLY; The release train name.
	Name *string
}

UpgradeGraph - The Upgrade Graph for appliance.

func (UpgradeGraph) MarshalJSON added in v0.2.0 

func (u UpgradeGraph) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UpgradeGraph.

func (*UpgradeGraph) UnmarshalJSON added in v0.2.0 

func (u *UpgradeGraph) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UpgradeGraph.

type UpgradeGraphProperties added in v0.2.0 

type UpgradeGraphProperties struct {
	// READ-ONLY; The current appliance version
	ApplianceVersion *string

	// READ-ONLY; This contains the current version and supported upgrade versions.
	SupportedVersions []*SupportedVersion
}

UpgradeGraphProperties - The Upgrade Graph Properties for appliance.

func (UpgradeGraphProperties) MarshalJSON added in v0.2.0 

func (u UpgradeGraphProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UpgradeGraphProperties.

func (*UpgradeGraphProperties) UnmarshalJSON added in v0.2.0 

func (u *UpgradeGraphProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UpgradeGraphProperties.

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.