← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/joyent/gosdc/localservices/cloudapi/service.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/joyent/gosdc/localservices/cloudapi/service.go
 
1
//
 
2
// gosdc - Go library to interact with the Joyent CloudAPI
 
3
//
 
4
// CloudAPI double testing service - internal direct API implementation
 
5
//
 
6
// Copyright (c) 2013 Joyent Inc.
 
7
//
 
8
// Written by Daniele Stroppa <daniele.stroppa@joyent.com>
 
9
//
 
10
 
 
11
package cloudapi
 
12
 
 
13
import (
 
14
        "fmt"
 
15
        "math/rand"
 
16
        "net/url"
 
17
        "strconv"
 
18
        "strings"
 
19
        "time"
 
20
 
 
21
        "github.com/joyent/gosdc/cloudapi"
 
22
        "github.com/joyent/gosdc/localservices"
 
23
)
 
24
 
 
25
var (
 
26
        separator       = "/"
 
27
        packagesFilters = []string{"name", "memory", "disk", "swap", "version", "vcpus", "group"}
 
28
        imagesFilters   = []string{"name", "os", "version", "public", "state", "owner", "type"}
 
29
        machinesFilters = []string{"type", "name", "image", "state", "memory", "tombstone", "limit", "offset", "credentials"}
 
30
)
 
31
 
 
32
type CloudAPI struct {
 
33
        localservices.ServiceInstance
 
34
        keys          []cloudapi.Key
 
35
        packages      []cloudapi.Package
 
36
        images        []cloudapi.Image
 
37
        machines      []*cloudapi.Machine
 
38
        machineFw     map[string]bool
 
39
        snapshots     map[string][]cloudapi.Snapshot
 
40
        firewallRules []*cloudapi.FirewallRule
 
41
        networks      []cloudapi.Network
 
42
}
 
43
 
 
44
func New(serviceURL, userAccount string) *CloudAPI {
 
45
        URL, err := url.Parse(serviceURL)
 
46
        if err != nil {
 
47
                panic(err)
 
48
        }
 
49
        hostname := URL.Host
 
50
        if !strings.HasSuffix(hostname, separator) {
 
51
                hostname += separator
 
52
        }
 
53
 
 
54
        keys := make([]cloudapi.Key, 0)
 
55
        machines := make([]*cloudapi.Machine, 0)
 
56
        machineFw := make(map[string]bool)
 
57
        snapshots := make(map[string][]cloudapi.Snapshot)
 
58
        firewallRules := make([]*cloudapi.FirewallRule, 0)
 
59
 
 
60
        cloudapiService := &CloudAPI{
 
61
                keys:          keys,
 
62
                packages:      initPackages(),
 
63
                images:        initImages(),
 
64
                machines:      machines,
 
65
                machineFw:     machineFw,
 
66
                snapshots:     snapshots,
 
67
                firewallRules: firewallRules,
 
68
                networks: []cloudapi.Network{
 
69
                        {Id: "123abc4d-0011-aabb-2233-ccdd4455", Name: "Test-Joyent-Public", Public: true},
 
70
                        {Id: "456def0a-33ff-7f8e-9a0b-33bb44cc", Name: "Test-Joyent-Private", Public: false},
 
71
                },
 
72
                ServiceInstance: localservices.ServiceInstance{
 
73
                        Scheme:      URL.Scheme,
 
74
                        Hostname:    hostname,
 
75
                        UserAccount: userAccount,
 
76
                },
 
77
        }
 
78
 
 
79
        return cloudapiService
 
80
}
 
