managedcassandras

package
v0.0.0-...-a81a29a Latest Latest
Warning

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

 Go to latest Published: Jun 15, 2023 License: MPL-2.0 Imports: 10 Imported by: 0

README

github.com/hashicorp/go-azure-sdk/resource-manager/cosmosdb/2022-05-15/managedcassandras Documentation

The managedcassandras SDK allows for interaction with the Azure Resource Manager Service cosmosdb (API Version 2022-05-15).

This readme covers example usages, but further information on using this SDK can be found in the project root.

Import Path

import "github.com/hashicorp/go-azure-sdk/resource-manager/cosmosdb/2022-05-15/managedcassandras"

Client Initialization

client := managedcassandras.NewManagedCassandrasClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: ManagedCassandrasClient.CassandraClustersCreateUpdate

ctx := context.TODO()
id := managedcassandras.NewCassandraClusterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue")

payload := managedcassandras.ClusterResource{
	// ...
}


if err := client.CassandraClustersCreateUpdateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: ManagedCassandrasClient.CassandraClustersDeallocate

ctx := context.TODO()
id := managedcassandras.NewCassandraClusterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue")

if err := client.CassandraClustersDeallocateThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: ManagedCassandrasClient.CassandraClustersDelete

ctx := context.TODO()
id := managedcassandras.NewCassandraClusterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue")

if err := client.CassandraClustersDeleteThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: ManagedCassandrasClient.CassandraClustersGet

ctx := context.TODO()
id := managedcassandras.NewCassandraClusterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue")

read, err := client.CassandraClustersGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: ManagedCassandrasClient.CassandraClustersInvokeCommand

ctx := context.TODO()
id := managedcassandras.NewCassandraClusterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue")

payload := managedcassandras.CommandPostBody{
	// ...
}


if err := client.CassandraClustersInvokeCommandThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: ManagedCassandrasClient.CassandraClustersListByResourceGroup

ctx := context.TODO()
id := managedcassandras.NewResourceGroupID("12345678-1234-9876-4563-123456789012", "example-resource-group")

