Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

compute

package

Go to main page

Versions in this module

v2

v2.0.1

Oct 14, 2022

v2.0.0

Sep 24, 2022

Changes in this version

+ const ImageCategoryBSD

+ const ImageCategoryLinux

+ const ImageCategoryWindows

+ var IPRangeAny = net.IPNet

+ var ProtocolIDs = map[string]int

+ var ProtocolNames = map[int]string

+ type Certificate compute.Certificate

+ func (c Certificate) Columns() []string

+ func (c Certificate) Keys() []string

+ func (c Certificate) String() string

+ func (c Certificate) Values() map[string]interface{}

+ type CertificateCreate = compute.CertificateCreate

+ type CertificateService struct

+ func NewCertificateService(client goclient.Client) CertificateService

+ func (c CertificateService) Create(ctx context.Context, data CertificateCreate) (Certificate, error)

+ func (c CertificateService) Delete(ctx context.Context, id int) error

+ func (c CertificateService) List(ctx context.Context) ([]Certificate, error)

+ type ElasticIP compute.ElasticIP

+ func (e ElasticIP) Columns() []string

+ func (e ElasticIP) Keys() []string

+ func (e ElasticIP) String() string

+ func (e ElasticIP) Values() map[string]interface{}

+ type ElasticIPAttach = compute.ElasticIPAttach

+ type ElasticIPCreate = compute.ElasticIPCreate

+ type ElasticIPService struct

+ func NewElasticIPService(client goclient.Client) ElasticIPService

+ func (e ElasticIPService) Attach(ctx context.Context, serverID int, data ElasticIPAttach) (ElasticIP, error)

+ func (e ElasticIPService) Create(ctx context.Context, data ElasticIPCreate) (ElasticIP, error)

+ func (e ElasticIPService) Delete(ctx context.Context, id int) error

+ func (e ElasticIPService) Detach(ctx context.Context, serverID, elasticIPID int) error

+ func (e ElasticIPService) List(ctx context.Context) ([]ElasticIP, error)

+ type Image struct

+ Availability []common.Location

+ func Images(ctx context.Context, client goclient.Client) ([]Image, error)

+ func (i Image) AvailableAt(location common.Location) bool

+ func (i Image) Columns() []string

+ func (i Image) IsWindows() bool

+ func (i Image) Keys() []string

+ func (i Image) String() string

+ func (i Image) Values() map[string]interface{}

+ type KeyPair compute.KeyPair

+ func (k KeyPair) Columns() []string

+ func (k KeyPair) Keys() []string

+ func (k KeyPair) String() string

+ func (k KeyPair) Values() map[string]interface{}

+ type KeyPairCreate = compute.KeyPairCreate

+ type KeyPairService struct

+ func NewKeyPairService(client goclient.Client) KeyPairService

+ func (k KeyPairService) Create(ctx context.Context, data KeyPairCreate) (KeyPair, error)

+ func (k KeyPairService) Delete(ctx context.Context, id int) error

+ func (k KeyPairService) List(ctx context.Context) ([]KeyPair, error)

+ type LoadBalancer compute.LoadBalancer

+ func (l LoadBalancer) Columns() []string

+ func (l LoadBalancer) Keys() []string

+ func (l LoadBalancer) String() string

+ func (l LoadBalancer) Values() map[string]interface{}

+ type LoadBalancerAlgorithm compute.LoadBalancerAlgorithm

+ func LoadBalancerAlgorithms(ctx context.Context, client goclient.Client) ([]LoadBalancerAlgorithm, error)

+ func (l LoadBalancerAlgorithm) Columns() []string

+ func (l LoadBalancerAlgorithm) Keys() []string

+ func (l LoadBalancerAlgorithm) String() string

+ func (l LoadBalancerAlgorithm) Values() map[string]interface{}

+ type LoadBalancerCreate = compute.LoadBalancerCreate

+ type LoadBalancerHealthCheckOptions = compute.LoadBalancerHealthCheckOptions

+ type LoadBalancerHealthCheckType compute.LoadBalancerHealthCheckType

+ func LoadBalancerHealthCheckTypes(ctx context.Context, client goclient.Client) ([]LoadBalancerHealthCheckType, error)

+ func (l LoadBalancerHealthCheckType) Columns() []string

+ func (l LoadBalancerHealthCheckType) Keys() []string

+ func (l LoadBalancerHealthCheckType) String() string

+ func (l LoadBalancerHealthCheckType) Values() map[string]interface{}