81
 
 
82
func initPackages() []cloudapi.Package {
 
83
        return []cloudapi.Package{
 
84
                {
 
85
                        Name:    "Micro",
 
86
                        Memory:  512,
 
87
                        Disk:    8192,
 
88
                        Swap:    1024,
 
89
                        VCPUs:   1,
 
90
                        Default: false,
 
91
                        Id:      "12345678-aaaa-bbbb-cccc-000000000000",
 
92
                        Version: "1.0.0",
 
93
                },
 
94
                {
 
95
                        Name:    "Small",
 
96
                        Memory:  1024,
 
97
                        Disk:    16384,
 
98
                        Swap:    2048,
 
99
                        VCPUs:   1,
 
100
                        Default: true,
 
101
                        Id:      "11223344-1212-abab-3434-aabbccddeeff",
 
102
                        Version: "1.0.2",
 
103
                },
 
104
                {
 
105
                        Name:    "Medium",
 
106
                        Memory:  2048,
 
107
                        Disk:    32768,
 
108
                        Swap:    4096,
 
109
                        VCPUs:   2,
 
110
                        Default: false,
 
111
                        Id:      "aabbccdd-abcd-abcd-abcd-112233445566",
 
112
                        Version: "1.0.4",
 
113
                },
 
114
                {
 
115
                        Name:    "Large",
 
116
                        Memory:  4096,
 
117
                        Disk:    65536,
 
118
                        Swap:    16384,
 
119
                        VCPUs:   4,
 
120
                        Default: false,
 
121
                        Id:      "00998877-dddd-eeee-ffff-111111111111",
 
122
                        Version: "1.0.1",
 
123
                },
 
124
        }
 
125
}
 
126
 
 
127
func initImages() []cloudapi.Image {
 
128
        return []cloudapi.Image{
 
129
                {
 
130
                        Id:          "12345678-a1a1-b2b2-c3c3-098765432100",
 
131
                        Name:        "SmartOS Std",
 
132
                        OS:          "smartos",
 
133
                        Version:     "13.3.1",
 
134
                        Type:        "smartmachine",
 
135
                        Description: "Test SmartOS image (32 bit)",
 
136
                        Homepage:    "http://test.joyent.com/Standard_Instance",
 
137
                        PublishedAt: "2014-01-08T17:42:31Z",
 
138
                        Public:      "true",
 
139
                        State:       "active",
 
140
                },
 
141
                {
 
142
                        Id:          "12345678-b1b1-a4a4-d8d8-111111999999",
 
143
                        Name:        "standard32",
 
144
                        OS:          "smartos",
 
145
                        Version:     "13.3.1",
 
146
                        Type:        "smartmachine",
 
147
                        Description: "Test SmartOS image (64 bit)",
 
148
                        Homepage:    "http://test.joyent.com/Standard_Instance",
 
149
                        PublishedAt: "2014-01-08T17:43:16Z",
 
150
                        Public:      "true",
 
151
                        State:       "active",
 
152
                },
 
153
                {
 
154
                        Id:          "a1b2c3d4-0011-2233-4455-0f1e2d3c4b5a",
 
155
                        Name:        "centos6.4",
 
156
                        OS:          "linux",
 
157
                        Version:     "2.4.1",
 
158
                        Type:        "virtualmachine",
 
159
                        Description: "Test CentOS 6.4 image (64 bit)",
 
160
                        PublishedAt: "2014-01-02T10:58:31Z",
 
161
                        Public:      "true",
 
162
                        State:       "active",
 
163
                },
 
164
                {
 
165
                        Id:          "11223344-0a0a-ff99-11bb-0a1b2c3d4e5f",
 
166
                        Name:        "ubuntu12.04",
 
167
                        OS:          "linux",
 
168
                        Version:     "2.3.1",
 
169
                        Type:        "virtualmachine",
 
170
                        Description: "Test Ubuntu 12.04 image (64 bit)",
 
171
                        PublishedAt: "2014-01-20T16:12:31Z",
 
172
                        Public:      "true",
 
173
                        State:       "active",
 
174
                },
 
175
                {
 
176
                        Id:          "11223344-0a0a-ee88-22ab-00aa11bb22cc",
 
177
                        Name:        "ubuntu12.10",
 
178
                        OS:          "linux",
 
179
                        Version:     "2.3.2",
 
180
                        Type:        "virtualmachine",
 
181
                        Description: "Test Ubuntu 12.10 image (64 bit)",
 
182
                        PublishedAt: "2014-01-20T16:12:31Z",
 
183
                        Public:      "true",
 
184
                        State:       "active",
 
185
                },
 
186
                {
 
187
                        Id:          "11223344-0a0a-dd77-33cd-abcd1234e5f6",
 
188
                        Name:        "ubuntu13.04",
 
189
                        OS:          "linux",
 
190
                        Version:     "2.2.8",
 
191
                        Type:        "virtualmachine",
 
192
                        Description: "Test Ubuntu 13.04 image (64 bit)",
 
193
                        PublishedAt: "2014-01-20T16:12:31Z",
 
194
                        Public:      "true",
 
195
                        State:       "active",
 
196
                },
 
197
        }
 
198
}
 
