compute

package
v2.0.1 Latest Latest
Warning

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

 Go to latest Published: Oct 14, 2022 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ImageCategoryLinux   = "linux"
	ImageCategoryWindows = "windows"
	ImageCategoryBSD     = "bsd"
)

Variables

View Source 
var IPRangeAny = net.IPNet{
	IP:   net.IPv4zero,
	Mask: net.IPv4Mask(0, 0, 0, 0),
}
View Source 
var ProtocolIDs = map[string]int{
	"any":  compute.ProtocolAny,
	"icmp": compute.ProtocolICMP,
	"tcp":  compute.ProtocolTCP,
	"udp":  compute.ProtocolUDP,
}
View Source 
var ProtocolNames = map[int]string{
	compute.ProtocolAny:  "any",
	compute.ProtocolICMP: "icmp",
	compute.ProtocolTCP:  "tcp",
	compute.ProtocolUDP:  "udp",
}

Functions

This section is empty.

Types

type Certificate 

type Certificate compute.Certificate

func (Certificate) Columns 

func (c Certificate) Columns() []string

func (Certificate) Keys 

func (c Certificate) Keys() []string

func (Certificate) String 

func (c Certificate) String() string

func (Certificate) Values 

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

type CertificateCreate 

type CertificateCreate = compute.CertificateCreate

type CertificateService 

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

func NewCertificateService 

func NewCertificateService(client goclient.Client) CertificateService

func (CertificateService) Create 

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

func (CertificateService) Delete 

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

func (CertificateService) List 

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

type ElasticIP 

type ElasticIP compute.ElasticIP

func (ElasticIP) Columns 

func (e ElasticIP) Columns() []string

func (ElasticIP) Keys 

func (e ElasticIP) Keys() []string

func (ElasticIP) String 

func (e ElasticIP) String() string

func (ElasticIP) Values 

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

type ElasticIPAttach 

type ElasticIPAttach = compute.ElasticIPAttach

type ElasticIPCreate 

type ElasticIPCreate = compute.ElasticIPCreate

type ElasticIPService 

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

func NewElasticIPService 

func NewElasticIPService(client goclient.Client) ElasticIPService

func (ElasticIPService) Attach 

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

func (ElasticIPService) Create 

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

func (ElasticIPService) Delete 

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

func (ElasticIPService) Detach 

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

func (ElasticIPService) List 

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

type Image 

type Image struct {
	compute.Image

	Availability []common.Location `json:"-"`
}

func Images 

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

func (Image) AvailableAt 

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

func (Image) Columns 

func (i Image) Columns() []string

func (Image) IsWindows 

func (i Image) IsWindows() bool

func (Image) Keys 

func (i Image) Keys() []string

func (Image) String 

func (i Image) String() string

func (Image) Values 

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

type KeyPair 

type KeyPair compute.KeyPair

func (KeyPair) Columns 

func (k KeyPair) Columns() []string

func (KeyPair) Keys 

func (k KeyPair) Keys() []string

func (KeyPair) String 

func (k KeyPair) String() string

func (KeyPair) Values 

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

type KeyPairCreate 

type KeyPairCreate = compute.KeyPairCreate

type KeyPairService 

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

func NewKeyPairService 

func NewKeyPairService(client goclient.Client) KeyPairService

func (KeyPairService) Create 

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

func (KeyPairService) Delete 

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

func (KeyPairService) List 

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

type LoadBalancer 

type LoadBalancer compute.LoadBalancer

func (LoadBalancer) Columns 

func (l LoadBalancer) Columns() []string

func (LoadBalancer) Keys 

func (l LoadBalancer) Keys() []string

func (LoadBalancer) String 

func (l LoadBalancer) String() string

func (LoadBalancer) Values 

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

type LoadBalancerAlgorithm 

type LoadBalancerAlgorithm compute.LoadBalancerAlgorithm

func LoadBalancerAlgorithms 

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

func (LoadBalancerAlgorithm) Columns 

func (l LoadBalancerAlgorithm) Columns() []string

func (LoadBalancerAlgorithm) Keys 

