resources

package
v6.7.5 Latest Latest
Warning

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

 Go to latest Published: Mar 21, 2024 License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func FtpUpload added in v6.7.4 

func FtpUpload(ctx context.Context, p UploadProperties) error

Types

type ApplicationLoadBalancer 

type ApplicationLoadBalancer struct {
	ionoscloud.ApplicationLoadBalancer
}

type ApplicationLoadBalancerForwardingRule 

type ApplicationLoadBalancerForwardingRule struct {
	ionoscloud.ApplicationLoadBalancerForwardingRule
}

type ApplicationLoadBalancerForwardingRuleProperties 

type ApplicationLoadBalancerForwardingRuleProperties struct {
	ionoscloud.ApplicationLoadBalancerForwardingRuleProperties
}

type ApplicationLoadBalancerForwardingRules 

type ApplicationLoadBalancerForwardingRules struct {
	ionoscloud.ApplicationLoadBalancerForwardingRules
}

type ApplicationLoadBalancerHttpRule 

type ApplicationLoadBalancerHttpRule struct {
	ionoscloud.ApplicationLoadBalancerHttpRule
}

type ApplicationLoadBalancerHttpRuleCondition 

type ApplicationLoadBalancerHttpRuleCondition struct {
	ionoscloud.ApplicationLoadBalancerHttpRuleCondition
}

type ApplicationLoadBalancerProperties 

type ApplicationLoadBalancerProperties struct {
	ionoscloud.ApplicationLoadBalancerProperties
}

type ApplicationLoadBalancerPut 

type ApplicationLoadBalancerPut struct {
	ionoscloud.ApplicationLoadBalancerPut
}

type ApplicationLoadBalancers 

type ApplicationLoadBalancers struct {
	ionoscloud.ApplicationLoadBalancers
}

type ApplicationLoadBalancersService 

type ApplicationLoadBalancersService interface {
	List(datacenterId string, params ListQueryParams) (ApplicationLoadBalancers, *Response, error)
	Get(datacenterId, applicationLoadBalancerId string, params QueryParams) (*ApplicationLoadBalancer, *Response, error)
	Create(datacenterId string, input ApplicationLoadBalancer, params QueryParams) (*ApplicationLoadBalancer, *Response, error)
	Update(datacenterId, applicationLoadBalancerId string, input ApplicationLoadBalancerProperties, params QueryParams) (*ApplicationLoadBalancer, *Response, error)
	Delete(datacenterId, applicationLoadBalancerId string, params QueryParams) (*Response, error)
	ListForwardingRules(datacenterId, applicationLoadBalancerId string, params ListQueryParams) (ApplicationLoadBalancerForwardingRules, *Response, error)
	GetForwardingRule(datacenterId, applicationLoadBalancerId, forwardingRuleId string, params QueryParams) (*ApplicationLoadBalancerForwardingRule, *Response, error)
	CreateForwardingRule(datacenterId, applicationLoadBalancerId string, input ApplicationLoadBalancerForwardingRule, params QueryParams) (*ApplicationLoadBalancerForwardingRule, *Response, error)
	UpdateForwardingRule(datacenterId, applicationLoadBalancerId, forwardingRuleId string, input *ApplicationLoadBalancerForwardingRuleProperties, params QueryParams) (*ApplicationLoadBalancerForwardingRule, *Response, error)
	DeleteForwardingRule(datacenterId, applicationLoadBalancerId, forwardingRuleId string, params QueryParams) (*Response, error)
	ListFlowLogs(datacenterId, applicationLoadBalancerId string, params ListQueryParams) (FlowLogs, *Response, error)
	GetFlowLog(datacenterId, applicationLoadBalancerId, flowLogId string, params QueryParams) (*FlowLog, *Response, error)
	CreateFlowLog(datacenterId, applicationLoadBalancerId string, input FlowLog, params QueryParams) (*FlowLog, *Response, error)
	UpdateFlowLog(datacenterId, applicationLoadBalancerId, flowLogId string, input *FlowLogProperties, params QueryParams) (*FlowLog, *Response, error)
	DeleteFlowLog(datacenterId, applicationLoadBalancerId, flowLogId string, params QueryParams) (*Response, error)
}

ApplicationLoadBalancersService is a wrapper around ionoscloud.ApplicationLoadBalancer

func NewApplicationLoadBalancerService 

func NewApplicationLoadBalancerService(client *client.Client, ctx context.Context) ApplicationLoadBalancersService

type AttachedVolumes 

type AttachedVolumes struct {
	ionoscloud.AttachedVolumes
}

type BackupUnit 

type BackupUnit struct {
	ionoscloud.BackupUnit
}

type BackupUnitProperties 

type BackupUnitProperties struct {
	ionoscloud.BackupUnitProperties
}

type BackupUnitSSO 

type BackupUnitSSO struct {
	ionoscloud.BackupUnitSSO
}

type BackupUnits 

type BackupUnits struct {
	ionoscloud.BackupUnits
}

type BackupUnitsService 

type BackupUnitsService interface {
	List(params ListQueryParams) (BackupUnits, *Response, error)
	Get(backupUnitId string, params QueryParams) (*BackupUnit, *Response, error)
	GetSsoUrl(backupUnitId string, params QueryParams) (*BackupUnitSSO, *Response, error)
	Create(u BackupUnit, params QueryParams) (*BackupUnit, *Response, error)
	Update(backupUnitId string, input BackupUnitProperties, params QueryParams) (*BackupUnit, *Response, error)
	Delete(backupUnitId string, params QueryParams) (*Response, error)
}