+ type LoadBalancerMember compute.LoadBalancerMember

+ func (l LoadBalancerMember) Columns() []string

+ func (l LoadBalancerMember) Host() string

+ func (l LoadBalancerMember) Keys() []string

+ func (l LoadBalancerMember) String() string

+ func (l LoadBalancerMember) Values() map[string]interface{}

+ type LoadBalancerMemberCreate = compute.LoadBalancerMemberCreate

+ type LoadBalancerMemberService struct

+ func NewLoadBalancerMemberService(client goclient.Client, loadBalancerID, poolID int) LoadBalancerMemberService

+ func (l LoadBalancerMemberService) Create(ctx context.Context, data LoadBalancerMemberCreate) (LoadBalancerMember, error)

+ func (l LoadBalancerMemberService) Delete(ctx context.Context, id int) error

+ func (l LoadBalancerMemberService) List(ctx context.Context) ([]LoadBalancerMember, error)

+ type LoadBalancerPool compute.LoadBalancerPool

+ func (l LoadBalancerPool) Columns() []string

+ func (l LoadBalancerPool) Keys() []string

+ func (l LoadBalancerPool) NameWithoutSpaces() string

+ func (l LoadBalancerPool) String() string

+ func (l LoadBalancerPool) Values() map[string]interface{}

+ type LoadBalancerPoolCreate = compute.LoadBalancerPoolCreate

+ type LoadBalancerPoolService struct

+ func NewLoadBalancerPoolService(client goclient.Client, loadBalancerID int) LoadBalancerPoolService

+ func (l LoadBalancerPoolService) Create(ctx context.Context, data LoadBalancerPoolCreate) (LoadBalancerPool, error)

+ func (l LoadBalancerPoolService) Delete(ctx context.Context, id int) error

+ func (l LoadBalancerPoolService) List(ctx context.Context) ([]LoadBalancerPool, error)

+ func (l LoadBalancerPoolService) Update(ctx context.Context, id int, data LoadBalancerPoolUpdate) (LoadBalancerPool, error)

+ type LoadBalancerPoolUpdate = compute.LoadBalancerPoolUpdate

+ type LoadBalancerProtocol compute.LoadBalancerProtocol

+ func LoadBalancerProtocols(ctx context.Context, client goclient.Client) ([]LoadBalancerProtocol, error)

+ func (l LoadBalancerProtocol) Columns() []string

+ func (l LoadBalancerProtocol) Keys() []string

+ func (l LoadBalancerProtocol) String() string

+ func (l LoadBalancerProtocol) Values() map[string]interface{}

+ type LoadBalancerService struct

+ func NewLoadBalancerService(client goclient.Client) LoadBalancerService

+ func (l LoadBalancerService) Create(ctx context.Context, data LoadBalancerCreate) (common.Ordering, error)

+ func (l LoadBalancerService) Delete(ctx context.Context, id int) error

+ func (l LoadBalancerService) Get(ctx context.Context, id int) (LoadBalancer, error)

+ func (l LoadBalancerService) List(ctx context.Context) ([]LoadBalancer, error)

+ func (l LoadBalancerService) Update(ctx context.Context, id int, data LoadBalancerUpdate) (LoadBalancer, error)

+ type LoadBalancerUpdate = compute.LoadBalancerUpdate

+ type Network compute.Network

+ func (n Network) Columns() []string

+ func (n Network) Keys() []string

+ func (n Network) String() string

+ func (n Network) Values() map[string]interface{}

+ type NetworkCreate = compute.NetworkCreate

+ type NetworkInterface compute.NetworkInterface

+ func (n NetworkInterface) Columns() []string

+ func (n NetworkInterface) Keys() []string

+ func (n NetworkInterface) String() string

+ func (n NetworkInterface) Values() map[string]interface{}

+ type NetworkInterfaceCreate = compute.NetworkInterfaceCreate

+ type NetworkInterfaceSecurityGroupUpdate = compute.NetworkInterfaceSecurityGroupUpdate

+ type NetworkInterfaceSecurityUpdate = compute.NetworkInterfaceSecurityUpdate

+ type NetworkInterfaceService struct

+ func NewNetworkInterfaceService(client goclient.Client, serverID int) NetworkInterfaceService

+ func (n NetworkInterfaceService) Create(ctx context.Context, data NetworkInterfaceCreate) (NetworkInterface, error)

+ func (n NetworkInterfaceService) Delete(ctx context.Context, id int) error

