doctl: github.com/digitalocean/doctl/do Index | Files | Directories

package do

import "github.com/digitalocean/doctl/do"

Index

Package Files

account.go actions.go balance.go billing_history.go cdns.go certificates.go databases.go domains.go droplet_actions.go droplets.go firewalls.go floating_ip_actions.go floating_ips.go image_actions.go images.go invoices.go kubernetes.go load_balancers.go pagination.go projects.go regions.go registry.go sizes.go snapshots.go sshkeys.go tags.go volume_actions.go volumes.go vpcs.go

Constants

const RegistryHostname = "registry.digitalocean.com"

RegistryHostname is the hostname for the DO registry

func PaginateResp Uses

func PaginateResp(gen Generator) ([]interface{}, error)

PaginateResp paginates a Response.

type Account Uses

type Account struct {
    *godo.Account
}

Account is a wrapper for godo.Account.

type AccountService Uses

type AccountService interface {
    Get() (*Account, error)
    RateLimit() (*RateLimit, error)
}

AccountService is an interface for interacting with DigitalOcean's account api.

func NewAccountService Uses

func NewAccountService(godoClient *godo.Client) AccountService

NewAccountService builds an AccountService instance.

type Action Uses

type Action struct {
    *godo.Action
}

Action is a wrapper for godo.Action

type Actions Uses

type Actions []Action

Actions is a slice of Action.

type ActionsService Uses

type ActionsService interface {
    List() (Actions, error)
    Get(int) (*Action, error)
}

ActionsService is an interface for interacting with DigitalOcean's action api.

func NewActionsService Uses

func NewActionsService(godoClient *godo.Client) ActionsService

NewActionsService builds an ActionsService instance.

type Balance Uses

type Balance struct {
    *godo.Balance
}

Balance is a wrapper for godo.Balance.

type BalanceService Uses

type BalanceService interface {
    Get() (*Balance, error)
}

BalanceService is an interface for interacting with DigitalOcean's balance api.

func NewBalanceService Uses

func NewBalanceService(godoClient *godo.Client) BalanceService

NewBalanceService builds an BalanceService instance.

type BillingHistory Uses

type BillingHistory struct {
    *godo.BillingHistory
}

BillingHistory is a wrapper for godo.BillingHistory

type BillingHistoryService Uses

type BillingHistoryService interface {
    List() (*BillingHistory, error)
}

BillingHistoryService is an interface for interacting with DigitalOcean's invoices api.

func NewBillingHistoryService Uses

func NewBillingHistoryService(client *godo.Client) BillingHistoryService

NewBillingHistoryService builds an BillingHistoryService instance.

type CDN Uses

type CDN struct {
    *godo.CDN
}

CDN is a wrapper for godo.CDN.

type CDNsService Uses

type CDNsService interface {
    List() ([]CDN, error)
    Get(string) (*CDN, error)
    Create(*godo.CDNCreateRequest) (*CDN, error)
    UpdateTTL(string, *godo.CDNUpdateTTLRequest) (*CDN, error)
    UpdateCustomDomain(string, *godo.CDNUpdateCustomDomainRequest) (*CDN, error)
    FlushCache(string, *godo.CDNFlushCacheRequest) error
    Delete(string) error
}

CDNsService is an interface for interacting with DigitalOcean's CDN api.

func NewCDNsService Uses

func NewCDNsService(godoClient *godo.Client) CDNsService

NewCDNsService builds an NewCDNsService instance.

type Certificate Uses

type Certificate struct {
    *godo.Certificate
}

Certificate wraps a godo Certificate.

type Certificates Uses

type Certificates []Certificate

Certificates is a slice of Certificate.

type CertificatesService Uses

type CertificatesService interface {
    Get(cID string) (*Certificate, error)
    Create(cr *godo.CertificateRequest) (*Certificate, error)
    List() (Certificates, error)
    Delete(cID string) error
}