BackupUnitsService is a wrapper around ionoscloud.BackupUnit

func NewBackupUnitService 

func NewBackupUnitService(client *client.Client, ctx context.Context) BackupUnitsService

type BalancedNics 

type BalancedNics struct {
	ionoscloud.BalancedNics
}

type Cdroms 

type Cdroms struct {
	ionoscloud.Cdroms
}

type Contract 

type Contract struct {
	ionoscloud.Contract
}

type Contracts 

type Contracts struct {
	ionoscloud.Contracts
}

type ContractsService 

type ContractsService interface {
	Get(params QueryParams) (Contracts, *Response, error)
}

ContractsService is a wrapper around ionoscloud.Contract

func NewContractService 

func NewContractService(client *client.Client, ctx context.Context) ContractsService

type CpuArchitectureProperties 

type CpuArchitectureProperties struct {
	ionoscloud.CpuArchitectureProperties
}

type Datacenter 

type Datacenter struct {
	ionoscloud.Datacenter
}

type DatacenterProperties 

type DatacenterProperties struct {
	ionoscloud.DatacenterProperties
}

type Datacenters 

type Datacenters struct {
	ionoscloud.Datacenters
}

type DatacentersService 

type DatacentersService interface {
	List(params ListQueryParams) (Datacenters, *Response, error)
	Get(datacenterId string, queryParams QueryParams) (*Datacenter, *Response, error)
	Create(name, description, region string, queryParams QueryParams) (*Datacenter, *Response, error)
	Update(datacenterId string, input DatacenterProperties, queryParams QueryParams) (*Datacenter, *Response, error)
	Delete(datacenterId string, queryParams QueryParams) (*Response, error)
}

DatacentersService is a wrapper around ionoscloud.Datacenter

func NewDataCenterService 

func NewDataCenterService(client *client.Client, ctx context.Context) DatacentersService

type FTPServerProperties 

type FTPServerProperties struct {
	Url               string // Server URL without any directory path. Example: ftp-fkb.ionos.com
	Port              int
	SkipVerify        bool           // Skip FTP server certificate verification. WARNING man-in-the-middle attack possible
	ServerCertificate *x509.CertPool // If FTP server uses self signed certificates, put this in tlsConfig. IONOS FTP Servers in prod DON'T need this
	Username          string
	Password          string
}

type FirewallRule 

type FirewallRule struct {
	ionoscloud.FirewallRule
}

type FirewallRuleProperties 

type FirewallRuleProperties struct {
	ionoscloud.FirewallruleProperties
}

type FirewallRules 

type FirewallRules struct {
	ionoscloud.FirewallRules
}

type FirewallRulesService 

type FirewallRulesService interface {
	List(datacenterId, serverId, nicId string, params ListQueryParams) (FirewallRules, *Response, error)
	Get(datacenterId, serverId, nicId, firewallRuleId string, params QueryParams) (*FirewallRule, *Response, error)
	Create(datacenterId, serverId, nicId string, input FirewallRule, params QueryParams) (*FirewallRule, *Response, error)
	Update(datacenterId, serverId, nicId, firewallRuleId string, input FirewallRuleProperties, params QueryParams) (*FirewallRule, *Response, error)
	Delete(datacenterId, serverId, nicId, firewallRuleId string, params QueryParams) (*Response, error)
}

FirewallRulesService is a wrapper around ionoscloud.FirewallRule

func NewFirewallRuleService 

func NewFirewallRuleService(client *client.Client, ctx context.Context) FirewallRulesService

type FlowLog 

type FlowLog struct {
	ionoscloud.FlowLog
}

type FlowLogProperties 

type FlowLogProperties struct {
	ionoscloud.FlowLogProperties
}

type FlowLogPut 

type FlowLogPut struct {
	ionoscloud.FlowLogPut
}

type FlowLogs 

type FlowLogs struct {
	ionoscloud.FlowLogs
}

type FlowLogsService 

type FlowLogsService interface {
	List(datacenterId, serverId, nicId string, params ListQueryParams) (FlowLogs, *Response, error)
	Get(datacenterId, serverId, nicId, flowLogId string, params QueryParams) (*FlowLog, *Response, error)
	Create(datacenterId, serverId, nicId string, input FlowLog, params QueryParams) (*FlowLog, *Response, error)
	Update(datacenterId, serverId, nicId, flowlogId string, input FlowLogPut, params QueryParams) (*FlowLog, *Response, error)
	Delete(datacenterId, serverId, nicId, flowLogId string, params QueryParams) (*Response, error)
}

FlowLogsService is a wrapper around ionoscloud.FlowLog

func NewFlowLogService 

func NewFlowLogService(client *client.Client, ctx context.Context) FlowLogsService

type Group 

type Group struct {
	ionoscloud.Group
}

type GroupMembers 

type GroupMembers struct {
	ionoscloud.GroupMembers
}

type GroupProperties 

type GroupProperties struct {
	ionoscloud.GroupProperties
}

type GroupShare 

type GroupShare struct {
	ionoscloud.GroupShare
}

type GroupShareProperties 

type GroupShareProperties struct {
	ionoscloud.GroupShareProperties
}

type GroupShares 

type GroupShares struct {
	ionoscloud.GroupShares
}

type Groups 

type Groups struct {
	ionoscloud.Groups
}

type GroupsService 