+ func (n NetworkInterfaceService) List(ctx context.Context) ([]NetworkInterface, error)

+ func (n NetworkInterfaceService) UpdateSecurity(ctx context.Context, id int, data NetworkInterfaceSecurityUpdate) (NetworkInterface, error)

+ func (n NetworkInterfaceService) UpdateSecurityGroups(ctx context.Context, id int, data NetworkInterfaceSecurityGroupUpdate) (NetworkInterface, error)

+ type NetworkService struct

+ func NewNetworkService(client goclient.Client) NetworkService

+ func (n NetworkService) Create(ctx context.Context, data NetworkCreate) (Network, error)

+ func (n NetworkService) Delete(ctx context.Context, id int) error

+ func (n NetworkService) List(ctx context.Context) ([]Network, error)

+ func (n NetworkService) Update(ctx context.Context, id int, data NetworkUpdate) (Network, error)

+ type NetworkUpdate = compute.NetworkUpdate

+ type Route compute.Route

+ func (r Route) Columns() []string

+ func (r Route) Keys() []string

+ func (r Route) String() string

+ func (r Route) Values() map[string]interface{}

+ type RouteCreate = compute.RouteCreate

+ type RouteService struct

+ func NewRouteService(client goclient.Client, routerID int) RouteService

+ func (r RouteService) Create(ctx context.Context, data RouteCreate) (Route, error)

+ func (r RouteService) Delete(ctx context.Context, id int) error

+ func (r RouteService) List(ctx context.Context) ([]Route, error)

+ type Router compute.Router

+ func (r Router) Columns() []string

+ func (r Router) Keys() []string

+ func (r Router) String() string

+ func (r Router) Values() map[string]interface{}

+ type RouterCreate = compute.RouterCreate

+ type RouterInterface compute.RouterInterface

+ func (r RouterInterface) Columns() []string

+ func (r RouterInterface) Keys() []string

+ func (r RouterInterface) String() string

+ func (r RouterInterface) Values() map[string]interface{}

+ type RouterInterfaceCreate = compute.RouterInterfaceCreate

+ type RouterInterfaceService struct

+ func NewRouterInterfaceService(client goclient.Client, routerID int) RouterInterfaceService

+ func (r RouterInterfaceService) Create(ctx context.Context, data RouterInterfaceCreate) (RouterInterface, error)

+ func (r RouterInterfaceService) Delete(ctx context.Context, id int) error

+ func (r RouterInterfaceService) List(ctx context.Context) ([]RouterInterface, error)

+ type RouterService struct

+ func NewRouterService(client goclient.Client) RouterService

+ func (r RouterService) Create(ctx context.Context, data RouterCreate) (Router, error)

+ func (r RouterService) Delete(ctx context.Context, id int) error

+ func (r RouterService) List(ctx context.Context) ([]Router, error)

+ func (r RouterService) Update(ctx context.Context, id int, data RouterUpdate) (Router, error)

+ type RouterUpdate = compute.RouterUpdate

+ type SecurityGroup compute.SecurityGroup

+ func (s SecurityGroup) Columns() []string

+ func (s SecurityGroup) Keys() []string

+ func (s SecurityGroup) String() string

+ func (s SecurityGroup) Values() map[string]interface{}

+ type SecurityGroupCreate = compute.SecurityGroupCreate

+ type SecurityGroupRule compute.SecurityGroupRule

+ func (s SecurityGroupRule) Columns() []string

+ func (s SecurityGroupRule) Keys() []string

+ func (s SecurityGroupRule) String() string

+ func (s SecurityGroupRule) Values() map[string]interface{}

+ type SecurityGroupRuleCreate = compute.SecurityGroupRuleOptions

+ type SecurityGroupRuleService struct

+ func NewSecurityGroupRuleService(client goclient.Client, securityGroupID int) SecurityGroupRuleService

+ func (s SecurityGroupRuleService) Create(ctx context.Context, data SecurityGroupRuleCreate) (SecurityGroupRule, error)

+ func (s SecurityGroupRuleService) Delete(ctx context.Context, id int) error

+ func (s SecurityGroupRuleService) List(ctx context.Context) ([]SecurityGroupRule, error)

+ func (s SecurityGroupRuleService) Update(ctx context.Context, id int, data SecurityGroupRuleUpdate) (SecurityGroupRule, error)

+ type SecurityGroupRuleUpdate = compute.SecurityGroupRuleOptions

