blob: c6d3a8e42359a9a4e473966eeca77de8b91114bd [file] [log] [blame]
Samuel A. Falvo IIc007c272014-02-10 20:49:26 -08001package servers
2
3import (
Ash Wilson6a310e02014-09-29 08:24:02 -04004 "encoding/base64"
Kevin Pikea2bfaea2015-04-21 11:45:59 -07005 "encoding/json"
Jon Perrittcc77da62014-11-16 13:14:21 -07006 "errors"
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -07007 "fmt"
Ash Wilson01626a32014-09-17 10:38:07 -04008
Jon Perritt27249f42016-02-18 10:35:59 -06009 "github.com/gophercloud/gophercloud"
10 "github.com/gophercloud/gophercloud/openstack/compute/v2/flavors"
Jon Perritt994370e2016-02-18 15:23:34 -060011 "github.com/gophercloud/gophercloud/openstack/compute/v2/images"
Jon Perritt27249f42016-02-18 10:35:59 -060012 "github.com/gophercloud/gophercloud/pagination"
Samuel A. Falvo IIc007c272014-02-10 20:49:26 -080013)
14
Jamie Hannafordbfe33b22014-10-16 12:45:40 +020015// ListOptsBuilder allows extensions to add additional parameters to the
16// List request.
17type ListOptsBuilder interface {
18 ToServerListQuery() (string, error)
19}
Kevin Pike9748b7b2015-05-05 07:34:07 -070020
Jamie Hannafordbfe33b22014-10-16 12:45:40 +020021// ListOpts allows the filtering and sorting of paginated collections through
22// the API. Filtering is achieved by passing in struct field values that map to
23// the server attributes you want to see returned. Marker and Limit are used
24// for pagination.
25type ListOpts struct {
26 // A time/date stamp for when the server last changed status.
27 ChangesSince string `q:"changes-since"`
28
29 // Name of the image in URL format.
30 Image string `q:"image"`
31
32 // Name of the flavor in URL format.
33 Flavor string `q:"flavor"`
34
35 // Name of the server as a string; can be queried with regular expressions.
36 // Realize that ?name=bob returns both bob and bobb. If you need to match bob
37 // only, you can use a regular expression matching the syntax of the
38 // underlying database server implemented for Compute.
39 Name string `q:"name"`
40
41 // Value of the status of the server so that you can filter on "ACTIVE" for example.
42 Status string `q:"status"`
43
44 // Name of the host as a string.
45 Host string `q:"host"`
46
47 // UUID of the server at which you want to set a marker.
48 Marker string `q:"marker"`
49
50 // Integer value for the limit of values to return.
51 Limit int `q:"limit"`
Daniel Speichert9342e522015-06-05 10:31:52 -040052
53 // Bool to show all tenants
54 AllTenants bool `q:"all_tenants"`
Jamie Hannafordbfe33b22014-10-16 12:45:40 +020055}
56
57// ToServerListQuery formats a ListOpts into a query string.
58func (opts ListOpts) ToServerListQuery() (string, error) {
59 q, err := gophercloud.BuildQueryString(opts)
60 if err != nil {
61 return "", err
62 }
63 return q.String(), nil
64}
65
Samuel A. Falvo IIc007c272014-02-10 20:49:26 -080066// List makes a request against the API to list servers accessible to you.
Jamie Hannafordbfe33b22014-10-16 12:45:40 +020067func List(client *gophercloud.ServiceClient, opts ListOptsBuilder) pagination.Pager {
68 url := listDetailURL(client)
69
70 if opts != nil {
71 query, err := opts.ToServerListQuery()
72 if err != nil {
73 return pagination.Pager{Err: err}
74 }
75 url += query
76 }
77
Ash Wilsonb8b16f82014-10-20 10:19:49 -040078 createPageFn := func(r pagination.PageResult) pagination.Page {
79 return ServerPage{pagination.LinkedPageBase{PageResult: r}}
Samuel A. Falvo IIc007c272014-02-10 20:49:26 -080080 }
81
Jamie Hannafordbfe33b22014-10-16 12:45:40 +020082 return pagination.NewPager(client, url, createPageFn)
Samuel A. Falvo IIc007c272014-02-10 20:49:26 -080083}
84
Ash Wilson2206a112014-10-02 10:57:38 -040085// CreateOptsBuilder describes struct types that can be accepted by the Create call.
Ash Wilson6a310e02014-09-29 08:24:02 -040086// The CreateOpts struct in this package does.
Ash Wilson2206a112014-10-02 10:57:38 -040087type CreateOptsBuilder interface {
Jon Perritt4149d7c2014-10-23 21:23:46 -050088 ToServerCreateMap() (map[string]interface{}, error)
Ash Wilson6a310e02014-09-29 08:24:02 -040089}
90
91// Network is used within CreateOpts to control a new server's network attachments.
92type Network struct {
93 // UUID of a nova-network to attach to the newly provisioned server.
94 // Required unless Port is provided.
95 UUID string
96
97 // Port of a neutron network to attach to the newly provisioned server.
98 // Required unless UUID is provided.
99 Port string
100
101 // FixedIP [optional] specifies a fixed IPv4 address to be used on this network.
102 FixedIP string
103}
104
Kevin Pike92e10b52015-04-10 15:16:57 -0700105// Personality is an array of files that are injected into the server at launch.
Kevin Pikea2bfaea2015-04-21 11:45:59 -0700106type Personality []*File
Kevin Pike92e10b52015-04-10 15:16:57 -0700107
108// File is used within CreateOpts and RebuildOpts to inject a file into the server at launch.
Kevin Pike9748b7b2015-05-05 07:34:07 -0700109// File implements the json.Marshaler interface, so when a Create or Rebuild operation is requested,
110// json.Marshal will call File's MarshalJSON method.
Kevin Pike92e10b52015-04-10 15:16:57 -0700111type File struct {
112 // Path of the file
Kevin Pikea2bfaea2015-04-21 11:45:59 -0700113 Path string
Kevin Pike92e10b52015-04-10 15:16:57 -0700114 // Contents of the file. Maximum content size is 255 bytes.
Kevin Pikea2bfaea2015-04-21 11:45:59 -0700115 Contents []byte
Kevin Pike92e10b52015-04-10 15:16:57 -0700116}
117
Kevin Pikea2bfaea2015-04-21 11:45:59 -0700118// MarshalJSON marshals the escaped file, base64 encoding the contents.
119func (f *File) MarshalJSON() ([]byte, error) {
120 file := struct {
121 Path string `json:"path"`
122 Contents string `json:"contents"`
123 }{
124 Path: f.Path,
125 Contents: base64.StdEncoding.EncodeToString(f.Contents),
Kevin Pike92e10b52015-04-10 15:16:57 -0700126 }
Kevin Pikea2bfaea2015-04-21 11:45:59 -0700127 return json.Marshal(file)
Kevin Pike92e10b52015-04-10 15:16:57 -0700128}
129
Ash Wilson6a310e02014-09-29 08:24:02 -0400130// CreateOpts specifies server creation parameters.
131type CreateOpts struct {
132 // Name [required] is the name to assign to the newly launched server.
jrperrittb1013232016-02-10 19:01:53 -0600133 Name string `b:"name,required"`
Ash Wilson6a310e02014-09-29 08:24:02 -0400134
Jon Perrittad5f1cb2015-05-20 10:38:13 -0600135 // ImageRef [optional; required if ImageName is not provided] is the ID or full
136 // URL to the image that contains the server's OS and initial state.
137 // Also optional if using the boot-from-volume extension.
Ash Wilson6a310e02014-09-29 08:24:02 -0400138 ImageRef string
139
Jon Perrittad5f1cb2015-05-20 10:38:13 -0600140 // ImageName [optional; required if ImageRef is not provided] is the name of the
141 // image that contains the server's OS and initial state.
142 // Also optional if using the boot-from-volume extension.
143 ImageName string
144
145 // FlavorRef [optional; required if FlavorName is not provided] is the ID or
146 // full URL to the flavor that describes the server's specs.
Ash Wilson6a310e02014-09-29 08:24:02 -0400147 FlavorRef string
148
Jon Perrittad5f1cb2015-05-20 10:38:13 -0600149 // FlavorName [optional; required if FlavorRef is not provided] is the name of
150 // the flavor that describes the server's specs.
151 FlavorName string
152
Ash Wilson6a310e02014-09-29 08:24:02 -0400153 // SecurityGroups [optional] lists the names of the security groups to which this server should belong.
154 SecurityGroups []string
155
156 // UserData [optional] contains configuration information or scripts to use upon launch.
157 // Create will base64-encode it for you.
158 UserData []byte
159
160 // AvailabilityZone [optional] in which to launch the server.
161 AvailabilityZone string
162
163 // Networks [optional] dictates how this server will be attached to available networks.
164 // By default, the server will be attached to all isolated networks for the tenant.
165 Networks []Network
166
167 // Metadata [optional] contains key-value pairs (up to 255 bytes each) to attach to the server.
168 Metadata map[string]string
169
Kevin Pike92e10b52015-04-10 15:16:57 -0700170 // Personality [optional] includes files to inject into the server at launch.
171 // Create will base64-encode file contents for you.
172 Personality Personality
Ash Wilson6a310e02014-09-29 08:24:02 -0400173
174 // ConfigDrive [optional] enables metadata injection through a configuration drive.
175 ConfigDrive bool
Jon Perrittf3b2e142014-11-04 16:00:19 -0600176
177 // AdminPass [optional] sets the root user password. If not set, a randomly-generated
178 // password will be created and returned in the response.
179 AdminPass string
Jon Perritt7b9671c2015-02-01 22:03:14 -0700180
181 // AccessIPv4 [optional] specifies an IPv4 address for the instance.
182 AccessIPv4 string
183
184 // AccessIPv6 [optional] specifies an IPv6 address for the instance.
185 AccessIPv6 string
Jon Perritt994370e2016-02-18 15:23:34 -0600186
187 // ServiceClient [optional] will allow calls to be made to retrieve an image or
188 // flavor ID by name.
189 ServiceClient *gophercloud.ServiceClient
Ash Wilson6a310e02014-09-29 08:24:02 -0400190}
191
Ash Wilsone45c9732014-09-29 10:54:12 -0400192// ToServerCreateMap assembles a request body based on the contents of a CreateOpts.
Jon Perritt4149d7c2014-10-23 21:23:46 -0500193func (opts CreateOpts) ToServerCreateMap() (map[string]interface{}, error) {
Ash Wilson6a310e02014-09-29 08:24:02 -0400194 server := make(map[string]interface{})
195
196 server["name"] = opts.Name
197 server["imageRef"] = opts.ImageRef
198 server["flavorRef"] = opts.FlavorRef
199
200 if opts.UserData != nil {
201 encoded := base64.StdEncoding.EncodeToString(opts.UserData)
202 server["user_data"] = &encoded
203 }
Ash Wilson6a310e02014-09-29 08:24:02 -0400204 if opts.ConfigDrive {
205 server["config_drive"] = "true"
206 }
207 if opts.AvailabilityZone != "" {
208 server["availability_zone"] = opts.AvailabilityZone
209 }
210 if opts.Metadata != nil {
211 server["metadata"] = opts.Metadata
212 }
Jon Perrittf3b2e142014-11-04 16:00:19 -0600213 if opts.AdminPass != "" {
214 server["adminPass"] = opts.AdminPass
215 }
Jon Perritt7b9671c2015-02-01 22:03:14 -0700216 if opts.AccessIPv4 != "" {
217 server["accessIPv4"] = opts.AccessIPv4
218 }
219 if opts.AccessIPv6 != "" {
220 server["accessIPv6"] = opts.AccessIPv6
221 }
Ash Wilson6a310e02014-09-29 08:24:02 -0400222
223 if len(opts.SecurityGroups) > 0 {
224 securityGroups := make([]map[string]interface{}, len(opts.SecurityGroups))
225 for i, groupName := range opts.SecurityGroups {
226 securityGroups[i] = map[string]interface{}{"name": groupName}
227 }
eselldf709942014-11-13 21:07:11 -0700228 server["security_groups"] = securityGroups
Ash Wilson6a310e02014-09-29 08:24:02 -0400229 }
Jon Perritt2a7797d2014-10-21 15:08:43 -0500230
Ash Wilson6a310e02014-09-29 08:24:02 -0400231 if len(opts.Networks) > 0 {
232 networks := make([]map[string]interface{}, len(opts.Networks))
233 for i, net := range opts.Networks {
234 networks[i] = make(map[string]interface{})
235 if net.UUID != "" {
236 networks[i]["uuid"] = net.UUID
237 }
238 if net.Port != "" {
239 networks[i]["port"] = net.Port
240 }
241 if net.FixedIP != "" {
242 networks[i]["fixed_ip"] = net.FixedIP
243 }
244 }
Jon Perritt2a7797d2014-10-21 15:08:43 -0500245 server["networks"] = networks
Ash Wilson6a310e02014-09-29 08:24:02 -0400246 }
247
Kevin Pike92e10b52015-04-10 15:16:57 -0700248 if len(opts.Personality) > 0 {
Kevin Pikea2bfaea2015-04-21 11:45:59 -0700249 server["personality"] = opts.Personality
Kevin Pike92e10b52015-04-10 15:16:57 -0700250 }
251
jrperrittb1013232016-02-10 19:01:53 -0600252 // If ImageRef isn't provided, use ImageName to ascertain the image ID.
253 if opts.ImageRef == "" {
254 if opts.ImageName == "" {
255 return nil, errors.New("One and only one of ImageRef and ImageName must be provided.")
256 }
Jon Perritt994370e2016-02-18 15:23:34 -0600257 if opts.ServiceClient == nil {
258 return nil, errors.New("A service client must be provided to find an image ID by name.")
259 }
260 imageID, err := images.IDFromName(opts.ServiceClient, opts.ImageName)
jrperrittb1013232016-02-10 19:01:53 -0600261 if err != nil {
262 return nil, err
263 }
264 server["imageRef"] = imageID
265 }
266
267 // If FlavorRef isn't provided, use FlavorName to ascertain the flavor ID.
268 if opts.FlavorRef == "" {
269 if opts.FlavorName == "" {
270 return nil, errors.New("One and only one of FlavorRef and FlavorName must be provided.")
271 }
Jon Perritt994370e2016-02-18 15:23:34 -0600272 if opts.ServiceClient == nil {
273 return nil, errors.New("A service client must be provided to find a flavor ID by name.")
274 }
275 flavorID, err := flavors.IDFromName(opts.ServiceClient, opts.FlavorName)
jrperrittb1013232016-02-10 19:01:53 -0600276 if err != nil {
277 return nil, err
278 }
279 server["flavorRef"] = flavorID
280 }
281
Jon Perritt4149d7c2014-10-23 21:23:46 -0500282 return map[string]interface{}{"server": server}, nil
Ash Wilson6a310e02014-09-29 08:24:02 -0400283}
284
Samuel A. Falvo IIce000732014-02-13 18:53:53 -0800285// Create requests a server to be provisioned to the user in the current tenant.
Ash Wilson2206a112014-10-02 10:57:38 -0400286func Create(client *gophercloud.ServiceClient, opts CreateOptsBuilder) CreateResult {
Jon Perritt4149d7c2014-10-23 21:23:46 -0500287 var res CreateResult
288
289 reqBody, err := opts.ToServerCreateMap()
290 if err != nil {
291 res.Err = err
292 return res
293 }
294
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100295 _, res.Err = client.Post(listURL(client), reqBody, &res.Body, nil)
Jon Perritt4149d7c2014-10-23 21:23:46 -0500296 return res
Samuel A. Falvo IIce000732014-02-13 18:53:53 -0800297}
298
299// Delete requests that a server previously provisioned be removed from your account.
Jamie Hannaford34732fe2014-10-27 11:29:36 +0100300func Delete(client *gophercloud.ServiceClient, id string) DeleteResult {
301 var res DeleteResult
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100302 _, res.Err = client.Delete(deleteURL(client, id), nil)
Jamie Hannaford34732fe2014-10-27 11:29:36 +0100303 return res
Samuel A. Falvo IIce000732014-02-13 18:53:53 -0800304}
305
Ian Duffy370c4302016-01-21 10:44:56 +0000306func ForceDelete(client *gophercloud.ServiceClient, id string) ActionResult {
307 var req struct {
308 ForceDelete string `json:"forceDelete"`
309 }
310
311 var res ActionResult
312 _, res.Err = client.Post(actionURL(client, id), req, nil, nil)
313 return res
314
315}
316
Ash Wilson7ddf0362014-09-17 10:59:09 -0400317// Get requests details on a single server, by ID.
Ash Wilsond27e0ff2014-09-25 11:50:31 -0400318func Get(client *gophercloud.ServiceClient, id string) GetResult {
319 var result GetResult
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100320 _, result.Err = client.Get(getURL(client, id), &result.Body, &gophercloud.RequestOpts{
321 OkCodes: []int{200, 203},
Samuel A. Falvo IIce000732014-02-13 18:53:53 -0800322 })
Ash Wilsond27e0ff2014-09-25 11:50:31 -0400323 return result
Samuel A. Falvo IIce000732014-02-13 18:53:53 -0800324}
325
Alex Gaynora6d5f9f2014-10-27 10:52:32 -0700326// UpdateOptsBuilder allows extensions to add additional attributes to the Update request.
Jon Perritt82048212014-10-13 22:33:13 -0500327type UpdateOptsBuilder interface {
Ash Wilsone45c9732014-09-29 10:54:12 -0400328 ToServerUpdateMap() map[string]interface{}
Ash Wilsondcbc8fb2014-09-29 09:05:44 -0400329}
330
331// UpdateOpts specifies the base attributes that may be updated on an existing server.
332type UpdateOpts struct {
333 // Name [optional] changes the displayed name of the server.
334 // The server host name will *not* change.
335 // Server names are not constrained to be unique, even within the same tenant.
336 Name string
337
338 // AccessIPv4 [optional] provides a new IPv4 address for the instance.
339 AccessIPv4 string
340
341 // AccessIPv6 [optional] provides a new IPv6 address for the instance.
342 AccessIPv6 string
343}
344
Ash Wilsone45c9732014-09-29 10:54:12 -0400345// ToServerUpdateMap formats an UpdateOpts structure into a request body.
346func (opts UpdateOpts) ToServerUpdateMap() map[string]interface{} {
Ash Wilsondcbc8fb2014-09-29 09:05:44 -0400347 server := make(map[string]string)
348 if opts.Name != "" {
349 server["name"] = opts.Name
350 }
351 if opts.AccessIPv4 != "" {
352 server["accessIPv4"] = opts.AccessIPv4
353 }
354 if opts.AccessIPv6 != "" {
355 server["accessIPv6"] = opts.AccessIPv6
356 }
357 return map[string]interface{}{"server": server}
358}
359
Samuel A. Falvo II22d3b772014-02-13 19:27:05 -0800360// Update requests that various attributes of the indicated server be changed.
Jon Perritt82048212014-10-13 22:33:13 -0500361func Update(client *gophercloud.ServiceClient, id string, opts UpdateOptsBuilder) UpdateResult {
Ash Wilsond27e0ff2014-09-25 11:50:31 -0400362 var result UpdateResult
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100363 reqBody := opts.ToServerUpdateMap()
364 _, result.Err = client.Put(updateURL(client, id), reqBody, &result.Body, &gophercloud.RequestOpts{
365 OkCodes: []int{200},
Samuel A. Falvo II22d3b772014-02-13 19:27:05 -0800366 })
Ash Wilsond27e0ff2014-09-25 11:50:31 -0400367 return result
Samuel A. Falvo II22d3b772014-02-13 19:27:05 -0800368}
Samuel A. Falvo IIca5f9a32014-03-11 17:52:58 -0700369
Ash Wilson01626a32014-09-17 10:38:07 -0400370// ChangeAdminPassword alters the administrator or root password for a specified server.
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200371func ChangeAdminPassword(client *gophercloud.ServiceClient, id, newPassword string) ActionResult {
Ash Wilsondc7daa82014-09-23 16:34:42 -0400372 var req struct {
373 ChangePassword struct {
374 AdminPass string `json:"adminPass"`
375 } `json:"changePassword"`
376 }
377
378 req.ChangePassword.AdminPass = newPassword
379
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200380 var res ActionResult
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100381 _, res.Err = client.Post(actionURL(client, id), req, nil, nil)
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200382 return res
Samuel A. Falvo IIca5f9a32014-03-11 17:52:58 -0700383}
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700384
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700385// ErrArgument errors occur when an argument supplied to a package function
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700386// fails to fall within acceptable values. For example, the Reboot() function
387// expects the "how" parameter to be one of HardReboot or SoftReboot. These
388// constants are (currently) strings, leading someone to wonder if they can pass
389// other string values instead, perhaps in an effort to break the API of their
390// provider. Reboot() returns this error in this situation.
391//
392// Function identifies which function was called/which function is generating
393// the error.
394// Argument identifies which formal argument was responsible for producing the
395// error.
396// Value provides the value as it was passed into the function.
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700397type ErrArgument struct {
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700398 Function, Argument string
Jon Perritt30558642014-04-14 17:07:12 -0500399 Value interface{}
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700400}
401
402// Error yields a useful diagnostic for debugging purposes.
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700403func (e *ErrArgument) Error() string {
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700404 return fmt.Sprintf("Bad argument in call to %s, formal parameter %s, value %#v", e.Function, e.Argument, e.Value)
405}
406
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700407func (e *ErrArgument) String() string {
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700408 return e.Error()
409}
410
Ash Wilson01626a32014-09-17 10:38:07 -0400411// RebootMethod describes the mechanisms by which a server reboot can be requested.
412type RebootMethod string
413
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700414// These constants determine how a server should be rebooted.
415// See the Reboot() function for further details.
416const (
Ash Wilson01626a32014-09-17 10:38:07 -0400417 SoftReboot RebootMethod = "SOFT"
418 HardReboot RebootMethod = "HARD"
419 OSReboot = SoftReboot
420 PowerCycle = HardReboot
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700421)
422
423// Reboot requests that a given server reboot.
424// Two methods exist for rebooting a server:
425//
Ash Wilson01626a32014-09-17 10:38:07 -0400426// HardReboot (aka PowerCycle) restarts the server instance by physically cutting power to the machine, or if a VM,
427// terminating it at the hypervisor level.
428// It's done. Caput. Full stop.
429// Then, after a brief while, power is restored or the VM instance restarted.
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700430//
Ash Wilson01626a32014-09-17 10:38:07 -0400431// SoftReboot (aka OSReboot) simply tells the OS to restart under its own procedures.
432// E.g., in Linux, asking it to enter runlevel 6, or executing "sudo shutdown -r now", or by asking Windows to restart the machine.
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200433func Reboot(client *gophercloud.ServiceClient, id string, how RebootMethod) ActionResult {
434 var res ActionResult
435
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700436 if (how != SoftReboot) && (how != HardReboot) {
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200437 res.Err = &ErrArgument{
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700438 Function: "Reboot",
439 Argument: "how",
Jon Perritt30558642014-04-14 17:07:12 -0500440 Value: how,
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700441 }
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200442 return res
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700443 }
Jon Perritt30558642014-04-14 17:07:12 -0500444
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100445 reqBody := struct {
446 C map[string]string `json:"reboot"`
447 }{
448 map[string]string{"type": string(how)},
449 }
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200450
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100451 _, res.Err = client.Post(actionURL(client, id), reqBody, nil, nil)
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200452 return res
Samuel A. Falvo II41c9f612014-03-11 19:00:10 -0700453}
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700454
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200455// RebuildOptsBuilder is an interface that allows extensions to override the
456// default behaviour of rebuild options
457type RebuildOptsBuilder interface {
458 ToServerRebuildMap() (map[string]interface{}, error)
459}
460
461// RebuildOpts represents the configuration options used in a server rebuild
462// operation
463type RebuildOpts struct {
464 // Required. The ID of the image you want your server to be provisioned on
Jamie Hannaforddcb8c272014-10-16 16:34:41 +0200465 ImageID string
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200466
467 // Name to set the server to
Jamie Hannaforddcb8c272014-10-16 16:34:41 +0200468 Name string
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200469
470 // Required. The server's admin password
Jamie Hannaforddcb8c272014-10-16 16:34:41 +0200471 AdminPass string
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200472
473 // AccessIPv4 [optional] provides a new IPv4 address for the instance.
Jamie Hannaforddcb8c272014-10-16 16:34:41 +0200474 AccessIPv4 string
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200475
476 // AccessIPv6 [optional] provides a new IPv6 address for the instance.
Jamie Hannaforddcb8c272014-10-16 16:34:41 +0200477 AccessIPv6 string
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200478
479 // Metadata [optional] contains key-value pairs (up to 255 bytes each) to attach to the server.
Jamie Hannaforddcb8c272014-10-16 16:34:41 +0200480 Metadata map[string]string
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200481
Kevin Pike92e10b52015-04-10 15:16:57 -0700482 // Personality [optional] includes files to inject into the server at launch.
483 // Rebuild will base64-encode file contents for you.
484 Personality Personality
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200485}
486
487// ToServerRebuildMap formats a RebuildOpts struct into a map for use in JSON
488func (opts RebuildOpts) ToServerRebuildMap() (map[string]interface{}, error) {
489 var err error
490 server := make(map[string]interface{})
491
492 if opts.AdminPass == "" {
493 err = fmt.Errorf("AdminPass is required")
494 }
495
496 if opts.ImageID == "" {
497 err = fmt.Errorf("ImageID is required")
498 }
499
500 if err != nil {
501 return server, err
502 }
503
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200504 server["adminPass"] = opts.AdminPass
505 server["imageRef"] = opts.ImageID
506
Jon Perritt12395212016-02-24 10:41:17 -0600507 if opts.Name != "" {
508 server["name"] = opts.Name
509 }
510
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200511 if opts.AccessIPv4 != "" {
512 server["accessIPv4"] = opts.AccessIPv4
513 }
514
515 if opts.AccessIPv6 != "" {
516 server["accessIPv6"] = opts.AccessIPv6
517 }
518
519 if opts.Metadata != nil {
520 server["metadata"] = opts.Metadata
521 }
522
Kevin Pike92e10b52015-04-10 15:16:57 -0700523 if len(opts.Personality) > 0 {
Kevin Pikea2bfaea2015-04-21 11:45:59 -0700524 server["personality"] = opts.Personality
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200525 }
526
527 return map[string]interface{}{"rebuild": server}, nil
528}
529
530// Rebuild will reprovision the server according to the configuration options
531// provided in the RebuildOpts struct.
532func Rebuild(client *gophercloud.ServiceClient, id string, opts RebuildOptsBuilder) RebuildResult {
Ash Wilsond27e0ff2014-09-25 11:50:31 -0400533 var result RebuildResult
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700534
535 if id == "" {
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200536 result.Err = fmt.Errorf("ID is required")
Ash Wilsond27e0ff2014-09-25 11:50:31 -0400537 return result
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700538 }
539
Jamie Hannaford6c9eb602014-10-16 16:28:07 +0200540 reqBody, err := opts.ToServerRebuildMap()
541 if err != nil {
542 result.Err = err
Ash Wilsond27e0ff2014-09-25 11:50:31 -0400543 return result
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700544 }
545
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100546 _, result.Err = client.Post(actionURL(client, id), reqBody, &result.Body, nil)
Ash Wilsond27e0ff2014-09-25 11:50:31 -0400547 return result
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700548}
549
Ash Wilson5f7cf182014-10-23 08:35:24 -0400550// ResizeOptsBuilder is an interface that allows extensions to override the default structure of
551// a Resize request.
552type ResizeOptsBuilder interface {
553 ToServerResizeMap() (map[string]interface{}, error)
554}
555
556// ResizeOpts represents the configuration options used to control a Resize operation.
557type ResizeOpts struct {
558 // FlavorRef is the ID of the flavor you wish your server to become.
559 FlavorRef string
560}
561
Alex Gaynor266e9332014-10-28 14:44:04 -0700562// ToServerResizeMap formats a ResizeOpts as a map that can be used as a JSON request body for the
Ash Wilson5f7cf182014-10-23 08:35:24 -0400563// Resize request.
564func (opts ResizeOpts) ToServerResizeMap() (map[string]interface{}, error) {
565 resize := map[string]interface{}{
566 "flavorRef": opts.FlavorRef,
567 }
568
569 return map[string]interface{}{"resize": resize}, nil
570}
571
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700572// Resize instructs the provider to change the flavor of the server.
Ash Wilson01626a32014-09-17 10:38:07 -0400573// Note that this implies rebuilding it.
574// Unfortunately, one cannot pass rebuild parameters to the resize function.
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700575// When the resize completes, the server will be in RESIZE_VERIFY state.
576// While in this state, you can explore the use of the new server's configuration.
577// If you like it, call ConfirmResize() to commit the resize permanently.
578// Otherwise, call RevertResize() to restore the old configuration.
Ash Wilson9e87a922014-10-23 14:29:22 -0400579func Resize(client *gophercloud.ServiceClient, id string, opts ResizeOptsBuilder) ActionResult {
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200580 var res ActionResult
Ash Wilson5f7cf182014-10-23 08:35:24 -0400581 reqBody, err := opts.ToServerResizeMap()
582 if err != nil {
583 res.Err = err
584 return res
585 }
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200586
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100587 _, res.Err = client.Post(actionURL(client, id), reqBody, nil, nil)
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200588 return res
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700589}
590
591// ConfirmResize confirms a previous resize operation on a server.
592// See Resize() for more details.
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200593func ConfirmResize(client *gophercloud.ServiceClient, id string) ActionResult {
594 var res ActionResult
595
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100596 reqBody := map[string]interface{}{"confirmResize": nil}
597 _, res.Err = client.Post(actionURL(client, id), reqBody, nil, &gophercloud.RequestOpts{
598 OkCodes: []int{201, 202, 204},
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700599 })
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200600 return res
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700601}
602
603// RevertResize cancels a previous resize operation on a server.
604// See Resize() for more details.
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200605func RevertResize(client *gophercloud.ServiceClient, id string) ActionResult {
606 var res ActionResult
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100607 reqBody := map[string]interface{}{"revertResize": nil}
608 _, res.Err = client.Post(actionURL(client, id), reqBody, nil, nil)
Jamie Hannaford8c072a32014-10-16 14:33:32 +0200609 return res
Samuel A. Falvo II808bb632014-03-12 00:07:50 -0700610}
Alex Gaynor39584a02014-10-28 13:59:21 -0700611
Alex Gaynor266e9332014-10-28 14:44:04 -0700612// RescueOptsBuilder is an interface that allows extensions to override the
613// default structure of a Rescue request.
Alex Gaynor39584a02014-10-28 13:59:21 -0700614type RescueOptsBuilder interface {
615 ToServerRescueMap() (map[string]interface{}, error)
616}
617
Alex Gaynor266e9332014-10-28 14:44:04 -0700618// RescueOpts represents the configuration options used to control a Rescue
619// option.
Alex Gaynor39584a02014-10-28 13:59:21 -0700620type RescueOpts struct {
Alex Gaynor266e9332014-10-28 14:44:04 -0700621 // AdminPass is the desired administrative password for the instance in
Alex Gaynorcfec7722014-11-13 13:33:49 -0800622 // RESCUE mode. If it's left blank, the server will generate a password.
Alex Gaynor39584a02014-10-28 13:59:21 -0700623 AdminPass string
624}
625
Jon Perrittcc77da62014-11-16 13:14:21 -0700626// ToServerRescueMap formats a RescueOpts as a map that can be used as a JSON
Alex Gaynor266e9332014-10-28 14:44:04 -0700627// request body for the Rescue request.
Alex Gaynor39584a02014-10-28 13:59:21 -0700628func (opts RescueOpts) ToServerRescueMap() (map[string]interface{}, error) {
629 server := make(map[string]interface{})
630 if opts.AdminPass != "" {
631 server["adminPass"] = opts.AdminPass
632 }
633 return map[string]interface{}{"rescue": server}, nil
634}
635
Alex Gaynor266e9332014-10-28 14:44:04 -0700636// Rescue instructs the provider to place the server into RESCUE mode.
Alex Gaynorfbe61bb2014-11-12 13:35:03 -0800637func Rescue(client *gophercloud.ServiceClient, id string, opts RescueOptsBuilder) RescueResult {
638 var result RescueResult
Alex Gaynor39584a02014-10-28 13:59:21 -0700639
640 if id == "" {
641 result.Err = fmt.Errorf("ID is required")
642 return result
643 }
644 reqBody, err := opts.ToServerRescueMap()
645 if err != nil {
646 result.Err = err
647 return result
648 }
649
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100650 _, result.Err = client.Post(actionURL(client, id), reqBody, &result.Body, &gophercloud.RequestOpts{
651 OkCodes: []int{200},
Alex Gaynor39584a02014-10-28 13:59:21 -0700652 })
653
654 return result
655}
Jon Perrittcc77da62014-11-16 13:14:21 -0700656
Jon Perritt789f8322014-11-21 08:20:04 -0700657// ResetMetadataOptsBuilder allows extensions to add additional parameters to the
658// Reset request.
659type ResetMetadataOptsBuilder interface {
660 ToMetadataResetMap() (map[string]interface{}, error)
Jon Perrittcc77da62014-11-16 13:14:21 -0700661}
662
Jon Perritt78c57ce2014-11-20 11:07:18 -0700663// MetadataOpts is a map that contains key-value pairs.
664type MetadataOpts map[string]string
Jon Perrittcc77da62014-11-16 13:14:21 -0700665
Jon Perritt789f8322014-11-21 08:20:04 -0700666// ToMetadataResetMap assembles a body for a Reset request based on the contents of a MetadataOpts.
667func (opts MetadataOpts) ToMetadataResetMap() (map[string]interface{}, error) {
Jon Perrittcc77da62014-11-16 13:14:21 -0700668 return map[string]interface{}{"metadata": opts}, nil
669}
670
Jon Perritt78c57ce2014-11-20 11:07:18 -0700671// ToMetadataUpdateMap assembles a body for an Update request based on the contents of a MetadataOpts.
672func (opts MetadataOpts) ToMetadataUpdateMap() (map[string]interface{}, error) {
Jon Perrittcc77da62014-11-16 13:14:21 -0700673 return map[string]interface{}{"metadata": opts}, nil
674}
675
Jon Perritt789f8322014-11-21 08:20:04 -0700676// ResetMetadata will create multiple new key-value pairs for the given server ID.
Jon Perrittcc77da62014-11-16 13:14:21 -0700677// Note: Using this operation will erase any already-existing metadata and create
678// the new metadata provided. To keep any already-existing metadata, use the
679// UpdateMetadatas or UpdateMetadata function.
Jon Perritt789f8322014-11-21 08:20:04 -0700680func ResetMetadata(client *gophercloud.ServiceClient, id string, opts ResetMetadataOptsBuilder) ResetMetadataResult {
681 var res ResetMetadataResult
682 metadata, err := opts.ToMetadataResetMap()
Jon Perrittcc77da62014-11-16 13:14:21 -0700683 if err != nil {
684 res.Err = err
685 return res
686 }
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100687 _, res.Err = client.Put(metadataURL(client, id), metadata, &res.Body, &gophercloud.RequestOpts{
688 OkCodes: []int{200},
Jon Perrittcc77da62014-11-16 13:14:21 -0700689 })
690 return res
691}
692
Jon Perritt78c57ce2014-11-20 11:07:18 -0700693// Metadata requests all the metadata for the given server ID.
694func Metadata(client *gophercloud.ServiceClient, id string) GetMetadataResult {
Jon Perrittcc77da62014-11-16 13:14:21 -0700695 var res GetMetadataResult
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100696 _, res.Err = client.Get(metadataURL(client, id), &res.Body, nil)
Jon Perrittcc77da62014-11-16 13:14:21 -0700697 return res
698}
699
Jon Perritt78c57ce2014-11-20 11:07:18 -0700700// UpdateMetadataOptsBuilder allows extensions to add additional parameters to the
701// Create request.
702type UpdateMetadataOptsBuilder interface {
703 ToMetadataUpdateMap() (map[string]interface{}, error)
704}
705
706// UpdateMetadata updates (or creates) all the metadata specified by opts for the given server ID.
707// This operation does not affect already-existing metadata that is not specified
708// by opts.
709func UpdateMetadata(client *gophercloud.ServiceClient, id string, opts UpdateMetadataOptsBuilder) UpdateMetadataResult {
710 var res UpdateMetadataResult
711 metadata, err := opts.ToMetadataUpdateMap()
712 if err != nil {
713 res.Err = err
714 return res
715 }
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100716 _, res.Err = client.Post(metadataURL(client, id), metadata, &res.Body, &gophercloud.RequestOpts{
717 OkCodes: []int{200},
Jon Perritt78c57ce2014-11-20 11:07:18 -0700718 })
719 return res
720}
721
722// MetadatumOptsBuilder allows extensions to add additional parameters to the
723// Create request.
724type MetadatumOptsBuilder interface {
725 ToMetadatumCreateMap() (map[string]interface{}, string, error)
726}
727
728// MetadatumOpts is a map of length one that contains a key-value pair.
729type MetadatumOpts map[string]string
730
731// ToMetadatumCreateMap assembles a body for a Create request based on the contents of a MetadataumOpts.
732func (opts MetadatumOpts) ToMetadatumCreateMap() (map[string]interface{}, string, error) {
733 if len(opts) != 1 {
734 return nil, "", errors.New("CreateMetadatum operation must have 1 and only 1 key-value pair.")
735 }
736 metadatum := map[string]interface{}{"meta": opts}
737 var key string
738 for k := range metadatum["meta"].(MetadatumOpts) {
739 key = k
740 }
741 return metadatum, key, nil
742}
743
744// CreateMetadatum will create or update the key-value pair with the given key for the given server ID.
745func CreateMetadatum(client *gophercloud.ServiceClient, id string, opts MetadatumOptsBuilder) CreateMetadatumResult {
746 var res CreateMetadatumResult
747 metadatum, key, err := opts.ToMetadatumCreateMap()
748 if err != nil {
749 res.Err = err
750 return res
751 }
752
Jamie Hannaford6a3a78f2015-03-24 14:56:12 +0100753 _, res.Err = client.Put(metadatumURL(client, id, key), metadatum, &res.Body, &gophercloud.RequestOpts{
754 OkCodes: []int{200},
Jon Perritt78c57ce2014-11-20 11:07:18 -0700755 })
756 return res
757}
758
759// Metadatum requests the key-value pair with the given key for the given server ID.
760func Metadatum(client *gophercloud.ServiceClient, id, key string) GetMetadatumResult {
761 var res GetMetadatumResult
Jon Perritta33da232016-03-02 04:43:08 -0600762 _, res.Err = client.Request("GET", metadatumURL(client, id, key), &gophercloud.RequestOpts{
Ash Wilson59fb6c42015-02-12 16:21:13 -0500763 JSONResponse: &res.Body,
Jon Perritt78c57ce2014-11-20 11:07:18 -0700764 })
765 return res
766}
767
768// DeleteMetadatum will delete the key-value pair with the given key for the given server ID.
769func DeleteMetadatum(client *gophercloud.ServiceClient, id, key string) DeleteMetadatumResult {
770 var res DeleteMetadatumResult
Pratik Mallyaee675fd2015-09-14 14:07:30 -0500771 _, res.Err = client.Delete(metadatumURL(client, id, key), nil)
Jon Perrittcc77da62014-11-16 13:14:21 -0700772 return res
773}
Jon Perritt5cb49482015-02-19 12:19:58 -0700774
775// ListAddresses makes a request against the API to list the servers IP addresses.
776func ListAddresses(client *gophercloud.ServiceClient, id string) pagination.Pager {
777 createPageFn := func(r pagination.PageResult) pagination.Page {
778 return AddressPage{pagination.SinglePageBase(r)}
779 }
780 return pagination.NewPager(client, listAddressesURL(client, id), createPageFn)
781}
Jon Perritt04d073c2015-02-19 21:46:23 -0700782
783// ListAddressesByNetwork makes a request against the API to list the servers IP addresses
784// for the given network.
785func ListAddressesByNetwork(client *gophercloud.ServiceClient, id, network string) pagination.Pager {
786 createPageFn := func(r pagination.PageResult) pagination.Page {
787 return NetworkAddressPage{pagination.SinglePageBase(r)}
788 }
789 return pagination.NewPager(client, listAddressesByNetworkURL(client, id, network), createPageFn)
790}
einarf2fc665e2015-04-16 20:16:21 +0000791
einarf4e5fdaf2015-04-16 23:14:59 +0000792type CreateImageOpts struct {
einarf2fc665e2015-04-16 20:16:21 +0000793 // Name [required] of the image/snapshot
794 Name string
795 // Metadata [optional] contains key-value pairs (up to 255 bytes each) to attach to the created image.
796 Metadata map[string]string
797}
798
einarf4e5fdaf2015-04-16 23:14:59 +0000799type CreateImageOptsBuilder interface {
800 ToServerCreateImageMap() (map[string]interface{}, error)
einarf2fc665e2015-04-16 20:16:21 +0000801}
802
einarf4e5fdaf2015-04-16 23:14:59 +0000803// ToServerCreateImageMap formats a CreateImageOpts structure into a request body.
804func (opts CreateImageOpts) ToServerCreateImageMap() (map[string]interface{}, error) {
einarf2fc665e2015-04-16 20:16:21 +0000805 var err error
806 img := make(map[string]interface{})
807 if opts.Name == "" {
einarf4e5fdaf2015-04-16 23:14:59 +0000808 return nil, fmt.Errorf("Cannot create a server image without a name")
einarf2fc665e2015-04-16 20:16:21 +0000809 }
810 img["name"] = opts.Name
811 if opts.Metadata != nil {
812 img["metadata"] = opts.Metadata
813 }
814 createImage := make(map[string]interface{})
815 createImage["createImage"] = img
816 return createImage, err
817}
818
einarf4e5fdaf2015-04-16 23:14:59 +0000819// CreateImage makes a request against the nova API to schedule an image to be created of the server
jrperrittb1013232016-02-10 19:01:53 -0600820func CreateImage(client *gophercloud.ServiceClient, serverID string, opts CreateImageOptsBuilder) CreateImageResult {
einarf4e5fdaf2015-04-16 23:14:59 +0000821 var res CreateImageResult
822 reqBody, err := opts.ToServerCreateImageMap()
einarf2fc665e2015-04-16 20:16:21 +0000823 if err != nil {
824 res.Err = err
825 return res
826 }
jrperrittb1013232016-02-10 19:01:53 -0600827 response, err := client.Post(actionURL(client, serverID), reqBody, nil, &gophercloud.RequestOpts{
einarf2fc665e2015-04-16 20:16:21 +0000828 OkCodes: []int{202},
829 })
830 res.Err = err
einarf4e5fdaf2015-04-16 23:14:59 +0000831 res.Header = response.Header
Kevin Pike9748b7b2015-05-05 07:34:07 -0700832 return res
einarf2fc665e2015-04-16 20:16:21 +0000833}
Jon Perritt6b0a8832015-06-04 14:32:30 -0600834
835// IDFromName is a convienience function that returns a server's ID given its name.
836func IDFromName(client *gophercloud.ServiceClient, name string) (string, error) {
837 serverCount := 0
838 serverID := ""
839 if name == "" {
840 return "", fmt.Errorf("A server name must be provided.")
841 }
842 pager := List(client, nil)
843 pager.EachPage(func(page pagination.Page) (bool, error) {
844 serverList, err := ExtractServers(page)
845 if err != nil {
846 return false, err
847 }
848
849 for _, s := range serverList {
850 if s.Name == name {
851 serverCount++
852 serverID = s.ID
853 }
854 }
855 return true, nil
856 })
857
858 switch serverCount {
859 case 0:
860 return "", fmt.Errorf("Unable to find server: %s", name)
861 case 1:
862 return serverID, nil
863 default:
864 return "", fmt.Errorf("Found %d servers matching %s", serverCount, name)
865 }
866}