type GroupsService interface {
	List(params ListQueryParams) (Groups, *Response, error)
	Get(groupId string, params QueryParams) (*Group, *Response, error)
	Create(u Group, params QueryParams) (*Group, *Response, error)
	Update(groupId string, input Group, params QueryParams) (*Group, *Response, error)
	Delete(groupId string, params QueryParams) (*Response, error)
	ListUsers(groupId string, params ListQueryParams) (GroupMembers, *Response, error)
	AddUser(groupId string, input User, params QueryParams) (*User, *Response, error)
	RemoveUser(groupId, userId string, params QueryParams) (*Response, error)
	ListShares(groupId string, params ListQueryParams) (GroupShares, *Response, error)
	GetShare(groupId, resourceId string, params QueryParams) (*GroupShare, *Response, error)
	AddShare(groupId, resourceId string, input GroupShare, params QueryParams) (*GroupShare, *Response, error)
	UpdateShare(groupId, resourceId string, input GroupShare, params QueryParams) (*GroupShare, *Response, error)
	RemoveShare(groupId, resourceId string, params QueryParams) (*Response, error)
	ListResources(groupId string, params ListQueryParams) (ResourceGroups, *Response, error)
}

GroupsService is a wrapper around ionoscloud.Group

func NewGroupService 

func NewGroupService(client *client.Client, ctx context.Context) GroupsService

type Image 

type Image struct {
	ionoscloud.Image
}

type ImageFileProperties 

type ImageFileProperties struct {
	Path       string // File name, server path (not local) and file extension included
	DataBuffer *bufio.Reader
}

type ImageProperties 

type ImageProperties struct {
	ionoscloud.ImageProperties
}

type Images 

type Images struct {
	ionoscloud.Images
}

type ImagesService 

type ImagesService interface {
	List(params ListQueryParams) (Images, *Response, error)
	Get(imageId string, params QueryParams) (*Image, *Response, error)
	Update(imageId string, imgProp ImageProperties, params QueryParams) (*Image, *Response, error)
	Delete(imageId string, params QueryParams) (*Response, error)
}

ImagesService is a wrapper around ionoscloud.Image

func NewImageService 

func NewImageService(client *client.Client, ctx context.Context) ImagesService

type IpBlock 

type IpBlock struct {
	ionoscloud.IpBlock
}

type IpBlockProperties 

type IpBlockProperties struct {
	ionoscloud.IpBlockProperties
}

type IpBlocks 

type IpBlocks struct {
	ionoscloud.IpBlocks
}

type IpBlocksService 

type IpBlocksService interface {
	List(params ListQueryParams) (IpBlocks, *Response, error)
	Get(IpBlockId string, params QueryParams) (*IpBlock, *Response, error)
	Create(name, location string, size int32, params QueryParams) (*IpBlock, *Response, error)
	Update(ipBlockId string, input IpBlockProperties, params QueryParams) (*IpBlock, *Response, error)
	Delete(ipBlockId string, params QueryParams) (*Response, error)
}

IpBlocksService is a wrapper around ionoscloud.IpBlock

func NewIpBlockService 

func NewIpBlockService(client *client.Client, ctx context.Context) IpBlocksService

type IpConsumer 

type IpConsumer struct {
	ionoscloud.IpConsumer
}

type IpFailover 

type IpFailover struct {
	ionoscloud.IPFailover
}

type K8sCluster 

type K8sCluster struct {
	ionoscloud.KubernetesCluster
}

type K8sClusterForPost 

type K8sClusterForPost struct {
	ionoscloud.KubernetesClusterForPost
}

type K8sClusterForPut 

type K8sClusterForPut struct {
	ionoscloud.KubernetesClusterForPut
}

type K8sClusterProperties 

type K8sClusterProperties struct {
	ionoscloud.KubernetesClusterProperties
}

type K8sClusterPropertiesForPost 

type K8sClusterPropertiesForPost struct {
	ionoscloud.KubernetesClusterPropertiesForPost
}

type K8sClusterPropertiesForPut 

type K8sClusterPropertiesForPut struct {
	ionoscloud.KubernetesClusterPropertiesForPut
}

type K8sClusters 

type K8sClusters struct {
	ionoscloud.KubernetesClusters
}

type K8sMaintenanceWindow 

type K8sMaintenanceWindow struct {
	ionoscloud.KubernetesMaintenanceWindow
}

type K8sNode 

type K8sNode struct {
	ionoscloud.KubernetesNode
}

type K8sNodePool 

type K8sNodePool struct {
	ionoscloud.KubernetesNodePool
}

type K8sNodePoolForPost 

type K8sNodePoolForPost struct {
	ionoscloud.KubernetesNodePoolForPost
}

type K8sNodePoolForPut 

type K8sNodePoolForPut struct {
	ionoscloud.KubernetesNodePoolForPut
}

type K8sNodePoolLan 

type K8sNodePoolLan struct {
	ionoscloud.KubernetesNodePoolLan
}

type K8sNodePoolProperties 

type K8sNodePoolProperties struct {
	ionoscloud.KubernetesNodePoolProperties
}

type K8sNodePoolPropertiesForPost 

type K8sNodePoolPropertiesForPost struct {
	ionoscloud.KubernetesNodePoolPropertiesForPost
}

type K8sNodePoolPropertiesForPut 

type K8sNodePoolPropertiesForPut struct {
	ionoscloud.KubernetesNodePoolPropertiesForPut
}

type K8sNodePools 

type K8sNodePools struct {
	ionoscloud.KubernetesNodePools
}

type K8sNodeProperties 

type K8sNodeProperties struct {
	ionoscloud.KubernetesNodeProperties
}

type K8sNodes 

type K8sNodes struct {
	ionoscloud.KubernetesNodes
}

type K8sService 

