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 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_volume(vca_client, **kwargs):
"""
create new volume, e.g.:
{
'use_external_resource': False,
'volume': {
'name': 'some-other',
'size': 11
}
}
"""
if ctx.node.properties.get('use_external_resource'):
ctx.logger.info("External resource has been used")
return
vdc_name = get_vcloud_config()['vdc']
name = ctx.node.properties['volume']['name']
size = ctx.node.properties['volume']['size']
size_in_Mb = size * 1024 * 1024
success, disk = vca_client.add_disk(vdc_name, name, size_in_Mb)
if success:
wait_for_task(vca_client, disk.get_Tasks()[0])
ctx.logger.info("Volume node {} has been created".format(name))
else:
raise cfy_exc.NonRecoverableError(
"Disk creation error: {0}".format(disk))
def delete(vca_client, **kwargs):
"""
delete vcloud air network
"""
if ctx.node.properties['use_external_resource'] is True:
del ctx.instance.runtime_properties[VCLOUD_NETWORK_NAME]
ctx.logger.info("Network was not deleted - external resource has"
" been used")
return
network_name = get_network_name(ctx.node.properties)
if not _dhcp_operation(vca_client, network_name, DELETE_POOL):
return set_retry(ctx)
ctx.logger.info("Delete network '{0}'".format(network_name))
success, task = vca_client.delete_vdc_network(
get_vcloud_config()['vdc'], network_name)
if success:
wait_for_task(vca_client, task)
ctx.logger.info(
"Network '{0}' has been successful deleted.".format(network_name))
else:
if task and CANT_DELETE in task:
ctx.logger.info("Network {} in use. Deleting the network skipped.".
format(network_name))
return
raise cfy_exc.NonRecoverableError(
"Could not delete network '{0}': {1}".format(network_name, task))
def delete(vca_client, **kwargs):
"""
delete vcloud air network
"""
if ctx.node.properties['use_external_resource'] is True:
del ctx.instance.runtime_properties[VCLOUD_NETWORK_NAME]
ctx.logger.info("Network was not deleted - external resource has"
" been used")
return
network_name = get_network_name(ctx.node.properties)
if not _dhcp_operation(vca_client, network_name, DELETE_POOL):
return set_retry(ctx)
ctx.logger.info("Delete network '{0}'".format(network_name))
success, task = vca_client.delete_vdc_network(
get_vcloud_config()['vdc'], network_name)
if success:
wait_for_task(vca_client, task)
ctx.logger.info(
"Network '{0}' has been successful deleted.".format(network_name))
else:
if task and CANT_DELETE in task:
ctx.logger.info("Network {} in use. Deleting the network skipped.".
format(network_name))
return
raise cfy_exc.NonRecoverableError(
"Could not delete network '{0}': {1}".format(network_name, 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 create_volume(vca_client, **kwargs):
"""
create new volume, e.g.:
{
'use_external_resource': False,
'volume': {
'name': 'some-other',
'size': 11
}
}
"""
if ctx.node.properties.get('use_external_resource'):
ctx.logger.info("External resource has been used")
return
vdc_name = get_vcloud_config()['vdc']
name = ctx.node.properties['volume']['name']
size = ctx.node.properties['volume']['size']
size_in_Mb = size * 1024 * 1024
ctx.logger.info("Create volume '{0}' to '{1}' with size {2}Mb.".format(
name, vdc_name, size_in_Mb))
success, disk = vca_client.add_disk(vdc_name, name, size_in_Mb)
if success:
wait_for_task(vca_client, disk.get_Tasks()[0])
ctx.logger.info("Volume node '{0}' has been created".format(name))
else:
raise cfy_exc.NonRecoverableError(
"Disk creation error: {0}".format(disk))
def del_ondemand_public_ip(vca_client, gateway, ip, ctx):
task = gateway.deallocate_public_ip(ip)
if task:
wait_for_task(vca_client, task)
ctx.logger.info("Public IP {0} deallocated".format(ip))
else:
raise cfy_exc.NonRecoverableError(
"Can't deallocate public ip {0} for ondemand service".format(ip))
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 save_gateway_configuration(gateway, vca_client):
task = gateway.save_services_configuration()
if task:
wait_for_task(vca_client, task)
return True
else:
error = taskType.parseString(gateway.response.content, True)
if BUSY_MESSAGE in error.message:
return False
else:
raise cfy_exc.NonRecoverableError(error.message)
def del_ondemand_public_ip(vca_client, gateway, ip, ctx):
"""
try to deallocate public ip
"""
task = gateway.deallocate_public_ip(ip)
if task:
wait_for_task(vca_client, task)
ctx.logger.info("Public IP {0} deallocated".format(ip))
else:
raise cfy_exc.NonRecoverableError(
"Can't deallocate public ip {0} for ondemand service".format(ip))
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 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))
wait_for_gateway(vca_client, gateway.get_name(), ctx)
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 stop(vca_client, **kwargs):
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")
wait_for_task(vca_client, task)
def delete(vca_client, **kwargs):
"""
delete vcloud air network
"""
if ctx.node.properties["use_external_resource"] is True:
del ctx.instance.runtime_properties[VCLOUD_NETWORK_NAME]
ctx.logger.info("Network was not deleted - external resource has" " been used")
return
network_name = get_network_name(ctx.node.properties)
_dhcp_operation(vca_client, network_name, DELETE_POOL)
success, task = vca_client.delete_vdc_network(get_vcloud_config()["vdc"], network_name)
if success:
ctx.logger.info("Network {0} has been successful deleted.".format(network_name))
else:
raise cfy_exc.NonRecoverableError("Could not delete network {0}".format(network_name))
wait_for_task(vca_client, task)
def save_gateway_configuration(gateway, vca_client):
"""
save gateway configuration,
return everything successfully finished
raise NonRecoverableError - can't get task description
"""
task = gateway.save_services_configuration()
if task:
wait_for_task(vca_client, task)
return True
else:
error = taskType.parseString(gateway.response.content, True)
if BUSY_MESSAGE in error.message:
return False
else:
raise cfy_exc.NonRecoverableError(error.message)
def delete_volume(vca_client, **kwargs):
"""
drop volume
"""
if ctx.node.properties.get('use_external_resource'):
ctx.logger.info("External resource has been used")
return
vdc_name = get_vcloud_config()['vdc']
name = ctx.node.properties['volume']['name']
success, task = vca_client.delete_disk(vdc_name, name)
if success:
wait_for_task(vca_client, task)
ctx.logger.info("Volume node {} has been deleted".format(name))
else:
raise cfy_exc.NonRecoverableError(
"Disk deletion error: {0}".format(task))
def delete(vca_client, **kwargs):
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")
wait_for_task(vca_client, task)
del ctx.instance.runtime_properties[VCLOUD_VAPP_NAME]
def save_gateway_configuration(gateway, vca_client):
"""
save gateway configuration,
return everything successfully finished
raise NonRecoverableError - can't get task description
"""
task = gateway.save_services_configuration()
if task:
wait_for_task(vca_client, task)
return True
else:
error = taskType.parseString(gateway.response.content, True)
if BUSY_MESSAGE in error.message:
return False
else:
raise cfy_exc.NonRecoverableError(error.message)
def delete_volume(vca_client, **kwargs):
"""
drop volume
"""
if ctx.node.properties.get('use_external_resource'):
ctx.logger.info("External resource has been used")
return
vdc_name = get_vcloud_config()['vdc']
name = ctx.node.properties['volume']['name']
success, task = vca_client.delete_disk(vdc_name, name)
if success:
wait_for_task(vca_client, task)
ctx.logger.info("Volume node {} has been deleted".format(name))
else:
raise cfy_exc.NonRecoverableError(
"Disk deletion error: {0}".format(task))
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")
wait_for_task(vca_client, task)
def get_ondemand_public_ip(vca_client, gateway, ctx):
old_public_ips = set(gateway.get_public_ips())
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")
# 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("Assign public IP {0}".format(new_ip))
else:
raise cfy_exc.NonRecoverableError(
"Can't get new public IP address")
return list(new_ip)[0]
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")
wait_for_task(vca_client, task)
del ctx.instance.runtime_properties[VCLOUD_VAPP_NAME]
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 delete(vca_client, **kwargs):
"""
delete vcloud air network
"""
if ctx.node.properties['use_external_resource'] is True:
del ctx.instance.runtime_properties[VCLOUD_NETWORK_NAME]
ctx.logger.info("Network was not deleted - external resource has"
" been used")
return
network_name = get_network_name(ctx.node.properties)
_dhcp_operation(vca_client, network_name, DELETE_POOL)
success, task = vca_client.delete_vdc_network(get_vcloud_config()['vdc'],
network_name)
if success:
ctx.logger.info(
"Network {0} has been successful deleted.".format(network_name))
else:
raise cfy_exc.NonRecoverableError(
"Could not delete network {0}".format(network_name))
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 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())
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")
# 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("Assign public IP {0}".format(new_ip))
else:
raise cfy_exc.NonRecoverableError(
"Can't get new public IP address")
return list(new_ip)[0]
def test_wait_for_task(self):
fake_client = self.generate_client()
# error in task
fake_task = self.generate_task(vcloud_plugin_common.TASK_STATUS_ERROR)
with mock.patch('vcloud_plugin_common.ctx', mock.MagicMock()):
with self.assertRaises(cfy_exc.NonRecoverableError):
vcloud_plugin_common.wait_for_task(fake_client, fake_task)
# success in task
fake_task = self.generate_task(
vcloud_plugin_common.TASK_STATUS_SUCCESS)
with mock.patch('vcloud_plugin_common.ctx', mock.MagicMock()):
vcloud_plugin_common.wait_for_task(fake_client, fake_task)
# success after wait
fake_task = self.generate_task(None)
fake_task_after_wait = self.generate_task(
vcloud_plugin_common.TASK_STATUS_SUCCESS)
sleep = mock.MagicMock(return_value=None)
response = mock.Mock()
response.content = 'Success'
with mock.patch(
'pyvcloud.schema.vcd.v1_5.schemas.vcloud.taskType.parseString',
mock.MagicMock(return_value=fake_task_after_wait)):
with mock.patch('requests.get',
mock.MagicMock(return_value=response)):
with mock.patch('time.sleep', sleep):
with mock.patch('vcloud_plugin_common.ctx',
mock.MagicMock()):
vcloud_plugin_common.wait_for_task(
fake_client, fake_task)
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 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 test_wait_for_task(self):
fake_client = self.generate_client()
fake_ctx = self.generate_node_context()
# error in task
fake_task = self.generate_task(
vcloud_plugin_common.TASK_STATUS_ERROR
)
with mock.patch('vcloud_plugin_common.ctx', fake_ctx):
with self.assertRaises(cfy_exc.NonRecoverableError):
vcloud_plugin_common.wait_for_task(fake_client, fake_task)
# success in task
fake_task = self.generate_task(
vcloud_plugin_common.TASK_STATUS_SUCCESS
)
with mock.patch('vcloud_plugin_common.ctx', fake_ctx):
vcloud_plugin_common.wait_for_task(fake_client, fake_task)
# success after wait
fake_task = self.generate_task(
None
)
fake_task_after_wait = self.generate_task(
vcloud_plugin_common.TASK_STATUS_SUCCESS
)
sleep = mock.MagicMock(return_value=None)
response = mock.Mock()
response.content = 'Success'
with mock.patch(
'pyvcloud.schema.vcd.v1_5.schemas.vcloud.taskType.parseString',
mock.MagicMock(return_value=fake_task_after_wait)
):
with mock.patch(
'requests.get', mock.MagicMock(return_value=response)
):
with mock.patch(
'time.sleep',
sleep
):
with mock.patch('vcloud_plugin_common.ctx',
fake_ctx):
vcloud_plugin_common.wait_for_task(
fake_client, fake_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...")
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 create(vca_client, **kwargs):
"""
create new vcloud air network, e.g.:
{
'use_external_resource': False,
'resource_id': 'secret_network',
'network': {
'dhcp': {
'dhcp_range': "10.1.1.128-10.1.1.255"
},
'static_range': "10.1.1.2-10.1.1.127",
'gateway_ip': "10.1.1.1",
'edge_gateway': 'gateway',
'name': 'secret_network',
"netmask": '255.255.255.0',
"dns": ["8.8.8.8", "4.4.4.4"]
}
}
"""
vdc_name = get_vcloud_config()['vdc']
if ctx.node.properties['use_external_resource']:
network_name = ctx.node.properties['resource_id']
if not is_network_exists(vca_client, network_name):
raise cfy_exc.NonRecoverableError(
"Can't find external resource: {0}".format(network_name))
ctx.instance.runtime_properties[VCLOUD_NETWORK_NAME] = network_name
ctx.logger.info(
"External resource {0} has been used".format(network_name))
return
net_prop = ctx.node.properties["network"]
network_name = get_network_name(ctx.node.properties)
if network_name in _get_network_list(vca_client,
get_vcloud_config()['vdc']):
raise cfy_exc.NonRecoverableError(
"Network {0} already exists, but parameter "
"'use_external_resource' is 'false' or absent".format(
network_name))
ip = _split_adresses(net_prop['static_range'])
gateway_name = net_prop['edge_gateway']
if not vca_client.get_gateway(vdc_name, gateway_name):
raise cfy_exc.NonRecoverableError(
"Gateway {0} not found".format(gateway_name))
start_address = ip.start
end_address = ip.end
gateway_ip = net_prop["gateway_ip"]
netmask = net_prop["netmask"]
dns1 = ""
dns2 = ""
dns_list = net_prop.get("dns")
if dns_list:
dns1 = dns_list[0]
if len(dns_list) > 1:
dns2 = dns_list[1]
dns_suffix = net_prop.get("dns_suffix")
success, result = vca_client.create_vdc_network(vdc_name, network_name,
gateway_name,
start_address, end_address,
gateway_ip, netmask, dns1,
dns2, dns_suffix)
if success:
ctx.logger.info(
"Network {0} has been successfully created.".format(network_name))
else:
raise cfy_exc.NonRecoverableError(
"Could not create network {0}: {1}".format(network_name, result))
wait_for_task(vca_client, result)
ctx.instance.runtime_properties[VCLOUD_NETWORK_NAME] = network_name
_dhcp_operation(vca_client, network_name, ADD_POOL)
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']
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(vca_client.response.content))
wait_for_task(vca_client, task)
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:
task = vapp.modify_vm_memory(vapp_name, memory)
if task:
wait_for_task(vca_client, task)
ctx.logger.info("Customize VM memory: {0}.".format(memory))
else:
raise cfy_exc.NonRecoverableError(
"Customize VM memory failed: {0}.".format(task)
)
if cpu:
task = vapp.modify_vm_cpu(vapp_name, cpu)
if task:
wait_for_task(vca_client, task)
ctx.logger.info("Customize VM cpu: {0}.".format(cpu))
else:
raise cfy_exc.NonRecoverableError(
"Customize VM cpu failed: {0}.".format(task)
)
ctx.instance.runtime_properties[VCLOUD_VAPP_NAME] = vapp_name
connections = _create_connections_list(vca_client)
# 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}"
.format(network_name, vapp_name))
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}"
.format(vapp_name, network_name))
wait_for_task(vca_client, task)
# customize root password and hostname
custom = server.get(GUEST_CUSTOMIZATION)
if custom:
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
script = _build_script(custom)
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")
wait_for_task(vca_client, task)
# This function avialable from API version 5.6
if vapp.customize_on_next_poweron():
ctx.logger.info("Customizations successful")
else:
raise cfy_exc.NonRecoverableError(
"Can't run customization in next power on")
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']
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(
vca_client.response.content))
wait_for_task(vca_client, task)
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:
task = vapp.modify_vm_memory(vapp_name, memory)
if task:
wait_for_task(vca_client, task)
ctx.logger.info("Customize VM memory: {0}.".format(memory))
else:
raise cfy_exc.NonRecoverableError(
"Customize VM memory failed: {0}.".format(task))
if cpu:
task = vapp.modify_vm_cpu(vapp_name, cpu)
if task:
wait_for_task(vca_client, task)
ctx.logger.info("Customize VM cpu: {0}.".format(cpu))
else:
raise cfy_exc.NonRecoverableError(
"Customize VM cpu failed: {0}.".format(task))
ctx.instance.runtime_properties[VCLOUD_VAPP_NAME] = vapp_name
connections = _create_connections_list(vca_client)
# 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}".format(
network_name, vapp_name))
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}".format(
vapp_name, network_name))
wait_for_task(vca_client, task)
# customize root password and hostname
custom = server.get(GUEST_CUSTOMIZATION)
if custom:
vdc = vca_client.get_vdc(config['vdc'])
vapp = vca_client.get_vapp(vdc, vapp_name)
script = _build_script(custom)
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")
wait_for_task(vca_client, task)
# This function avialable from API version 5.6
if vapp.customize_on_next_poweron():
ctx.logger.info("Customizations successful")
else:
raise cfy_exc.NonRecoverableError(
"Can't run customization in next power on")
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, **kwargs):
"""
create new vcloud air network, e.g.:
{
'use_external_resource': False,
'resource_id': 'secret_network',
'network': {
'dhcp': {
'dhcp_range': "10.1.1.128-10.1.1.255"
},
'static_range': "10.1.1.2-10.1.1.127",
'gateway_ip': "10.1.1.1",
'edge_gateway': 'gateway',
'name': 'secret_network',
"netmask": '255.255.255.0',
"dns": ["8.8.8.8", "4.4.4.4"]
}
}
"""
vdc_name = get_vcloud_config()['vdc']
if ctx.node.properties['use_external_resource']:
network_name = ctx.node.properties['resource_id']
if not is_network_exists(vca_client, network_name):
raise cfy_exc.NonRecoverableError(
"Can't find external resource: {0}".format(network_name))
ctx.instance.runtime_properties[VCLOUD_NETWORK_NAME] = network_name
ctx.logger.info(
"External resource {0} has been used".format(network_name))
return
network_name = get_network_name(ctx.node.properties)
if not ctx.instance.runtime_properties.get(SKIP_CREATE_NETWORK):
net_prop = ctx.node.properties["network"]
if network_name in _get_network_list(vca_client,
get_vcloud_config()['vdc']):
raise cfy_exc.NonRecoverableError(
"Network {0} already exists, but parameter "
"'use_external_resource' is 'false' or absent"
.format(network_name))
ip = _split_adresses(net_prop['static_range'])
gateway_name = net_prop['edge_gateway']
get_gateway(vca_client, gateway_name)
start_address = ip.start
end_address = ip.end
gateway_ip = net_prop["gateway_ip"]
netmask = net_prop["netmask"]
dns1 = ""
dns2 = ""
dns_list = net_prop.get("dns")
if dns_list:
dns1 = dns_list[0]
if len(dns_list) > 1:
dns2 = dns_list[1]
dns_suffix = net_prop.get("dns_suffix")
ctx.logger.info("Create network {0}."
.format(network_name))
success, result = vca_client.create_vdc_network(
vdc_name, network_name, gateway_name, start_address,
end_address, gateway_ip, netmask, dns1, dns2, dns_suffix)
if success:
wait_for_task(vca_client, result)
ctx.logger.info("Network {0} has been successfully created."
.format(network_name))
else:
raise cfy_exc.NonRecoverableError(
"Could not create network {0}: {1}".
format(network_name, result))
ctx.instance.runtime_properties[VCLOUD_NETWORK_NAME] = network_name
if not _dhcp_operation(vca_client, network_name, ADD_POOL):
ctx.instance.runtime_properties[SKIP_CREATE_NETWORK] = True
return set_retry(ctx)