199
 
 
200
func generatePublicIPAddress() string {
 
201
        r := rand.New(rand.NewSource(time.Now().UnixNano()))
 
202
        return fmt.Sprintf("32.151.%d.%d", r.Intn(255), r.Intn(255))
 
203
}
 
204
 
 
205
func generatePrivateIPAddress() string {
 
206
        r := rand.New(rand.NewSource(time.Now().UnixNano()))
 
207
        return fmt.Sprintf("10.201.%d.%d", r.Intn(255), r.Intn(255))
 
208
}
 
209
 
 
210
func contains(list []string, elem string) bool {
 
211
        for _, t := range list {
 
212
                if t == elem {
 
213
                        return true
 
214
                }
 
215
        }
 
216
        return false
 
217
}
 
218
 
 
219
// Keys APIs
 
220
func (c *CloudAPI) ListKeys() ([]cloudapi.Key, error) {
 
221
        if err := c.ProcessFunctionHook(c); err != nil {
 
222
                return nil, err
 
223
        }
 
224
 
 
225
        return c.keys, nil
 
226
}
 
227
 
 
228
func (c *CloudAPI) GetKey(keyName string) (*cloudapi.Key, error) {
 
229
        if err := c.ProcessFunctionHook(c, keyName); err != nil {
 
230
                return nil, err
 
231
        }
 
232
 
 
233
        for _, key := range c.keys {
 
234
                if key.Name == keyName {
 
235
                        return &key, nil
 
236
                }
 
237
        }
 
238
 
 
239
        return nil, fmt.Errorf("Key %s not found", keyName)
 
240
}
 
241
 
 
242
func (c *CloudAPI) CreateKey(keyName, key string) (*cloudapi.Key, error) {
 
243
        if err := c.ProcessFunctionHook(c, keyName, key); err != nil {
 
244
                return nil, err
 
245
        }
 
246
 
 
247
        // check if key already exists or keyName already in use
 
248
        for _, k := range c.keys {
 
249
                if k.Name == keyName {
 
250
                        return nil, fmt.Errorf("Key name %s already in use", keyName)
 
251
                }
 
252
                if k.Key == key {
 
253
                        return nil, fmt.Errorf("Key %s already exists", key)
 
254
                }
 
255
        }
 
256
 
 
257
        newKey := cloudapi.Key{Name: keyName, Fingerprint: "", Key: key}
 
258
        c.keys = append(c.keys, newKey)
 
259
 
 
260
        return &newKey, nil
 
261
}
 
262
 
 
263
func (c *CloudAPI) DeleteKey(keyName string) error {
 
264
        if err := c.ProcessFunctionHook(c, keyName); err != nil {
 
265
                return err
 
266
        }
 
267
 
 
268
        for i, key := range c.keys {
 
269
                if key.Name == keyName {
 
270
                        c.keys = append(c.keys[:i], c.keys[i+1:]...)
 
271
                        return nil
 
272
                }
 
273
        }
 
274
 
 
275
        return fmt.Errorf("Key %s not found", keyName)
 
276
}
 
277
 
 
278
// Packages APIs
 