read, err := client.CassandraClustersListByResourceGroup(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: ManagedCassandrasClient.CassandraClustersListBySubscription

ctx := context.TODO()
id := managedcassandras.NewSubscriptionID("12345678-1234-9876-4563-123456789012")

read, err := client.CassandraClustersListBySubscription(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: ManagedCassandrasClient.CassandraClustersStart

ctx := context.TODO()
id := managedcassandras.NewCassandraClusterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue")

if err := client.CassandraClustersStartThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: ManagedCassandrasClient.CassandraClustersStatus

ctx := context.TODO()
id := managedcassandras.NewCassandraClusterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue")

read, err := client.CassandraClustersStatus(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: ManagedCassandrasClient.CassandraClustersUpdate

ctx := context.TODO()
id := managedcassandras.NewCassandraClusterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue")

payload := managedcassandras.ClusterResource{
	// ...
}


if err := client.CassandraClustersUpdateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: ManagedCassandrasClient.CassandraDataCentersCreateUpdate

ctx := context.TODO()
id := managedcassandras.NewDataCenterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue", "dataCenterValue")

payload := managedcassandras.DataCenterResource{
	// ...
}


if err := client.CassandraDataCentersCreateUpdateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: ManagedCassandrasClient.CassandraDataCentersDelete

ctx := context.TODO()
id := managedcassandras.NewDataCenterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue", "dataCenterValue")

if err := client.CassandraDataCentersDeleteThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: ManagedCassandrasClient.CassandraDataCentersGet

ctx := context.TODO()
id := managedcassandras.NewDataCenterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue", "dataCenterValue")

read, err := client.CassandraDataCentersGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: ManagedCassandrasClient.CassandraDataCentersList

ctx := context.TODO()
id := managedcassandras.NewCassandraClusterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue")

read, err := client.CassandraDataCentersList(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: ManagedCassandrasClient.CassandraDataCentersUpdate

ctx := context.TODO()
id := managedcassandras.NewDataCenterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "cassandraClusterValue", "dataCenterValue")

payload := managedcassandras.DataCenterResource{
	// ...
}


if err := client.CassandraDataCentersUpdateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func PossibleValuesForAuthenticationMethod 

func PossibleValuesForAuthenticationMethod() []string

func PossibleValuesForConnectionState 

func PossibleValuesForConnectionState() []string

func PossibleValuesForManagedCassandraProvisioningState 

func PossibleValuesForManagedCassandraProvisioningState() []string

func PossibleValuesForNodeState 

func PossibleValuesForNodeState() []string

func ValidateCassandraClusterID 

func ValidateCassandraClusterID(input interface{}, key string) (warnings []string, errors []error)

ValidateCassandraClusterID checks that 'input' can be parsed as a Cassandra Cluster ID

func ValidateDataCenterID 

func ValidateDataCenterID(input interface{}, key string) (warnings []string, errors []error)

ValidateDataCenterID checks that 'input' can be parsed as a Data Center ID

Types

type AuthenticationMethod 

type AuthenticationMethod string
const (
	AuthenticationMethodCassandra AuthenticationMethod = "Cassandra"
	AuthenticationMethodNone      AuthenticationMethod = "None"
)

type CassandraClusterId 

type CassandraClusterId struct {
	SubscriptionId       string
	ResourceGroupName    string
	CassandraClusterName string
}

CassandraClusterId is a struct representing the Resource ID for a Cassandra Cluster

func NewCassandraClusterID 

func NewCassandraClusterID(subscriptionId string, resourceGroupName string, cassandraClusterName string) CassandraClusterId

NewCassandraClusterID returns a new CassandraClusterId struct

func ParseCassandraClusterID 

func ParseCassandraClusterID(input string) (*CassandraClusterId, error)

ParseCassandraClusterID parses 'input' into a CassandraClusterId

func ParseCassandraClusterIDInsensitively 

func ParseCassandraClusterIDInsensitively(input string) (*CassandraClusterId, error)

ParseCassandraClusterIDInsensitively parses 'input' case-insensitively into a CassandraClusterId note: this method should only be used for API response data and not user input

func (CassandraClusterId) ID 

func (id CassandraClusterId) ID() string

ID returns the formatted Cassandra Cluster ID

func (CassandraClusterId) Segments 

func (id CassandraClusterId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Cassandra Cluster ID

func (CassandraClusterId) String 

func (id CassandraClusterId) String() string

String returns a human-readable description of this Cassandra Cluster ID

type CassandraClusterPublicStatus 

type CassandraClusterPublicStatus struct {
	ConnectionErrors *[]ConnectionError                                `json:"connectionErrors,omitempty"`
	DataCenters      *[]CassandraClusterPublicStatusDataCentersInlined `json:"dataCenters,omitempty"`
	ETag             *string                                           `json:"eTag,omitempty"`
	ReaperStatus     *ManagedCassandraReaperStatus                     `json:"reaperStatus,omitempty"`
}

type CassandraClusterPublicStatusDataCentersInlined 

type CassandraClusterPublicStatusDataCentersInlined struct {
	Name      *string                                                       `json:"name,omitempty"`
	Nodes     *[]CassandraClusterPublicStatusDataCentersInlinedNodesInlined `json:"nodes,omitempty"`
	SeedNodes *[]string                                                     `json:"seedNodes,omitempty"`
}

type CassandraClusterPublicStatusDataCentersInlinedNodesInlined 

type CassandraClusterPublicStatusDataCentersInlinedNodesInlined struct {
	Address                  *string    `json:"address,omitempty"`
	CpuUsage                 *float64   `json:"cpuUsage,omitempty"`
	DiskFreeKB               *int64     `json:"diskFreeKB,omitempty"`
	DiskUsedKB               *int64     `json:"diskUsedKB,omitempty"`
	HostID                   *string    `json:"hostID,omitempty"`
	Load                     *string    `json:"load,omitempty"`
	MemoryBuffersAndCachedKB *int64     `json:"memoryBuffersAndCachedKB,omitempty"`
	MemoryFreeKB             *int64     `json:"memoryFreeKB,omitempty"`
	MemoryTotalKB            *int64     `json:"memoryTotalKB,omitempty"`
	MemoryUsedKB             *int64     `json:"memoryUsedKB,omitempty"`
	Rack                     *string    `json:"rack,omitempty"`
	Size                     *int64     `json:"size,omitempty"`
	State                    *NodeState `json:"state,omitempty"`
	Status                   *string    `json:"status,omitempty"`
	Timestamp                *string    `json:"timestamp,omitempty"`
	Tokens                   *[]string  `json:"tokens,omitempty"`
}

type CassandraClustersCreateUpdateOperationResponse 

type CassandraClustersCreateUpdateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraClustersDeallocateOperationResponse 

type CassandraClustersDeallocateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraClustersDeleteOperationResponse 

type CassandraClustersDeleteOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraClustersGetOperationResponse 

type CassandraClustersGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *ClusterResource
}

type CassandraClustersInvokeCommandOperationResponse 

type CassandraClustersInvokeCommandOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraClustersListByResourceGroupOperationResponse 

type CassandraClustersListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	Model        *ListClusters
}

type CassandraClustersListBySubscriptionOperationResponse 

type CassandraClustersListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	Model        *ListClusters
}

type CassandraClustersStartOperationResponse 

type CassandraClustersStartOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraClustersStatusOperationResponse 

type CassandraClustersStatusOperationResponse struct {
	HttpResponse *http.Response
	Model        *CassandraClusterPublicStatus
}

type CassandraClustersUpdateOperationResponse 

type CassandraClustersUpdateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraDataCentersCreateUpdateOperationResponse 

type CassandraDataCentersCreateUpdateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraDataCentersDeleteOperationResponse 

type CassandraDataCentersDeleteOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraDataCentersGetOperationResponse 

type CassandraDataCentersGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *DataCenterResource
}

