mirror of
https://github.com/thegeeklab/ansible-later.git
synced 2024-07-06 09:00:58 +02:00
345 lines
11 KiB
Python
345 lines
11 KiB
Python
#!/usr/bin/python
|
|
# Copyright: (c) 2015, Ansible, Inc.
|
|
# 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 = '''
|
|
---
|
|
module: vca_vapp
|
|
short_description: Manages vCloud Air vApp instances.
|
|
description:
|
|
- This module will actively managed vCloud Air vApp instances. Instances
|
|
can be created and deleted as well as both deployed and undeployed.
|
|
version_added: "2.0"
|
|
author:
|
|
- Peter Sprygada (@privateip)
|
|
options:
|
|
vapp_name:
|
|
description:
|
|
- The name of the vCloud Air vApp instance
|
|
required: yes
|
|
template_name:
|
|
description:
|
|
- The name of the vApp template to use to create the vApp instance. If
|
|
the I(state) is not `absent` then the I(template_name) value must be
|
|
provided. The I(template_name) must be previously uploaded to the
|
|
catalog specified by I(catalog_name)
|
|
network_name:
|
|
description:
|
|
- The name of the network that should be attached to the virtual machine
|
|
in the vApp. The virtual network specified must already be created in
|
|
the vCloud Air VDC. If the I(state) is not 'absent' then the
|
|
I(network_name) argument must be provided.
|
|
network_mode:
|
|
description:
|
|
- Configures the mode of the network connection.
|
|
default: pool
|
|
choices: ['pool', 'dhcp', 'static']
|
|
vm_name:
|
|
description:
|
|
- The name of the virtual machine instance in the vApp to manage.
|
|
vm_cpus:
|
|
description:
|
|
- The number of vCPUs to configure for the VM in the vApp. If the
|
|
I(vm_name) argument is provided, then this becomes a per VM setting
|
|
otherwise it is applied to all VMs in the vApp.
|
|
vm_memory:
|
|
description:
|
|
- The amount of memory in MB to allocate to VMs in the vApp. If the
|
|
I(vm_name) argument is provided, then this becomes a per VM setting
|
|
otherise it is applied to all VMs in the vApp.
|
|
operation:
|
|
description:
|
|
- Specifies an operation to be performed on the vApp.
|
|
default: noop
|
|
choices: ['noop', 'poweron', 'poweroff', 'suspend', 'shutdown', 'reboot', 'reset']
|
|
state:
|
|
description:
|
|
- Configures the state of the vApp.
|
|
default: present
|
|
choices: ['present', 'absent', 'deployed', 'undeployed']
|
|
username:
|
|
description:
|
|
- The vCloud Air username to use during authentication
|
|
password:
|
|
description:
|
|
- The vCloud Air password to use during authentication
|
|
org:
|
|
description:
|
|
- The org to login to for creating vapp, mostly set when the service_type is vdc.
|
|
instance_id:
|
|
description:
|
|
- The instance id in a vchs environment to be used for creating the vapp
|
|
host:
|
|
description:
|
|
- The authentication host to be used when service type is vcd.
|
|
api_version:
|
|
description:
|
|
- The api version to be used with the vca
|
|
default: "5.7"
|
|
service_type:
|
|
description:
|
|
- The type of service we are authenticating against
|
|
default: vca
|
|
choices: [ "vca", "vchs", "vcd" ]
|
|
vdc_name:
|
|
description:
|
|
- The name of the virtual data center (VDC) where the vm should be created or contains the vAPP.
|
|
extends_documentation_fragment: vca
|
|
'''
|
|
|
|
EXAMPLES = '''
|
|
- name: Creates a new vApp in a VCA instance
|
|
vca_vapp:
|
|
vapp_name: tower
|
|
state: present
|
|
template_name: 'Ubuntu Server 12.04 LTS (amd64 20150127)'
|
|
vdc_name: VDC1
|
|
instance_id: '<your instance id here>'
|
|
username: '<your username here>'
|
|
password: '<your password here>'
|
|
delegate_to: localhost
|
|
'''
|
|
|
|
from ansible.module_utils.vca import VcaAnsibleModule, VcaError
|
|
|
|
DEFAULT_VAPP_OPERATION = 'noop'
|
|
|
|
VAPP_STATUS = {
|
|
'Powered off': 'poweroff',
|
|
'Powered on': 'poweron',
|
|
'Suspended': 'suspend'
|
|
}
|
|
|
|
VAPP_STATES = ['present', 'absent', 'deployed', 'undeployed']
|
|
VAPP_OPERATIONS = ['poweron', 'poweroff', 'suspend', 'shutdown',
|
|
'reboot', 'reset', 'noop']
|
|
|
|
|
|
def get_instance(module):
|
|
vapp_name = module.params['vapp_name']
|
|
inst = dict(vapp_name=vapp_name, state='absent')
|
|
try:
|
|
vapp = module.get_vapp(vapp_name)
|
|
if vapp:
|
|
status = module.vca.get_status(vapp.me.get_status())
|
|
inst['status'] = VAPP_STATUS.get(status, 'unknown')
|
|
inst['state'] = 'deployed' if vapp.me.deployed else 'undeployed'
|
|
return inst
|
|
except VcaError:
|
|
return inst
|
|
|
|
|
|
def create(module):
|
|
vdc_name = module.params['vdc_name']
|
|
vapp_name = module.params['vapp_name']
|
|
template_name = module.params['template_name']
|
|
catalog_name = module.params['catalog_name']
|
|
network_name = module.params['network_name']
|
|
network_mode = module.params['network_mode']
|
|
vm_name = module.params['vm_name']
|
|
vm_cpus = module.params['vm_cpus']
|
|
vm_memory = module.params['vm_memory']
|
|
deploy = module.params['state'] == 'deploy'
|
|
poweron = module.params['operation'] == 'poweron'
|
|
|
|
task = module.vca.create_vapp(vdc_name, vapp_name, template_name,
|
|
catalog_name, network_name, 'bridged',
|
|
vm_name, vm_cpus, vm_memory, deploy, poweron)
|
|
|
|
if task is False:
|
|
module.fail('Failed to create vapp: %s' % vapp_name)
|
|
|
|
module.vca.block_until_completed(task)
|
|
|
|
# Connect the network to the Vapp/VM and return asigned IP
|
|
if network_name is not None:
|
|
vm_ip = connect_to_network(module, vdc_name, vapp_name, network_name, network_mode)
|
|
return vm_ip
|
|
|
|
|
|
def delete(module):
|
|
vdc_name = module.params['vdc_name']
|
|
vapp_name = module.params['vapp_name']
|
|
module.vca.delete_vapp(vdc_name, vapp_name)
|
|
|
|
|
|
def do_operation(module):
|
|
vapp_name = module.params['vapp_name']
|
|
operation = module.params['operation']
|
|
|
|
vm_name = module.params.get('vm_name')
|
|
vm = None
|
|
if vm_name:
|
|
vm = module.get_vm(vapp_name, vm_name)
|
|
|
|
if operation == 'poweron':
|
|
operation = 'powerOn'
|
|
elif operation == 'poweroff':
|
|
operation = 'powerOff'
|
|
|
|
cmd = 'power:%s' % operation
|
|
module.get_vapp(vapp_name).execute(cmd, 'post', targetVM=vm)
|
|
|
|
|
|
def set_state(module):
|
|
state = module.params['state']
|
|
vapp = module.get_vapp(module.params['vapp_name'])
|
|
if state == 'deployed':
|
|
action = module.params['operation'] == 'poweron'
|
|
if not vapp.deploy(action):
|
|
module.fail('unable to deploy vapp')
|
|
elif state == 'undeployed':
|
|
action = module.params['operation']
|
|
if action == 'poweroff':
|
|
action = 'powerOff'
|
|
elif action != 'suspend':
|
|
action = None
|
|
if not vapp.undeploy(action):
|
|
module.fail('unable to undeploy vapp')
|
|
|
|
|
|
def connect_to_network(module, vdc_name, vapp_name, network_name, network_mode):
|
|
nets = filter(lambda n: n.name == network_name, module.vca.get_networks(vdc_name))
|
|
if len(nets) != 1:
|
|
module.fail_json("Unable to find network %s " % network_name)
|
|
|
|
the_vdc = module.vca.get_vdc(vdc_name)
|
|
the_vapp = module.vca.get_vapp(the_vdc, vapp_name)
|
|
|
|
if the_vapp and the_vapp.name != vapp_name:
|
|
module.fail_json(msg="Failed to find vapp named %s" % the_vapp.name)
|
|
|
|
# Connect vApp
|
|
task = the_vapp.connect_to_network(nets[0].name, nets[0].href)
|
|
result = module.vca.block_until_completed(task)
|
|
|
|
if result is None:
|
|
module.fail_json(msg="Failed to complete task")
|
|
|
|
# Connect VM
|
|
ip_allocation_mode = None
|
|
if network_mode == 'pool':
|
|
ip_allocation_mode = 'POOL'
|
|
elif network_mode == 'dhcp':
|
|
ip_allocation_mode = 'DHCP'
|
|
|
|
task = the_vapp.connect_vms(nets[0].name, connection_index=0, ip_allocation_mode=ip_allocation_mode)
|
|
if result is None:
|
|
module.fail_json(msg="Failed to complete task")
|
|
|
|
result = module.vca.block_until_completed(task)
|
|
if result is None:
|
|
module.fail_json(msg="Failed to complete task")
|
|
|
|
# Update VApp info and get VM IP
|
|
the_vapp = module.vca.get_vapp(the_vdc, vapp_name)
|
|
if the_vapp is None:
|
|
module.fail_json(msg="Failed to get vapp named %s" % vapp_name)
|
|
|
|
return get_vm_details(module)
|
|
|
|
|
|
def get_vm_details(module):
|
|
vdc_name = module.params['vdc_name']
|
|
vapp_name = module.params['vapp_name']
|
|
vm_name = module.params['vm_name']
|
|
the_vdc = module.vca.get_vdc(vdc_name)
|
|
the_vapp = module.vca.get_vapp(the_vdc, vapp_name)
|
|
if the_vapp and the_vapp.name != vapp_name:
|
|
module.fail_json(msg="Failed to find vapp named %s" % the_vapp.name)
|
|
the_vm_details = dict()
|
|
|
|
for vm in the_vapp.me.Children.Vm:
|
|
sections = vm.get_Section()
|
|
|
|
customization_section = (
|
|
filter(lambda section:
|
|
section.__class__.__name__ ==
|
|
"GuestCustomizationSectionType",
|
|
sections)[0])
|
|
if customization_section.get_AdminPasswordEnabled():
|
|
the_vm_details["vm_admin_password"] = customization_section.get_AdminPassword()
|
|
|
|
virtual_hardware_section = (
|
|
filter(lambda section:
|
|
section.__class__.__name__ ==
|
|
"VirtualHardwareSection_Type",
|
|
sections)[0])
|
|
items = virtual_hardware_section.get_Item()
|
|
ips = []
|
|
_url = '{http://www.vmware.com/vcloud/v1.5}ipAddress'
|
|
for item in items:
|
|
if item.Connection:
|
|
for c in item.Connection:
|
|
if c.anyAttributes_.get(
|
|
_url):
|
|
ips.append(c.anyAttributes_.get(
|
|
_url))
|
|
if len(ips) > 0:
|
|
the_vm_details["vm_ip"] = ips[0]
|
|
|
|
return the_vm_details
|
|
|
|
|
|
def main():
|
|
argument_spec = dict(
|
|
vapp_name=dict(required=True),
|
|
vdc_name=dict(required=True),
|
|
template_name=dict(),
|
|
catalog_name=dict(default='Public Catalog'),
|
|
network_name=dict(),
|
|
network_mode=dict(default='pool', choices=['dhcp', 'static', 'pool']),
|
|
vm_name=dict(),
|
|
vm_cpus=dict(),
|
|
vm_memory=dict(),
|
|
operation=dict(default=DEFAULT_VAPP_OPERATION, choices=VAPP_OPERATIONS),
|
|
state=dict(default='present', choices=VAPP_STATES)
|
|
)
|
|
|
|
module = VcaAnsibleModule(argument_spec=argument_spec,
|
|
supports_check_mode=True)
|
|
|
|
state = module.params['state']
|
|
operation = module.params['operation']
|
|
|
|
instance = get_instance(module)
|
|
|
|
result = dict(changed=False)
|
|
|
|
if instance and state == 'absent':
|
|
if not module.check_mode:
|
|
delete(module)
|
|
result['changed'] = True
|
|
|
|
elif state != 'absent':
|
|
if instance['state'] == 'absent':
|
|
if not module.check_mode:
|
|
result['ansible_facts'] = create(module)
|
|
result['changed'] = True
|
|
|
|
elif instance['state'] != state and state != 'present':
|
|
if not module.check_mode:
|
|
set_state(module)
|
|
result['changed'] = True
|
|
|
|
if operation != instance.get('status') and operation != 'noop':
|
|
if not module.check_mode:
|
|
do_operation(module)
|
|
result['changed'] = True
|
|
result['ansible_facts'] = get_vm_details(module)
|
|
|
|
return module.exit(**result)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|