CertificatesService is the godo CertificatesService interface.

func NewCertificatesService Uses

func NewCertificatesService(client *godo.Client) CertificatesService

NewCertificatesService builds an instance of CertificatesService.

type Database Uses

type Database struct {
    *godo.Database
}

Database is a wrapper for godo.Database

type DatabaseBackup Uses

type DatabaseBackup struct {
    *godo.DatabaseBackup
}

DatabaseBackup is a wrapper for godo.DatabaseBackup

type DatabaseBackups Uses

type DatabaseBackups []DatabaseBackup

DatabaseBackups is a slice of DatabaseBackup

type DatabaseConnection Uses

type DatabaseConnection struct {
    *godo.DatabaseConnection
}

DatabaseConnection is a wrapper for godo.DatabaseConnection

type DatabaseDB Uses

type DatabaseDB struct {
    *godo.DatabaseDB
}

DatabaseDB is a wrapper for godo.DatabaseDB

type DatabaseDBs Uses

type DatabaseDBs []DatabaseDB

DatabaseDBs is a slice of DatabaseDB

type DatabaseMaintenanceWindow Uses

type DatabaseMaintenanceWindow struct {
    *godo.DatabaseMaintenanceWindow
}

DatabaseMaintenanceWindow is a wrapper for godo.DatabaseMaintenanceWindow

type DatabasePool Uses

type DatabasePool struct {
    *godo.DatabasePool
}

DatabasePool is a wrapper for godo.DatabasePool

type DatabasePools Uses

type DatabasePools []DatabasePool

DatabasePools is a slice of DatabasePool

type DatabaseReplica Uses

type DatabaseReplica struct {
    *godo.DatabaseReplica
}

DatabaseReplica is a wrapper for godo.DatabaseReplica

type DatabaseReplicas Uses

type DatabaseReplicas []DatabaseReplica

DatabaseReplicas is a slice of DatabaseReplica

type DatabaseUser Uses

type DatabaseUser struct {
    *godo.DatabaseUser
}

DatabaseUser is a wrapper for godo.DatabaseUser

type DatabaseUsers Uses

type DatabaseUsers []DatabaseUser

DatabaseUsers is a slice of DatabaseUser

type Databases Uses

type Databases []Database

Databases is a slice of Database

type DatabasesService Uses

type DatabasesService interface {
    List() (Databases, error)
    Get(string) (*Database, error)
    Create(*godo.DatabaseCreateRequest) (*Database, error)
    Delete(string) error
    GetConnection(string) (*DatabaseConnection, error)
    ListBackups(string) (DatabaseBackups, error)
    Resize(string, *godo.DatabaseResizeRequest) error
    Migrate(string, *godo.DatabaseMigrateRequest) error

    GetMaintenance(string) (*DatabaseMaintenanceWindow, error)
    UpdateMaintenance(string, *godo.DatabaseUpdateMaintenanceRequest) error

    GetUser(string, string) (*DatabaseUser, error)
    ListUsers(string) (DatabaseUsers, error)
    CreateUser(string, *godo.DatabaseCreateUserRequest) (*DatabaseUser, error)
    DeleteUser(string, string) error
    ResetUserAuth(string, string, *godo.DatabaseResetUserAuthRequest) (*DatabaseUser, error)

    ListDBs(string) (DatabaseDBs, error)
    CreateDB(string, *godo.DatabaseCreateDBRequest) (*DatabaseDB, error)
    GetDB(string, string) (*DatabaseDB, error)
    DeleteDB(string, string) error

    ListPools(string) (DatabasePools, error)
    CreatePool(string, *godo.DatabaseCreatePoolRequest) (*DatabasePool, error)
    GetPool(string, string) (*DatabasePool, error)
    DeletePool(string, string) error

    GetReplica(string, string) (*DatabaseReplica, error)
    ListReplicas(string) (DatabaseReplicas, error)
    CreateReplica(string, *godo.DatabaseCreateReplicaRequest) (*DatabaseReplica, error)
    DeleteReplica(string, string) error
    GetReplicaConnection(string, string) (*DatabaseConnection, error)

    GetSQLMode(string) ([]string, error)
    SetSQLMode(string, ...string) error
}

