pools

package
v0.0.1 Latest Latest
Warning

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

 Go to latest Published: Sep 11, 2020 License: Apache-2.0 Imports: 3 Imported by: 3

Documentation

Overview

Package pools provides information and interaction with Pools and Members of the LBaaS v2 extension for the OpenStack Networking service.

Example to List Pools 

listOpts := pools.ListOpts{
	LoadbalancerID: "c79a4468-d788-410c-bf79-9a8ef6354852",
}

allPages, err := pools.List(networkClient, listOpts).AllPages()
if err != nil {
	panic(err)
}

allPools, err := pools.ExtractMonitors(allPages)
if err != nil {
	panic(err)
}

for _, pools := range allPools {
	fmt.Printf("%+v\n", pool)
}

Example to Create a Pool 

createOpts := pools.CreateOpts{
	LBMethod:       pools.LBMethodRoundRobin,
	Protocol:       "HTTP",
	Name:           "Example pool",
	LoadbalancerID: "79e05663-7f03-45d2-a092-8b94062f22ab",
}

pool, err := pools.Create(networkClient, createOpts).Extract()
if err != nil {
	panic(err)
}

Example to Update a Pool 

poolID := "d67d56a6-4a86-4688-a282-f46444705c64"

updateOpts := pools.UpdateOpts{
	Name: "new-name",
}

pool, err := pools.Update(networkClient, poolID, updateOpts).Extract()
if err != nil {
	panic(err)
}

Example to Delete a Pool 

poolID := "d67d56a6-4a86-4688-a282-f46444705c64"
err := pools.Delete(networkClient, poolID).ExtractErr()
if err != nil {
	panic(err)
}

Example to List Pool Members 

poolID := "d67d56a6-4a86-4688-a282-f46444705c64"

listOpts := pools.ListMemberOpts{
	ProtocolPort: 80,
}

allPages, err := pools.ListMembers(networkClient, poolID, listOpts).AllPages()
if err != nil {
	panic(err)
}

allMembers, err := pools.ExtractMembers(allPages)
if err != nil {
	panic(err)
}

for _, member := allMembers {
	fmt.Printf("%+v\n", member)
}

Example to Create a Member 

poolID := "d67d56a6-4a86-4688-a282-f46444705c64"

createOpts := pools.CreateMemberOpts{
	Name:         "db",
	SubnetID:     "1981f108-3c48-48d2-b908-30f7d28532c9",
	Address:      "10.0.2.11",
	ProtocolPort: 80,
	Weight:       10,
}

member, err := pools.CreateMember(networkClient, poolID, createOpts).Extract()
if err != nil {
	panic(err)
}

Example to Update a Member 

poolID := "d67d56a6-4a86-4688-a282-f46444705c64"
memberID := "64dba99f-8af8-4200-8882-e32a0660f23e"

updateOpts := pools.UpdateMemberOpts{
	Name:   "new-name",
	Weight: 4,
}

member, err := pools.UpdateMember(networkClient, poolID, memberID, updateOpts).Extract()
if err != nil {
	panic(err)
}

Example to Delete a Member 

poolID := "d67d56a6-4a86-4688-a282-f46444705c64"
memberID := "64dba99f-8af8-4200-8882-e32a0660f23e"

err := pools.DeleteMember(networkClient, poolID, memberID).ExtractErr()
if err != nil {
	panic(err)
}

Index

Constants

View Source 
const (
	LBMethodRoundRobin       LBMethod = "ROUND_ROBIN"
	LBMethodLeastConnections LBMethod = "LEAST_CONNECTIONS"
	LBMethodSourceIp         LBMethod = "SOURCE_IP"

	ProtocolTCP   Protocol = "TCP"
	ProtocolHTTP  Protocol = "HTTP"
	ProtocolHTTPS Protocol = "HTTPS"
)

Supported attributes for create/update operations.

Variables

This section is empty.

Functions

func List 

func List(c *golangsdk.ServiceClient, opts ListOptsBuilder) pagination.Pager

List returns a Pager which allows you to iterate over a collection of pools. It accepts a ListOpts struct, which allows you to filter and sort the returned collection for greater efficiency.

Default policy settings return only those pools that are owned by the tenant who submits the request, unless an admin user submits the request.

func ListMembers 

func ListMembers(c *golangsdk.ServiceClient, poolID string, opts ListMembersOptsBuilder) pagination.Pager

ListMembers returns a Pager which allows you to iterate over a collection of members. It accepts a ListMembersOptsBuilder, which allows you to filter and sort the returned collection for greater efficiency.

