keypairs

Documentation

Overview

Package keypairs provides the ability to manage key pairs as well as create servers with a specified key pair.

Example to List Key Pairs

allPages, err := keypairs.List(computeClient).AllPages()
if err != nil {
	panic(err)
}

allKeyPairs, err := keypairs.ExtractKeyPairs(allPages)
if err != nil {
	panic(err)
}

for _, kp := range allKeyPairs {
	fmt.Printf("%+v\n", kp)
}

Example to Create a Key Pair

createOpts := keypairs.CreateOpts{
	Name: "keypair-name",
}

keypair, err := keypairs.Create(computeClient, createOpts).Extract()
if err != nil {
	panic(err)
}

fmt.Printf("%+v", keypair)

Example to Import a Key Pair

createOpts := keypairs.CreateOpts{
	Name:      "keypair-name",
	PublicKey: "public-key",
}

keypair, err := keypairs.Create(computeClient, createOpts).Extract()
if err != nil {
	panic(err)
}

Example to Delete a Key Pair

err := keypairs.Delete(computeClient, "keypair-name").ExtractErr()
if err != nil {
	panic(err)
}

Example to Create a Server With a Key Pair

serverCreateOpts := servers.CreateOpts{
	Name:      "server_name",
	ImageRef:  "image-uuid",
	FlavorRef: "flavor-uuid",
}

createOpts := keypairs.CreateOptsExt{
	CreateOptsBuilder: serverCreateOpts,
	KeyName:           "keypair-name",
}

server, err := servers.Create(computeClient, createOpts).Extract()
if err != nil {
	panic(err)
}

Index

• func List(client *eclcloud.ServiceClient) pagination.Pager
• type CreateOpts
  • func (opts CreateOpts) ToKeyPairCreateMap() (map[string]interface{}, error)
• type CreateOptsBuilder
• type CreateOptsExt
  • func (opts CreateOptsExt) ToServerCreateMap() (map[string]interface{}, error)
• type CreateResult
  • func Create(client *eclcloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult)
  • func (r CreateResult) Extract() (*KeyPair, error)
• type DeleteResult
  • func Delete(client *eclcloud.ServiceClient, name string) (r DeleteResult)
• type GetResult
  • func Get(client *eclcloud.ServiceClient, name string) (r GetResult)
  • func (r GetResult) Extract() (*KeyPair, error)
• type KeyPair
  • func ExtractKeyPairs(r pagination.Page) ([]KeyPair, error)
• type KeyPairPage
  • func (page KeyPairPage) IsEmpty() (bool, error)

Functions

func List

func List(client *eclcloud.ServiceClient) pagination.Pager

List returns a Pager that allows you to iterate over a collection of KeyPairs.

Types

type CreateOpts

type CreateOpts struct {
	// Name is a friendly name to refer to this KeyPair in other services.
	Name string `json:"name" required:"true"`

	// PublicKey [optional] is a pregenerated OpenSSH-formatted public key.
	// If provided, this key will be imported and no new key will be created.
	PublicKey string `json:"public_key,omitempty"`
}

CreateOpts specifies KeyPair creation or import parameters.

func (CreateOpts) ToKeyPairCreateMap

func (opts CreateOpts) ToKeyPairCreateMap() (map[string]interface{}, error)

ToKeyPairCreateMap constructs a request body from CreateOpts.

type CreateOptsBuilder

type CreateOptsBuilder interface {
	ToKeyPairCreateMap() (map[string]interface{}, error)
}

CreateOptsBuilder allows extensions to add additional parameters to the Create request.

type CreateOptsExt

type CreateOptsExt struct {
	servers.CreateOptsBuilder

	// KeyName is the name of the key pair.
	KeyName string `json:"key_name,omitempty"`
}

CreateOptsExt adds a KeyPair option to the base CreateOpts.

func (CreateOptsExt) ToServerCreateMap

func (opts CreateOptsExt) ToServerCreateMap() (map[string]interface{}, error)

ToServerCreateMap adds the key_name to the base server creation options.

type CreateResult

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

CreateResult is the response from a Create operation. Call its Extract method to interpret it as a KeyPair.

func Create

func Create(client *eclcloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult)

Create requests the creation of a new KeyPair on the server, or to import a pre-existing keypair.

func (CreateResult) Extract

func (r CreateResult) Extract() (*KeyPair, error)

Extract is a method that attempts to interpret any KeyPair resource response as a KeyPair struct.

type DeleteResult

type DeleteResult struct {
	eclcloud.ErrResult
}

DeleteResult is the response from a Delete operation. Call its ExtractErr method to determine if the call succeeded or failed.

func Delete

func Delete(client *eclcloud.ServiceClient, name string) (r DeleteResult)

Delete requests the deletion of a previous stored KeyPair from the server.

type GetResult

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

GetResult is the response from a Get operation. Call its Extract method to interpret it as a KeyPair.

func Get

func Get(client *eclcloud.ServiceClient, name string) (r GetResult)

Get returns public data about a previously uploaded KeyPair.

func (GetResult) Extract

func (r GetResult) Extract() (*KeyPair, error)

Extract is a method that attempts to interpret any KeyPair resource response as a KeyPair struct.

type KeyPair

type KeyPair struct {
	// Name is used to refer to this keypair from other services within this
	// region.
	Name string `json:"name"`

	// Fingerprint is a short sequence of bytes that can be used to authenticate
	// or validate a longer public key.
	Fingerprint string `json:"fingerprint"`

	// PublicKey is the public key from this pair, in OpenSSH format.
	// "ssh-rsa AAAAB3Nz..."
	PublicKey string `json:"public_key"`

	// PrivateKey is the private key from this pair, in PEM format.
	// "-----BEGIN RSA PRIVATE KEY-----\nMIICXA..."
	// It is only present if this KeyPair was just returned from a Create call.
	PrivateKey string `json:"private_key"`

	// UserID is the user who owns this KeyPair.
	UserID string `json:"user_id"`
}

KeyPair is an SSH key known to the Enterprise Cloud that is available to be injected into servers.

func ExtractKeyPairs

func ExtractKeyPairs(r pagination.Page) ([]KeyPair, error)

ExtractKeyPairs interprets a page of results as a slice of KeyPairs.

type KeyPairPage

type KeyPairPage struct {
	pagination.SinglePageBase
}

KeyPairPage stores a single page of all KeyPair results from a List call. Use the ExtractKeyPairs function to convert the results to a slice of KeyPairs.

func (KeyPairPage) IsEmpty

func (page KeyPairPage) IsEmpty() (bool, error)

IsEmpty determines whether or not a KeyPairPage is empty.