DatabasesService is an interface for interacting with DigitalOcean's Database API

func NewDatabasesService Uses

func NewDatabasesService(client *godo.Client) DatabasesService

NewDatabasesService builds a DatabasesService instance.

type Domain Uses

type Domain struct {
    *godo.Domain
}

Domain wraps a godo Domain.

type DomainRecord Uses

type DomainRecord struct {
    *godo.DomainRecord
}

DomainRecord wraps a godo DomainRecord.

type DomainRecordEditRequest Uses

type DomainRecordEditRequest struct {
    Type     string `json:"type,omitempty"`
    Name     string `json:"name,omitempty"`
    Data     string `json:"data,omitempty"`
    Priority int    `json:"priority"`
    Port     *int   `json:"port,omitempty"`
    TTL      int    `json:"ttl,omitempty"`
    Weight   int    `json:"weight"`
    Flags    int    `json:"flags"`
    Tag      string `json:"tag,omitempty"`
}

A DomainRecordEditRequest is used in place of godo's DomainRecordEditRequest in order to work around the fact that we cannot send a port value of 0 via godo due to Go's JSON encoding logic.

type DomainRecords Uses

type DomainRecords []DomainRecord

DomainRecords is a slice of DomainRecord.

type Domains Uses

type Domains []Domain

Domains is a slice of Domain.

type DomainsService Uses

type DomainsService interface {
    List() (Domains, error)
    Get(string) (*Domain, error)
    Create(*godo.DomainCreateRequest) (*Domain, error)
    Delete(string) error

    Records(string) (DomainRecords, error)
    Record(string, int) (*DomainRecord, error)
    DeleteRecord(string, int) error
    EditRecord(string, int, *DomainRecordEditRequest) (*DomainRecord, error)
    CreateRecord(string, *DomainRecordEditRequest) (*DomainRecord, error)
}

DomainsService is the godo DOmainsService interface.

func NewDomainsService Uses

func NewDomainsService(client *godo.Client) DomainsService

NewDomainsService builds an instance of DomainsService.

type Droplet Uses

type Droplet struct {
    *godo.Droplet
}

Droplet is a wrapper for godo.Droplet

type DropletActionsService Uses

type DropletActionsService interface {
    Shutdown(int) (*Action, error)
    ShutdownByTag(string) (Actions, error)
    PowerOff(int) (*Action, error)
    PowerOffByTag(string) (Actions, error)
    PowerOn(int) (*Action, error)
    PowerOnByTag(string) (Actions, error)
    PowerCycle(int) (*Action, error)
    PowerCycleByTag(string) (Actions, error)
    Reboot(int) (*Action, error)
    Restore(int, int) (*Action, error)
    Resize(int, string, bool) (*Action, error)
    Rename(int, string) (*Action, error)
    Snapshot(int, string) (*Action, error)
    SnapshotByTag(string, string) (Actions, error)
    EnableBackups(int) (*Action, error)
    EnableBackupsByTag(string) (Actions, error)
    DisableBackups(int) (*Action, error)
    DisableBackupsByTag(string) (Actions, error)
    PasswordReset(int) (*Action, error)
    RebuildByImageID(int, int) (*Action, error)
    RebuildByImageSlug(int, string) (*Action, error)
    ChangeKernel(int, int) (*Action, error)
    EnableIPv6(int) (*Action, error)
    EnableIPv6ByTag(string) (Actions, error)
    EnablePrivateNetworking(int) (*Action, error)
    EnablePrivateNetworkingByTag(string) (Actions, error)
    Get(int, int) (*Action, error)
    GetByURI(string) (*Action, error)
}