279
func (c *CloudAPI) ListPackages(filters map[string]string) ([]cloudapi.Package, error) {
 
280
        if err := c.ProcessFunctionHook(c, filters); err != nil {
 
281
                return nil, err
 
282
        }
 
283
 
 
284
        availablePackages := c.packages
 
285
 
 
286
        if filters != nil {
 
287
                for k, f := range filters {
 
288
                        // check if valid filter
 
289
                        if contains(packagesFilters, k) {
 
290
                                pkgs := []cloudapi.Package{}
 
291
                                // filter from availablePackages and add to pkgs
 
292
                                for _, p := range availablePackages {
 
293
                                        if k == "name" && p.Name == f {
 
294
                                                pkgs = append(pkgs, p)
 
295
                                        } else if k == "memory" {
 
296
                                                i, err := strconv.Atoi(f)
 
297
                                                if err == nil && p.Memory == i {
 
298
                                                        pkgs = append(pkgs, p)
 
299
                                                }
 
300
                                        } else if k == "disk" {
 
301
                                                i, err := strconv.Atoi(f)
 
302
                                                if err == nil && p.Disk == i {
 
303
                                                        pkgs = append(pkgs, p)
 
304
                                                }
 
305
                                        } else if k == "swap" {
 
306
                                                i, err := strconv.Atoi(f)
 
307
                                                if err == nil && p.Swap == i {
 
308
                                                        pkgs = append(pkgs, p)
 
309
                                                }
 
310
                                        } else if k == "version" && p.Version == f {
 
311
                                                pkgs = append(pkgs, p)
 
312
                                        } else if k == "vcpus" {
 
313
                                                i, err := strconv.Atoi(f)
 
314
                                                if err == nil && p.VCPUs == i {
 
315
                                                        pkgs = append(pkgs, p)
 
316
                                                }
 
317
                                        } else if k == "group" && p.Group == f {
 
318
                                                pkgs = append(pkgs, p)
 
319
                                        }
 
320
                                }
 
321
                                availablePackages = pkgs
 
322
                        }
 
323
                }
 
324
        }
 
325
 
 
326
        return availablePackages, nil
 
327
}
 
328
 
 
329
func (c *CloudAPI) GetPackage(packageName string) (*cloudapi.Package, error) {
 
330
        if err := c.ProcessFunctionHook(c, packageName); err != nil {
 
331
                return nil, err
 
332
        }
 
333
 
 
334
        for _, pkg := range c.packages {
 
335
                if pkg.Name == packageName {
 
336
                        return &pkg, nil
 
337
                }
 
338
                if pkg.Id == packageName {
 
339
                        return &pkg, nil
 
340
                }
 
341
        }
 
342
 
 
343
        return nil, fmt.Errorf("Package %s not found", packageName)
 
344
}
 
345
 
 
346
// Images APIs
 
347
func (c *CloudAPI) ListImages(filters map[string]string) ([]cloudapi.Image, error) {
 
348
        if err := c.ProcessFunctionHook(c, filters); err != nil {
 
349
                return nil, err
 
350
        }
 
351
 
 
352
        availableImages := c.images
 
353
 
 
354
        if filters != nil {
 
355
                for k, f := range filters {
 
356
                        // check if valid filter
 
357
                        if contains(imagesFilters, k) {
 
358
                                imgs := []cloudapi.Image{}
 
359
                                // filter from availableImages and add to imgs
 
360
                                for _, i := range availableImages {
 
361
                                        if k == "name" && i.Name == f {
 
362
                                                imgs = append(imgs, i)
 
363
                                        } else if k == "os" && i.OS == f {
 
364
                                                imgs = append(imgs, i)
 
365
                                        } else if k == "version" && i.Version == f {
 
366
                                                imgs = append(imgs, i)
 
367
                                        } else if k == "public" && i.Public == f {
 
368
                                                imgs = append(imgs, i)
 
369
                                        } else if k == "state" && i.State == f {
 
370
                                                imgs = append(imgs, i)
 
371
                                        } else if k == "owner" && i.Owner == f {
 
372
                                                imgs = append(imgs, i)
 
373
                                        } else if k == "type" && i.Type == f {
 
374
                                                imgs = append(imgs, i)
 
375
                                        }
 
376
                                }
 
377
                                availableImages = imgs
 
378
                        }
 
379
                }
 
380
        }
 
381
 
 
382
        return availableImages, nil
 
383
}
 