type CassandraDataCentersListOperationResponse 

type CassandraDataCentersListOperationResponse struct {
	HttpResponse *http.Response
	Model        *ListDataCenters
}

type CassandraDataCentersUpdateOperationResponse 

type CassandraDataCentersUpdateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type Certificate 

type Certificate struct {
	Pem *string `json:"pem,omitempty"`
}

type ClusterResource 

type ClusterResource struct {
	Id         *string                    `json:"id,omitempty"`
	Identity   *identity.SystemAssigned   `json:"identity,omitempty"`
	Location   *string                    `json:"location,omitempty"`
	Name       *string                    `json:"name,omitempty"`
	Properties *ClusterResourceProperties `json:"properties,omitempty"`
	Tags       *map[string]string         `json:"tags,omitempty"`
	Type       *string                    `json:"type,omitempty"`
}

type ClusterResourceProperties 

type ClusterResourceProperties struct {
	AuthenticationMethod          *AuthenticationMethod              `json:"authenticationMethod,omitempty"`
	CassandraAuditLoggingEnabled  *bool                              `json:"cassandraAuditLoggingEnabled,omitempty"`
	CassandraVersion              *string                            `json:"cassandraVersion,omitempty"`
	ClientCertificates            *[]Certificate                     `json:"clientCertificates,omitempty"`
	ClusterNameOverride           *string                            `json:"clusterNameOverride,omitempty"`
	Deallocated                   *bool                              `json:"deallocated,omitempty"`
	DelegatedManagementSubnetId   *string                            `json:"delegatedManagementSubnetId,omitempty"`
	ExternalGossipCertificates    *[]Certificate                     `json:"externalGossipCertificates,omitempty"`
	ExternalSeedNodes             *[]SeedNode                        `json:"externalSeedNodes,omitempty"`
	GossipCertificates            *[]Certificate                     `json:"gossipCertificates,omitempty"`
	HoursBetweenBackups           *int64                             `json:"hoursBetweenBackups,omitempty"`
	InitialCassandraAdminPassword *string                            `json:"initialCassandraAdminPassword,omitempty"`
	PrometheusEndpoint            *SeedNode                          `json:"prometheusEndpoint,omitempty"`
	ProvisioningState             *ManagedCassandraProvisioningState `json:"provisioningState,omitempty"`
	RepairEnabled                 *bool                              `json:"repairEnabled,omitempty"`
	RestoreFromBackupId           *string                            `json:"restoreFromBackupId,omitempty"`
	SeedNodes                     *[]SeedNode                        `json:"seedNodes,omitempty"`
}

type CommandOutput 

type CommandOutput struct {
	CommandOutput *string `json:"commandOutput,omitempty"`
}

type CommandPostBody 

type CommandPostBody struct {
	Arguments          *map[string]string `json:"arguments,omitempty"`
	CassandraStopStart *bool              `json:"cassandra-stop-start,omitempty"`
	Command            string             `json:"command"`
	Host               string             `json:"host"`
	Readwrite          *bool              `json:"readwrite,omitempty"`
}

