gophercloud: github.com/rackspace/gophercloud/openstack/networking/v2/extensions/layer3/routers Index | Files

package routers

import "github.com/rackspace/gophercloud/openstack/networking/v2/extensions/layer3/routers"

Index

Package Files

requests.go results.go urls.go

func ExtractRouters Uses

func ExtractRouters(page pagination.Page) ([]Router, error)

ExtractRouters accepts a Page struct, specifically a RouterPage struct, and extracts the elements into a slice of Router structs. In other words, a generic collection is mapped into a relevant slice.

func List Uses

func List(c *gophercloud.ServiceClient, opts ListOpts) pagination.Pager

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

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

type CreateOpts Uses

type CreateOpts struct {
    Name         string
    AdminStateUp *bool
    Distributed  *bool
    TenantID     string
    GatewayInfo  *GatewayInfo
}

CreateOpts contains all the values needed to create a new router. There are no required values.

func (CreateOpts) ToRouterCreateMap Uses

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

ToRouterCreateMap casts a CreateOpts struct to a map.

type CreateOptsBuilder Uses

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

CreateOptsBuilder is the interface options structs have to satisfy in order to be used in the main Create operation in this package. Since many extensions decorate or modify the common logic, it is useful for them to satisfy a basic interface in order for them to be used.

type CreateResult Uses

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

CreateResult represents the result of a create operation.

func Create Uses

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

Create accepts a CreateOpts struct and uses the values to create a new logical router. When it is created, the router does not have an internal interface - it is not associated to any subnet.