384
 
 
385
func (c *CloudAPI) GetImage(imageId string) (*cloudapi.Image, error) {
 
386
        if err := c.ProcessFunctionHook(c, imageId); err != nil {
 
387
                return nil, err
 
388
        }
 
389
 
 
390
        for _, image := range c.images {
 
391
                if image.Id == imageId {
 
392
                        return &image, nil
 
393
                }
 
394
        }
 
395
 
 
396
        return nil, fmt.Errorf("Image %s not found", imageId)
 
397
}
 
398
 
 
399
// Machine APIs
 
400
func (c *CloudAPI) ListMachines(filters map[string]string) ([]*cloudapi.Machine, error) {
 
401
        if err := c.ProcessFunctionHook(c, filters); err != nil {
 
402
                return nil, err
 
403
        }
 
404
 
 
405
        availableMachines := c.machines
 
406
 
 
407
        if filters != nil {
 
408
                for k, f := range filters {
 
409
                        // check if valid filter
 
410
                        if contains(machinesFilters, k) {
 
411
                                machines := []*cloudapi.Machine{}
 
412
                                // filter from availableMachines and add to machines
 
413
                                for _, m := range availableMachines {
 
414
                                        if k == "name" && m.Name == f {
 
415
                                                machines = append(machines, m)
 
416
                                        } else if k == "type" && m.Type == f {
 
417
                                                machines = append(machines, m)
 
418
                                        } else if k == "state" && m.State == f {
 
419
                                                machines = append(machines, m)
 
420
                                        } else if k == "image" && m.Image == f {
 
421
                                                machines = append(machines, m)
 
422
                                        } else if k == "memory" {
 
423
                                                i, err := strconv.Atoi(f)
 
424
                                                if err == nil && m.Memory == i {
 
425
                                                        machines = append(machines, m)
 
426
                                                }
 
427
                                        } else if strings.HasPrefix(k, "tags.") {
 
428
                                                for t, v := range m.Tags {
 
429
                                                        if t == k[strings.Index(k, ".")+1:] && v == f {
 
430
                                                                machines = append(machines, m)
 
431
                                                        }
 
432
                                                }
 
433
                                        }
 
434
                                }
 
435
                                availableMachines = machines
 
436
                        }
 
437
                }
 
438
        }
 
439
 
 
440
        return availableMachines, nil
 
441
}
 
442
 
 
443
func (c *CloudAPI) CountMachines() (int, error) {
 
444
        if err := c.ProcessFunctionHook(c); err != nil {
 
445
                return 0, err
 
446
        }
 
447
 
 
448
        return len(c.machines), nil
 
449
}
 
450
 
 
451
func (c *CloudAPI) GetMachine(machineId string) (*cloudapi.Machine, error) {
 
452
        if err := c.ProcessFunctionHook(c, machineId); err != nil {
 
453
                return nil, err
 
454
        }
 
455
 
 
456
        for _, machine := range c.machines {
 
457
                if machine.Id == machineId {
 
458
                        return machine, nil
 
459
                }
 
460
        }
 
461
 
 
462
        return nil, fmt.Errorf("Machine %s not found", machineId)
 
463
}
 