Default policy settings return only those members that are owned by the tenant who submits the request, unless an admin user submits the request.

Types

type CreateMemberOpts 

type CreateMemberOpts struct {
	// The IP address of the member to receive traffic from the load balancer.
	Address string `json:"address" required:"true"`

	// The port on which to listen for client traffic.
	ProtocolPort int `json:"protocol_port" required:"true"`

	// Name of the Member.
	Name string `json:"name,omitempty"`

	// TenantID is the UUID of the project who owns the Member.
	// Only administrative users can specify a project UUID other than their own.
	TenantID string `json:"tenant_id,omitempty"`

	// ProjectID is the UUID of the project who owns the Member.
	// Only administrative users can specify a project UUID other than their own.
	ProjectID string `json:"project_id,omitempty"`

	// A positive integer value that indicates the relative portion of traffic
	// that  this member should receive from the pool. For example, a member with
	// a weight  of 10 receives five times as much traffic as a member with a
	// weight of 2.
	Weight int `json:"weight,omitempty"`

	// If you omit this parameter, LBaaS uses the vip_subnet_id parameter value
	// for the subnet UUID.
	SubnetID string `json:"subnet_id,omitempty"`

	// The administrative state of the Pool. A valid value is true (UP)
	// or false (DOWN).
	AdminStateUp *bool `json:"admin_state_up,omitempty"`
}

CreateMemberOpts is the common options struct used in this package's CreateMember operation.

func (CreateMemberOpts) ToMemberCreateMap 

func (opts CreateMemberOpts) ToMemberCreateMap() (map[string]interface{}, error)

ToMemberCreateMap builds a request body from CreateMemberOpts.

type CreateMemberOptsBuilder 

type CreateMemberOptsBuilder interface {
	ToMemberCreateMap() (map[string]interface{}, error)
}

CreateMemberOptsBuilder allows extensions to add additional parameters to the CreateMember request.

type CreateMemberResult 

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

CreateMemberResult represents the result of a CreateMember operation. Call its Extract method to interpret it as a Member.

func CreateMember 

func CreateMember(c *golangsdk.ServiceClient, poolID string, opts CreateMemberOpts) (r CreateMemberResult)

CreateMember will create and associate a Member with a particular Pool.

func (CreateMemberResult) Extract 

func (r CreateMemberResult) Extract() (*Member, error)

ExtractMember is a function that accepts a result and extracts a member.

type CreateOpts 

type CreateOpts struct {
	// The algorithm used to distribute load between the members of the pool. The
	// current specification supports LBMethodRoundRobin, LBMethodLeastConnections
	// and LBMethodSourceIp as valid values for this attribute.
	LBMethod LBMethod `json:"lb_algorithm" required:"true"`

	// The protocol used by the pool members, you can use either
	// ProtocolTCP, ProtocolHTTP, or ProtocolHTTPS.
	Protocol Protocol `json:"protocol" required:"true"`

	// The Loadbalancer on which the members of the pool will be associated with.
	// Note: one of LoadbalancerID or ListenerID must be provided.
	LoadbalancerID string `json:"loadbalancer_id,omitempty" xor:"ListenerID"`

	// The Listener on which the members of the pool will be associated with.
	// Note: one of LoadbalancerID or ListenerID must be provided.
	ListenerID string `json:"listener_id,omitempty" xor:"LoadbalancerID"`

	// TenantID is the UUID of the project who owns the Pool.
	// Only administrative users can specify a project UUID other than their own.
	TenantID string `json:"tenant_id,omitempty"`

	// ProjectID is the UUID of the project who owns the Pool.
	// Only administrative users can specify a project UUID other than their own.
	ProjectID string `json:"project_id,omitempty"`

	// Name of the pool.
	Name string `json:"name,omitempty"`

	// Human-readable description for the pool.
	Description string `json:"description,omitempty"`

	// Persistence is the session persistence of the pool.
	// Omit this field to prevent session persistence.
	Persistence *SessionPersistence `json:"session_persistence,omitempty"`

	// The administrative state of the Pool. A valid value is true (UP)
	// or false (DOWN).
	AdminStateUp *bool `json:"admin_state_up,omitempty"`
}

CreateOpts is the common options struct used in this package's Create operation.

func (CreateOpts) ToPoolCreateMap 

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

ToPoolCreateMap builds a request body from CreateOpts.

type CreateOptsBuilder 

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

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

type CreateResult 

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