type K8sService interface {
	ListClusters(params ListQueryParams) (K8sClusters, *Response, error)
	GetCluster(clusterId string, params QueryParams) (*K8sCluster, *Response, error)
	//IsPublicCluster(clusterId string) (bool, error)
	CreateCluster(u K8sClusterForPost, params QueryParams) (*K8sCluster, *Response, error)
	UpdateCluster(clusterId string, input K8sClusterForPut, params QueryParams) (*K8sCluster, *Response, error)
	DeleteCluster(clusterId string, params QueryParams) (*Response, error)
	ReadKubeConfig(clusterId string) (string, *Response, error)
	ListNodePools(clusterId string, params ListQueryParams) (K8sNodePools, *Response, error)
	GetNodePool(clusterId, nodepoolId string, params QueryParams) (*K8sNodePool, *Response, error)
	CreateNodePool(clusterId string, nodepool K8sNodePoolForPost, params QueryParams) (*K8sNodePool, *Response, error)
	UpdateNodePool(clusterId, nodepoolId string, nodepool K8sNodePoolForPut, params QueryParams) (*K8sNodePool, *Response, error)
	DeleteNodePool(clusterId, nodepoolId string, params QueryParams) (*Response, error)
	DeleteNode(clusterId, nodepoolId, nodeId string, params QueryParams) (*Response, error)
	RecreateNode(clusterId, nodepoolId, nodeId string, params QueryParams) (*Response, error)
	GetNode(clusterId, nodepoolId, nodeId string, params QueryParams) (*K8sNode, *Response, error)
	ListNodes(clusterId, nodepoolId string, params ListQueryParams) (K8sNodes, *Response, error)
	ListVersions() ([]string, *Response, error)
	GetVersion() (string, *Response, error)
}

K8sService is a wrapper around ionoscloud.K8s

func NewK8sService 

func NewK8sService(client *client.Client, ctx context.Context) K8sService

type Label 

type Label struct {
	ionoscloud.Label
}

type LabelResource 

type LabelResource struct {
	ionoscloud.LabelResource
}

type LabelResources 

type LabelResources struct {
	ionoscloud.LabelResources
}

type LabelResourcesService 

type LabelResourcesService interface {
	GetByUrn(labelurn string) (*Label, *Response, error)
	List(params ListQueryParams) (Labels, *Response, error)
	DatacenterList(params ListQueryParams, datacenterId string) (LabelResources, *Response, error)
	DatacenterGet(datacenterId, key string) (*LabelResource, *Response, error)
	DatacenterCreate(datacenterId, key, value string) (*LabelResource, *Response, error)
	DatacenterDelete(datacenterId, key string) (*Response, error)
	ServerList(params ListQueryParams, datacenterId, serverId string) (LabelResources, *Response, error)
	ServerGet(datacenterId, serverId, key string) (*LabelResource, *Response, error)
	ServerCreate(datacenterId, serverId, key, value string) (*LabelResource, *Response, error)
	ServerDelete(datacenterId, serverId, key string) (*Response, error)
	VolumeList(params ListQueryParams, datacenterId, serverId string) (LabelResources, *Response, error)
	VolumeGet(datacenterId, serverId, key string) (*LabelResource, *Response, error)
	VolumeCreate(datacenterId, serverId, key, value string) (*LabelResource, *Response, error)
	VolumeDelete(datacenterId, serverId, key string) (*Response, error)
	IpBlockList(params ListQueryParams, ipblockId string) (LabelResources, *Response, error)
	IpBlockGet(ipblockId, key string) (*LabelResource, *Response, error)
	IpBlockCreate(ipblockId, key, value string) (*LabelResource, *Response, error)
	IpBlockDelete(ipblockId, key string) (*Response, error)
	SnapshotList(params ListQueryParams, snapshotId string) (LabelResources, *Response, error)
	SnapshotGet(snapshotId, key string) (*LabelResource, *Response, error)
	SnapshotCreate(snapshotId, key, value string) (*LabelResource, *Response, error)
	SnapshotDelete(snapshotId, key string) (*Response, error)
}

LabelResourcesService is a wrapper around ionoscloud.LabelResource

func NewLabelResourceService 

func NewLabelResourceService(client *client.Client, ctx context.Context) LabelResourcesService

type Labels 

type Labels struct {
	ionoscloud.Labels
}

type Lan 

type Lan struct {
	ionoscloud.Lan
}

type LanNics 

type LanNics struct {
	ionoscloud.LanNics
}

type LanPost 

type LanPost struct {
	ionoscloud.LanPost
}

type LanProperties 

type LanProperties struct {
	ionoscloud.LanProperties
}

type Lans 

type Lans struct {
	ionoscloud.Lans
}

type LansService 

type LansService interface {
	List(datacenterId string, params ListQueryParams) (Lans, *Response, error)
	Get(datacenterId, lanId string, params QueryParams) (*Lan, *Response, error)
	Create(datacenterId string, input LanPost, params QueryParams) (*LanPost, *Response, error)
	Update(datacenterId, lanId string, input LanProperties, params QueryParams) (*Lan, *Response, error)
	Delete(datacenterId, lanId string, params QueryParams) (*Response, error)
}

LansService is a wrapper around ionoscloud.Lan

func NewLanService 

func NewLanService(client *client.Client, ctx context.Context) LansService

type ListQueryParams 

type ListQueryParams struct {
	Filters     *map[string][]string `json:"Filters,omitempty"`
	OrderBy     *string              `json:"OrderBy,omitempty"`
	MaxResults  *int32               `json:"MaxResults,omitempty"`
	QueryParams QueryParams          `json:"QueryParams,omitempty"`
}