type ConnectionError 

type ConnectionError struct {
	ConnectionState *ConnectionState `json:"connectionState,omitempty"`
	Exception       *string          `json:"exception,omitempty"`
	IPFrom          *string          `json:"iPFrom,omitempty"`
	IPTo            *string          `json:"iPTo,omitempty"`
	Port            *int64           `json:"port,omitempty"`
}

type ConnectionState 

type ConnectionState string
const (
	ConnectionStateDatacenterToDatacenterNetworkError           ConnectionState = "DatacenterToDatacenterNetworkError"
	ConnectionStateInternalError                                ConnectionState = "InternalError"
	ConnectionStateInternalOperatorToDataCenterCertificateError ConnectionState = "InternalOperatorToDataCenterCertificateError"
	ConnectionStateOK                                           ConnectionState = "OK"
	ConnectionStateOperatorToDataCenterNetworkError             ConnectionState = "OperatorToDataCenterNetworkError"
	ConnectionStateUnknown                                      ConnectionState = "Unknown"
)

type DataCenterId 

type DataCenterId struct {
	SubscriptionId       string
	ResourceGroupName    string
	CassandraClusterName string
	DataCenterName       string
}

DataCenterId is a struct representing the Resource ID for a Data Center

func NewDataCenterID 

func NewDataCenterID(subscriptionId string, resourceGroupName string, cassandraClusterName string, dataCenterName string) DataCenterId

NewDataCenterID returns a new DataCenterId struct

func ParseDataCenterID 

func ParseDataCenterID(input string) (*DataCenterId, error)

ParseDataCenterID parses 'input' into a DataCenterId

func ParseDataCenterIDInsensitively 

func ParseDataCenterIDInsensitively(input string) (*DataCenterId, error)

ParseDataCenterIDInsensitively parses 'input' case-insensitively into a DataCenterId note: this method should only be used for API response data and not user input

func (DataCenterId) ID 

func (id DataCenterId) ID() string

ID returns the formatted Data Center ID

func (DataCenterId) Segments 