CreateResult represents the result of a Create operation. Call its Extract method to interpret the result as a Pool.

func Create 

func Create(c *golangsdk.ServiceClient, opts CreateOptsBuilder) (r CreateResult)

Create accepts a CreateOpts struct and uses the values to create a new load balancer pool.

func (CreateResult) Extract 

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

Extract is a function that accepts a result and extracts a pool.

type DeleteMemberResult 

type DeleteMemberResult struct {
	golangsdk.ErrResult
}

DeleteMemberResult represents the result of a DeleteMember operation. Call its ExtractErr method to determine if the request succeeded or failed.

func DeleteMember 

func DeleteMember(c *golangsdk.ServiceClient, poolID string, memberID string) (r DeleteMemberResult)

DisassociateMember will remove and disassociate a Member from a particular Pool.

type DeleteResult 

type DeleteResult struct {
	golangsdk.ErrResult
}

DeleteResult represents the result of a Delete operation. Call its ExtractErr method to determine if the request succeeded or failed.

func Delete 

func Delete(c *golangsdk.ServiceClient, id string) (r DeleteResult)

Delete will permanently delete a particular pool based on its unique ID.

type GetMemberResult 

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

GetMemberResult represents the result of a GetMember operation. Call its Extract method to interpret it as a Member.

func GetMember 

func GetMember(c *golangsdk.ServiceClient, poolID string, memberID string) (r GetMemberResult)

GetMember retrieves a particular Pool Member based on its unique ID.

func (GetMemberResult) Extract 

func (r GetMemberResult) Extract() (*Member, error)

ExtractMember is a function that accepts a result and extracts a member.

type GetResult 

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

GetResult represents the result of a Get operation. Call its Extract method to interpret the result as a Pool.

func Get 

func Get(c *golangsdk.ServiceClient, id string) (r GetResult)

Get retrieves a particular pool based on its unique ID.

func (GetResult) Extract 

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

Extract is a function that accepts a result and extracts a pool.

type LBMethod 

type LBMethod string

type ListMembersOpts 

type ListMembersOpts struct {
	Name         string `q:"name"`
	Weight       int    `q:"weight"`
	AdminStateUp *bool  `q:"admin_state_up"`
	TenantID     string `q:"tenant_id"`
	Address      string `q:"address"`
	ProtocolPort int    `q:"protocol_port"`
	ID           string `q:"id"`
	Limit        int    `q:"limit"`
	Marker       string `q:"marker"`
	SortKey      string `q:"sort_key"`
	SortDir      string `q:"sort_dir"`
}

ListMembersOpts allows the filtering and sorting of paginated collections through the API. Filtering is achieved by passing in struct field values that map to the Member attributes you want to see returned. SortKey allows you to sort by a particular Member attribute. SortDir sets the direction, and is either `asc' or `desc'. Marker and Limit are used for pagination.

func (ListMembersOpts) ToMembersListQuery 

func (opts ListMembersOpts) ToMembersListQuery() (string, error)

ToMemberListQuery formats a ListOpts into a query string.

type ListMembersOptsBuilder 

type ListMembersOptsBuilder interface {
	ToMembersListQuery() (string, error)
}

ListMemberOptsBuilder allows extensions to add additional parameters to the ListMembers request.

type ListOpts 

type ListOpts struct {
	LBMethod       string `q:"lb_algorithm"`
	Protocol       string `q:"protocol"`
	TenantID       string `q:"tenant_id"`
	ProjectID      string `q:"project_id"`
	AdminStateUp   *bool  `q:"admin_state_up"`
	Name           string `q:"name"`
	ID             string `q:"id"`
	LoadbalancerID string `q:"loadbalancer_id"`
	ListenerID     string `q:"listener_id"`
	Limit          int    `q:"limit"`
	Marker         string `q:"marker"`
	SortKey        string `q:"sort_key"`
	SortDir        string `q:"sort_dir"`
}

ListOpts allows the filtering and sorting of paginated collections through the API. Filtering is achieved by passing in struct field values that map to the Pool attributes you want to see returned. SortKey allows you to sort by a particular Pool attribute. SortDir sets the direction, and is either `asc' or `desc'. Marker and Limit are used for pagination.

func (ListOpts) ToPoolListQuery 

func (opts ListOpts) ToPoolListQuery() (string, error)

ToPoolListQuery formats a ListOpts into a query string.

type ListOptsBuilder 

type ListOptsBuilder interface {
	ToPoolListQuery() (string, error)
}

ListOptsBuilder allows extensions to add additional parameters to the List request.