464
 
 
465
func (c *CloudAPI) CreateMachine(name, pkg, image string, metadata, tags map[string]string) (*cloudapi.Machine, error) {
 
466
        if err := c.ProcessFunctionHook(c, name, pkg, image); err != nil {
 
467
                return nil, err
 
468
        }
 
469
 
 
470
        machineId, err := localservices.NewUUID()
 
471
        if err != nil {
 
472
                return nil, err
 
473
        }
 
474
 
 
475
        mPkg, err := c.GetPackage(pkg)
 
476
        if err != nil {
 
477
                return nil, err
 
478
        }
 
479
 
 
480
        mImg, err := c.GetImage(image)
 
481
        if err != nil {
 
482
                return nil, err
 
483
        }
 
484
 
 
485
        publicIP := generatePublicIPAddress()
 
486
 
 
487
        newMachine := &cloudapi.Machine{
 
488
                Id:        machineId,
 
489
                Name:      name,
 
490
                Type:      mImg.Type,
 
491
                State:     "running",
 
492
                Memory:    mPkg.Memory,
 
493
                Disk:      mPkg.Disk,
 
494
                IPs:       []string{publicIP, generatePrivateIPAddress()},
 
495
                Created:   time.Now().Format("2013-11-26T19:47:13.448Z"),
 
496
                Package:   pkg,
 
497
                Image:     image,
 
498
                Metadata:  metadata,
 
499
                Tags:      tags,
 
500
                PrimaryIP: publicIP,
 
501
        }
 
502
        c.machines = append(c.machines, newMachine)
 
503
 
 
504
        return newMachine, nil
 
505
}
 
506
 
 
507
func (c *CloudAPI) StopMachine(machineId string) error {
 
508
        if err := c.ProcessFunctionHook(c, machineId); err != nil {
 
509
                return err
 
510
        }
 
511
 
 
512
        for _, machine := range c.machines {
 
513
                if machine.Id == machineId {
 
514
                        machine.State = "stopped"
 
515
                        machine.Updated = time.Now().Format("2013-11-26T19:47:13.448Z")
 
516
                        return nil
 
517
                }
 
518
        }
 
519
 
 
520
        return fmt.Errorf("Machine %s not found", machineId)
 
521
}
 
522
 
 
523
func (c *CloudAPI) StartMachine(machineId string) error {
 
524
        if err := c.ProcessFunctionHook(c, machineId); err != nil {
 
525
                return err
 
526
        }
 
527
 
 
528
        for _, machine := range c.machines {
 
529
                if machine.Id == machineId {
 
530
                        machine.State = "running"
 
531
                        machine.Updated = time.Now().Format("2013-11-26T19:47:13.448Z")
 
532
                        return nil
 
533
                }
 
534
        }
 
535
 
 
536
        return fmt.Errorf("Machine %s not found", machineId)
 
537
}
 
538
 
 
539
func (c *CloudAPI) RebootMachine(machineId string) error {
 
540
        if err := c.ProcessFunctionHook(c, machineId); err != nil {
 
541
                return err
 
542
        }
 
543
 
 
544
        for _, machine := range c.machines {
 
545
                if machine.Id == machineId {
 
546
                        machine.State = "running"
 
547
                        machine.Updated = time.Now().Format("2013-11-26T19:47:13.448Z")
 
548
                        return nil
 
549
                }
 
550
        }
 
551
 
 
552
        return fmt.Errorf("Machine %s not found", machineId)
 
553
}
 
554
 
 
555
func (c *CloudAPI) ResizeMachine(machineId, packageName string) error {
 
556
        if err := c.ProcessFunctionHook(c, machineId, packageName); err != nil {
 
557
                return err
 
558
        }
 
559
 
 
560
        mPkg, err := c.GetPackage(packageName)
 
561
        if err != nil {
 
562
                return err
 
563
        }
 
564
 
 
565
        for _, machine := range c.machines {
 
566
                if machine.Id == machineId {
 
567
                        machine.Package = packageName
 
568
                        machine.Memory = mPkg.Memory
 
569
                        machine.Disk = mPkg.Disk
 
570
                        machine.Updated = time.Now().Format("2013-11-26T19:47:13.448Z")
 
571
                        return nil
 
572
                }
 
573
        }
 
574
 
 
575
        return fmt.Errorf("Machine %s not found", machineId)
 
576
}
 
577
 
 
578
func (c *CloudAPI) RenameMachine(machineId, newName string) error {
 
579
        if err := c.ProcessFunctionHook(c, machineId, newName); err != nil {
 
580
                return err
 
581
        }
 
582
 
 
583
        for _, machine := range c.machines {
 
584
                if machine.Id == machineId {
 
585
                        machine.Name = newName
 
586
                        machine.Updated = time.Now().Format("2013-11-26T19:47:13.448Z")
 
587
                        return nil
 
588
                }
 
589
        }
 
590
 
 
591
        return fmt.Errorf("Machine %s not found", machineId)
 
592
}
 