func (ListQueryParams) SetDepth 

func (q ListQueryParams) SetDepth(depth int32) ListQueryParams

func (ListQueryParams) SetFilters 

func (q ListQueryParams) SetFilters(filters map[string][]string) ListQueryParams

func (ListQueryParams) SetMaxResults 

func (q ListQueryParams) SetMaxResults(maxResults int32) ListQueryParams

func (ListQueryParams) SetOrderBy 

func (q ListQueryParams) SetOrderBy(orderBy string) ListQueryParams

func (ListQueryParams) SetPretty 

func (q ListQueryParams) SetPretty(pretty bool) ListQueryParams

type Loadbalancer 

type Loadbalancer struct {
	ionoscloud.Loadbalancer
}

type LoadbalancerProperties 

type LoadbalancerProperties struct {
	ionoscloud.LoadbalancerProperties
}

type Loadbalancers 

type Loadbalancers struct {
	ionoscloud.Loadbalancers
}

type LoadbalancersService 

type LoadbalancersService interface {
	List(datacenterId string, params ListQueryParams) (Loadbalancers, *Response, error)
	Get(datacenterId, loadbalancerId string, params QueryParams) (*Loadbalancer, *Response, error)
	Create(datacenterId, name string, dhcp bool, params QueryParams) (*Loadbalancer, *Response, error)
	Update(datacenterId, loadbalancerId string, input LoadbalancerProperties, params QueryParams) (*Loadbalancer, *Response, error)
	Delete(datacenterId, loadbalancerId string, params QueryParams) (*Response, error)
	AttachNic(datacenterId, loadbalancerId, nicId string, params QueryParams) (*Nic, *Response, error)
	ListNics(datacenterId, loadbalancerId string, params ListQueryParams) (BalancedNics, *Response, error)
	GetNic(datacenterId, loadbalancerId, nicId string, params QueryParams) (*Nic, *Response, error)
	DetachNic(datacenterId, loadbalancerId, nicId string, params QueryParams) (*Response, error)
}

LoadbalancersService is a wrapper around ionoscloud.Loadbalancer

func NewLoadbalancerService 

func NewLoadbalancerService(client *client.Client, ctx context.Context) LoadbalancersService

type Location 

type Location struct {
	ionoscloud.Location
}

type Locations 

type Locations struct {
	ionoscloud.Locations
}

type LocationsService 

type LocationsService interface {
	List(params ListQueryParams) (Locations, *Response, error)
	GetByRegionAndLocationId(regionId, locationId string, params QueryParams) (*Location, *Response, error)
	GetByRegionId(regionId string, params QueryParams) (Locations, *Response, error)
}

LocationsService is a wrapper around ionoscloud.Location

func NewLocationService 

func NewLocationService(client *client.Client, ctx context.Context) LocationsService

type NatGateway 

type NatGateway struct {
	ionoscloud.NatGateway
}

type NatGatewayLanProperties 

type NatGatewayLanProperties struct {
	ionoscloud.NatGatewayLanProperties
}

type NatGatewayProperties 

type NatGatewayProperties struct {
	ionoscloud.NatGatewayProperties
}

type NatGatewayRule 

type NatGatewayRule struct {
	ionoscloud.NatGatewayRule
}

type NatGatewayRuleProperties 

type NatGatewayRuleProperties struct {
	ionoscloud.NatGatewayRuleProperties
}

type NatGatewayRules 

type NatGatewayRules struct {
	ionoscloud.NatGatewayRules
}

type NatGateways 

type NatGateways struct {
	ionoscloud.NatGateways
}

type NatGatewaysService 

type NatGatewaysService interface {
	List(datacenterId string, params ListQueryParams) (NatGateways, *Response, error)
	Get(datacenterId, natGatewayId string, params QueryParams) (*NatGateway, *Response, error)
	Create(datacenterId string, input NatGateway, params QueryParams) (*NatGateway, *Response, error)
	Update(datacenterId, natGatewayId string, input NatGatewayProperties, params QueryParams) (*NatGateway, *Response, error)
	Delete(datacenterId, natGatewayId string, params QueryParams) (*Response, error)
	ListRules(datacenterId, natGatewayId string, params ListQueryParams) (NatGatewayRules, *Response, error)
	GetRule(datacenterId, natGatewayId, ruleId string, params QueryParams) (*NatGatewayRule, *Response, error)
	CreateRule(datacenterId, natGatewayId string, input NatGatewayRule, params QueryParams) (*NatGatewayRule, *Response, error)
	UpdateRule(datacenterId, natGatewayId, ruleId string, input NatGatewayRuleProperties, params QueryParams) (*NatGatewayRule, *Response, error)
	DeleteRule(datacenterId, natGatewayId, ruleId string, params QueryParams) (*Response, error)
	ListFlowLogs(datacenterId, natGatewayId string, params ListQueryParams) (FlowLogs, *Response, error)
	GetFlowLog(datacenterId, natGatewayId, flowlogId string, params QueryParams) (*FlowLog, *Response, error)
	CreateFlowLog(datacenterId, natGatewayId string, input FlowLog, params QueryParams) (*FlowLog, *Response, error)
	UpdateFlowLog(datacenterId, natGatewayId, flowlogId string, input *FlowLogProperties, params QueryParams) (*FlowLog, *Response, error)
	DeleteFlowLog(datacenterId, natGatewayId, flowlogId string, params QueryParams) (*Response, error)
}

NatGatewaysService is a wrapper around ionoscloud.NatGateway

func NewNatGatewayService 

func NewNatGatewayService(client *client.Client, ctx context.Context) NatGatewaysService