DropletActionsService is an interface for interacting with DigitalOcean's droplet action api.

func NewDropletActionsService Uses

func NewDropletActionsService(godoClient *godo.Client) DropletActionsService

NewDropletActionsService builds an instance of DropletActionsService.

type DropletIPTable Uses

type DropletIPTable map[InterfaceType]string

DropletIPTable is a table of interface IPS.

type Droplets Uses

type Droplets []Droplet

Droplets is a slice of Droplet.

type DropletsService Uses

type DropletsService interface {
    List() (Droplets, error)
    ListByTag(string) (Droplets, error)
    Get(int) (*Droplet, error)
    Create(*godo.DropletCreateRequest, bool) (*Droplet, error)
    CreateMultiple(*godo.DropletMultiCreateRequest) (Droplets, error)
    Delete(int) error
    DeleteByTag(string) error
    Kernels(int) (Kernels, error)
    Snapshots(int) (Images, error)
    Backups(int) (Images, error)
    Actions(int) (Actions, error)
    Neighbors(int) (Droplets, error)
}

DropletsService is an interface for interacting with DigitalOcean's droplet api.

func NewDropletsService Uses

func NewDropletsService(client *godo.Client) DropletsService

NewDropletsService builds a DropletsService instance.

type Firewall Uses

type Firewall struct {
    *godo.Firewall
}

Firewall wraps a godo Firewall.

type Firewalls Uses

type Firewalls []Firewall

Firewalls is a slice of Firewall.

type FirewallsService Uses

type FirewallsService interface {
    Get(fID string) (*Firewall, error)
    Create(fr *godo.FirewallRequest) (*Firewall, error)
    Update(fID string, fr *godo.FirewallRequest) (*Firewall, error)
    List() (Firewalls, error)
    ListByDroplet(dID int) (Firewalls, error)
    Delete(fID string) error
    AddDroplets(fID string, dIDs ...int) error
    RemoveDroplets(fID string, dIDs ...int) error
    AddTags(fID string, tags ...string) error
    RemoveTags(fID string, tags ...string) error
    AddRules(fID string, rr *godo.FirewallRulesRequest) error
    RemoveRules(fID string, rr *godo.FirewallRulesRequest) error
}

FirewallsService is the godo FirewallsService interface.

func NewFirewallsService Uses

func NewFirewallsService(client *godo.Client) FirewallsService

NewFirewallsService builds an instance of FirewallsService.

type FloatingIP Uses

type FloatingIP struct {
    *godo.FloatingIP
}

FloatingIP wraps a godo FloatingIP.

type FloatingIPActionsService Uses

type FloatingIPActionsService interface {
    Assign(ip string, dropletID int) (*Action, error)
    Unassign(ip string) (*Action, error)
    Get(ip string, actionID int) (*Action, error)
    List(ip string, opt *godo.ListOptions) ([]Action, error)
}

FloatingIPActionsService is an interface for interacting with DigitalOcean's floating ip action api.

func NewFloatingIPActionsService Uses

func NewFloatingIPActionsService(godoClient *godo.Client) FloatingIPActionsService

NewFloatingIPActionsService builds a FloatingIPActionsService instance.

type FloatingIPs Uses

type FloatingIPs []FloatingIP

FloatingIPs is a slice of FloatingIP.

type FloatingIPsService Uses

type FloatingIPsService interface {
    List() (FloatingIPs, error)
    Get(ip string) (*FloatingIP, error)
    Create(ficr *godo.FloatingIPCreateRequest) (*FloatingIP, error)
    Delete(ip string) error
}

FloatingIPsService is the godo FloatingIPsService interface.

func NewFloatingIPsService Uses

func NewFloatingIPsService(client *godo.Client) FloatingIPsService

NewFloatingIPsService builds an instance of FloatingIPsService.

type Generator Uses

type Generator func(*godo.ListOptions) ([]interface{}, *godo.Response, error)