593
 
 
594
func (c *CloudAPI) ListMachineFirewallRules(machineId string) ([]*cloudapi.FirewallRule, error) {
 
595
        if err := c.ProcessFunctionHook(c, machineId); err != nil {
 
596
                return nil, err
 
597
        }
 
598
 
 
599
        fwRules := []*cloudapi.FirewallRule{}
 
600
        for _, r := range c.firewallRules {
 
601
                vm := "vm " + machineId
 
602
                if strings.Contains(r.Rule, vm) {
 
603
                        fwRules = append(fwRules, r)
 
604
                }
 
605
        }
 
606
 
 
607
        return fwRules, nil
 
608
}
 
609
 
 
610
func (c *CloudAPI) EnableFirewallMachine(machineId string) error {
 
611
        if err := c.ProcessFunctionHook(c, machineId); err != nil {
 
612
                return err
 
613
        }
 
614
 
 
615
        c.machineFw[machineId] = true
 
616
 
 
617
        return nil
 
618
}
 
619
 
 
620
func (c *CloudAPI) DisableFirewallMachine(machineId string) error {
 
621
        if err := c.ProcessFunctionHook(c, machineId); err != nil {
 
622
                return err
 
623
        }
 
624
 
 
625
        c.machineFw[machineId] = false
 
626
 
 
627
        return nil
 
628
}
 
629
 
 
630
func (c *CloudAPI) DeleteMachine(machineId string) error {
 
631
        if err := c.ProcessFunctionHook(c, machineId); err != nil {
 
632
                return err
 
633
        }
 
634
 
 
635
        for i, machine := range c.machines {
 
636
                if machine.Id == machineId {
 
637
                        if machine.State == "stopped" {
 
638
                                c.machines = append(c.machines[:i], c.machines[i+1:]...)
 
639
                                return nil
 
640
                        } else {
 
641
                                return fmt.Errorf("Cannot Delete machine %s, machine is not stopped.", machineId)
 
642
                        }
 
643
                }
 
644
        }
 
645
 
 
646
        return fmt.Errorf("Machine %s not found", machineId)
 
647
}
 
648
 
 
649
// FirewallRule APIs
 
650
func (c *CloudAPI) ListFirewallRules() ([]*cloudapi.FirewallRule, error) {
 
651
        if err := c.ProcessFunctionHook(c); err != nil {
 
652
                return nil, err
 
653
        }
 
654
 
 
655
        return c.firewallRules, nil
 
656
}
 
657
 
 
658
func (c *CloudAPI) GetFirewallRule(fwRuleId string) (*cloudapi.FirewallRule, error) {
 
659
        if err := c.ProcessFunctionHook(c, fwRuleId); err != nil {
 
660
                return nil, err
 
661
        }
 
662
 
 
663
        for _, r := range c.firewallRules {
 
664
                if strings.EqualFold(r.Id, fwRuleId) {
 
665
                        return r, nil
 
666
                }
 
667
        }
 
668
 
 
669
        return nil, fmt.Errorf("Firewall rule %s not found", fwRuleId)
 
670
}
 
671
 
 
672
func (c *CloudAPI) CreateFirewallRule(rule string, enabled bool) (*cloudapi.FirewallRule, error) {
 
673
        if err := c.ProcessFunctionHook(c, rule, enabled); err != nil {
 
674
                return nil, err
 
675
        }
 
676
 
 
677
        fwRuleId, err := localservices.NewUUID()
 
678
        if err != nil {
 
679
                return nil, fmt.Errorf("Error creating firewall rule: %q", err)
 
680
        }
 
681
 
 
682
        fwRule := &cloudapi.FirewallRule{Id: fwRuleId, Rule: rule, Enabled: enabled}
 
683
        c.firewallRules = append(c.firewallRules, fwRule)
 
684
 
 
685
        return fwRule, nil
 
686
}
 
