// Delete deletes the interface with interfaceID attached to the instance with // instanceID. func Delete(c *gophercloud.ServiceClient, instanceID, interfaceID string) DeleteResult { var res DeleteResult _, res.Err = c.Request("DELETE", deleteURL(c, instanceID, interfaceID), gophercloud.RequestOpts{ OkCodes: []int{200, 204}, }) return res }
// Get is a function that retrieves an account's metadata. To extract just the // custom metadata, call the ExtractMetadata method on the GetResult. To extract // all the headers that are returned (including the metadata), call the // ExtractHeader method on the GetResult. func Get(c *gophercloud.ServiceClient, opts GetOptsBuilder) GetResult { var res GetResult h := c.AuthenticatedHeaders() if opts != nil { headers, err := opts.ToAccountGetMap() if err != nil { res.Err = err return res } for k, v := range headers { h[k] = v } } resp, err := c.Request("HEAD", getURL(c), gophercloud.RequestOpts{ MoreHeaders: h, OkCodes: []int{204}, }) if resp != nil { res.Header = resp.Header } res.Err = err return res }
// Delete is the operation responsible for permanently deleting a VIP. func Delete(c *gophercloud.ServiceClient, lbID, vipID int) DeleteResult { var res DeleteResult _, res.Err = c.Request("DELETE", resourceURL(c, lbID, vipID), gophercloud.RequestOpts{ OkCodes: []int{202}, }) return res }
// Update changes an existing endpoint with new data. // All fields are optional in the provided EndpointOpts. func Update(client *gophercloud.ServiceClient, endpointID string, opts EndpointOpts) UpdateResult { type endpoint struct { Interface *string `json:"interface,omitempty"` Name *string `json:"name,omitempty"` Region *string `json:"region,omitempty"` URL *string `json:"url,omitempty"` ServiceID *string `json:"service_id,omitempty"` } type request struct { Endpoint endpoint `json:"endpoint"` } reqBody := request{Endpoint: endpoint{}} reqBody.Endpoint.Interface = gophercloud.MaybeString(string(opts.Availability)) reqBody.Endpoint.Name = gophercloud.MaybeString(opts.Name) reqBody.Endpoint.Region = gophercloud.MaybeString(opts.Region) reqBody.Endpoint.URL = gophercloud.MaybeString(opts.URL) reqBody.Endpoint.ServiceID = gophercloud.MaybeString(opts.ServiceID) var result UpdateResult _, result.Err = client.Request("PATCH", endpointURL(client, endpointID), gophercloud.RequestOpts{ JSONBody: &reqBody, JSONResponse: &result.Body, OkCodes: []int{200}, }) return result }
// Update is a function that creates, updates, or deletes an object's metadata. func Update(c *gophercloud.ServiceClient, containerName, objectName string, opts UpdateOptsBuilder) UpdateResult { var res UpdateResult h := c.AuthenticatedHeaders() if opts != nil { headers, err := opts.ToObjectUpdateMap() if err != nil { res.Err = err return res } for k, v := range headers { h[k] = v } } url := updateURL(c, containerName, objectName) resp, err := c.Request("POST", url, gophercloud.RequestOpts{ MoreHeaders: h, }) if resp != nil { res.Header = resp.Header } res.Err = err return res }
// GetPassword makes a request against the nova API to get the encrypted administrative password. func GetPassword(client *gophercloud.ServiceClient, serverId string) GetPasswordResult { var res GetPasswordResult _, res.Err = client.Request("GET", passwordURL(client, serverId), gophercloud.RequestOpts{ JSONResponse: &res.Body, }) return res }
// Get retreives data for the given stack template. func Get(c *gophercloud.ServiceClient, stackName, stackID string) GetResult { var res GetResult _, res.Err = c.Request("GET", getURL(c, stackName, stackID), gophercloud.RequestOpts{ JSONResponse: &res.Body, }) return res }
// Create is a function that creates a new object or replaces an existing object. func Create(c *gophercloud.ServiceClient, containerName, objectName string, content io.ReadSeeker, opts CreateOptsBuilder) CreateResult { var res CreateResult url := createURL(c, containerName, objectName) h := make(map[string]string) if opts != nil { headers, query, err := opts.ToObjectCreateParams() if err != nil { res.Err = err return res } for k, v := range headers { h[k] = v } url += query } ropts := gophercloud.RequestOpts{ RawBody: content, MoreHeaders: h, } resp, err := c.Request("PUT", url, ropts) if resp != nil { res.Header = resp.Header } res.Err = err return res }
// Delete is a function that deletes a container. func Delete(c *gophercloud.ServiceClient, containerName string) DeleteResult { var res DeleteResult _, res.Err = c.Request("DELETE", deleteURL(c, containerName), gophercloud.RequestOpts{ OkCodes: []int{202, 204}, }) return res }
// Create is a function that creates a new container. func Create(c *gophercloud.ServiceClient, containerName string, opts CreateOptsBuilder) CreateResult { var res CreateResult h := make(map[string]string) if opts != nil { headers, err := opts.ToContainerCreateMap() if err != nil { res.Err = err return res } for k, v := range headers { h[k] = v } } resp, err := c.Request("PUT", createURL(c, containerName), gophercloud.RequestOpts{ MoreHeaders: h, OkCodes: []int{201, 202, 204}, }) if resp != nil { res.Header = resp.Header } res.Err = err return res }
// Update allows floating IP resources to be updated. Currently, the only way to // "update" a floating IP is to associate it with a new internal port, or // disassociated it from all ports. See UpdateOpts for instructions of how to // do this. func Update(c *gophercloud.ServiceClient, id string, opts UpdateOpts) UpdateResult { type floatingIP struct { PortID *string `json:"port_id"` } type request struct { FloatingIP floatingIP `json:"floatingip"` } var portID *string if opts.PortID == "" { portID = nil } else { portID = &opts.PortID } reqBody := request{FloatingIP: floatingIP{PortID: portID}} // Send request to API var res UpdateResult _, res.Err = c.Request("PUT", resourceURL(c, id), gophercloud.RequestOpts{ JSONBody: &reqBody, JSONResponse: &res.Body, OkCodes: []int{200}, }) return res }
// Create accepts a CreateOpts struct and uses the values to create a new // load balancer pool member. func Create(c *gophercloud.ServiceClient, opts CreateOpts) CreateResult { type member struct { TenantID string `json:"tenant_id,omitempty"` ProtocolPort int `json:"protocol_port"` Address string `json:"address"` PoolID string `json:"pool_id"` } type request struct { Member member `json:"member"` } reqBody := request{Member: member{ Address: opts.Address, TenantID: opts.TenantID, ProtocolPort: opts.ProtocolPort, PoolID: opts.PoolID, }} var res CreateResult _, res.Err = c.Request("POST", rootURL(c), gophercloud.RequestOpts{ JSONBody: &reqBody, JSONResponse: &res.Body, OkCodes: []int{201}, }) return res }
// 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 Create(c *gophercloud.ServiceClient, opts CreateOpts) CreateResult { type router struct { Name *string `json:"name,omitempty"` AdminStateUp *bool `json:"admin_state_up,omitempty"` TenantID *string `json:"tenant_id,omitempty"` GatewayInfo *GatewayInfo `json:"external_gateway_info,omitempty"` } type request struct { Router router `json:"router"` } reqBody := request{Router: router{ Name: gophercloud.MaybeString(opts.Name), AdminStateUp: opts.AdminStateUp, TenantID: gophercloud.MaybeString(opts.TenantID), }} if opts.GatewayInfo != nil { reqBody.Router.GatewayInfo = opts.GatewayInfo } var res CreateResult _, res.Err = c.Request("POST", rootURL(c), gophercloud.RequestOpts{ JSONBody: &reqBody, JSONResponse: &res.Body, OkCodes: []int{201}, }) return res }
// 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 Update(c *gophercloud.ServiceClient, id string, opts UpdateOpts) UpdateResult { type router struct { Name *string `json:"name,omitempty"` AdminStateUp *bool `json:"admin_state_up,omitempty"` GatewayInfo *GatewayInfo `json:"external_gateway_info,omitempty"` } type request struct { Router router `json:"router"` } reqBody := request{Router: router{ Name: gophercloud.MaybeString(opts.Name), AdminStateUp: opts.AdminStateUp, }} if opts.GatewayInfo != nil { reqBody.Router.GatewayInfo = opts.GatewayInfo } // Send request to API var res UpdateResult _, res.Err = c.Request("PUT", resourceURL(c, id), gophercloud.RequestOpts{ JSONBody: &reqBody, JSONResponse: &res.Body, OkCodes: []int{200}, }) return res }
// Create is the operation responsible for creating a new node on a load // balancer. Since every load balancer exists in both ServiceNet and the public // Internet, both private and public IP addresses can be used for nodes. // // If nodes need time to boot up services before they become operational, you // can temporarily prevent traffic from being sent to that node by setting the // Condition field to DRAINING. Health checks will still be performed; but once // your node is ready, you can update its condition to ENABLED and have it // handle traffic. func Create(client *gophercloud.ServiceClient, loadBalancerID int, opts CreateOptsBuilder) CreateResult { var res CreateResult reqBody, err := opts.ToNodeCreateMap() if err != nil { res.Err = err return res } resp, err := client.Request("POST", rootURL(client, loadBalancerID), gophercloud.RequestOpts{ JSONBody: &reqBody, JSONResponse: &res.Body, OkCodes: []int{202}, }) if err != nil { res.Err = err return res } pr, err := pagination.PageResultFrom(resp) if err != nil { res.Err = err return res } return CreateResult{pagination.SinglePageBase(pr)} }
// Download is a function that retrieves the content and metadata for an object. // To extract just the content, pass the DownloadResult response to the // ExtractContent function. func Download(c *gophercloud.ServiceClient, containerName, objectName string, opts DownloadOptsBuilder) DownloadResult { var res DownloadResult url := downloadURL(c, containerName, objectName) h := c.AuthenticatedHeaders() if opts != nil { headers, query, err := opts.ToObjectDownloadParams() if err != nil { res.Err = err return res } for k, v := range headers { h[k] = v } url += query } resp, err := c.Request("GET", url, gophercloud.RequestOpts{ MoreHeaders: h, OkCodes: []int{200, 304}, }) if resp != nil { res.Header = resp.Header res.Body = resp.Body } res.Err = err return res }
// Create is an operation which provisions a new security group with default // security group rules for the IPv4 and IPv6 ether types. func Create(c *gophercloud.ServiceClient, opts CreateOpts) CreateResult { var res CreateResult // Validate required opts if opts.Name == "" { res.Err = errNameRequired return res } type secgroup struct { Name string `json:"name"` Description string `json:"description,omitempty"` } type request struct { SecGroup secgroup `json:"security_group"` } reqBody := request{SecGroup: secgroup{ Name: opts.Name, Description: opts.Description, }} _, res.Err = c.Request("POST", rootURL(c), gophercloud.RequestOpts{ JSONBody: &reqBody, JSONResponse: &res.Body, OkCodes: []int{201}, }) return res }
// Copy is a function that copies one object to another. func Copy(c *gophercloud.ServiceClient, containerName, objectName string, opts CopyOptsBuilder) CopyResult { var res CopyResult h := c.AuthenticatedHeaders() headers, err := opts.ToObjectCopyMap() if err != nil { res.Err = err return res } for k, v := range headers { h[k] = v } url := copyURL(c, containerName, objectName) resp, err := c.Request("COPY", url, gophercloud.RequestOpts{ MoreHeaders: h, OkCodes: []int{201}, }) if resp != nil { res.Header = resp.Header } res.Err = err return res }
// DisassociateMonitor will disassociate a health monitor with a particular // pool. When dissociation is successful, the health monitor will no longer // check for the health of the members of the pool. func DisassociateMonitor(c *gophercloud.ServiceClient, poolID, monitorID string) AssociateResult { var res AssociateResult _, res.Err = c.Request("DELETE", disassociateURL(c, poolID, monitorID), gophercloud.RequestOpts{ OkCodes: []int{204}, }) return res }
// Delete will delete objects or containers in bulk. func Delete(c *gophercloud.ServiceClient, opts DeleteOptsBuilder) DeleteResult { var res DeleteResult if opts == nil { return res } reqString, err := opts.ToBulkDeleteBody() if err != nil { res.Err = err return res } reqBody := strings.NewReader(reqString) resp, err := c.Request("DELETE", deleteURL(c), gophercloud.RequestOpts{ MoreHeaders: map[string]string{"Content-Type": "text/plain"}, OkCodes: []int{200}, JSONBody: reqBody, JSONResponse: &res.Body, }) res.Header = resp.Header res.Err = err return res }
// Create accepts a CreateOpts struct and uses the values to create a new // load balancer pool. func Create(c *gophercloud.ServiceClient, opts CreateOpts) CreateResult { type pool struct { Name string `json:"name"` TenantID string `json:"tenant_id,omitempty"` Protocol string `json:"protocol"` SubnetID string `json:"subnet_id"` LBMethod string `json:"lb_method"` } type request struct { Pool pool `json:"pool"` } reqBody := request{Pool: pool{ Name: opts.Name, TenantID: opts.TenantID, Protocol: opts.Protocol, SubnetID: opts.SubnetID, LBMethod: opts.LBMethod, }} var res CreateResult _, res.Err = c.Request("POST", rootURL(c), gophercloud.RequestOpts{ JSONBody: &reqBody, JSONResponse: &res.Body, OkCodes: []int{201}, }) return res }
// Metadatum requests the key-value pair with the given key for the given server ID. func Metadatum(client *gophercloud.ServiceClient, id, key string) GetMetadatumResult { var res GetMetadatumResult _, res.Err = client.Request("GET", metadatumURL(client, id, key), gophercloud.RequestOpts{ JSONResponse: &res.Body, }) return res }
// Update is a function that creates, updates, or deletes an account's metadata. // To extract the headers returned, call the Extract method on the UpdateResult. func Update(c *gophercloud.ServiceClient, opts UpdateOptsBuilder) UpdateResult { var res UpdateResult h := make(map[string]string) if opts != nil { headers, err := opts.ToAccountUpdateMap() if err != nil { res.Err = err return res } for k, v := range headers { h[k] = v } } resp, err := c.Request("POST", updateURL(c), gophercloud.RequestOpts{ MoreHeaders: h, OkCodes: []int{201, 202, 204}, }) if resp != nil { res.Header = resp.Header } res.Err = err return res }
// Delete removes an existing service. // It either deletes all associated endpoints, or fails until all endpoints are deleted. func Delete(client *gophercloud.ServiceClient, serviceID string) DeleteResult { var res DeleteResult _, res.Err = client.Request("DELETE", serviceURL(client, serviceID), gophercloud.RequestOpts{ OkCodes: []int{204}, }) return res }
// Update is an operation which modifies the attributes of the specified VIP. func Update(c *gophercloud.ServiceClient, id string, opts UpdateOpts) UpdateResult { type vip struct { Name string `json:"name,omitempty"` PoolID string `json:"pool_id,omitempty"` Description *string `json:"description,omitempty"` Persistence *SessionPersistence `json:"session_persistence,omitempty"` ConnLimit *int `json:"connection_limit,omitempty"` AdminStateUp *bool `json:"admin_state_up,omitempty"` } type request struct { VirtualIP vip `json:"vip"` } reqBody := request{VirtualIP: vip{ Name: opts.Name, PoolID: opts.PoolID, Description: gophercloud.MaybeString(opts.Description), ConnLimit: opts.ConnLimit, AdminStateUp: opts.AdminStateUp, }} if opts.Persistence != nil { reqBody.VirtualIP.Persistence = opts.Persistence } var res UpdateResult _, res.Err = c.Request("PUT", resourceURL(c, id), gophercloud.RequestOpts{ JSONBody: &reqBody, JSONResponse: &res.Body, OkCodes: []int{200, 202}, }) return res }
// Delete will permanently delete a particular firewall rule based on its unique ID. func Delete(c *gophercloud.ServiceClient, id string) DeleteResult { var res DeleteResult _, res.Err = c.Request("DELETE", resourceURL(c, id), gophercloud.RequestOpts{ OkCodes: []int{204}, }) return res }
// Enable is a function that enables/disables a CDN container. func Enable(c *gophercloud.ServiceClient, containerName string, opts EnableOptsBuilder) EnableResult { var res EnableResult h := c.AuthenticatedHeaders() if opts != nil { headers, err := opts.ToCDNContainerEnableMap() if err != nil { res.Err = err return res } for k, v := range headers { h[k] = v } } resp, err := c.Request("PUT", enableURL(c, containerName), gophercloud.RequestOpts{ MoreHeaders: h, OkCodes: []int{201, 202, 204}, }) if resp != nil { res.Header = resp.Header } res.Err = err return res }
// Get returns additional information about a service, given its ID. func Get(client *gophercloud.ServiceClient, serviceID string) GetResult { var result GetResult _, result.Err = client.Request("GET", serviceURL(client, serviceID), gophercloud.RequestOpts{ JSONResponse: &result.Body, OkCodes: []int{200}, }) return result }
// Get retrieves a particular firewall rule based on its unique ID. func Get(c *gophercloud.ServiceClient, id string) GetResult { var res GetResult _, res.Err = c.Request("GET", resourceURL(c, id), gophercloud.RequestOpts{ JSONResponse: &res.Body, OkCodes: []int{200}, }) return res }
// Get returns public data about a previously uploaded KeyPair. func Get(client *gophercloud.ServiceClient, name string) GetResult { var res GetResult _, res.Err = client.Request("GET", getURL(client, name), gophercloud.RequestOpts{ JSONResponse: &res.Body, OkCodes: []int{200}, }) return res }