You can optionally specify an external gateway for a router using the GatewayInfo struct. The external gateway for the router must be plugged into an external network (it is external if its `router:external' field is set to true).

func (CreateResult) Extract Uses

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

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

type DeleteResult Uses

type DeleteResult struct {
    gophercloud.ErrResult
}

DeleteResult represents the result of a delete operation.

func Delete Uses

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

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

type GatewayInfo Uses

type GatewayInfo struct {
    NetworkID string `json:"network_id" mapstructure:"network_id"`
}

GatewayInfo represents the information of an external gateway for any particular network router.

type GetResult Uses

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

GetResult represents the result of a get operation.

func Get Uses

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

Get retrieves a particular router based on its unique ID.

func (GetResult) Extract Uses

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

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

type InterfaceInfo Uses

type InterfaceInfo struct {
    // The ID of the subnet which this interface is associated with.
    SubnetID string `json:"subnet_id" mapstructure:"subnet_id"`

    // The ID of the port that is a part of the subnet.
    PortID string `json:"port_id" mapstructure:"port_id"`

    // The UUID of the interface.
    ID  string `json:"id" mapstructure:"id"`

    // Owner of the interface.
    TenantID string `json:"tenant_id" mapstructure:"tenant_id"`
}

InterfaceInfo represents information about a particular router interface. As mentioned above, in order for a router to forward to a subnet, it needs an interface.

type InterfaceOpts Uses

type InterfaceOpts struct {
    SubnetID string
    PortID   string
}

InterfaceOpts allow you to work with operations that either add or remote an internal interface from a router.

type InterfaceResult Uses

type InterfaceResult struct {
    gophercloud.Result
}

InterfaceResult represents the result of interface operations, such as AddInterface() and RemoveInterface().

func AddInterface Uses

func AddInterface(c *gophercloud.ServiceClient, id string, opts InterfaceOpts) InterfaceResult

AddInterface attaches a subnet to an internal router interface. You must specify either a SubnetID or PortID in the request body. If you specify both, the operation will fail and an error will be returned.

If you specify a SubnetID, the gateway IP address for that particular subnet is used to create the router interface. Alternatively, if you specify a PortID, the IP address associated with the port is used to create the router interface.

If you reference a port that is associated with multiple IP addresses, or if the port is associated with zero IP addresses, the operation will fail and a 400 Bad Request error will be returned.

If you reference a port already in use, the operation will fail and a 409 Conflict error will be returned.

The PortID that is returned after using Extract() on the result of this operation can either be the same PortID passed in or, on the other hand, the identifier of a new port created by this operation. After the operation completes, the device ID of the port is set to the router ID, and the device owner attribute is set to `network:router_interface'.

func RemoveInterface Uses

func RemoveInterface(c *gophercloud.ServiceClient, id string, opts InterfaceOpts) InterfaceResult

RemoveInterface removes an internal router interface, which detaches a subnet from the router. You must specify either a SubnetID or PortID, since these values are used to identify the router interface to remove.

Unlike AddInterface, you can also specify both a SubnetID and PortID. If you choose to specify both, the subnet ID must correspond to the subnet ID of the first IP address on the port specified by the port ID. Otherwise, the operation will fail and return a 409 Conflict error.

If the router, subnet or port which are referenced do not exist or are not visible to you, the operation will fail and a 404 Not Found error will be returned. After this operation completes, the port connecting the router with the subnet is removed from the subnet for the network.

func (InterfaceResult) Extract Uses

func (r InterfaceResult) Extract() (*InterfaceInfo, error)

Extract is a function that accepts a result and extracts an information struct.

type ListOpts Uses

type ListOpts struct {
    ID           string `q:"id"`
    Name         string `q:"name"`
    AdminStateUp *bool  `q:"admin_state_up"`
    Distributed  *bool  `q:"distributed"`
    Status       string `q:"status"`
    TenantID     string `q:"tenant_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 floating IP attributes you want to see returned. SortKey allows you to sort by a particular network attribute. SortDir sets the direction, and is either `asc' or `desc'. Marker and Limit are used for pagination.

type Route Uses

type Route struct {
    NextHop         string `mapstructure:"nexthop" json:"nexthop"`
    DestinationCIDR string `mapstructure:"destination" json:"destination"`
}

type Router Uses

type Router struct {
    // Indicates whether or not a router is currently operational.
    Status string `json:"status" mapstructure:"status"`

    // Information on external gateway for the router.
    GatewayInfo GatewayInfo `json:"external_gateway_info" mapstructure:"external_gateway_info"`

    // Administrative state of the router.
    AdminStateUp bool `json:"admin_state_up" mapstructure:"admin_state_up"`

    // Whether router is disitrubted or not..
    Distributed bool `json:"distributed" mapstructure:"distributed"`

    // Human readable name for the router. Does not have to be unique.
    Name string `json:"name" mapstructure:"name"`

    // Unique identifier for the router.
    ID  string `json:"id" mapstructure:"id"`

    // Owner of the router. Only admin users can specify a tenant identifier
    // other than its own.
    TenantID string `json:"tenant_id" mapstructure:"tenant_id"`

    Routes []Route `json:"routes" mapstructure:"routes"`
}

Router represents a Neutron router. A router is a logical entity that forwards packets across internal subnets and NATs (network address translation) them on external networks through an appropriate gateway.

A router has an interface for each subnet with which it is associated. By default, the IP address of such interface is the subnet's gateway IP. Also, whenever a router is associated with a subnet, a port for that router interface is added to the subnet's network.

type RouterPage Uses

type RouterPage struct {
    pagination.LinkedPageBase
}

RouterPage is the page returned by a pager when traversing over a collection of routers.

func (RouterPage) IsEmpty Uses

func (p RouterPage) IsEmpty() (bool, error)

IsEmpty checks whether a RouterPage struct is empty.

func (RouterPage) NextPageURL Uses

func (p RouterPage) NextPageURL() (string, error)

NextPageURL is invoked when a paginated collection of routers 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 UpdateOpts Uses

type UpdateOpts struct {
    Name         string
    AdminStateUp *bool
    Distributed  *bool
    GatewayInfo  *GatewayInfo
    Routes       []Route
}

UpdateOpts contains the values used when updating a router.

type UpdateResult Uses

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

UpdateResult represents the result of an update operation.

func Update Uses

func Update(c *gophercloud.ServiceClient, id string, opts UpdateOpts) UpdateResult

Update allows routers to be updated. You can update the name, administrative state, and the external gateway. For more information about how to set the external gateway for a router, see Create. This operation does not enable the update of router interfaces. To do this, use the AddInterface and RemoveInterface functions.

func (UpdateResult) Extract Uses

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

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

Package routers imports 4 packages (graph) and is imported by 34 packages. Updated 2016-07-23. Refresh now. Tools for package owners.