687
 
 
688
func (c *CloudAPI) UpdateFirewallRule(fwRuleId, rule string, enabled bool) (*cloudapi.FirewallRule, error) {
 
689
        if err := c.ProcessFunctionHook(c, fwRuleId, rule, enabled); err != nil {
 
690
                return nil, err
 
691
        }
 
692
 
 
693
        for _, r := range c.firewallRules {
 
694
                if strings.EqualFold(r.Id, fwRuleId) {
 
695
                        r.Rule = rule
 
696
                        r.Enabled = enabled
 
697
                        return r, nil
 
698
                }
 
699
        }
 
700
 
 
701
        return nil, fmt.Errorf("Firewall rule %s not found", fwRuleId)
 
702
}
 
703
 
 
704
func (c *CloudAPI) EnableFirewallRule(fwRuleId string) (*cloudapi.FirewallRule, error) {
 
705
        if err := c.ProcessFunctionHook(c, fwRuleId); err != nil {
 
706
                return nil, err
 
707
        }
 
708
 
 
709
        for _, r := range c.firewallRules {
 
710
                if strings.EqualFold(r.Id, fwRuleId) {
 
711
                        r.Enabled = true
 
712
                        return r, nil
 
713
                }
 
714
        }
 
715
 
 
716
        return nil, fmt.Errorf("Firewall rule %s not found", fwRuleId)
 
717
}
 
718
 
 
719
func (c *CloudAPI) DisableFirewallRule(fwRuleId string) (*cloudapi.FirewallRule, error) {
 
720
        if err := c.ProcessFunctionHook(c, fwRuleId); err != nil {
 
721
                return nil, err
 
722
        }
 
723
 
 
724
        for _, r := range c.firewallRules {
 
725
                if strings.EqualFold(r.Id, fwRuleId) {
 
726
                        r.Enabled = false
 
727
                        return r, nil
 
728
                }
 
729
        }
 
730
 
 
731
        return nil, fmt.Errorf("Firewall rule %s not found", fwRuleId)
 
732
}
 
733
 
 
734
func (c *CloudAPI) DeleteFirewallRule(fwRuleId string) error {
 
735
        if err := c.ProcessFunctionHook(c, fwRuleId); err != nil {
 
736
                return err
 
737
        }
 
738
 
 
739
        for i, r := range c.firewallRules {
 
740
                if strings.EqualFold(r.Id, fwRuleId) {
 
741
                        c.firewallRules = append(c.firewallRules[:i], c.firewallRules[i+1:]...)
 
742
                        return nil
 
743
                }
 
744
        }
 
745
 
 
746
        return fmt.Errorf("Firewall rule %s not found", fwRuleId)
 
747
}
 
748
 
 
749
func (c *CloudAPI) ListFirewallRuleMachines(fwRuleId string) ([]*cloudapi.Machine, error) {
 
750
        if err := c.ProcessFunctionHook(c, fwRuleId); err != nil {
 
751
                return nil, err
 
752
        }
 
753
 
 
754
        return c.machines, nil
 
755
}
 
756
 
 
757
// Networks API
 
758
func (c *CloudAPI) ListNetworks() ([]cloudapi.Network, error) {
 
759
        if err := c.ProcessFunctionHook(c); err != nil {
 
760
                return nil, err
 
761
        }
 
762
 
 
763
        return c.networks, nil
 
764
}
 
765
 
 
766
func (c *CloudAPI) GetNetwork(networkId string) (*cloudapi.Network, error) {
 
767
        if err := c.ProcessFunctionHook(c, networkId); err != nil {
 
768
                return nil, err
 
769
        }
 
770
 
 
771
        for _, n := range c.networks {
 
772
                if strings.EqualFold(n.Id, networkId) {
 
773
                        return &n, nil
 
774
                }
 
775
        }
 
776
 
 
777
        return nil, fmt.Errorf("Network %s not found", networkId)
 
778
}