Generator is a function that generates the list to be paginated.

type Image Uses

type Image struct {
    *godo.Image
}

Image is a werapper for godo.Image

type ImageActionsService Uses

type ImageActionsService interface {
    Get(int, int) (*Action, error)
    Convert(int) (*Action, error)
    Transfer(int, *godo.ActionRequest) (*Action, error)
}

ImageActionsService is an interface for interacting with DigitalOcean's image action api.

func NewImageActionsService Uses

func NewImageActionsService(client *godo.Client) ImageActionsService

NewImageActionsService builds an ImageActionsService instance.

type Images Uses

type Images []Image

Images is a slice of Droplet.

type ImagesService Uses

type ImagesService interface {
    List(public bool) (Images, error)
    ListDistribution(public bool) (Images, error)
    ListApplication(public bool) (Images, error)
    ListUser(public bool) (Images, error)
    GetByID(id int) (*Image, error)
    GetBySlug(slug string) (*Image, error)
    Update(id int, iur *godo.ImageUpdateRequest) (*Image, error)
    Delete(id int) error
    Create(icr *godo.CustomImageCreateRequest) (*Image, error)
}

ImagesService is the godo ImagesService interface.

func NewImagesService Uses

func NewImagesService(client *godo.Client) ImagesService

NewImagesService builds an instance of ImagesService.

type InterfaceType Uses

type InterfaceType string

InterfaceType is a an interface type.

const (
    // InterfacePublic is a public interface.
    InterfacePublic InterfaceType = "public"
    // InterfacePrivate is a private interface.
    InterfacePrivate InterfaceType = "private"
)

type Invoice Uses

type Invoice struct {
    *godo.Invoice
}

Invoice is a wrapper for godo.Invoice

type InvoiceItem Uses

type InvoiceItem struct {
    *godo.InvoiceItem
}

InvoiceItem is a wrapper for godo.InvoiceItem

type InvoiceList Uses

type InvoiceList struct {
    *godo.InvoiceList
}

InvoiceList is a the results when listing invoices

type InvoiceSummary Uses

type InvoiceSummary struct {
    *godo.InvoiceSummary
}

InvoiceSummary is a wrapper for godo.InvoiceSummary

type InvoicesService Uses

type InvoicesService interface {
    Get(string) (*Invoice, error)
    List() (*InvoiceList, error)
    GetSummary(string) (*InvoiceSummary, error)
    GetPDF(string) ([]byte, error)
    GetCSV(string) ([]byte, error)
}

InvoicesService is an interface for interacting with DigitalOcean's invoices api.

func NewInvoicesService Uses

func NewInvoicesService(client *godo.Client) InvoicesService

NewInvoicesService builds an InvoicesService instance.

type Kernel Uses

type Kernel struct {
    *godo.Kernel
}

Kernel is a wrapper for godo.Kernel

type Kernels Uses

type Kernels []Kernel

Kernels is a slice of Kernel.

type KeysService Uses

type KeysService interface {
    List() (SSHKeys, error)
    Get(id string) (*SSHKey, error)
    Create(kcr *godo.KeyCreateRequest) (*SSHKey, error)
    Update(id string, kur *godo.KeyUpdateRequest) (*SSHKey, error)
    Delete(id string) error
}

KeysService is the godo KeysService interface.

func NewKeysService Uses

func NewKeysService(client *godo.Client) KeysService

NewKeysService builds an instance of KeysService.

type KubernetesCluster Uses

type KubernetesCluster struct {
    *godo.KubernetesCluster
}

KubernetesCluster wraps a godo KubernetesCluster.

type KubernetesClusterCredentials Uses

type KubernetesClusterCredentials struct {
    *godo.KubernetesClusterCredentials
}

KubernetesClusterCredentials wraps a godo KubernetesClusterCredentials.

type KubernetesClusters Uses

type KubernetesClusters []KubernetesCluster