func (l LoadBalancerAlgorithm) Keys() []string

func (LoadBalancerAlgorithm) String 

func (l LoadBalancerAlgorithm) String() string

func (LoadBalancerAlgorithm) Values 

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

type LoadBalancerCreate 

type LoadBalancerCreate = compute.LoadBalancerCreate

type LoadBalancerHealthCheckOptions 

type LoadBalancerHealthCheckOptions = compute.LoadBalancerHealthCheckOptions

type LoadBalancerHealthCheckType 

type LoadBalancerHealthCheckType compute.LoadBalancerHealthCheckType

func LoadBalancerHealthCheckTypes 

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

func (LoadBalancerHealthCheckType) Columns 

func (l LoadBalancerHealthCheckType) Columns() []string

func (LoadBalancerHealthCheckType) Keys 

func (l LoadBalancerHealthCheckType) Keys() []string

func (LoadBalancerHealthCheckType) String 

func (l LoadBalancerHealthCheckType) String() string

func (LoadBalancerHealthCheckType) Values 

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

type LoadBalancerMember 

type LoadBalancerMember compute.LoadBalancerMember

func (LoadBalancerMember) Columns 

func (l LoadBalancerMember) Columns() []string

func (LoadBalancerMember) Host 

func (l LoadBalancerMember) Host() string

func (LoadBalancerMember) Keys 

func (l LoadBalancerMember) Keys() []string

func (LoadBalancerMember) String 

func (l LoadBalancerMember) String() string

func (LoadBalancerMember) Values 

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

type LoadBalancerMemberCreate 

type LoadBalancerMemberCreate = compute.LoadBalancerMemberCreate

type LoadBalancerMemberService 

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

func NewLoadBalancerMemberService 

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

func (LoadBalancerMemberService) Create 

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

func (LoadBalancerMemberService) Delete 

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

func (LoadBalancerMemberService) List 

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

type LoadBalancerPool 

type LoadBalancerPool compute.LoadBalancerPool

func (LoadBalancerPool) Columns 

func (l LoadBalancerPool) Columns() []string

func (LoadBalancerPool) Keys 

func (l LoadBalancerPool) Keys() []string

func (LoadBalancerPool) NameWithoutSpaces 

func (l LoadBalancerPool) NameWithoutSpaces() string

func (LoadBalancerPool) String 

func (l LoadBalancerPool) String() string

func (LoadBalancerPool) Values 

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

type LoadBalancerPoolCreate 

type LoadBalancerPoolCreate = compute.LoadBalancerPoolCreate

type LoadBalancerPoolService 

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

func NewLoadBalancerPoolService 

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

func (LoadBalancerPoolService) Create 

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

func (LoadBalancerPoolService) Delete 

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

func (LoadBalancerPoolService) List 

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

func (LoadBalancerPoolService) Update 

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

type LoadBalancerPoolUpdate 

type LoadBalancerPoolUpdate = compute.LoadBalancerPoolUpdate

type LoadBalancerProtocol 

type LoadBalancerProtocol compute.LoadBalancerProtocol

func LoadBalancerProtocols 

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

func (LoadBalancerProtocol) Columns 

func (l LoadBalancerProtocol) Columns() []string

func (LoadBalancerProtocol) Keys 

func (l LoadBalancerProtocol) Keys() []string

func (LoadBalancerProtocol) String 

func (l LoadBalancerProtocol) String() string

func (LoadBalancerProtocol) Values 

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

type LoadBalancerService 

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

func NewLoadBalancerService 

func NewLoadBalancerService(client goclient.Client) LoadBalancerService

func (LoadBalancerService) Create 

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

func (LoadBalancerService) Delete 

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

func (LoadBalancerService) Get 

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

func (LoadBalancerService) List 

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

func (LoadBalancerService) Update 

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

type LoadBalancerUpdate 

type LoadBalancerUpdate = compute.LoadBalancerUpdate

type Network 

type Network compute.Network

func (Network) Columns 

func (n Network) Columns() []string

func (Network) Keys 