+ type SecurityGroupService struct

+ func NewSecurityGroupService(client goclient.Client) SecurityGroupService

+ func (s SecurityGroupService) Create(ctx context.Context, data SecurityGroupCreate) (SecurityGroup, error)

+ func (s SecurityGroupService) Delete(ctx context.Context, id int) error

+ func (s SecurityGroupService) List(ctx context.Context) ([]SecurityGroup, error)

+ func (s SecurityGroupService) Update(ctx context.Context, id int, data SecurityGroupUpdate) (SecurityGroup, error)

+ type SecurityGroupUpdate = compute.SecurityGroupUpdate

+ type Server compute.Server

+ func (s Server) Columns() []string

+ func (s Server) Keys() (identifiers []string)

+ func (s Server) String() string

+ func (s Server) Values() map[string]interface{}

+ type ServerAction compute.ServerAction

+ func (d ServerAction) Columns() []string

+ func (d ServerAction) Keys() []string

+ func (d ServerAction) Values() map[string]interface{}

+ type ServerActionService struct

+ func NewServerActionService(client goclient.Client) ServerActionService

+ func (d ServerActionService) Run(ctx context.Context, serverID int, data ServerRunAction) (Server, error)

+ type ServerCreate = compute.ServerCreate

+ type ServerRunAction = compute.ServerPerform

+ type ServerService struct

+ func NewServerService(client goclient.Client) ServerService

+ func (s ServerService) Create(ctx context.Context, data ServerCreate) (common.Ordering, error)

+ func (s ServerService) Delete(ctx context.Context, id int, deleteElasticIPs bool) error

+ func (s ServerService) Get(ctx context.Context, id int) (Server, error)

+ func (s ServerService) List(ctx context.Context) ([]Server, error)

+ func (s ServerService) Update(ctx context.Context, id int, data ServerUpdate) (Server, error)

+ func (s ServerService) Upgrade(ctx context.Context, id int, data ServerUpgrade) (common.Ordering, error)

+ type ServerUpdate = compute.ServerUpdate

+ type ServerUpgrade = compute.ServerUpgrade

+ type Snapshot compute.Snapshot

+ func (s Snapshot) Columns() []string

+ func (s Snapshot) Keys() []string

+ func (s Snapshot) String() string

+ func (s Snapshot) Values() map[string]interface{}

+ type SnapshotCreate = compute.SnapshotCreate

+ type SnapshotService struct

+ func NewSnapshotService(client goclient.Client) SnapshotService

+ func (v SnapshotService) Create(ctx context.Context, data SnapshotCreate) (Snapshot, error)

+ func (v SnapshotService) Delete(ctx context.Context, volumeID int) error

+ func (v SnapshotService) List(ctx context.Context) ([]Snapshot, error)

+ func (v SnapshotService) Update(ctx context.Context, volumeID int, data SnapshotUpdate) (Snapshot, error)

+ type SnapshotUpdate = compute.SnapshotUpdate

+ type Volume compute.Volume

+ func (v Volume) Columns() []string

+ func (v Volume) Keys() []string

+ func (v Volume) String() string

+ func (v Volume) Values() map[string]interface{}

+ type VolumeAttach = compute.VolumeAttach

+ type VolumeCreate = compute.VolumeCreate

+ type VolumeExpand = compute.VolumeExpand

+ type VolumeRevert = compute.VolumeRevert

+ type VolumeService struct

+ func NewVolumeService(client goclient.Client) VolumeService

+ func (v VolumeService) Attach(ctx context.Context, volumeID int, data VolumeAttach) (Volume, error)

+ func (v VolumeService) Create(ctx context.Context, data VolumeCreate) (Volume, error)

+ func (v VolumeService) Delete(ctx context.Context, volumeID int) error

+ func (v VolumeService) Detach(ctx context.Context, volumeID, serverID int) error

+ func (v VolumeService) Expand(ctx context.Context, volumeID int, data VolumeExpand) (Volume, error)

+ func (v VolumeService) List(ctx context.Context) ([]Volume, error)

+ func (v VolumeService) Revert(ctx context.Context, volumeID int, data VolumeRevert) (Volume, error)

+ func (v VolumeService) Update(ctx context.Context, volumeID int, data VolumeUpdate) (Volume, error)

+ type VolumeUpdate = compute.VolumeUpdate

v2.0.0-rc.1

Jul 12, 2022

v2.0.0-citest.2

Aug 2, 2022