type ListenerID 

type ListenerID struct {
	ID string `json:"id"`
}

ListenerID represents a listener.

type LoadBalancerID 

type LoadBalancerID struct {
	ID string `json:"id"`
}

LoadBalancerID represents a load balancer.

type Member 

type Member struct {
	// Name of the Member.
	Name string `json:"name"`

	// Weight of Member.
	Weight int `json:"weight"`

	// The administrative state of the member, which is up (true) or down (false).
	AdminStateUp bool `json:"admin_state_up"`

	// Owner of the Member.
	TenantID string `json:"tenant_id"`

	// Parameter value for the subnet UUID.
	SubnetID string `json:"subnet_id"`

	// The Pool to which the Member belongs.
	PoolID string `json:"pool_id"`

	// The IP address of the Member.
	Address string `json:"address"`

	// The port on which the application is hosted.
	ProtocolPort int `json:"protocol_port"`

	// The unique ID for the Member.
	ID string `json:"id"`

	// The provisioning status of the member.
	// This value is ACTIVE, PENDING_* or ERROR.
	ProvisioningStatus string `json:"provisioning_status"`
}

Member represents the application running on a backend server.

func ExtractMembers 

func ExtractMembers(r pagination.Page) ([]Member, error)

ExtractMembers accepts a Page struct, specifically a MemberPage struct, and extracts the elements into a slice of Members structs. In other words, a generic collection is mapped into a relevant slice.

type MemberPage 

type MemberPage struct {
	pagination.LinkedPageBase
}

MemberPage is the page returned by a pager when traversing over a collection of Members in a Pool.

func (MemberPage) IsEmpty 

func (r MemberPage) IsEmpty() (bool, error)

IsEmpty checks whether a MemberPage struct is empty.

func (MemberPage) NextPageURL 

func (r MemberPage) NextPageURL() (string, error)

NextPageURL is invoked when a paginated collection of members has reached the end of a page and the pager seeks to traverse over a new one. In order to do this, it needs to construct the next page's URL.

type Pool 

type Pool struct {
	// The load-balancer algorithm, which is round-robin, least-connections, and
	// so on. This value, which must be supported, is dependent on the provider.
	// Round-robin must be supported.
	LBMethod string `json:"lb_algorithm"`

	// The protocol of the Pool, which is TCP, HTTP, or HTTPS.
	Protocol string `json:"protocol"`

	// Description for the Pool.
	Description string `json:"description"`

	// A list of listeners objects IDs.
	Listeners []ListenerID `json:"listeners"` //[]map[string]interface{}

	// A list of member objects IDs.
	Members []Member `json:"members"`

	// The ID of associated health monitor.
	MonitorID string `json:"healthmonitor_id"`

	// The network on which the members of the Pool will be located. Only members
	// that are on this network can be added to the Pool.
	SubnetID string `json:"subnet_id"`

	// Owner of the Pool.
	TenantID string `json:"tenant_id"`

	// The administrative state of the Pool, which is up (true) or down (false).
	AdminStateUp bool `json:"admin_state_up"`

	// Pool name. Does not have to be unique.
	Name string `json:"name"`

	// The unique ID for the Pool.
	ID string `json:"id"`

	// A list of load balancer objects IDs.
	Loadbalancers []LoadBalancerID `json:"loadbalancers"`

	// Indicates whether connections in the same session will be processed by the
	// same Pool member or not.
	Persistence SessionPersistence `json:"session_persistence"`

	// The load balancer provider.
	Provider string `json:"provider"`

	// The Monitor associated with this Pool.
	Monitor monitors.Monitor `json:"healthmonitor"`

	// The provisioning status of the pool.
	// This value is ACTIVE, PENDING_* or ERROR.
	ProvisioningStatus string `json:"provisioning_status"`
}

Pool represents a logical set of devices, such as web servers, that you group together to receive and process traffic. The load balancing function chooses a Member of the Pool according to the configured load balancing method to handle the new requests or connections received on the VIP address.

func ExtractPools 

func ExtractPools(r pagination.Page) ([]Pool, error)

ExtractPools accepts a Page struct, specifically a PoolPage struct, and extracts the elements into a slice of Pool structs. In other words, a generic collection is mapped into a relevant slice.

type PoolPage 

type PoolPage struct {
	pagination.LinkedPageBase
}

PoolPage is the page returned by a pager when traversing over a collection of pools.

func (PoolPage) IsEmpty 

func (r PoolPage) IsEmpty() (bool, error)

