← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/altoros/gosigma/client.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/altoros/gosigma/client.go
 
1
// Copyright 2014 ALTOROS
 
2
// Licensed under the AGPLv3, see LICENSE file for details.
 
3
 
 
4
package gosigma
 
5
 
 
6
import (
 
7
        "crypto/tls"
 
8
        "errors"
 
9
        "time"
 
10
 
 
11
        "github.com/altoros/gosigma/https"
 
12
)
 
13
 
 
14
// A RequestSpec defines the type of client request
 
15
type RequestSpec bool
 
16
 
 
17
const (
 
18
        // RequestShort requests server to return short object representation
 
19
        RequestShort RequestSpec = false
 
20
        // RequestDetail requests server to return detail object representation
 
21
        RequestDetail RequestSpec = true
 
22
)
 
23
 
 
24
// A LibrarySpec defines the type of drive library to use
 
25
type LibrarySpec bool
 
26
 
 
27
const (
 
28
        // LibraryAccount requests server to use user account drive library
 
29
        LibraryAccount LibrarySpec = false
 
30
        // LibraryMedia requests server to use public drive library
 
31
        LibraryMedia LibrarySpec = true
 
32
)
 
33
 
 
34
// A Client sends and receives requests to CloudSigma endpoint
 
35
type Client struct {
 
36
        endpoint         string
 
37
        https            *https.Client
 
38
        logger           https.Logger
 
39
        operationTimeout time.Duration
 
40
}
 
41
 
 
42
var errEmptyUsername = errors.New("username is not allowed to be empty")
 
43
var errEmptyPassword = errors.New("password is not allowed to be empty")
 
44
var errEmptyUUID = errors.New("uuid is not allowed to be empty")
 
45
 
 
46
// NewClient returns new CloudSigma client object
 
47
func NewClient(endpoint string, username, password string,
 
48
        tlsConfig *tls.Config) (*Client, error) {
 
49
 
 
50
        endpoint = ResolveEndpoint(endpoint)
 
51
 
 
52
        if len(username) == 0 {
 
53
                return nil, errEmptyUsername
 
54
        }
 
55
 
 
56
        if len(password) == 0 {
 
57
                return nil, errEmptyPassword
 
58
        }
 
59
 
 
60
        client := &Client{
 
61
                endpoint: endpoint,
 
62
                https:    https.NewAuthClient(username, password, tlsConfig),
 
63
        }
 
64
 
 
65
        return client, nil
 
66
}
 
67
 
 
68
// ConnectTimeout sets connection timeout
 
69
func (c Client) ConnectTimeout(timeout time.Duration) {
 
70
        c.https.ConnectTimeout(timeout)
 
71
}
 
72
 
 
73
// GetConnectTimeout returns connection timeout for the object
 
74
func (c Client) GetConnectTimeout() time.Duration {
 
75
        return c.https.GetConnectTimeout()
 
76
}
 
77
 
 
78
// ReadWriteTimeout sets read-write timeout
 
79
func (c Client) ReadWriteTimeout(timeout time.Duration) {
 
80
        c.https.ReadWriteTimeout(timeout)
 
81
}
 
82
 
 
83
// GetReadWriteTimeout returns connection timeout for the object
 
84
func (c Client) GetReadWriteTimeout() time.Duration {
 
85
        return c.https.GetReadWriteTimeout()
 
86
}
 
87
 
 
88
// OperationTimeout sets timeout for cloud operations (like cloning, starting, stopping etc)
 
89
func (c *Client) OperationTimeout(timeout time.Duration) {
 
90
        c.operationTimeout = timeout
 
91
}
 
92
 
 
93
// GetOperationTimeout gets timeout for cloud operations (like cloning, starting, stopping etc)
 
94
func (c Client) GetOperationTimeout() time.Duration {
 
95
        return c.operationTimeout
 
96
}
 
97
 
 
98
// Logger sets logger for http traces
 
99
func (c *Client) Logger(logger https.Logger) {
 
100
        c.logger = logger
 
101
        c.https.Logger(logger)
 
102
}
 
103
 
 
104
// Servers in current account
 
105
func (c *Client) Servers(rqspec RequestSpec) ([]Server, error) {
 
106
        objs, err := c.getServers(rqspec)
 
107
        if err != nil {
 
108
                return nil, err
 
109
        }
 
110
 
 
111
        servers := make([]Server, len(objs))
 
112
        for i := 0; i < len(objs); i++ {
 
113
                servers[i] = &server{
 
114
                        client: c,
 
115
                        obj:    &objs[i],
 
116
                }
 
117
        }
 
118
 
 
119
        return servers, nil
 
120
}
 
121
 
 
122
// ServersFiltered in current account with filter applied
 
