servergroups

Documentation

Overview

Package servergroups provides the ability to manage server groups.

Example to List Server Groups

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

allServerGroups, err := servergroups.ExtractServerGroups(allPages)
if err != nil {
	panic(err)
}

for _, sg := range allServerGroups {
	fmt.Printf("%#v\n", sg)
}

Example to Create a Server Group

createOpts := servergroups.CreateOpts{
	Name:     "my_sg",
	Policies: []string{"anti-affinity"},
}

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

Example to Create a Server Group with additional microversion 2.64 fields

	createOpts := servergroups.CreateOpts{
		Name:   "my_sg",
		Policy: "anti-affinity",
        	Rules: &servergroups.Rules{
            		MaxServerPerHost: 3,
        	},
	}

	computeClient.Microversion = "2.64"
	result := servergroups.Create(computeClient, createOpts)

	serverGroup, err := result.Extract()
	if err != nil {
		panic(err)
	}

	policy, err := servergroups.ExtractPolicy(result.Result)
	if err != nil {
		panic(err)
	}

	rules, err := servergroups.ExtractRules(result.Result)
	if err != nil {
		panic(err)
	}

Example to Delete a Server Group

sgID := "7a6f29ad-e34d-4368-951a-58a08f11cfb7"
err := servergroups.Delete(computeClient, sgID).ExtractErr()
if err != nil {
	panic(err)
}

Example to get additional fields with microversion 2.64 or later

computeClient.Microversion = "2.64"
result := servergroups.Get(computeClient, "616fb98f-46ca-475e-917e-2563e5a8cd19")

policy, err := servergroups.ExtractPolicy(result.Result)
if err != nil {
	panic(err)
}
fmt.Printf("Policy: %s\n", policy)

rules, err := servergroups.ExtractRules(result.Result)
if err != nil {
	panic(err)
}
fmt.Printf("Max server per host: %s\n", rules.MaxServerPerHost)

Index

• func ExtractPolicy(r gophercloud.Result) (string, error)
• func List(client *gophercloud.ServiceClient) pagination.Pager
• type CreateOpts
  • func (opts CreateOpts) ToServerGroupCreateMap() (map[string]interface{}, error)
• type CreateOptsBuilder
• type CreateResult
  • func Create(client *gophercloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult)
• type DeleteResult
  • func Delete(client *gophercloud.ServiceClient, id string) (r DeleteResult)
• type GetResult
  • func Get(client *gophercloud.ServiceClient, id string) (r GetResult)
• type Rules
  • func ExtractRules(r gophercloud.Result) (Rules, error)
• type ServerGroup
  • func ExtractServerGroups(r pagination.Page) ([]ServerGroup, error)
• type ServerGroupPage
  • func (page ServerGroupPage) IsEmpty() (bool, error)
• type ServerGroupResult
  • func (r ServerGroupResult) Extract() (*ServerGroup, error)

Functions

func ExtractPolicy

func ExtractPolicy(r gophercloud.Result) (string, error)

ExtractPolicy will extract the policy attribute. This requires the client to be set to microversion 2.64 or later.

func List

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

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

Types

type CreateOpts

type CreateOpts struct {
	// Name is the name of the server group.
	Name string `json:"name" required:"true"`

	// Policies are the server group policies.
	Policies []string `json:"policies,omitempty"`

	// Policy specifies the name of a policy.
	// Requires microversion 2.64 or later.
	Policy string `json:"policy,omitempty"`

	// Rules specifies the set of rules.
	// Requires microversion 2.64 or later.
	Rules *Rules `json:"rules,omitempty"`
}

CreateOpts specifies Server Group creation parameters.

func (CreateOpts) ToServerGroupCreateMap

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

ToServerGroupCreateMap constructs a request body from CreateOpts.

type CreateOptsBuilder

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

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

type CreateResult

type CreateResult struct {
	ServerGroupResult
}

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

func Create

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

Create requests the creation of a new Server Group.

type DeleteResult

type DeleteResult struct {
	gophercloud.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 *gophercloud.ServiceClient, id string) (r DeleteResult)

Delete requests the deletion of a previously allocated ServerGroup.

type GetResult

type GetResult struct {
	ServerGroupResult
}

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

func Get

func Get(client *gophercloud.ServiceClient, id string) (r GetResult)

Get returns data about a previously created ServerGroup.

type Rules

type Rules struct {
	// MaxServerPerHost specifies how many servers can reside on a single compute host.
	// It can be used only with the "anti-affinity" policy.
	MaxServerPerHost int `json:"max_server_per_host,omitempty"`
}

Rules represents set of rules for a policy.

func ExtractRules

func ExtractRules(r gophercloud.Result) (Rules, error)

ExtractRules will extract the rules attribute. This requires the client to be set to microversion 2.64 or later.

type ServerGroup

type ServerGroup struct {
	// ID is the unique ID of the Server Group.
	ID string `json:"id"`

	// Name is the common name of the server group.
	Name string `json:"name"`

	// Polices are the group policies.
	//
	// Normally a single policy is applied:
	//
	// "affinity" will place all servers within the server group on the
	// same compute node.
	//
	// "anti-affinity" will place servers within the server group on different
	// compute nodes.
	Policies []string `json:"policies"`

	// Members are the members of the server group.
	Members []string `json:"members"`

	// Metadata includes a list of all user-specified key-value pairs attached
	// to the Server Group.
	Metadata map[string]interface{}
}

A ServerGroup creates a policy for instance placement in the cloud. You should use extract methods from microversions.go to retrieve additional fields.

func ExtractServerGroups

func ExtractServerGroups(r pagination.Page) ([]ServerGroup, error)

ExtractServerGroups interprets a page of results as a slice of ServerGroups.

type ServerGroupPage

type ServerGroupPage struct {
	pagination.SinglePageBase
}

ServerGroupPage stores a single page of all ServerGroups results from a List call.

func (ServerGroupPage) IsEmpty

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

IsEmpty determines whether or not a ServerGroupsPage is empty.

type ServerGroupResult

type ServerGroupResult struct {
	gophercloud.Result
}

func (ServerGroupResult) Extract

func (r ServerGroupResult) Extract() (*ServerGroup, error)

Extract is a method that attempts to interpret any Server Group resource response as a ServerGroup struct.