KubernetesClusters is a slice of KubernetesCluster.

type KubernetesNodePool Uses

type KubernetesNodePool struct {
    *godo.KubernetesNodePool
}

KubernetesNodePool wraps a godo KubernetesNodePool.

type KubernetesNodePools Uses

type KubernetesNodePools []KubernetesNodePool

KubernetesNodePools is a slice of KubernetesNodePool.

type KubernetesNodeSize Uses

type KubernetesNodeSize struct {
    *godo.KubernetesNodeSize
}

KubernetesNodeSize wraps a godo KubernetesNodeSize.

type KubernetesNodeSizes Uses

type KubernetesNodeSizes []KubernetesNodeSize

KubernetesNodeSizes is a slice of KubernetesNodeSizes.

type KubernetesRegion Uses

type KubernetesRegion struct {
    *godo.KubernetesRegion
}

KubernetesRegion wraps a godo KubernetesRegion.

type KubernetesRegions Uses

type KubernetesRegions []KubernetesRegion

KubernetesRegions is a slice of KubernetesRegions.

type KubernetesService Uses

type KubernetesService interface {
    Get(clusterID string) (*KubernetesCluster, error)
    GetKubeConfig(clusterID string) ([]byte, error)
    GetCredentials(clusterID string) (*KubernetesClusterCredentials, error)
    GetUpgrades(clusterID string) (KubernetesVersions, error)
    List() (KubernetesClusters, error)
    Create(create *godo.KubernetesClusterCreateRequest) (*KubernetesCluster, error)
    Update(clusterID string, update *godo.KubernetesClusterUpdateRequest) (*KubernetesCluster, error)
    Upgrade(clusterID string, versionSlug string) error
    Delete(clusterID string) error

    CreateNodePool(clusterID string, req *godo.KubernetesNodePoolCreateRequest) (*KubernetesNodePool, error)
    GetNodePool(clusterID, poolID string) (*KubernetesNodePool, error)
    ListNodePools(clusterID string) (KubernetesNodePools, error)
    UpdateNodePool(clusterID, poolID string, req *godo.KubernetesNodePoolUpdateRequest) (*KubernetesNodePool, error)
    // RecycleNodePoolNodes is DEPRECATED please use DeleteNode
    RecycleNodePoolNodes(clusterID, poolID string, req *godo.KubernetesNodePoolRecycleNodesRequest) error
    DeleteNodePool(clusterID, poolID string) error
    DeleteNode(clusterID, poolID, nodeID string, req *godo.KubernetesNodeDeleteRequest) error

    GetVersions() (KubernetesVersions, error)
    GetRegions() (KubernetesRegions, error)
    GetNodeSizes() (KubernetesNodeSizes, error)
}

KubernetesService is the godo KubernetesService interface.

func NewKubernetesService Uses

func NewKubernetesService(client *godo.Client) KubernetesService

NewKubernetesService builds an instance of KubernetesService.

type KubernetesVersion Uses

type KubernetesVersion struct {
    *godo.KubernetesVersion
}

KubernetesVersion wraps a godo KubernetesVersion.

type KubernetesVersions Uses

type KubernetesVersions []KubernetesVersion

KubernetesVersions is a slice of KubernetesVersions.

type LoadBalancer Uses

type LoadBalancer struct {
    *godo.LoadBalancer
}

LoadBalancer wraps a godo LoadBalancer.

type LoadBalancers Uses

type LoadBalancers []LoadBalancer

LoadBalancers is a slice of LoadBalancer.

type LoadBalancersService Uses

type LoadBalancersService interface {
    Get(lbID string) (*LoadBalancer, error)
    List() (LoadBalancers, error)
    Create(lbr *godo.LoadBalancerRequest) (*LoadBalancer, error)
    Update(lbID string, lbr *godo.LoadBalancerRequest) (*LoadBalancer, error)
    Delete(lbID string) error
    AddDroplets(lbID string, dIDs ...int) error
    RemoveDroplets(lbID string, dIDs ...int) error
    AddForwardingRules(lbID string, rules ...godo.ForwardingRule) error
    RemoveForwardingRules(lbID string, rules ...godo.ForwardingRule) error
}