type NetworkLoadBalancer 

type NetworkLoadBalancer struct {
	ionoscloud.NetworkLoadBalancer
}

type NetworkLoadBalancerForwardingRule 

type NetworkLoadBalancerForwardingRule struct {
	ionoscloud.NetworkLoadBalancerForwardingRule
}

type NetworkLoadBalancerForwardingRuleHealthCheck 

type NetworkLoadBalancerForwardingRuleHealthCheck struct {
	ionoscloud.NetworkLoadBalancerForwardingRuleHealthCheck
}

type NetworkLoadBalancerForwardingRuleProperties 

type NetworkLoadBalancerForwardingRuleProperties struct {
	ionoscloud.NetworkLoadBalancerForwardingRuleProperties
}

type NetworkLoadBalancerForwardingRuleTarget 

type NetworkLoadBalancerForwardingRuleTarget struct {
	ionoscloud.NetworkLoadBalancerForwardingRuleTarget
}

type NetworkLoadBalancerForwardingRuleTargetHealthCheck 

type NetworkLoadBalancerForwardingRuleTargetHealthCheck struct {
	ionoscloud.NetworkLoadBalancerForwardingRuleTargetHealthCheck
}

type NetworkLoadBalancerForwardingRules 

type NetworkLoadBalancerForwardingRules struct {
	ionoscloud.NetworkLoadBalancerForwardingRules
}

type NetworkLoadBalancerProperties 

type NetworkLoadBalancerProperties struct {
	ionoscloud.NetworkLoadBalancerProperties
}

type NetworkLoadBalancerPut 

type NetworkLoadBalancerPut struct {
	ionoscloud.NetworkLoadBalancerPut
}

type NetworkLoadBalancers 

type NetworkLoadBalancers struct {
	ionoscloud.NetworkLoadBalancers
}

type NetworkLoadBalancersService 

type NetworkLoadBalancersService interface {
	List(datacenterId string, params ListQueryParams) (NetworkLoadBalancers, *Response, error)
	Get(datacenterId, networkLoadBalancerId string, params QueryParams) (*NetworkLoadBalancer, *Response, error)
	Create(datacenterId string, input NetworkLoadBalancer, params QueryParams) (*NetworkLoadBalancer, *Response, error)
	Update(datacenterId, networkLoadBalancerId string, input NetworkLoadBalancerProperties, params QueryParams) (*NetworkLoadBalancer, *Response, error)
	Delete(datacenterId, networkLoadBalancerId string, params QueryParams) (*Response, error)
	ListForwardingRules(datacenterId, networkLoadBalancerId string, params ListQueryParams) (NetworkLoadBalancerForwardingRules, *Response, error)
	GetForwardingRule(datacenterId, networkLoadBalancerId, forwardingRuleId string, params QueryParams) (*NetworkLoadBalancerForwardingRule, *Response, error)
	CreateForwardingRule(datacenterId, networkLoadBalancerId string, input NetworkLoadBalancerForwardingRule, params QueryParams) (*NetworkLoadBalancerForwardingRule, *Response, error)
	UpdateForwardingRule(datacenterId, networkLoadBalancerId, forwardingRuleId string, input *NetworkLoadBalancerForwardingRuleProperties, params QueryParams) (*NetworkLoadBalancerForwardingRule, *Response, error)
	DeleteForwardingRule(datacenterId, networkLoadBalancerId, forwardingRuleId string, params QueryParams) (*Response, error)
	ListFlowLogs(datacenterId, networkLoadBalancerId string, params ListQueryParams) (FlowLogs, *Response, error)
	GetFlowLog(datacenterId, networkLoadBalancerId, flowLogId string, params QueryParams) (*FlowLog, *Response, error)
	CreateFlowLog(datacenterId, networkLoadBalancerId string, input FlowLog, params QueryParams) (*FlowLog, *Response, error)
	UpdateFlowLog(datacenterId, networkLoadBalancerId, flowLogId string, input *FlowLogProperties, params QueryParams) (*FlowLog, *Response, error)
	DeleteFlowLog(datacenterId, networkLoadBalancerId, flowLogId string, params QueryParams) (*Response, error)
}

NetworkLoadBalancersService is a wrapper around ionoscloud.NetworkLoadBalancer

func NewNetworkLoadBalancerService 

func NewNetworkLoadBalancerService(client *client.Client, ctx context.Context) NetworkLoadBalancersService

type Nic 

type Nic struct {
	ionoscloud.Nic
}

type NicProperties 

type NicProperties struct {
	ionoscloud.NicProperties
}

type Nics 

type Nics struct {
	ionoscloud.Nics
}

type NicsService 

type NicsService interface {
	List(datacenterId, serverId string, params ListQueryParams) (Nics, *Response, error)
	Get(datacenterId, serverId, nicId string, params QueryParams) (*Nic, *Response, error)
	Create(datacenterId, serverId string, input Nic, params QueryParams) (*Nic, *Response, error)
	Update(datacenterId, serverId, nicId string, input NicProperties, params QueryParams) (*Nic, *Response, error)
	Delete(datacenterId, serverId, nicId string, params QueryParams) (*Response, error)
}

NicsService is a wrapper around ionoscloud.Nic

func NewNicService 

func NewNicService(client *client.Client, ctx context.Context) NicsService

type PccsService 

