← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/govmomi/object/folder.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/juju/govmomi/object/folder.go
 
1
/*
 
2
Copyright (c) 2014 VMware, Inc. All Rights Reserved.
 
3
 
 
4
Licensed under the Apache License, Version 2.0 (the "License");
 
5
you may not use this file except in compliance with the License.
 
6
You may obtain a copy of the License at
 
7
 
 
8
    http://www.apache.org/licenses/LICENSE-2.0
 
9
 
 
10
Unless required by applicable law or agreed to in writing, software
 
11
distributed under the License is distributed on an "AS IS" BASIS,
 
12
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
13
See the License for the specific language governing permissions and
 
14
limitations under the License.
 
15
*/
 
16
 
 
17
package object
 
18
 
 
19
import (
 
20
        "github.com/juju/govmomi/vim25"
 
21
        "github.com/juju/govmomi/vim25/methods"
 
22
        "github.com/juju/govmomi/vim25/mo"
 
23
        "github.com/juju/govmomi/vim25/types"
 
24
        "golang.org/x/net/context"
 
25
)
 
26
 
 
27
type Folder struct {
 
28
        Common
 
29
}
 
30
 
 
31
func NewFolder(c *vim25.Client, ref types.ManagedObjectReference) *Folder {
 
32
        return &Folder{
 
33
                Common: NewCommon(c, ref),
 
34
        }
 
35
}
 
36
 
 
37
func NewRootFolder(c *vim25.Client) *Folder {
 
38
        return NewFolder(c, c.ServiceContent.RootFolder)
 
39
}
 
40
 
 
41
func (f Folder) Children(ctx context.Context) ([]Reference, error) {
 
42
        var mf mo.Folder
 
43
 
 
44
        err := f.Properties(ctx, f.Reference(), []string{"childEntity"}, &mf)
 
45
        if err != nil {
 
46
                return nil, err
 
47
        }
 
48
 
 
49
        var rs []Reference
 
50
        for _, e := range mf.ChildEntity {
 
51
                if r := NewReference(f.c, e); r != nil {
 
52
                        rs = append(rs, r)
 
53
                }
 
54
        }
 
55
 
 
56
        return rs, nil
 
57
}
 
58
 
 
59
func (f Folder) CreateDatacenter(ctx context.Context, datacenter string) (*Datacenter, error) {
 
60
        req := types.CreateDatacenter{
 
61
                This: f.Reference(),
 
62
                Name: datacenter,
 
63
        }
 
64
 
 
65
        res, err := methods.CreateDatacenter(ctx, f.c, &req)
 
66
        if err != nil {
 
67
                return nil, err
 
68
        }
 
69
 
 
70
        // Response will be nil if this is an ESX host that does not belong to a vCenter
 
71
        if res == nil {
 
72
                return nil, nil
 
73
        }
 
74
 
 
75
        return NewDatacenter(f.c, res.Returnval), nil
 
76
}
 
77
 
 
78
func (f Folder) CreateFolder(ctx context.Context, name string) (*Folder, error) {
 
79
        req := types.CreateFolder{
 
80
                This: f.Reference(),
 
81
                Name: name,
 
82
        }
 
83
 
 
84
        res, err := methods.CreateFolder(ctx, f.c, &req)
 
85
        if err != nil {
 
86
                return nil, err
 
87
        }
 
88
 
 
89
        return NewFolder(f.c, res.Returnval), err
 
90
}
 
91
 
 
92
func (f Folder) CreateVM(ctx context.Context, config types.VirtualMachineConfigSpec, pool *ResourcePool, host *HostSystem) (*Task, error) {
 
93
        req := types.CreateVM_Task{
 
94
                This:   f.Reference(),
 
95
                Config: config,
 
96
                Pool:   pool.Reference(),
 
97
        }
 
98
 
 
99
        if host != nil {
 
100
                ref := host.Reference()
 
101
                req.Host = &ref
 
102
        }
 
103
 
 
104
        res, err := methods.CreateVM_Task(ctx, f.c, &req)
 
105
        if err != nil {
 
106
                return nil, err
 
107
        }
 
108
 
 
109
        return NewTask(f.c, res.Returnval), nil
 
110
}
 
111
 
 
112
func (f Folder) RegisterVM(ctx context.Context, path string, name string, asTemplate bool, pool *ResourcePool, host *HostSystem) (*Task, error) {
 
113
        req := types.RegisterVM_Task{
 
114
                This:       f.Reference(),
 
115
                Path:       path,
 
116
                AsTemplate: asTemplate,
 
117
        }
 
118
 
 
119
        if name != "" {
 
120
                req.Name = name
 
121
        }
 
122
 
 
123
        if host != nil {
 
124
                ref := host.Reference()
 
125
                req.Host = &ref
 
126
        }
 
127
 
 
128
        if pool != nil {
 
129
                ref := pool.Reference()
 
130
                req.Pool = &ref
 
131
        }
 
132
 
 
133
        res, err := methods.RegisterVM_Task(ctx, f.c, &req)
 
134
        if err != nil {
 
135
                return nil, err
 
136
        }
 
137
 
 
138
        return NewTask(f.c, res.Returnval), nil
 
139
}