LoadBalancersService is the godo LoadBalancersService interface.

func NewLoadBalancersService Uses

func NewLoadBalancersService(client *godo.Client) LoadBalancersService

NewLoadBalancersService builds an instance of LoadBalancersService.

type Project Uses

type Project struct {
    *godo.Project
}

Project wraps a godo Project.

type ProjectResource Uses

type ProjectResource struct {
    *godo.ProjectResource
}

ProjectResource wraps a godo ProjectResource

type ProjectResources Uses

type ProjectResources []ProjectResource

ProjectResources is a slice of ProjectResource.

type Projects Uses

type Projects []Project

Projects is a slice of Project.

type ProjectsService Uses

type ProjectsService interface {
    List() (Projects, error)
    GetDefault() (*Project, error)
    Get(projectUUID string) (*Project, error)
    Create(*godo.CreateProjectRequest) (*Project, error)
    Update(projectUUID string, req *godo.UpdateProjectRequest) (*Project, error)
    Delete(projectUUID string) error

    ListResources(projectUUID string) (ProjectResources, error)
    AssignResources(projectUUID string, resources []string) (ProjectResources, error)
}

ProjectsService is the godo ProjectsService interface.

func NewProjectsService Uses

func NewProjectsService(client *godo.Client) ProjectsService

NewProjectsService builds an instance of ProjectsService.

type RateLimit Uses

type RateLimit struct {
    *godo.Rate
}

RateLimit is a wrapper for godo.Rate.

type Region Uses

type Region struct {
    *godo.Region
}

Region wraps godo Region.

type Regions Uses

type Regions []Region

Regions is a slice of Region.

type RegionsService Uses

type RegionsService interface {
    List() (Regions, error)
}

RegionsService is the godo RegionsService interface.

func NewRegionsService Uses

func NewRegionsService(client *godo.Client) RegionsService

NewRegionsService builds an instance of RegionsService.

type Registry Uses

type Registry struct {
    *godo.Registry
}

Registry wraps a godo Registry.

func (*Registry) Endpoint Uses

func (r *Registry) Endpoint() string

Endpoint returns the registry endpoint for image tagging

type RegistryService Uses

type RegistryService interface {
    Get() (*Registry, error)
    Create(*godo.RegistryCreateRequest) (*Registry, error)
    Delete() error
    DockerCredentials(*godo.RegistryDockerCredentialsRequest) (*godo.DockerCredentials, error)
    ListRepositoryTags(string, string) ([]RepositoryTag, error)
    ListRepositories(string) ([]Repository, error)
    DeleteTag(string, string, string) error
    DeleteManifest(string, string, string) error
    Endpoint() string
}

RegistryService is the godo RegistryService interface.

func NewRegistryService Uses

func NewRegistryService(client *godo.Client) RegistryService

NewRegistryService builds an instance of RegistryService.

type Repository Uses

type Repository struct {
    *godo.Repository
}

Repository wraps a godo Repository

type RepositoryTag Uses

type RepositoryTag struct {
    *godo.RepositoryTag
}

RepositoryTag wraps a godo RepositoryTag

type SSHKey Uses

type SSHKey struct {
    *godo.Key
}

SSHKey wraps godo Key.

type SSHKeys Uses

type SSHKeys []SSHKey

SSHKeys is a slice of SSHKey

type Size Uses

type Size struct {
    *godo.Size
}

Size wraps godo Size.

type Sizes Uses

type Sizes []Size

Sizes is a slice of Size.

type SizesService Uses

type SizesService interface {
    List() (Sizes, error)
}

SizesService is the godo SizesService interface.

func NewSizesService Uses

