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
|
/*
Copyright (c) 2017 VMware, Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package rule
import (
"context"
"flag"
"github.com/vmware/govmomi/govc/cli"
"github.com/vmware/govmomi/vim25/types"
)
type create struct {
*SpecFlag
*InfoFlag
vmhost bool
affinity bool
antiaffinity bool
depends bool
}
func init() {
cli.Register("cluster.rule.create", &create{})
}
func (cmd *create) Register(ctx context.Context, f *flag.FlagSet) {
cmd.SpecFlag = new(SpecFlag)
cmd.SpecFlag.Register(ctx, f)
cmd.InfoFlag, ctx = NewInfoFlag(ctx)
cmd.InfoFlag.Register(ctx, f)
f.BoolVar(&cmd.vmhost, "vm-host", false, "Virtual Machines to Hosts")
f.BoolVar(&cmd.affinity, "affinity", false, "Keep Virtual Machines Together")
f.BoolVar(&cmd.antiaffinity, "anti-affinity", false, "Separate Virtual Machines")
f.BoolVar(&cmd.depends, "depends", false, "Virtual Machines to Virtual Machines")
}
func (cmd *create) Process(ctx context.Context) error {
if cmd.name == "" {
return flag.ErrHelp
}
return cmd.InfoFlag.Process(ctx)
}
func (cmd *create) Usage() string {
return "NAME..."
}
func (cmd *create) Description() string {
return `Create cluster rule.
Rules are not enabled by default, use the 'enable' flag to enable upon creation or cluster.rule.change after creation.
One of '-affinity', '-anti-affinity', '-depends' or '-vm-host' must be provided to specify the rule type.
With '-affinity' or '-anti-affinity', at least 2 vm NAME arguments must be specified.
With '-depends', vm group NAME and vm group dependency NAME arguments must be specified.
With '-vm-host', use the '-vm-group' flag combined with the '-host-affine-group' and/or '-host-anti-affine-group' flags.
Examples:
govc cluster.rule.create -name pod1 -enable -affinity vm_a vm_b vm_c
govc cluster.rule.create -name pod2 -enable -anti-affinity vm_d vm_e vm_f
govc cluster.rule.create -name pod3 -enable -mandatory -vm-host -vm-group my_vms -host-affine-group my_hosts
govc cluster.rule.create -name pod4 -depends vm_group_app vm_group_db`
}
func (cmd *create) Run(ctx context.Context, f *flag.FlagSet) error {
args := f.Args()
update := types.ArrayUpdateSpec{Operation: types.ArrayUpdateOperationAdd}
var rule types.BaseClusterRuleInfo
var err error
switch {
case cmd.vmhost:
rule = &cmd.ClusterVmHostRuleInfo
case cmd.affinity:
rule = &cmd.ClusterAffinityRuleSpec
if len(args) < 2 {
return flag.ErrHelp // can't create this rule without 2 or more hosts
}
cmd.ClusterAffinityRuleSpec.Vm, err = cmd.ObjectList(ctx, "VirtualMachine", args)
if err != nil {
return err
}
case cmd.antiaffinity:
rule = &cmd.ClusterAntiAffinityRuleSpec
if len(args) < 2 {
return flag.ErrHelp // can't create this rule without 2 or more hosts
}
cmd.ClusterAntiAffinityRuleSpec.Vm, err = cmd.ObjectList(ctx, "VirtualMachine", args)
if err != nil {
return err
}
case cmd.depends:
if len(args) != 2 {
return flag.ErrHelp
}
rule = &types.ClusterDependencyRuleInfo{
VmGroup: args[0],
DependsOnVmGroup: args[1],
}
default:
return flag.ErrHelp
}
if cmd.Enabled == nil {
// ClusterDependencyRuleInfo throws InvalidArgument if Enabled == nil
cmd.Enabled = types.NewBool(false)
}
info := rule.GetClusterRuleInfo()
info.Name = cmd.name
info.Enabled = cmd.Enabled
info.Mandatory = cmd.Mandatory
info.UserCreated = types.NewBool(true)
return cmd.Apply(ctx, update, rule)
}
|
