forked from ansible/ansible
-
Notifications
You must be signed in to change notification settings - Fork 7
/
vmware_guest_powerstate.py
221 lines (200 loc) · 8.81 KB
/
vmware_guest_powerstate.py
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
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright: (c) 2017, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = r'''
---
module: vmware_guest_powerstate
short_description: Manages power states of virtual machines in vCenter
description:
- Power on / Power off / Restart a virtual machine.
version_added: '2.5'
author:
- Abhijeet Kasurde (@Akasurde) <akasurde@redhat.com>
requirements:
- python >= 2.6
- PyVmomi
options:
state:
description:
- Set the state of the virtual machine.
choices: [ powered-off, powered-on, reboot-guest, restarted, shutdown-guest, suspended, present]
default: present
name:
description:
- Name of the virtual machine to work with.
- Virtual machine names in vCenter are not necessarily unique, which may be problematic, see C(name_match).
name_match:
description:
- If multiple virtual machines matching the name, use the first or last found.
default: first
choices: [ first, last ]
uuid:
description:
- UUID of the instance to manage if known, this is VMware's unique identifier.
- This is required if name is not supplied.
folder:
description:
- Destination folder, absolute or relative path to find an existing guest or create the new guest.
- The folder should include the datacenter. ESX's datacenter is ha-datacenter
- 'Examples:'
- ' folder: /ha-datacenter/vm'
- ' folder: ha-datacenter/vm'
- ' folder: /datacenter1/vm'
- ' folder: datacenter1/vm'
- ' folder: /datacenter1/vm/folder1'
- ' folder: datacenter1/vm/folder1'
- ' folder: /folder1/datacenter1/vm'
- ' folder: folder1/datacenter1/vm'
- ' folder: /folder1/datacenter1/vm/folder2'
- ' folder: vm/folder2'
- ' folder: folder2'
default: /vm
scheduled_at:
description:
- Date and time in string format at which specificed task needs to be performed.
- "The required format for date and time - 'dd/mm/yyyy hh:mm'."
- Scheduling task requires vCenter server. A standalone ESXi server does not support this option.
force:
description:
- Ignore warnings and complete the actions.
- This parameter is useful while forcing virtual machine state.
default: False
type: bool
version_added: 2.5
state_change_timeout:
description:
- If the C(state) is set to C(shutdown-guest), by default the module will return immediately after sending the shutdown signal.
- If this argument is set to a positive integer, the module will instead wait for the VM to reach the poweredoff state.
- The value sets a timeout in seconds for the module to wait for the state change.
default: 0
version_added: '2.6'
extends_documentation_fragment: vmware.documentation
'''
EXAMPLES = r'''
- name: Set the state of a virtual machine to poweroff
vmware_guest_powerstate:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
validate_certs: no
folder: /"{{ datacenter_name }}"/vm/my_folder
name: "{{ guest_name }}"
state: powered-off
delegate_to: localhost
register: deploy
- name: Set the state of a virtual machine to poweroff at given scheduled time
vmware_guest_powerstate:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: /"{{ datacenter_name }}"/vm/my_folder
name: "{{ guest_name }}"
state: powered-off
scheduled_at: "09/01/2018 10:18"
delegate_to: localhost
register: deploy_at_schedule_datetime
- name: Wait for the virtual machine to shutdown
vmware_guest_powerstate:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: "{{ guest_name }}"
state: shutdown-guest
state_change_timeout: 200
delegate_to: localhost
register: deploy
'''
RETURN = r''' # '''
try:
from pyVmomi import vim, vmodl
except ImportError:
pass
from datetime import datetime
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.vmware import PyVmomi, set_vm_power_state, vmware_argument_spec
from ansible.module_utils._text import to_native
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
state=dict(type='str', default='present',
choices=['present', 'powered-off', 'powered-on', 'reboot-guest', 'restarted', 'shutdown-guest', 'suspended']),
name=dict(type='str'),
name_match=dict(type='str', choices=['first', 'last'], default='first'),
uuid=dict(type='str'),
folder=dict(type='str', default='/vm'),
force=dict(type='bool', default=False),
scheduled_at=dict(type='str'),
state_change_timeout=dict(type='int', default=0),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False,
mutually_exclusive=[
['name', 'uuid'],
],
)
result = dict(changed=False,)
pyv = PyVmomi(module)
# Check if the VM exists before continuing
vm = pyv.get_vm()
if vm:
# VM already exists, so set power state
scheduled_at = module.params.get('scheduled_at', None)
if scheduled_at:
if not pyv.is_vcenter():
module.fail_json(msg="Scheduling task requires vCenter, hostname %s "
"is an ESXi server." % module.params.get('hostname'))
powerstate = {
'powered-off': vim.VirtualMachine.PowerOff,
'powered-on': vim.VirtualMachine.PowerOn,
'reboot-guest': vim.VirtualMachine.RebootGuest,
'restarted': vim.VirtualMachine.Reset,
'shutdown-guest': vim.VirtualMachine.ShutdownGuest,
'suspended': vim.VirtualMachine.Suspend,
}
dt = ''
try:
dt = datetime.strptime(scheduled_at, '%d/%m/%Y %H:%M')
except ValueError as e:
module.fail_json(msg="Failed to convert given date and time string to Python datetime object,"
"please specify string in 'dd/mm/yyyy hh:mm' format: %s" % to_native(e))
schedule_task_spec = vim.scheduler.ScheduledTaskSpec()
schedule_task_desc = 'Schedule task for vm %s for operation %s at %s' % (vm.name,
module.params.get('state'),
scheduled_at)
schedule_task_spec.name = schedule_task_desc
schedule_task_spec.description = schedule_task_desc
schedule_task_spec.scheduler = vim.scheduler.OnceTaskScheduler()
schedule_task_spec.scheduler.runAt = dt
schedule_task_spec.action = vim.action.MethodAction()
schedule_task_spec.action.name = powerstate[module.params.get('state')]
schedule_task_spec.enabled = True
try:
pyv.content.scheduledTaskManager.CreateScheduledTask(vm, schedule_task_spec)
# As this is async task, we create scheduled task and mark state to changed.
module.exit_json(changed=True)
except vim.fault.InvalidName as e:
module.fail_json(msg="Failed to create scheduled task %s for %s : %s" % (module.params.get('state'),
vm.name,
to_native(e.msg)))
except vim.fault.DuplicateName as e:
module.exit_json(chanaged=False, details=to_native(e.msg))
except vmodl.fault.InvalidArgument as e:
module.fail_json(msg="Failed to create scheduled task %s as specifications "
"given are invalid: %s" % (module.params.get('state'),
to_native(e.msg)))
else:
result = set_vm_power_state(pyv.content, vm, module.params['state'], module.params['force'], module.params['state_change_timeout'])
else:
module.fail_json(msg="Unable to set power state for non-existing virtual machine : '%s'" % (module.params.get('uuid') or module.params.get('name')))
if result.get('failed') is True:
module.fail_json(**result)
module.exit_json(**result)
if __name__ == '__main__':
main()