func NewSizesService(client *godo.Client) SizesService

NewSizesService builds an instance of SizesService.

type Snapshot Uses

type Snapshot struct {
    *godo.Snapshot
}

Snapshot is a wrapper for godo.Snapshot

type Snapshots Uses

type Snapshots []Snapshot

Snapshots is a slice of Snapshot.

type SnapshotsService Uses

type SnapshotsService interface {
    List() (Snapshots, error)
    ListVolume() (Snapshots, error)
    ListDroplet() (Snapshots, error)
    Get(string) (*Snapshot, error)
    Delete(string) error
}

SnapshotsService is an interface for interacting with DigitalOcean's snapshot api.

func NewSnapshotsService Uses

func NewSnapshotsService(client *godo.Client) SnapshotsService

NewSnapshotsService builds a SnapshotsService instance.

type Tag Uses

type Tag struct {
    *godo.Tag
}

Tag is a wrapper for godo.Tag

type Tags Uses

type Tags []Tag

Tags is a slice of Tag.

type TagsService Uses

type TagsService interface {
    List() (Tags, error)
    Get(string) (*Tag, error)
    Create(*godo.TagCreateRequest) (*Tag, error)
    Delete(string) error
    TagResources(string, *godo.TagResourcesRequest) error
    UntagResources(string, *godo.UntagResourcesRequest) error
}

TagsService is an interface for interacting with DigitalOcean's tags api.

func NewTagsService Uses

func NewTagsService(godoClient *godo.Client) TagsService

NewTagsService builds a TagsService instance.

type VPC Uses

type VPC struct {
    *godo.VPC
}

VPC wraps a godo VPC.

type VPCs Uses

type VPCs []VPC

VPCs is a slice of VPC.

type VPCsService Uses

type VPCsService interface {
    Get(vpcUUID string) (*VPC, error)
    List() (VPCs, error)
    Create(vpcr *godo.VPCCreateRequest) (*VPC, error)
    Update(vpcUUID string, vpcr *godo.VPCUpdateRequest) (*VPC, error)
    Delete(vpcUUID string) error
}

VPCsService is the godo VPCsService interface.

func NewVPCsService Uses

func NewVPCsService(client *godo.Client) VPCsService

NewVPCsService builds an instance of VPCsService.

type Volume Uses

type Volume struct {
    *godo.Volume
}

Volume is a wrapper for godo.Volume.

type VolumeActionsService Uses

type VolumeActionsService interface {
    Attach(string, int) (*Action, error)
    Detach(string, int) (*Action, error)
    Get(string, int) (*Action, error)
    List(string, *godo.ListOptions) ([]Action, error)
    Resize(string, int, string) (*Action, error)
}

VolumeActionsService is an interface for interacting with DigitalOcean's volume-action api.

func NewVolumeActionsService Uses

func NewVolumeActionsService(godoClient *godo.Client) VolumeActionsService

NewVolumeActionsService builds an VolumeActionsService instance.

type VolumesService Uses

type VolumesService interface {
    List() ([]Volume, error)
    CreateVolume(*godo.VolumeCreateRequest) (*Volume, error)
    DeleteVolume(string) error
    Get(string) (*Volume, error)
    CreateSnapshot(*godo.SnapshotCreateRequest) (*Snapshot, error)
    GetSnapshot(string) (*Snapshot, error)
    DeleteSnapshot(string) error
    ListSnapshots(string, *godo.ListOptions) ([]Snapshot, error)
}

VolumesService is an interface for interacting with DigitalOcean's volume api.

func NewVolumesService Uses

func NewVolumesService(godoClient *godo.Client) VolumesService

NewVolumesService builds an NewVolumesService instance.

Directories

PathSynopsis
mocksPackage mocks is a generated GoMock package.

Package do imports 10 packages (graph) and is imported by 26 packages. Updated 2020-05-19. Refresh now. Tools for package owners.