func (n Network) Keys() []string

func (Network) String 

func (n Network) String() string

func (Network) Values 

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

type NetworkCreate 

type NetworkCreate = compute.NetworkCreate

type NetworkInterface 

type NetworkInterface compute.NetworkInterface

func (NetworkInterface) Columns 

func (n NetworkInterface) Columns() []string

func (NetworkInterface) Keys 

func (n NetworkInterface) Keys() []string

func (NetworkInterface) String 

func (n NetworkInterface) String() string

func (NetworkInterface) Values 

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

type NetworkInterfaceCreate 

type NetworkInterfaceCreate = compute.NetworkInterfaceCreate

type NetworkInterfaceSecurityGroupUpdate 

type NetworkInterfaceSecurityGroupUpdate = compute.NetworkInterfaceSecurityGroupUpdate

type NetworkInterfaceSecurityUpdate 

type NetworkInterfaceSecurityUpdate = compute.NetworkInterfaceSecurityUpdate

type NetworkInterfaceService 

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

func NewNetworkInterfaceService 

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

func (NetworkInterfaceService) Create 

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

func (NetworkInterfaceService) Delete 

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

func (NetworkInterfaceService) List 

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

func (NetworkInterfaceService) UpdateSecurity 

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

func (NetworkInterfaceService) UpdateSecurityGroups 

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

type NetworkService 

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

func NewNetworkService 

func NewNetworkService(client goclient.Client) NetworkService

func (NetworkService) Create 

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

func (NetworkService) Delete 

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

func (NetworkService) List 

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

func (NetworkService) Update 

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

type NetworkUpdate 

type NetworkUpdate = compute.NetworkUpdate

type Route 

type Route compute.Route

func (Route) Columns 

func (r Route) Columns() []string

func (Route) Keys 

func (r Route) Keys() []string

func (Route) String 

func (r Route) String() string

func (Route) Values 

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

type RouteCreate 

type RouteCreate = compute.RouteCreate

type RouteService 

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

func NewRouteService 

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

func (RouteService) Create 

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

func (RouteService) Delete 

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

func (RouteService) List 

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

type Router 

type Router compute.Router

func (Router) Columns 

func (r Router) Columns() []string

func (Router) Keys 

func (r Router) Keys() []string

func (Router) String 

func (r Router) String() string

func (Router) Values 

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

type RouterCreate 

type RouterCreate = compute.RouterCreate

type RouterInterface 

type RouterInterface compute.RouterInterface

func (RouterInterface) Columns 

func (r RouterInterface) Columns() []string

func (RouterInterface) Keys 

func (r RouterInterface) Keys() []string

func (RouterInterface) String 

func (r RouterInterface) String() string

func (RouterInterface) Values 

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

type RouterInterfaceCreate 

type RouterInterfaceCreate = compute.RouterInterfaceCreate

type RouterInterfaceService 

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

func NewRouterInterfaceService 

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

func (RouterInterfaceService) Create 

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

func (RouterInterfaceService) Delete 

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

func (RouterInterfaceService) List 

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

type RouterService 

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

func NewRouterService 

func NewRouterService(client goclient.Client) RouterService

func (RouterService) Create 

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

func (RouterService) Delete 

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

func (RouterService) List 

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

func (RouterService) Update 

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

type RouterUpdate 

type RouterUpdate = compute.RouterUpdate

type SecurityGroup 

type SecurityGroup compute.SecurityGroup

func (SecurityGroup) Columns 

func (s SecurityGroup) Columns() []string

func (SecurityGroup) Keys 

func (s SecurityGroup) Keys() []string

func (SecurityGroup) String 

func (s SecurityGroup) String() string

func (SecurityGroup) Values 

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

type SecurityGroupCreate 

type SecurityGroupCreate = compute.SecurityGroupCreate

type SecurityGroupRule 

type SecurityGroupRule compute.SecurityGroupRule

func (SecurityGroupRule) Columns 

func (s SecurityGroupRule) Columns() []string

func (SecurityGroupRule) Keys 

func (s SecurityGroupRule) Keys() []string