func (id DataCenterId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Data Center ID

func (DataCenterId) String 

func (id DataCenterId) String() string

String returns a human-readable description of this Data Center ID

type DataCenterResource 

type DataCenterResource struct {
	Id         *string                       `json:"id,omitempty"`
	Name       *string                       `json:"name,omitempty"`
	Properties *DataCenterResourceProperties `json:"properties,omitempty"`
	Type       *string                       `json:"type,omitempty"`
}

type DataCenterResourceProperties 

type DataCenterResourceProperties struct {
	AvailabilityZone                   *bool                              `json:"availabilityZone,omitempty"`
	BackupStorageCustomerKeyUri        *string                            `json:"backupStorageCustomerKeyUri,omitempty"`
	Base64EncodedCassandraYamlFragment *string                            `json:"base64EncodedCassandraYamlFragment,omitempty"`
	DataCenterLocation                 *string                            `json:"dataCenterLocation,omitempty"`
	DelegatedSubnetId                  *string                            `json:"delegatedSubnetId,omitempty"`
	DiskCapacity                       *int64                             `json:"diskCapacity,omitempty"`
	DiskSku                            *string                            `json:"diskSku,omitempty"`
	ManagedDiskCustomerKeyUri          *string                            `json:"managedDiskCustomerKeyUri,omitempty"`
	NodeCount                          *int64                             `json:"nodeCount,omitempty"`
	ProvisioningState                  *ManagedCassandraProvisioningState `json:"provisioningState,omitempty"`
	SeedNodes                          *[]SeedNode                        `json:"seedNodes,omitempty"`
	Sku                                *string                            `json:"sku,omitempty"`
}

type ListClusters 

type ListClusters struct {
	Value *[]ClusterResource `json:"value,omitempty"`
}

type ListDataCenters 

type ListDataCenters struct {
	Value *[]DataCenterResource `json:"value,omitempty"`
}

type ManagedCassandraProvisioningState 

type ManagedCassandraProvisioningState string
const (
	ManagedCassandraProvisioningStateCanceled  ManagedCassandraProvisioningState = "Canceled"
	ManagedCassandraProvisioningStateCreating  ManagedCassandraProvisioningState = "Creating"
	ManagedCassandraProvisioningStateDeleting  ManagedCassandraProvisioningState = "Deleting"
	ManagedCassandraProvisioningStateFailed    ManagedCassandraProvisioningState = "Failed"
	ManagedCassandraProvisioningStateSucceeded ManagedCassandraProvisioningState = "Succeeded"
	ManagedCassandraProvisioningStateUpdating  ManagedCassandraProvisioningState = "Updating"
)

type ManagedCassandraReaperStatus 

type ManagedCassandraReaperStatus struct {
	Healthy         *bool              `json:"healthy,omitempty"`
	RepairRunIds    *map[string]string `json:"repairRunIds,omitempty"`
	RepairSchedules *map[string]string `json:"repairSchedules,omitempty"`
}

type ManagedCassandrasClient 

type ManagedCassandrasClient struct {
	Client autorest.Client
	// contains filtered or unexported fields
}

func NewManagedCassandrasClientWithBaseURI 

func NewManagedCassandrasClientWithBaseURI(endpoint string) ManagedCassandrasClient

func (ManagedCassandrasClient) CassandraClustersCreateUpdate 

func (c ManagedCassandrasClient) CassandraClustersCreateUpdate(ctx context.Context, id CassandraClusterId, input ClusterResource) (result CassandraClustersCreateUpdateOperationResponse, err error)

CassandraClustersCreateUpdate ...

func (ManagedCassandrasClient) CassandraClustersCreateUpdateThenPoll 

func (c ManagedCassandrasClient) CassandraClustersCreateUpdateThenPoll(ctx context.Context, id CassandraClusterId, input ClusterResource) error

CassandraClustersCreateUpdateThenPoll performs CassandraClustersCreateUpdate then polls until it's completed

func (ManagedCassandrasClient) CassandraClustersDeallocate 

func (c ManagedCassandrasClient) CassandraClustersDeallocate(ctx context.Context, id CassandraClusterId) (result CassandraClustersDeallocateOperationResponse, err error)

CassandraClustersDeallocate ...

func (ManagedCassandrasClient) CassandraClustersDeallocateThenPoll 

func (c ManagedCassandrasClient) CassandraClustersDeallocateThenPoll(ctx context.Context, id CassandraClusterId) error

CassandraClustersDeallocateThenPoll performs CassandraClustersDeallocate then polls until it's completed

func (ManagedCassandrasClient) CassandraClustersDelete 

func (c ManagedCassandrasClient) CassandraClustersDelete(ctx context.Context, id CassandraClusterId) (result CassandraClustersDeleteOperationResponse, err error)

CassandraClustersDelete ...

func (ManagedCassandrasClient) CassandraClustersDeleteThenPoll 

func (c ManagedCassandrasClient) CassandraClustersDeleteThenPoll(ctx context.Context, id CassandraClusterId) error

CassandraClustersDeleteThenPoll performs CassandraClustersDelete then polls until it's completed

func (ManagedCassandrasClient) CassandraClustersGet 

func (c ManagedCassandrasClient) CassandraClustersGet(ctx context.Context, id CassandraClusterId) (result CassandraClustersGetOperationResponse, err error)

CassandraClustersGet ...

func (ManagedCassandrasClient) CassandraClustersInvokeCommand 

func (c ManagedCassandrasClient) CassandraClustersInvokeCommand(ctx context.Context, id CassandraClusterId, input CommandPostBody) (result CassandraClustersInvokeCommandOperationResponse, err error)

CassandraClustersInvokeCommand ...

func (ManagedCassandrasClient) CassandraClustersInvokeCommandThenPoll 

func (c ManagedCassandrasClient) CassandraClustersInvokeCommandThenPoll(ctx context.Context, id CassandraClusterId, input CommandPostBody) error

CassandraClustersInvokeCommandThenPoll performs CassandraClustersInvokeCommand then polls until it's completed

func (ManagedCassandrasClient) CassandraClustersListByResourceGroup 

func (c ManagedCassandrasClient) CassandraClustersListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result CassandraClustersListByResourceGroupOperationResponse, err error)

CassandraClustersListByResourceGroup ...

func (ManagedCassandrasClient) CassandraClustersListBySubscription 

func (c ManagedCassandrasClient) CassandraClustersListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result CassandraClustersListBySubscriptionOperationResponse, err error)

CassandraClustersListBySubscription ...

func (ManagedCassandrasClient) CassandraClustersStart 