IsEmpty checks whether a PoolPage struct is empty.

func (PoolPage) NextPageURL 

func (r PoolPage) NextPageURL() (string, error)

NextPageURL is invoked when a paginated collection of pools has reached the end of a page and the pager seeks to traverse over a new one. In order to do this, it needs to construct the next page's URL.

type Protocol 

type Protocol string

type SessionPersistence 

type SessionPersistence struct {
	// The type of persistence mode.
	Type string `json:"type"`

	// Name of cookie if persistence mode is set appropriately.
	CookieName string `json:"cookie_name,omitempty"`
}

SessionPersistence represents the session persistence feature of the load balancing service. It attempts to force connections or requests in the same session to be processed by the same member as long as it is ative. Three types of persistence are supported:

SOURCE_IP: With this mode, all connections originating from the same source 

IP address, will be handled by the same Member of the Pool.

HTTP_COOKIE: With this persistence mode, the load balancing function will 

create a cookie on the first request from a client. Subsequent
requests containing the same cookie value will be handled by
the same Member of the Pool.

APP_COOKIE: With this persistence mode, the load balancing function will 

rely on a cookie established by the backend application. All
requests carrying the same cookie value will be handled by the
same Member of the Pool.

type UpdateMemberOpts 

type UpdateMemberOpts struct {
	// Name of the Member.
	Name string `json:"name,omitempty"`

	// A positive integer value that indicates the relative portion of traffic
	// that this member should receive from the pool. For example, a member with
	// a weight of 10 receives five times as much traffic as a member with a
	// weight of 2.
	Weight int `json:"weight,omitempty"`

	// The administrative state of the Pool. A valid value is true (UP)
	// or false (DOWN).
	AdminStateUp *bool `json:"admin_state_up,omitempty"`
}

UpdateMemberOpts is the common options struct used in this package's Update operation.

func (UpdateMemberOpts) ToMemberUpdateMap 

func (opts UpdateMemberOpts) ToMemberUpdateMap() (map[string]interface{}, error)

ToMemberUpdateMap builds a request body from UpdateMemberOpts.

type UpdateMemberOptsBuilder 

type UpdateMemberOptsBuilder interface {
	ToMemberUpdateMap() (map[string]interface{}, error)
}

UpdateMemberOptsBuilder allows extensions to add additional parameters to the List request.

type UpdateMemberResult 

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

UpdateMemberResult represents the result of an UpdateMember operation. Call its Extract method to interpret it as a Member.

func UpdateMember 

func UpdateMember(c *golangsdk.ServiceClient, poolID string, memberID string, opts UpdateMemberOptsBuilder) (r UpdateMemberResult)

Update allows Member to be updated.

func (UpdateMemberResult) Extract 

func (r UpdateMemberResult) Extract() (*Member, error)

ExtractMember is a function that accepts a result and extracts a member.

type UpdateOpts 

type UpdateOpts struct {
	// Name of the pool.
	Name string `json:"name,omitempty"`

	// Human-readable description for the pool.
	Description string `json:"description,omitempty"`

	// The algorithm used to distribute load between the members of the pool. The
	// current specification supports LBMethodRoundRobin, LBMethodLeastConnections
	// and LBMethodSourceIp as valid values for this attribute.
	LBMethod LBMethod `json:"lb_algorithm,omitempty"`

	// The administrative state of the Pool. A valid value is true (UP)
	// or false (DOWN).
	AdminStateUp *bool `json:"admin_state_up,omitempty"`
}

UpdateOpts is the common options struct used in this package's Update operation.

func (UpdateOpts) ToPoolUpdateMap 

func (opts UpdateOpts) ToPoolUpdateMap() (map[string]interface{}, error)

ToPoolUpdateMap builds a request body from UpdateOpts.

type UpdateOptsBuilder 

type UpdateOptsBuilder interface {
	ToPoolUpdateMap() (map[string]interface{}, error)
}

UpdateOptsBuilder allows extensions to add additional parameters to the Update request.

type UpdateResult 

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

UpdateResult represents the result of an Update operation. Call its Extract method to interpret the result as a Pool.

func Update 

func Update(c *golangsdk.ServiceClient, id string, opts UpdateOptsBuilder) (r UpdateResult)

Update allows pools to be updated.

func (UpdateResult) Extract 

func (r UpdateResult) Extract() (*Pool, error)

Extract is a function that accepts a result and extracts a pool.

Source Files

View all Source files

Directories

Path Synopsis
pools unit tests
 pools unit tests

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.