type PccsService interface {
	List(params ListQueryParams) (PrivateCrossConnects, *Response, error)
	Get(pccId string, params QueryParams) (*PrivateCrossConnect, *Response, error)
	GetPeers(pccId string) (*[]Peer, *Response, error)
	Create(u PrivateCrossConnect, params QueryParams) (*PrivateCrossConnect, *Response, error)
	Update(pccId string, input PrivateCrossConnectProperties, params QueryParams) (*PrivateCrossConnect, *Response, error)
	Delete(pccId string, params QueryParams) (*Response, error)
}

PccsService is a wrapper around ionoscloud.PrivateCrossConnect

func NewPrivateCrossConnectService 

func NewPrivateCrossConnectService(client *client.Client, ctx context.Context) PccsService

type Peer 

type Peer struct {
	ionoscloud.Peer
}

type PrivateCrossConnect 

type PrivateCrossConnect struct {
	ionoscloud.PrivateCrossConnect
}

type PrivateCrossConnectProperties 

type PrivateCrossConnectProperties struct {
	ionoscloud.PrivateCrossConnectProperties
}

type PrivateCrossConnects 

type PrivateCrossConnects struct {
	ionoscloud.PrivateCrossConnects
}

type QueryParams 

type QueryParams struct {
	Depth  *int32 `json:"Depth,omitempty"`
	Pretty *bool  `json:"Pretty,omitempty"`
}

func (QueryParams) SetDepth 

func (d QueryParams) SetDepth(depth int32) QueryParams

func (QueryParams) SetPretty 

func (d QueryParams) SetPretty(pretty bool) QueryParams

type RemoteConsoleUrl 

type RemoteConsoleUrl struct {
	ionoscloud.RemoteConsoleUrl
}

type Request 

type Request struct {
	ionoscloud.Request
}

type RequestStatus 

type RequestStatus struct {
	ionoscloud.RequestStatus
}

type Requests 

type Requests struct {
	ionoscloud.Requests
}

type RequestsService 

type RequestsService interface {
	List(params ListQueryParams) (Requests, *Response, error)
	Get(requestId string, params QueryParams) (*Request, *Response, error)
	GetStatus(requestId string) (*RequestStatus, *Response, error)
	Wait(requestId string) (*Response, error)
}

RequestsService is a wrapper around ionoscloud.Request

func NewRequestService 

func NewRequestService(client *client.Client, ctx context.Context) RequestsService

type Resource 

type Resource struct {
	ionoscloud.Resource
}

type ResourceGroups 

type ResourceGroups struct {
	ionoscloud.ResourceGroups
}

type Resources 

type Resources struct {
	ionoscloud.Resources
}

type Response 

type Response struct {
	ionoscloud.APIResponse
}

type S3Key 

type S3Key struct {
	ionoscloud.S3Key
}

type S3Keys 

type S3Keys struct {
	ionoscloud.S3Keys
}

type S3KeysService 

type S3KeysService interface {
	List(userId string, params ListQueryParams) (S3Keys, *Response, error)
	Get(userId, keyId string, params QueryParams) (*S3Key, *Response, error)
	Create(userId string, params QueryParams) (*S3Key, *Response, error)
	Update(userId, keyId string, key S3Key, params QueryParams) (*S3Key, *Response, error)
	Delete(userId, keyId string, params QueryParams) (*Response, error)
}

S3KeysService is a wrapper around ionoscloud.S3Key

func NewS3KeyService 

func NewS3KeyService(client *client.Client, ctx context.Context) S3KeysService

type Server 

type Server struct {
	ionoscloud.Server
}

type ServerProperties 

type ServerProperties struct {
	ionoscloud.ServerProperties
}

type Servers 

type Servers struct {
	ionoscloud.Servers
}

type ServersService 

type ServersService interface {
	List(datacenterId string, params ListQueryParams) (Servers, *Response, error)
	Get(datacenterId, serverId string, params QueryParams) (*Server, *Response, error)
	Create(datacenterId string, input Server, params QueryParams) (*Server, *Response, error)
	Update(datacenterId, serverId string, input ServerProperties, params QueryParams) (*Server, *Response, error)
	Delete(datacenterId, serverId string, params QueryParams) (*Response, error)
	Start(datacenterId, serverId string, params QueryParams) (*Response, error)
	Stop(datacenterId, serverId string, params QueryParams) (*Response, error)
	Reboot(datacenterId, serverId string, params QueryParams) (*Response, error)
	Suspend(datacenterId, serverId string, params QueryParams) (*Response, error)
	Resume(datacenterId, serverId string, params QueryParams) (*Response, error)
	GetToken(datacenterId, serverId string) (Token, *Response, error)
	GetRemoteConsoleUrl(datacenterId, serverId string) (RemoteConsoleUrl, *Response, error)
	AttachVolume(datacenterId, serverId, volumeId string, params QueryParams) (*Volume, *Response, error)
	DetachVolume(datacenterId, serverId, volumeId string, params QueryParams) (*Response, error)
	ListVolumes(datacenterId, serverId string, params ListQueryParams) (AttachedVolumes, *Response, error)
	GetVolume(datacenterId, serverId, volumeId string, params QueryParams) (*Volume, *Response, error)
	ListCdroms(datacenterId, serverId string, params ListQueryParams) (Cdroms, *Response, error)
	AttachCdrom(datacenterId, serverId, cdromId string, params QueryParams) (*Image, *Response, error)
	GetCdrom(datacenterId, serverId, cdromId string, params QueryParams) (*Image, *Response, error)
	DetachCdrom(datacenterId, serverId, cdromId string, params QueryParams) (*Response, error)
}

ServersService is a wrapper around ionoscloud.Server

func NewServerService 

func NewServerService(client *client.Client, ctx context.Context) ServersService

type Snapshot 

type Snapshot struct {
	ionoscloud.Snapshot
}