func (SecurityGroupRule) String 

func (s SecurityGroupRule) String() string

func (SecurityGroupRule) Values 

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

type SecurityGroupRuleCreate 

type SecurityGroupRuleCreate = compute.SecurityGroupRuleOptions

type SecurityGroupRuleService 

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

func NewSecurityGroupRuleService 

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

func (SecurityGroupRuleService) Create 

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

func (SecurityGroupRuleService) Delete 

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

func (SecurityGroupRuleService) List 

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

func (SecurityGroupRuleService) Update 

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

type SecurityGroupRuleUpdate 

type SecurityGroupRuleUpdate = compute.SecurityGroupRuleOptions

type SecurityGroupService 

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

func NewSecurityGroupService 

func NewSecurityGroupService(client goclient.Client) SecurityGroupService

func (SecurityGroupService) Create 

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

func (SecurityGroupService) Delete 

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

func (SecurityGroupService) List 

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

func (SecurityGroupService) Update 

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

type SecurityGroupUpdate 

type SecurityGroupUpdate = compute.SecurityGroupUpdate

type Server 

type Server compute.Server

func (Server) Columns 

func (s Server) Columns() []string

func (Server) Keys 

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

func (Server) String 

func (s Server) String() string

func (Server) Values 

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

type ServerAction 

type ServerAction compute.ServerAction

func (ServerAction) Columns 

func (d ServerAction) Columns() []string

func (ServerAction) Keys 

func (d ServerAction) Keys() []string

func (ServerAction) Values 

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

type ServerActionService 

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

func NewServerActionService 

func NewServerActionService(client goclient.Client) ServerActionService

func (ServerActionService) Run 

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

type ServerCreate 

type ServerCreate = compute.ServerCreate

type ServerRunAction 

type ServerRunAction = compute.ServerPerform

type ServerService 

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

func NewServerService 

func NewServerService(client goclient.Client) ServerService

func (ServerService) Create 

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

func (ServerService) Delete 

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

func (ServerService) Get 

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

func (ServerService) List 

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

func (ServerService) Update 

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

func (ServerService) Upgrade 

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

type ServerUpdate 

type ServerUpdate = compute.ServerUpdate

type ServerUpgrade 

type ServerUpgrade = compute.ServerUpgrade

type Snapshot 

type Snapshot compute.Snapshot

func (Snapshot) Columns 

func (s Snapshot) Columns() []string

func (Snapshot) Keys 

func (s Snapshot) Keys() []string

func (Snapshot) String 

func (s Snapshot) String() string

func (Snapshot) Values 

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

type SnapshotCreate 

type SnapshotCreate = compute.SnapshotCreate

type SnapshotService 

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

func NewSnapshotService 

func NewSnapshotService(client goclient.Client) SnapshotService

func (SnapshotService) Create 

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

func (SnapshotService) Delete 

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

func (SnapshotService) List 

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

func (SnapshotService) Update 

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

type SnapshotUpdate 

type SnapshotUpdate = compute.SnapshotUpdate

type Volume 

type Volume compute.Volume

func (Volume) Columns 

func (v Volume) Columns() []string

func (Volume) Keys 

func (v Volume) Keys() []string

func (Volume) String 

func (v Volume) String() string

func (Volume) Values 

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

type VolumeAttach 

type VolumeAttach = compute.VolumeAttach

type VolumeCreate 

type VolumeCreate = compute.VolumeCreate

type VolumeExpand 

type VolumeExpand = compute.VolumeExpand

type VolumeRevert 

type VolumeRevert = compute.VolumeRevert

type VolumeService 

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

func NewVolumeService 

func NewVolumeService(client goclient.Client) VolumeService

func (VolumeService) Attach 

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

func (VolumeService) Create 

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

func (VolumeService) Delete 

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

func (VolumeService) Detach 

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

func (VolumeService) Expand 

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

func (VolumeService) List 

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

func (VolumeService) Revert 

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

func (VolumeService) Update 

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

type VolumeUpdate 

type VolumeUpdate = compute.VolumeUpdate

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.