def configure(vca_client, **kwargs):
ctx.logger.info("Configure server")
server = {'name': ctx.instance.id}
server.update(ctx.node.properties.get('server', {}))
vapp_name = server['name']
config = get_vcloud_config()
custom = server.get(GUEST_CUSTOMIZATION, {})
public_keys = _get_connected_keypairs()
if custom or public_keys:
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
script = _build_script(custom, public_keys)
password = custom.get('admin_password')
computer_name = custom.get('computer_name')
task = vapp.customize_guest_os(
vapp_name,
customization_script=script,
computer_name=computer_name,
admin_password=password
)
if task is None:
raise cfy_exc.NonRecoverableError(
"Could not set guest customization parameters. {0}".
format(error_response(vapp)))
wait_for_task(vca_client, task)
if vapp.customize_on_next_poweron():
ctx.logger.info("Customizations successful")
else:
raise cfy_exc.NonRecoverableError(
"Can't run customization in next power on. {0}".
format(error_response(vapp)))
hardware = server.get('hardware')
if hardware:
cpu = hardware.get('cpu')
memory = hardware.get('memory')
_check_hardware(cpu, memory)
vapp = vca_client.get_vapp(
vca_client.get_vdc(config['vdc']), vapp_name
)
if memory:
try:
task = vapp.modify_vm_memory(vapp_name, memory)
wait_for_task(vca_client, task)
ctx.logger.info("Customize VM memory: '{0}'.".format(memory))
except Exception:
raise cfy_exc.NonRecoverableError(
"Customize VM memory failed: '{0}'. {1}".
format(task, error_response(vapp)))
if cpu:
try:
task = vapp.modify_vm_cpu(vapp_name, cpu)
wait_for_task(vca_client, task)
ctx.logger.info("Customize VM cpu: '{0}'.".format(cpu))
except Exception:
raise cfy_exc.NonRecoverableError(
"Customize VM cpu failed: '{0}'. {1}".
format(task, error_response(vapp)))
def configure(vca_client, **kwargs):
ctx.logger.info("Configure server")
server = {'name': ctx.instance.id}
server.update(ctx.node.properties.get('server', {}))
vapp_name = server['name']
config = get_vcloud_config()
custom = server.get(GUEST_CUSTOMIZATION, {})
public_keys = _get_connected_keypairs()
if custom or public_keys:
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
script = _build_script(custom, public_keys)
password = custom.get('admin_password')
computer_name = custom.get('computer_name')
ctx.logger.info("Customize guest OS")
task = vapp.customize_guest_os(vapp_name,
customization_script=script,
computer_name=computer_name,
admin_password=password)
if task is None:
raise cfy_exc.NonRecoverableError(
"Could not set guest customization parameters. {0}".format(
error_response(vapp)))
wait_for_task(vca_client, task)
if vapp.customize_on_next_poweron():
ctx.logger.info("Customizations successful")
else:
raise cfy_exc.NonRecoverableError(
"Can't run customization in next power on. {0}".format(
error_response(vapp)))
hardware = server.get('hardware')
if hardware:
cpu = hardware.get('cpu')
memory = hardware.get('memory')
_check_hardware(cpu, memory)
vapp = vca_client.get_vapp(vca_client.get_vdc(config['vdc']),
vapp_name)
if memory:
try:
ctx.logger.info("Customize VM memory: '{0}'.".format(memory))
task = vapp.modify_vm_memory(vapp_name, memory)
wait_for_task(vca_client, task)
except Exception:
raise cfy_exc.NonRecoverableError(
"Customize VM memory failed: '{0}'. {1}".format(
task, error_response(vapp)))
if cpu:
try:
ctx.logger.info("Customize VM cpu: '{0}'.".format(cpu))
task = vapp.modify_vm_cpu(vapp_name, cpu)
wait_for_task(vca_client, task)
except Exception:
raise cfy_exc.NonRecoverableError(
"Customize VM cpu failed: '{0}'. {1}".format(
task, error_response(vapp)))
def create(vca_client, **kwargs):
"""create vdc"""
config = get_vcloud_config()
# Subscription service does not support vdc create,
# you must use predefined vdc only
if is_subscription(config['service_type']):
raise cfy_exc.NonRecoverableError(
"Unable create VDC on subscription service.")
if ctx.node.properties.get(USE_EXTERNAL_RESOURCE):
# use external resource, does not create anything
res_id = ctx.node.properties[RESOURCE_ID]
ctx.instance.runtime_properties[VDC_NAME] = res_id
vdc = vca_client.get_vdc(res_id)
if not vdc:
raise cfy_exc.NonRecoverableError(
"Unable to find external VDC {0}.".format(res_id))
ctx.logger.info("External resource {0} has been used".format(res_id))
else:
# create new vdc
vdc_name = ctx.node.properties.get('name')
if not vdc_name:
raise cfy_exc.NonRecoverableError("'vdc_name' not specified.")
task = vca_client.create_vdc(vdc_name)
if not task:
raise cfy_exc.NonRecoverableError(
"Could not create VDC: {0}".format(error_response(vca_client)))
wait_for_task(vca_client, task)
def create(vca_client, **kwargs):
"""create vdc"""
config = get_vcloud_config()
# Subscription service does not support vdc create,
# you must use predefined vdc only
if is_subscription(config['service_type']):
raise cfy_exc.NonRecoverableError(
"Unable create VDC on subscription service.")
if ctx.node.properties.get(USE_EXTERNAL_RESOURCE):
# use external resource, does not create anything
res_id = ctx.node.properties[RESOURCE_ID]
ctx.instance.runtime_properties[VDC_NAME] = res_id
vdc = vca_client.get_vdc(res_id)
if not vdc:
raise cfy_exc.NonRecoverableError(
"Unable to find external VDC {0}."
.format(res_id))
ctx.logger.info(
"External resource {0} has been used".format(res_id))
else:
# create new vdc
vdc_name = ctx.node.properties.get('name')
if not vdc_name:
raise cfy_exc.NonRecoverableError("'vdc_name' not specified.")
task = vca_client.create_vdc(vdc_name)
if not task:
raise cfy_exc.NonRecoverableError("Could not create VDC: {0}"
.format(error_response(vca_client)))
wait_for_task(vca_client, task)
def start(vca_client, **kwargs):
"""
power on server and wait network connection availability for host
"""
if ctx.node.properties.get('use_external_resource'):
ctx.logger.info('not starting server since an external server is '
'being used')
else:
vapp_name = get_vapp_name(ctx.instance.runtime_properties)
config = get_vcloud_config()
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
if _vapp_is_on(vapp) is False:
ctx.logger.info("Power-on VApp {0}".format(vapp_name))
task = vapp.poweron()
if not task:
raise cfy_exc.NonRecoverableError(
"Could not power-on vApp. {0}".format(
error_response(vapp)))
wait_for_task(vca_client, task)
if not _get_state(vca_client):
return ctx.operation.retry(
message="Waiting for VM's configuration to complete",
retry_after=5)
def start(vca_client, **kwargs):
"""
power on server and wait network connection availability for host
"""
if ctx.node.properties.get('use_external_resource'):
ctx.logger.info('not starting server since an external server is '
'being used')
else:
vapp_name = get_vapp_name(ctx.instance.runtime_properties)
config = get_vcloud_config()
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
if _vapp_is_on(vapp) is False:
ctx.logger.info("Power-on VApp {0}".format(vapp_name))
task = vapp.poweron()
if not task:
raise cfy_exc.NonRecoverableError(
"Could not power-on vApp. {0}".
format(error_response(vapp)))
wait_for_task(vca_client, task)
if not _get_state(vca_client):
return ctx.operation.retry(
message="Waiting for VM's configuration to complete",
retry_after=5)
def _power_on_vm(vca_client, vapp, vapp_name):
"""Poweron VM"""
if _vapp_is_on(vapp) is False:
ctx.logger.info("Power-on VApp {0}".format(vapp_name))
task = vapp.poweron()
if not task:
raise cfy_exc.NonRecoverableError(
"Could not power-on vApp. {0}".
format(error_response(vapp)))
wait_for_task(vca_client, task)
def _volume_operation(vca_client, operation):
"""
attach/detach volume
"""
vdc_name = get_vcloud_config()['vdc']
vdc = vca_client.get_vdc(vdc_name)
vmName = get_vapp_name(ctx.target.instance.runtime_properties)
if ctx.source.node.properties.get('use_external_resource'):
volumeName = ctx.source.node.properties['resource_id']
else:
volumeName = ctx.source.node.properties['volume']['name']
vapp = vca_client.get_vapp(vdc, vmName)
for ref in vca_client.get_diskRefs(vdc):
if ref.name == volumeName:
if operation == 'ATTACH':
ctx.logger.info("Attach volume node '{0}'.".format(volumeName))
task = vapp.attach_disk_to_vm(vmName, ref)
if task:
wait_for_task(vca_client, task)
ctx.logger.info(
"Volume node '{0}' has been attached".format(
volumeName))
else:
raise cfy_exc.NonRecoverableError(
"Can't attach disk: '{0}' with error: {1}".format(
volumeName, error_response(vapp)))
elif operation == 'DETACH':
ctx.logger.info("Detach volume node '{0}'.".format(volumeName))
task = vapp.detach_disk_from_vm(vmName, ref)
if task:
wait_for_task(vca_client, task)
ctx.logger.info(
"Volume node '{0}' has been detached.".format(
volumeName))
else:
raise cfy_exc.NonRecoverableError(
"Can't detach disk: '{0}'. With error: {1}".format(
volumeName, error_response(vapp)))
else:
raise cfy_exc.NonRecoverableError(
"Unknown operation '{0}'".format(operation))
def _volume_operation(vca_client, operation):
"""
attach/detach volume
"""
vdc_name = get_vcloud_config()['vdc']
vdc = vca_client.get_vdc(vdc_name)
vmName = get_vapp_name(ctx.target.instance.runtime_properties)
if ctx.source.node.properties.get('use_external_resource'):
volumeName = ctx.source.node.properties['resource_id']
else:
volumeName = ctx.source.node.properties['volume']['name']
vapp = vca_client.get_vapp(vdc, vmName)
for ref in vca_client.get_diskRefs(vdc):
if ref.name == volumeName:
if operation == 'ATTACH':
ctx.logger.info("Attach volume node '{0}'.".format(volumeName))
task = vapp.attach_disk_to_vm(vmName, ref)
if task:
wait_for_task(vca_client, task)
ctx.logger.info(
"Volume node '{0}' has been attached".format(volumeName))
else:
raise cfy_exc.NonRecoverableError(
"Can't attach disk: '{0}' with error: {1}".
format(volumeName, error_response(vapp)))
elif operation == 'DETACH':
ctx.logger.info("Detach volume node '{0}'.".format(volumeName))
task = vapp.detach_disk_from_vm(vmName, ref)
if task:
wait_for_task(vca_client, task)
ctx.logger.info(
"Volume node '{0}' has been detached.".
format(volumeName))
else:
raise cfy_exc.NonRecoverableError(
"Can't detach disk: '{0}'. With error: {1}".
format(volumeName, error_response(vapp)))
else:
raise cfy_exc.NonRecoverableError(
"Unknown operation '{0}'".format(operation))
def del_ondemand_public_ip(vca_client, gateway, ip, ctx):
"""
try to deallocate public ip
"""
ctx.logger.info("Try to deallocate public IP {0}".format(ip))
task = gateway.deallocate_public_ip(ip)
if task:
wait_for_task(vca_client, task)
ctx.logger.info("Public IP {0} was deallocated".format(ip))
else:
raise cfy_exc.NonRecoverableError(
"Can't deallocate public ip {0}. {1} for ondemand service".
format(ip, error_response(gateway)))
def delete(vca_client, **kwargs):
"""delete vdc"""
# external resource - no actions
if ctx.node.properties.get(USE_EXTERNAL_RESOURCE):
ctx.logger.info('Not deleting VDC since an external VDC is '
'being used')
else:
# created in our workflow
vdc_name = ctx.node.properties.get('name')
status, task = vca_client.delete_vdc(vdc_name)
if not status:
raise cfy_exc.NonRecoverableError(
"Could not delete VDC: {0}".format(error_response(vca_client)))
wait_for_task(vca_client, task)
# clean up runtime_properties
if VDC_NAME in ctx.instance.runtime_properties:
del ctx.instance.runtime_properties[VDC_NAME]
def delete(vca_client, **kwargs):
"""delete vdc"""
# external resource - no actions
if ctx.node.properties.get(USE_EXTERNAL_RESOURCE):
ctx.logger.info('Not deleting VDC since an external VDC is '
'being used')
else:
# created in our workflow
vdc_name = ctx.node.properties.get('name')
status, task = vca_client.delete_vdc(vdc_name)
if not status:
raise cfy_exc.NonRecoverableError("Could not delete VDC: {0}"
.format(error_response(vca_client)))
wait_for_task(vca_client, task)
# clean up runtime_properties
if VDC_NAME in ctx.instance.runtime_properties:
del ctx.instance.runtime_properties[VDC_NAME]
def stop(vca_client, **kwargs):
"""
poweroff server, if external resource - server stay poweroned
"""
if ctx.node.properties.get('use_external_resource'):
ctx.logger.info('not stopping server since an external server is '
'being used')
else:
vapp_name = get_vapp_name(ctx.instance.runtime_properties)
config = get_vcloud_config()
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
ctx.logger.info("Power-off and undeploy VApp {0}".format(vapp_name))
task = vapp.undeploy()
if not task:
raise cfy_exc.NonRecoverableError("Could not undeploy vApp {0}".
format(error_response(vapp)))
wait_for_task(vca_client, task)
def stop(vca_client, **kwargs):
"""
poweroff server, if external resource - server stay poweroned
"""
if ctx.node.properties.get('use_external_resource'):
ctx.logger.info('not stopping server since an external server is '
'being used')
else:
vapp_name = get_vapp_name(ctx.instance.runtime_properties)
config = get_vcloud_config()
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
ctx.logger.info("Power-off and undeploy VApp {0}".format(vapp_name))
task = vapp.undeploy()
if not task:
raise cfy_exc.NonRecoverableError(
"Could not undeploy vApp {0}".format(error_response(vapp)))
wait_for_task(vca_client, task)
def delete(vca_client, **kwargs):
"""
delete server
"""
if ctx.node.properties.get('use_external_resource'):
ctx.logger.info('not deleting server since an external server is '
'being used')
else:
vapp_name = get_vapp_name(ctx.instance.runtime_properties)
config = get_vcloud_config()
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
ctx.logger.info("Deleting VApp {0}".format(vapp_name))
task = vapp.delete()
if not task:
raise cfy_exc.NonRecoverableError("Could not delete vApp {0}".
format(error_response(vapp)))
wait_for_task(vca_client, task)
del ctx.instance.runtime_properties[VCLOUD_VAPP_NAME]
def delete(vca_client, **kwargs):
"""
delete server
"""
if ctx.node.properties.get('use_external_resource'):
ctx.logger.info('not deleting server since an external server is '
'being used')
else:
vapp_name = get_vapp_name(ctx.instance.runtime_properties)
config = get_vcloud_config()
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
ctx.logger.info("Deleting VApp {0}".format(vapp_name))
task = vapp.delete()
if not task:
raise cfy_exc.NonRecoverableError(
"Could not delete vApp {0}".format(error_response(vapp)))
wait_for_task(vca_client, task)
del ctx.instance.runtime_properties[VCLOUD_VAPP_NAME]
def get_ondemand_public_ip(vca_client, gateway, ctx):
"""
try to allocate new public ip for ondemand service
"""
old_public_ips = set(gateway.get_public_ips())
ctx.logger.info("Try to allocate public IP")
task = gateway.allocate_public_ip()
if task:
wait_for_task(vca_client, task)
else:
raise cfy_exc.NonRecoverableError(
"Can't get public ip for ondemand service {0}".format(error_response(gateway)))
# update gateway for new IP address
gateway = vca_client.get_gateways(get_vcloud_config()['vdc'])[0]
new_public_ips = set(gateway.get_public_ips())
new_ip = new_public_ips - old_public_ips
if new_ip:
ctx.logger.info("Public IP {0} was asigned.".format(new_ip))
else:
raise cfy_exc.NonRecoverableError(
"Can't get new public IP address")
return list(new_ip)[0]
def get_ondemand_public_ip(vca_client, gateway, ctx):
"""
try to allocate new public ip for ondemand service
"""
old_public_ips = set(gateway.get_public_ips())
allocated_ips = set([address.external
for address in collectAssignedIps(gateway)])
available_ips = old_public_ips - allocated_ips
if available_ips:
new_ip = list(available_ips)[0]
ctx.logger.info("Public IP {0} was reused.".format(new_ip))
return new_ip
for i in xrange(RETRY_COUNT):
ctx.logger.info("Try to allocate public IP")
wait_for_gateway(vca_client, gateway.get_name(), ctx)
task = gateway.allocate_public_ip()
if task:
try:
wait_for_task(vca_client, task)
break
except cfy_exc.NonRecoverableError:
continue
else:
raise cfy_exc.NonRecoverableError(
"Can't get public ip for ondemand service {0}".
format(error_response(gateway)))
# update gateway for new IP address
gateway = vca_client.get_gateways(get_vcloud_config()['vdc'])[0]
new_public_ips = set(gateway.get_public_ips())
new_ip = new_public_ips - old_public_ips
if new_ip:
ctx.logger.info("Public IP {0} was asigned.".format(new_ip))
else:
raise cfy_exc.NonRecoverableError(
"Can't get new public IP address")
return list(new_ip)[0]
def remove_keys(vca_client, **kwargs):
ctx.logger.info("Remove public keys from VM.")
relationships = getattr(ctx.target.instance, 'relationships', None)
if relationships:
public_keys = [
relationship.target.instance.runtime_properties['public_key']
for relationship in relationships
if 'public_key' in
relationship.target.instance.runtime_properties
]
else:
return
vdc = vca_client.get_vdc(get_vcloud_config()['vdc'])
vapp_name = ctx.target.instance.id
vapp = vca_client.get_vapp(vdc, vapp_name)
if not vapp:
vapp_name = ctx.target.node.properties['server'].get('name', '')
vapp = vca_client.get_vapp(vdc, vapp_name)
if not vapp:
raise cfy_exc.NonRecoverableError(
"Unable to find vAPP server "
"by its name {0}.".format(vapp_name))
ctx.logger.info("Using vAPP {0}".format(str(vapp_name)))
script = "#!/bin/sh\n" + _build_public_keys_script(public_keys,
_remove_key_script)
task = vapp.undeploy()
if not task:
raise cfy_exc.NonRecoverableError(
"Can't power off VM. {0}".format(vapp_name))
wait_for_task(vca_client, task)
task = vapp.customize_guest_os(
vapp_name,
customization_script=script)
if not task:
raise cfy_exc.NonRecoverableError(
"Could not set guest customization parameters. {0}.".
format(error_response(vapp)))
wait_for_task(vca_client, task)
if vapp.customize_on_next_poweron():
ctx.logger.info("Customizations successful.")
else:
customization_task = vapp.force_customization(vapp_name)
if customization_task:
ctx.logger.info("Customizations forced")
wait_for_task(vca_client, customization_task)
else:
raise cfy_exc.NonRecoverableError(
"Can't run customization on next power on. {0}.".
format(error_response(vapp)))
vapp = vca_client.get_vapp(vdc, vapp_name)
task = vapp.poweron()
if not task:
raise cfy_exc.NonRecoverableError(
"Can't poweron VM. {0}".format(vapp_name))
wait_for_task(vca_client, task)
ctx.logger.info("Power on after deleting public key successful.")
ctx.logger.info("Remove keys from properties.")
host_rt_properties = ctx.target.instance.runtime_properties
if SSH_KEY in host_rt_properties:
del host_rt_properties[SSH_KEY]
def _create(vca_client, config, server):
"""
create server by template,
customize:
* hardware: memmory/cpu
* software: root password, computer internal hostname
connect vm to network
"""
vapp_name = server['name']
vapp_template = server['template']
vapp_catalog = server['catalog']
connections = _create_connections_list(vca_client)
ctx.logger.info("Creating VApp with parameters: {0}".format(server))
task = vca_client.create_vapp(config['vdc'],
vapp_name,
vapp_template,
vapp_catalog,
vm_name=vapp_name)
if not task:
raise cfy_exc.NonRecoverableError("Could not create vApp: {0}".format(
error_response(vca_client)))
wait_for_task(vca_client, task)
ctx.instance.runtime_properties[VCLOUD_VAPP_NAME] = vapp_name
# we allways have connection to management_network_name
if connections:
for index, connection in enumerate(connections):
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
if vapp is None:
raise cfy_exc.NonRecoverableError(
"vApp '{0}' could not be found".format(vapp_name))
network_name = connection.get('network')
network = get_network(vca_client, network_name)
ctx.logger.info("Connect network '{0}' to server '{1}'.".format(
network_name, vapp_name))
task = vapp.connect_to_network(network_name, network.get_href())
if not task:
raise cfy_exc.NonRecoverableError(
"Could not add network {0} to VApp {1}. {2}".format(
network_name, vapp_name, error_response(vapp)))
wait_for_task(vca_client, task)
connections_primary_index = None
if connection.get('primary_interface'):
connections_primary_index = index
ip_address = connection.get('ip_address')
mac_address = connection.get('mac_address')
ip_allocation_mode = connection.get('ip_allocation_mode',
'POOL').upper()
connection_args = {
'network_name': network_name,
'connection_index': index,
'connections_primary_index': connections_primary_index,
'ip_allocation_mode': ip_allocation_mode,
'mac_address': mac_address,
'ip_address': ip_address
}
ctx.logger.info("Connecting network with parameters {0}".format(
str(connection_args)))
task = vapp.connect_vms(**connection_args)
if task is None:
raise cfy_exc.NonRecoverableError(
"Could not connect vApp {0} to network {1}. {2}".format(
vapp_name, network_name, error_response(vapp)))
wait_for_task(vca_client, task)
def _create(vca_client, config, server):
"""
create server by template,
customize:
* hardware: memmory/cpu
* software: root password, computer internal hostname
connect vm to network
"""
vapp_name = server['name']
vapp_template = server['template']
vapp_catalog = server['catalog']
connections = _create_connections_list(vca_client)
ctx.logger.info("Creating VApp with parameters: {0}".format(server))
task = vca_client.create_vapp(config['vdc'],
vapp_name,
vapp_template,
vapp_catalog,
vm_name=vapp_name)
if not task:
raise cfy_exc.NonRecoverableError("Could not create vApp: {0}"
.format(error_response(vca_client)))
wait_for_task(vca_client, task)
ctx.instance.runtime_properties[VCLOUD_VAPP_NAME] = vapp_name
# we allways have connection to management_network_name
if connections:
for index, connection in enumerate(connections):
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
if vapp is None:
raise cfy_exc.NonRecoverableError(
"vApp '{0}' could not be found".format(vapp_name))
network_name = connection.get('network')
network = get_network(vca_client, network_name)
task = vapp.connect_to_network(network_name, network.get_href())
if not task:
raise cfy_exc.NonRecoverableError(
"Could not add network {0} to VApp {1}. {2}"
.format(network_name, vapp_name, error_response(vapp)))
wait_for_task(vca_client, task)
connections_primary_index = None
if connection.get('primary_interface'):
connections_primary_index = index
ip_address = connection.get('ip_address')
mac_address = connection.get('mac_address')
ip_allocation_mode = connection.get('ip_allocation_mode',
'POOL').upper()
connection_args = {
'network_name': network_name,
'connection_index': index,
'connections_primary_index': connections_primary_index,
'ip_allocation_mode': ip_allocation_mode,
'mac_address': mac_address,
'ip_address': ip_address
}
ctx.logger.info("Connecting network with parameters {0}"
.format(str(connection_args)))
task = vapp.connect_vms(**connection_args)
if task is None:
raise cfy_exc.NonRecoverableError(
"Could not connect vApp {0} to network {1}. {2}"
.format(vapp_name, network_name, error_response(vapp)))
wait_for_task(vca_client, task)
def configure(vca_client, **kwargs):
if ctx.node.properties.get('use_external_resource'):
ctx.logger.info('Avoiding external resource configuration.')
else:
ctx.logger.info("Configure server")
server = {'name': ctx.instance.id}
server.update(ctx.node.properties.get('server', {}))
ctx.logger.info("Server properties: {0}"
.format(str(server)))
vapp_name = server['name']
config = get_vcloud_config()
custom = server.get(GUEST_CUSTOMIZATION, {})
public_keys = _get_connected_keypairs()
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
if not vapp:
raise cfy_exc.NonRecoverableError(
"Unable to find vAPP server "
"by its name {0}.".format(vapp_name))
ctx.logger.info("Using vAPP {0}".format(str(vapp_name)))
hardware = server.get('hardware')
if hardware:
cpu = hardware.get('cpu')
memory = hardware.get('memory')
_check_hardware(cpu, memory)
if memory:
try:
ctx.logger.info(
"Customize VM memory: '{0}'.".format(memory)
)
task = vapp.modify_vm_memory(vapp_name, memory)
wait_for_task(vca_client, task)
except Exception:
raise cfy_exc.NonRecoverableError(
"Customize VM memory failed: '{0}'. {1}".
format(task, error_response(vapp)))
if cpu:
try:
ctx.logger.info(
"Customize VM cpu: '{0}'.".format(cpu)
)
task = vapp.modify_vm_cpu(vapp_name, cpu)
wait_for_task(vca_client, task)
except Exception:
raise cfy_exc.NonRecoverableError(
"Customize VM cpu failed: '{0}'. {1}".
format(task, error_response(vapp)))
if custom or public_keys:
script = _build_script(custom, public_keys)
password = custom.get('admin_password')
computer_name = custom.get('computer_name')
ctx.logger.info("Customizing guest OS.")
task = vapp.customize_guest_os(
vapp_name,
customization_script=script,
computer_name=computer_name,
admin_password=password
)
if task is None:
raise cfy_exc.NonRecoverableError(
"Could not set guest customization parameters. {0}".
format(error_response(vapp)))
wait_for_task(vca_client, task)
if vapp.customize_on_next_poweron():
ctx.logger.info("Customizations successful")
else:
customization_task = vapp.force_customization(vapp_name)
if customization_task:
ctx.logger.info("Customizations forced")
wait_for_task(vca_client, customization_task)
else:
raise cfy_exc.NonRecoverableError(
"Can't run customization in next power on. {0}".
format(error_response(vapp)))
if not _is_primary_connection_has_ip(vapp):
ctx.logger.info("Power on server for get dhcp ip.")
# we have to start vapp before continue
_power_on_vm(vca_client, vapp, vapp_name)
for attempt in xrange(RETRY_COUNT):
vapp = vca_client.get_vapp(vdc, vapp_name)
if _is_primary_connection_has_ip(vapp):
return
ctx.logger.info(
"No ip assigned. Retrying... {}/{} attempt."
.format(attempt + 1, RETRY_COUNT)
)
time.sleep(GATEWAY_TIMEOUT)
ctx.logger.info("We dont recieve ip, try next time...")