type SnapshotProperties 

type SnapshotProperties struct {
	ionoscloud.SnapshotProperties
}

type Snapshots 

type Snapshots struct {
	ionoscloud.Snapshots
}

type SnapshotsService 

type SnapshotsService interface {
	List(params ListQueryParams) (Snapshots, *Response, error)
	Get(snapshotId string, params QueryParams) (*Snapshot, *Response, error)
	Create(datacenterId, volumeId, name, description, licenceType string, secAuthProtection bool, params QueryParams) (*Snapshot, *Response, error)
	Update(snapshotId string, snapshotProp SnapshotProperties, params QueryParams) (*Snapshot, *Response, error)
	Restore(datacenterId, volumeId, snapshotId string, params QueryParams) (*Response, error)
	Delete(snapshotId string, params QueryParams) (*Response, error)
}

SnapshotsService is a wrapper around ionoscloud.Snapshot

func NewSnapshotService 

func NewSnapshotService(client *client.Client, ctx context.Context) SnapshotsService

type TargetGroup 

type TargetGroup struct {
	ionoscloud.TargetGroup
}

type TargetGroupHealthCheck 

type TargetGroupHealthCheck struct {
	ionoscloud.TargetGroupHealthCheck
}

type TargetGroupHttpHealthCheck 

type TargetGroupHttpHealthCheck struct {
	ionoscloud.TargetGroupHttpHealthCheck
}

type TargetGroupProperties 

type TargetGroupProperties struct {
	ionoscloud.TargetGroupProperties
}

type TargetGroupTarget 

type TargetGroupTarget struct {
	ionoscloud.TargetGroupTarget
}

type TargetGroups 

type TargetGroups struct {
	ionoscloud.TargetGroups
}

type TargetGroupsService 

type TargetGroupsService interface {
	List(params ListQueryParams) (TargetGroups, *Response, error)
	Get(targetGroupId string, params QueryParams) (*TargetGroup, *Response, error)
	Create(tg TargetGroup, params QueryParams) (*TargetGroup, *Response, error)
	Update(targetGroupId string, input *TargetGroupProperties, params QueryParams) (*TargetGroup, *Response, error)
	Delete(targetGroupId string, params QueryParams) (*Response, error)
}

TargetGroupsService is a wrapper around ionoscloud.TargetGroup

func NewTargetGroupService 

func NewTargetGroupService(client *client.Client, ctx context.Context) TargetGroupsService

type Template 

type Template struct {
	ionoscloud.Template
}

type TemplateProperties 

type TemplateProperties struct {
	ionoscloud.TemplateProperties
}

type Templates 

type Templates struct {
	ionoscloud.Templates
}

type TemplatesService 

type TemplatesService interface {
	List(params ListQueryParams) (Templates, *Response, error)
	Get(templateId string, params QueryParams) (*Template, *Response, error)
}

TemplatesService is a wrapper around ionoscloud.Template

func NewTemplateService 

func NewTemplateService(client *client.Client, ctx context.Context) TemplatesService

type Token 

type Token struct {
	ionoscloud.Token
}

type UploadProperties 

type UploadProperties struct {
	ImageFileProperties
	FTPServerProperties
}

UploadProperties contains info needed to initialize an FTP connection to IONOS server and upload an image.

type User 

type User struct {
	ionoscloud.User
}

type UserPost 

type UserPost struct {
	ionoscloud.UserPost
}

type UserProperties 

type UserProperties struct {
	ionoscloud.UserProperties
}

type UserPropertiesPost 

type UserPropertiesPost struct {
	ionoscloud.UserPropertiesPost
}

type UserPropertiesPut 

type UserPropertiesPut struct {
	ionoscloud.UserPropertiesPut
}

type UserPut 

type UserPut struct {
	ionoscloud.UserPut
}

type Users 

type Users struct {
	ionoscloud.Users
}

type UsersService 

type UsersService interface {
	List(params ListQueryParams) (Users, *Response, error)
	Get(userId string, params QueryParams) (*User, *Response, error)
	Create(u UserPost, params QueryParams) (*User, *Response, error)
	Update(userId string, input UserPut, params QueryParams) (*User, *Response, error)
	Delete(userId string, params QueryParams) (*Response, error)
	ListResources() (Resources, *Response, error)
	GetResourcesByType(resourceType string) (Resources, *Response, error)
	GetResourceByTypeAndId(resourceType, resourceId string) (*Resource, *Response, error)
}

UsersService is a wrapper around ionoscloud.User

func NewUserService 

func NewUserService(client *client.Client, ctx context.Context) UsersService

type Volume 

type Volume struct {
	ionoscloud.Volume
}

type VolumeProperties 

type VolumeProperties struct {
	ionoscloud.VolumeProperties
}

type Volumes 

type Volumes struct {
	ionoscloud.Volumes
}

type VolumesService 

type VolumesService interface {
	List(datacenterId string, params ListQueryParams) (Volumes, *Response, error)
	Get(datacenterId, volumeId string, params QueryParams) (*Volume, *Response, error)
	Create(datacenterId string, input Volume, params QueryParams) (*Volume, *Response, error)
	Update(datacenterId, volumeId string, input VolumeProperties, params QueryParams) (*Volume, *Response, error)
	Delete(datacenterId, volumeId string, params QueryParams) (*Response, error)
}

func NewVolumeService 

func NewVolumeService(client *client.Client, ctx context.Context) VolumesService

Source Files

View all Source files

Directories

Path Synopsis
Package mock_resources is a generated GoMock package.
 Package mock_resources is a generated GoMock package.

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.