/
requests.go
180 lines (155 loc) · 5.99 KB
/
requests.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
package attachments
import (
"github.com/gophercloud/gophercloud"
"github.com/gophercloud/gophercloud/pagination"
)
// CreateOptsBuilder allows extensions to add additional parameters to the
// Create request.
type CreateOptsBuilder interface {
ToAttachmentCreateMap() (map[string]interface{}, error)
}
// CreateOpts contains options for creating a Volume attachment. This object is
// passed to the Create function. For more information about these parameters,
// see the Attachment object.
type CreateOpts struct {
// VolumeUUID is the UUID of the Cinder volume to create the attachment
// record for.
VolumeUUID string `json:"volume_uuid"`
// InstanceUUID is the ID of the Server to create the attachment for.
// When attaching to a Nova Server this is the Nova Server (Instance)
// UUID.
InstanceUUID string `json:"instance_uuid"`
// Connector is an optional map containing all of the needed atachment
// information for exmaple initiator IQN, etc.
Connector map[string]interface{} `json:"connector,omitempty"`
// Mode is an attachment mode. Acceptable values are read-only ('ro')
// and read-and-write ('rw'). Available only since 3.54 microversion.
// For APIs from 3.27 till 3.53 use Connector["mode"] = "rw|ro".
Mode string `json:"mode,omitempty"`
}
// ToAttachmentCreateMap assembles a request body based on the contents of a
// CreateOpts.
func (opts CreateOpts) ToAttachmentCreateMap() (map[string]interface{}, error) {
return gophercloud.BuildRequestBody(opts, "attachment")
}
// Create will create a new Attachment based on the values in CreateOpts. To
// extract the Attachment object from the response, call the Extract method on
// the CreateResult.
func Create(client *gophercloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult) {
b, err := opts.ToAttachmentCreateMap()
if err != nil {
r.Err = err
return
}
resp, err := client.Post(createURL(client), b, &r.Body, &gophercloud.RequestOpts{
OkCodes: []int{200, 202},
})
_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
return
}
// Delete will delete the existing Attachment with the provided ID.
func Delete(client *gophercloud.ServiceClient, id string) (r DeleteResult) {
resp, err := client.Delete(deleteURL(client, id), &gophercloud.RequestOpts{
OkCodes: []int{200},
})
_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
return
}
// Get retrieves the Attachment with the provided ID. To extract the Attachment
// object from the response, call the Extract method on the GetResult.
func Get(client *gophercloud.ServiceClient, id string) (r GetResult) {
resp, err := client.Get(getURL(client, id), &r.Body, nil)
_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
return
}
// ListOptsBuilder allows extensions to add additional parameters to the List
// request.
type ListOptsBuilder interface {
ToAttachmentListQuery() (string, error)
}
// ListOpts holds options for listing Attachments. It is passed to the attachments.List
// function.
type ListOpts struct {
// AllTenants will retrieve attachments of all tenants/projects.
AllTenants bool `q:"all_tenants"`
// Status will filter by the specified status.
Status string `q:"status"`
// ProjectID will filter by a specific tenant/project ID.
ProjectID string `q:"project_id"`
// VolumeID will filter by a specific volume ID.
VolumeID string `q:"volume_id"`
// InstanceID will filter by a specific instance ID.
InstanceID string `q:"instance_id"`
// Comma-separated list of sort keys and optional sort directions in the
// form of <key>[:<direction>].
Sort string `q:"sort"`
// Requests a page size of items.
Limit int `q:"limit"`
// Used in conjunction with limit to return a slice of items.
Offset int `q:"offset"`
// The ID of the last-seen item.
Marker string `q:"marker"`
}
// ToAttachmentListQuery formats a ListOpts into a query string.
func (opts ListOpts) ToAttachmentListQuery() (string, error) {
q, err := gophercloud.BuildQueryString(opts)
return q.String(), err
}
// List returns Attachments optionally limited by the conditions provided in
// ListOpts.
func List(client *gophercloud.ServiceClient, opts ListOptsBuilder) pagination.Pager {
url := listURL(client)
if opts != nil {
query, err := opts.ToAttachmentListQuery()
if err != nil {
return pagination.Pager{Err: err}
}
url += query
}
return pagination.NewPager(client, url, func(r pagination.PageResult) pagination.Page {
return AttachmentPage{pagination.LinkedPageBase{PageResult: r}}
})
}
// UpdateOptsBuilder allows extensions to add additional parameters to the
// Update request.
type UpdateOptsBuilder interface {
ToAttachmentUpdateMap() (map[string]interface{}, error)
}
// UpdateOpts contain options for updating an existing Attachment.
// This is used to finalize an attachment that was created without a
// connector (reserve).
type UpdateOpts struct {
Connector map[string]interface{} `json:"connector"`
}
// ToAttachmentUpdateMap assembles a request body based on the contents of an
// UpdateOpts.
func (opts UpdateOpts) ToAttachmentUpdateMap() (map[string]interface{}, error) {
return gophercloud.BuildRequestBody(opts, "attachment")
}
// Update will update the Attachment with provided information. To extract the
// updated Attachment from the response, call the Extract method on the
// UpdateResult.
func Update(client *gophercloud.ServiceClient, id string, opts UpdateOptsBuilder) (r UpdateResult) {
b, err := opts.ToAttachmentUpdateMap()
if err != nil {
r.Err = err
return
}
resp, err := client.Put(updateURL(client, id), b, &r.Body, &gophercloud.RequestOpts{
OkCodes: []int{200},
})
_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
return
}
// Complete will complete an attachment for a cinder volume.
// Available starting in the 3.44 microversion.
func Complete(client *gophercloud.ServiceClient, id string) (r CompleteResult) {
b := map[string]interface{}{
"os-complete": nil,
}
resp, err := client.Post(completeURL(client, id), b, nil, &gophercloud.RequestOpts{
OkCodes: []int{204},
})
_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
return
}