123
func (c *Client) ServersFiltered(rqspec RequestSpec, filter func(s Server) bool) ([]Server, error) {
 
124
        objs, err := c.getServers(rqspec)
 
125
        if err != nil {
 
126
                return nil, err
 
127
        }
 
128
 
 
129
        servers := make([]Server, 0, len(objs))
 
130
        for i := 0; i < len(objs); i++ {
 
131
                s := &server{
 
132
                        client: c,
 
133
                        obj:    &objs[i],
 
134
                }
 
135
                if filter(s) {
 
136
                        servers = append(servers, s)
 
137
                }
 
138
        }
 
139
 
 
140
        return servers, nil
 
141
}
 
142
 
 
143
// Server returns given server by uuid, requesting endpoint for server information
 
144
func (c *Client) Server(uuid string) (Server, error) {
 
145
        obj, err := c.getServer(uuid)
 
146
        if err != nil {
 
147
                return nil, err
 
148
        }
 
149
 
 
150
        srv := &server{
 
151
                client: c,
 
152
                obj:    obj,
 
153
        }
 
154
 
 
155
        return srv, nil
 
156
}
 
157
 
 
158
// CreateServer in CloudSigma user account
 
159
func (c *Client) CreateServer(components Components) (Server, error) {
 
160
        objs, err := c.createServer(components)
 
161
        if err != nil {
 
162
                return nil, err
 
163
        }
 
164
 
 
165
        if len(objs) == 0 {
 
166
                return nil, errors.New("no servers in response from endpoint")
 
167
        }
 
168
 
 
169
        s := &server{
 
170
                client: c,
 
171
                obj:    &objs[0],
 
172
        }
 
173
 
 
174
        return s, nil
 
175
}
 
176
 
 
177
// StartServer by uuid of server instance.
 
178
func (c Client) StartServer(uuid string, avoid []string) error {
 
179
        return c.startServer(uuid, avoid)
 
180
}
 
181
 
 
182
// StopServer by uuid of server instance
 
183
func (c Client) StopServer(uuid string) error {
 
184
        return c.stopServer(uuid)
 
185
}
 
186
 
 
187
// RemoveServer by uuid of server instance with an option recursively removing attached drives.
 
188
// See RecurseXXX constants in server.go file.
 
189
func (c Client) RemoveServer(uuid, recurse string) error {
 
190
        return c.removeServer(uuid, recurse)
 
191
}
 
192
 
 
193
// Drives returns list of drives
 
194
func (c *Client) Drives(rqspec RequestSpec, libspec LibrarySpec) ([]Drive, error) {
 
195
        objs, err := c.getDrives(rqspec, libspec)
 
196
        if err != nil {
 
197
                return nil, err
 
198
        }
 
199
 
 
200
        drives := make([]Drive, len(objs))
 
201
        for i := 0; i < len(objs); i++ {
 
202
                drives[i] = &drive{
 
203
                        client:  c,
 
204
                        obj:     &objs[i],
 
205
                        library: libspec,
 
206
                }
 
207
        }
 
208
 
 
209
        return drives, nil
 
210
}
 
211
 
 
212
// Drive returns given drive by uuid
 
213
func (c *Client) Drive(uuid string, libspec LibrarySpec) (Drive, error) {
 
214
        obj, err := c.getDrive(uuid, libspec)
 
215
        if err != nil {
 
216
                return nil, err
 
217
        }
 
218
 
 
219
        drv := &drive{
 
220
                client:  c,
 
221
                obj:     obj,
 
222
                library: libspec,
 
223
        }
 
224
 
 
225
        return drv, nil
 
226
}
 
227
 
 
228
// CloneDrive clones given drive by uuid
 
229
func (c *Client) CloneDrive(uuid string, libspec LibrarySpec, params CloneParams, avoid []string) (Drive, error) {
 
230
        obj, err := c.cloneDrive(uuid, libspec, params, avoid)
 
231
        if err != nil {
 
232
                return nil, err
 
233
        }
 
234
 
 
235
        drv := &drive{
 
236
                client:  c,
 
237
                obj:     obj,
 
238
                library: LibraryAccount,
 
239
        }
 
240
 
 
241
        return drv, nil
 
242
}
 
243
 
 
244
// RemoveDrive removes given drive by uuid
 
245
func (c *Client) RemoveDrive(uuid string, libspec LibrarySpec) error {
 
246
        return c.removeDrive(uuid, libspec)
 
247
}
 
248
 
 
249
// Job returns job object by uuid
 
250
func (c *Client) Job(uuid string) (Job, error) {
 
251
        obj, err := c.getJob(uuid)
 
252
        if err != nil {
 
253
                return nil, err
 
254
        }
 
255
 
 
256
        j := &job{
 
257
                client: c,
 
258
                obj:    obj,
 
259
        }
 
260
 
 
261
        return j, nil
 
262
}
 
263
 
 
264
// ReadContext reads and returns context of current server
 
265
func (c Client) ReadContext() (Context, error) {
 
266
        obj, err := c.readContext()
 
267
        if err != nil {
 
268
                return nil, err
 
269
        }
 
270
 
 
271
        ctx := context{obj: obj}
 
272
 
 
273
        return ctx, nil
 
274
}