func (c ManagedCassandrasClient) CassandraClustersStart(ctx context.Context, id CassandraClusterId) (result CassandraClustersStartOperationResponse, err error)

CassandraClustersStart ...

func (ManagedCassandrasClient) CassandraClustersStartThenPoll 

func (c ManagedCassandrasClient) CassandraClustersStartThenPoll(ctx context.Context, id CassandraClusterId) error

CassandraClustersStartThenPoll performs CassandraClustersStart then polls until it's completed

func (ManagedCassandrasClient) CassandraClustersStatus 

func (c ManagedCassandrasClient) CassandraClustersStatus(ctx context.Context, id CassandraClusterId) (result CassandraClustersStatusOperationResponse, err error)

CassandraClustersStatus ...

func (ManagedCassandrasClient) CassandraClustersUpdate 

func (c ManagedCassandrasClient) CassandraClustersUpdate(ctx context.Context, id CassandraClusterId, input ClusterResource) (result CassandraClustersUpdateOperationResponse, err error)

CassandraClustersUpdate ...

func (ManagedCassandrasClient) CassandraClustersUpdateThenPoll 

func (c ManagedCassandrasClient) CassandraClustersUpdateThenPoll(ctx context.Context, id CassandraClusterId, input ClusterResource) error

CassandraClustersUpdateThenPoll performs CassandraClustersUpdate then polls until it's completed

func (ManagedCassandrasClient) CassandraDataCentersCreateUpdate 

func (c ManagedCassandrasClient) CassandraDataCentersCreateUpdate(ctx context.Context, id DataCenterId, input DataCenterResource) (result CassandraDataCentersCreateUpdateOperationResponse, err error)

CassandraDataCentersCreateUpdate ...

func (ManagedCassandrasClient) CassandraDataCentersCreateUpdateThenPoll 

func (c ManagedCassandrasClient) CassandraDataCentersCreateUpdateThenPoll(ctx context.Context, id DataCenterId, input DataCenterResource) error

CassandraDataCentersCreateUpdateThenPoll performs CassandraDataCentersCreateUpdate then polls until it's completed

func (ManagedCassandrasClient) CassandraDataCentersDelete 

func (c ManagedCassandrasClient) CassandraDataCentersDelete(ctx context.Context, id DataCenterId) (result CassandraDataCentersDeleteOperationResponse, err error)

CassandraDataCentersDelete ...

func (ManagedCassandrasClient) CassandraDataCentersDeleteThenPoll 

func (c ManagedCassandrasClient) CassandraDataCentersDeleteThenPoll(ctx context.Context, id DataCenterId) error

CassandraDataCentersDeleteThenPoll performs CassandraDataCentersDelete then polls until it's completed

func (ManagedCassandrasClient) CassandraDataCentersGet 

func (c ManagedCassandrasClient) CassandraDataCentersGet(ctx context.Context, id DataCenterId) (result CassandraDataCentersGetOperationResponse, err error)

CassandraDataCentersGet ...

func (ManagedCassandrasClient) CassandraDataCentersList 

func (c ManagedCassandrasClient) CassandraDataCentersList(ctx context.Context, id CassandraClusterId) (result CassandraDataCentersListOperationResponse, err error)

CassandraDataCentersList ...

func (ManagedCassandrasClient) CassandraDataCentersUpdate 

func (c ManagedCassandrasClient) CassandraDataCentersUpdate(ctx context.Context, id DataCenterId, input DataCenterResource) (result CassandraDataCentersUpdateOperationResponse, err error)

CassandraDataCentersUpdate ...

func (ManagedCassandrasClient) CassandraDataCentersUpdateThenPoll 

func (c ManagedCassandrasClient) CassandraDataCentersUpdateThenPoll(ctx context.Context, id DataCenterId, input DataCenterResource) error

CassandraDataCentersUpdateThenPoll performs CassandraDataCentersUpdate then polls until it's completed

type NodeState 

type NodeState string
const (
	NodeStateJoining NodeState = "Joining"
	NodeStateLeaving NodeState = "Leaving"
	NodeStateMoving  NodeState = "Moving"
	NodeStateNormal  NodeState = "Normal"
	NodeStateStopped NodeState = "Stopped"
)

type SeedNode 

type SeedNode struct {
	IPAddress *string `json:"ipAddress,omitempty"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.