def test_0060_detach_disk_from_vm_in_vapp(self):
"""Test the method vapp.detach_disk_to_vm().
Invoke the method for the second independent disk, detach it from the
first vm of the vApp created during setup. We need to power down the
vm before running this test, and power it back on once the test
is over.
This test passes if the disk detachment task succeeds.
"""
vdc = Environment.get_test_vdc(TestDisk._client)
vapp = VApp(TestDisk._client, href=TestDisk._test_vapp_href)
vm_name = TestDisk._test_vapp_first_vm_name
disk = vdc.get_disk(disk_id=TestDisk._idisk2_id)
# vm needs to be powered off for detach to succeed.
is_vapp_powered_on_before_test = vapp.is_powered_on()
if is_vapp_powered_on_before_test:
task = vapp.power_off()
TestDisk._client.get_task_monitor().wait_for_success(task=task)
vapp.reload()
task = vapp.detach_disk_from_vm(disk_href=disk.get('href'),
vm_name=vm_name)
TestDisk._client.get_task_monitor().wait_for_success(task=task)
vapp.reload()
# restore vApp to powered on state (if required)
if is_vapp_powered_on_before_test:
task = vapp.power_on()
TestDisk._client.get_task_monitor().wait_for_success(task=task)
def power_on(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
vapp = self.get_vapp()
try:
if not vapp.is_powered_on():
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client,
name=vapp_name,
resource=vapp_resource)
power_on_vapp_task = vapp.power_on()
self.execute_task(power_on_vapp_task)
response['msg'] = 'Vapp {} has been powered on.'.format(
vapp_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp {} is already powered on.'.format(
vapp_name)
except OperationNotSupportedException:
response[
'warnings'] = 'Operation is not supported. You may have no VM(s) in {}'.format(
vapp_name)
return response
def power_on(ctx, name):
try:
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
task = vapp.power_on()
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def test_0070_upgrade_virtual_hardware(self):
vapp_obj = VApp(VAppTest._client, href=VAppTest._test_vapp)
self._power_off_and_undeploy(vapp_obj)
result = VAppTest._runner.invoke(
vapp, args=['upgrade-virtual-hardware', VAppTest._test_vapp_name])
self.assertEqual(0, result.exit_code)
result = VAppTest._runner.invoke(
vapp, args=['deploy', VAppTest._test_vapp_name])
self.assertEqual(0, result.exit_code)
vapp_obj.reload()
task = vapp_obj.power_on()
VAppTest._client.get_task_monitor().wait_for_success(task)
def update(client, context, vappInfo):
logging.info("__INIT__update[Vapp]")
cresult = vapp_pb2.UpdateVAppResult()
cresult.updated = False
print("Vapp[ {0} ], Vdc[ {1} ]".format(vappInfo.name, vappInfo.vdc))
org_resource = client.get_org()
org = Org(client, resource=org_resource)
try:
vdc_resource = org.get_vdc(vappInfo.vdc)
vdc = VDC(client, name=vappInfo.vdc, resource=vdc_resource)
vapp_resource = vdc.get_vapp(vappInfo.name)
vapp = VApp(client, name=vappInfo.name, resource=vapp_resource)
resp = None
if (vappInfo.power_on == True):
logging.info("Powering on [Vapp %v]".format(vappInfo.name))
resp = vapp.power_on()
else:
logging.info("Powering off [Vapp %v]".format(vappInfo.name))
resp = vapp.undeploy()
task = client.get_task_monitor().wait_for_status(
task=resp,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st == TaskStatus.SUCCESS.value:
message = 'status : {0} '.format(st)
logging.info(message)
cresult.updated = True
else:
raise errors.VappUpdateError(
etree.tostring(task, pretty_print=True))
except Exception as e:
error_message = '__ERROR_updating [Vapp] power_on={0} for Vapp {1} . __ErrorMessage__ {2}'.format(
vappInfo.power_on, vappInfo.name, str(e))
logging.warn(error_message)
cresult.updated = False
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
logging.info("__DONE__update[Vapp]")
return cresult
def update(client, context, vappInfo):
logging.info("__INIT__update[Vapp]")
cresult = vapp_pb2.UpdateVAppResult()
cresult.updated = False
print("Vapp[ {0} ], Vdc[ {1} ]".format(vappInfo.name, vappInfo.vdc))
org_resource = client.get_org()
org = Org(client, resource=org_resource)
try:
vdc_resource = org.get_vdc(vappInfo.vdc)
vdc = VDC(client, name=vappInfo.vdc, resource=vdc_resource)
vapp_resource = vdc.get_vapp(vappInfo.name)
vapp = VApp(client, name=vappInfo.name, resource=vapp_resource)
resp = None
if (vappInfo.power_on == True):
logging.info("Powering on [Vapp %v]".format(vappInfo.name))
resp = vapp.power_on()
else:
logging.info("Powering off [Vapp %v]".format(vappInfo.name))
resp = vapp.undeploy()
task = client.get_task_monitor().wait_for_status(
task=resp,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st == TaskStatus.SUCCESS.value:
message = 'status : {0} '.format(st)
logging.info(message)
cresult.updated = True
else:
raise errors.VappUpdateError(
etree.tostring(task, pretty_print=True))
except Exception as e:
error_message = '__ERROR_updating [Vapp] power_on={0} for Vapp {1} . __ErrorMessage__ {2}'.format(
vappInfo.power_on, vappInfo.name, str(e))
logging.warn(error_message)
cresult.updated = False
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
logging.info("__DONE__update[Vapp]")
return cresult
def power_on(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_on_vapp_task = vapp.power_on()
self.execute_task(power_on_vapp_task)
response['msg'] = 'Vapp {} has been powered on.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already powered on.'.format(vapp_name)
return response
def power_on(self):
params = self.module.params
client = self.module.client
vdc_name = params.get('vdc')
vapp_name = params.get('name')
response = dict()
vdc = self.get_vdc_object(vdc_name)
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, name=vapp_name, resource=vapp_resource)
power_on_vapp_task = vapp.power_on()
self.execute_task(power_on_vapp_task)
response['msg'] = 'Vapp {} has been powered on.'.format(vapp_name)
response['changed'] = True
return response
def power_on(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_on_vapp_task = vapp.power_on()
self.execute_task(power_on_vapp_task)
response['msg'] = 'Vapp {} has been powered on.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already powered on.'.format(
vapp_name)
return response
def power_on(ctx, name, vm_names):
try:
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
if len(vm_names) == 0:
task = vapp.power_on()
stdout(task, ctx)
else:
for vm_name in vm_names:
vm = VM(client, resource=vapp.get_vm(vm_name))
task = vm.power_on()
stdout(task, ctx)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def test_0060_download_ova(self):
vapp_obj = VApp(VAppTest._client, href=VAppTest._test_vapp)
self._power_off_and_undeploy(vapp_obj)
result = VAppTest._runner.invoke(
vapp,
args=[
'download', VAppTest._test_vapp_name, VAppTest._ova_file_name,
'-o'
])
self.assertEqual(0, result.exit_code)
result = VAppTest._runner.invoke(
vapp, args=['deploy', VAppTest._test_vapp_name])
self.assertEqual(0, result.exit_code)
vapp_obj.reload()
task = vapp_obj.power_on()
VAppTest._client.get_task_monitor().wait_for_success(task)
# Remove downloaded vapp file
os.remove(VAppTest._ova_file_name)
def power_on(ctx, name, vm_names):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
if len(vm_names) == 0:
task = vapp.power_on()
stdout(task, ctx)
else:
for vm_name in vm_names:
vm = VM(client, resource=vapp.get_vm(vm_name))
task = vm.power_on()
stdout(task, ctx)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def test_0090_install_retain_temp_vapp(config, unregister_cse_before_test):
"""Test install.
Installation options: '--config', '--template', '--ssh-key',
'--retain-temp-vapp'.
Tests that installation:
- downloads/uploads ova file,
- creates photon temp vapp,
- creates k8s templates
- skips deleting the temp vapp
- checks that proper packages are installed in the vm in temp vApp
command: cse install --config cse_test_config.yaml --retain-temp-vapp
--ssh-key ~/.ssh/id_rsa.pub
required files: ~/.ssh/id_rsa.pub, cse_test_config.yaml
expected: cse registered, catalog exists, source ovas exist,
temp vapps exist, k8s templates exist.
"""
cmd = f"install --config {env.ACTIVE_CONFIG_FILEPATH} --ssh-key " \
f"{env.SSH_KEY_FILEPATH} --retain-temp-vapp"
result = env.CLI_RUNNER.invoke(cli, cmd.split(), catch_exceptions=False)
assert result.exit_code == 0,\
testutils.format_command_info('cse', cmd, result.exit_code,
result.output)
# check that cse was registered correctly
env.check_cse_registration(config['amqp']['routing_key'],
config['amqp']['exchange'])
vdc = VDC(env.CLIENT, href=env.VDC_HREF)
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
for template_config in env.TEMPLATE_DEFINITIONS:
# check that source ova file exists in catalog
assert env.catalog_item_exists(
template_config['source_ova_name']), \
'Source ova file does not existswhen it should.'
# check that k8s templates exist
catalog_item_name = get_revisioned_template_name(
template_config['name'], template_config['revision'])
assert env.catalog_item_exists(catalog_item_name), \
'k8s template does not exist when it should.'
# check that temp vapp exists
temp_vapp_name = testutils.get_temp_vapp_name(template_config['name'])
try:
vdc.reload()
vapp_resource = vdc.get_vapp(temp_vapp_name)
except EntityNotFoundException:
assert False, 'vApp does not exist when it should.'
# ssh into vms to check for installed software
vapp = VApp(env.CLIENT, resource=vapp_resource)
# The temp vapp is shutdown before the template is captured, it
# needs to be powered on before trying to ssh into it.
task = vapp.power_on()
env.CLIENT.get_task_monitor().wait_for_success(task)
# HACK! let the ssh daemon come up
time.sleep(env.WAIT_INTERVAL) # 30 seconds
ip = vapp.get_primary_ip(TEMP_VAPP_VM_NAME)
try:
ssh_client.connect(ip, username='******')
# run different commands depending on OS
if 'photon' in temp_vapp_name:
script_filepath = get_local_script_filepath(
template_config['name'], template_config['revision'],
ScriptFile.CUST)
script = read_data_file(script_filepath)
pattern = r'(kubernetes\S*)'
packages = re.findall(pattern, script)
stdin, stdout, stderr = ssh_client.exec_command("rpm -qa")
installed = [line.strip('.x86_64\n') for line in stdout]
for package in packages:
assert package in installed, \
f"{package} not found in Photon VM"
elif 'ubuntu' in temp_vapp_name:
script_filepath = get_local_script_filepath(
template_config['name'], template_config['revision'],
ScriptFile.CUST)
script = read_data_file(script_filepath)
pattern = r'((kubernetes|docker\S*|kubelet|kubeadm|kubectl)\S*=\S*)' # noqa: E501
packages = [tup[0] for tup in re.findall(pattern, script)]
cmd = "dpkg -l | awk '{print $2\"=\"$3}'"
stdin, stdout, stderr = ssh_client.exec_command(cmd)
installed = [line.strip() for line in stdout]
for package in packages:
assert package in installed, \
f"{package} not found in Ubuntu VM"
finally:
if ssh_client:
ssh_client.close()
def create_template(ctx, config, client, org, vdc_resource, catalog,
no_capture, template):
ctx.obj = {}
ctx.obj['client'] = client
try:
source_ova_item = org.get_catalog_item(config['broker']['catalog'],
template['source_ova_name'])
except Exception:
source_ova_item = upload_source_ova(config, client, org, template)
click.secho('Find source ova \'%s\': %s' %
(template['source_ova_name'],
bool_to_msg(source_ova_item is not None)))
if source_ova_item is None:
return None
item_id = source_ova_item.get('id')
flag = False
while True:
q = client.get_typed_query(
'adminCatalogItem',
query_result_format=QueryResultFormat.ID_RECORDS,
qfilter='id==%s' % item_id)
records = list(q.execute())
if records[0].get('status') == 'RESOLVED':
if flag:
click.secho('done', fg='blue')
break
else:
if flag:
click.secho('.', nl=False, fg='green')
else:
click.secho('Waiting for upload to complete...',
nl=False,
fg='green')
flag = True
time.sleep(5)
vdc = VDC(client, resource=vdc_resource)
try:
vapp_resource = vdc.get_vapp(template['temp_vapp'])
except Exception:
vapp_resource = None
if vapp_resource is None:
click.secho('Creating vApp template \'%s\'' % template['temp_vapp'],
fg='green')
init_script = get_data_file('init-%s.sh' % template['name'])
vapp_resource = vdc.instantiate_vapp(
template['temp_vapp'],
catalog.get('name'),
template['source_ova_name'],
network=config['broker']['network'],
fence_mode='bridged',
ip_allocation_mode=config['broker']['ip_allocation_mode'],
deploy=True,
power_on=True,
memory=template['mem'],
cpu=template['cpu'],
password=None,
cust_script=init_script,
accept_all_eulas=True,
vm_name=template['temp_vapp'],
hostname=template['temp_vapp'],
storage_profile=config['broker']['storage_profile'])
stdout(vapp_resource.Tasks.Task[0], ctx)
vapp = VApp(client, resource=vapp_resource)
if template[
'source_ova_name'] == 'ubuntu-16.04-server-cloudimg-amd64.ova':
vapp.reload()
vs = get_vsphere(config, vapp, template['temp_vapp'])
vs.connect()
moid = vapp.get_vm_moid(template['temp_vapp'])
vm = vs.get_vm_by_moid(moid)
vs.wait_until_tools_ready(vm,
sleep=5,
callback=wait_for_tools_ready_callback)
click.secho('Rebooting vApp (Ubuntu)', fg='green')
vapp.reload()
task = vapp.shutdown()
stdout(task, ctx)
vapp.reload()
task = vapp.power_on()
stdout(task, ctx)
click.secho('Customizing vApp template \'%s\'' % template['temp_vapp'],
fg='green')
vapp.reload()
password_auto = vapp.get_admin_password(template['temp_vapp'])
cust_script = get_data_file('cust-%s.sh' % template['name'])
for attempt in range(5):
click.secho('Attempt #%s' % str(attempt + 1), fg='green')
vs = get_vsphere(config, vapp, template['temp_vapp'])
vs.connect()
moid = vapp.get_vm_moid(template['temp_vapp'])
vm = vs.get_vm_by_moid(moid)
vs.wait_until_tools_ready(vm,
sleep=5,
callback=wait_for_tools_ready_callback)
result = []
try:
result = vs.execute_script_in_guest(
vm,
'root',
password_auto,
cust_script,
target_file=None,
wait_for_completion=True,
wait_time=10,
get_output=True,
delete_script=True,
callback=wait_for_guest_execution_callback)
except Exception as e:
LOGGER.error(traceback.format_exc())
click.secho(traceback.format_exc(), fg='red')
if len(result) > 0:
click.secho('Result: %s' % result)
result_stdout = result[1].content.decode()
result_stderr = result[2].content.decode()
click.secho('stderr:')
if len(result_stderr) > 0:
click.secho(result_stderr, err=True)
click.secho('stdout:')
if len(result_stdout) > 0:
click.secho(result_stdout, err=False)
if result[0] == 0:
break
if len(result) == 0 or result[0] != 0:
click.secho('Customization attempt #%s failed' %
int(attempt + 1),
fg='red')
if attempt < 4:
click.secho('Will try again')
time.sleep(5)
else:
raise Exception('Failed to customize VM')
if not no_capture:
capture_as_template(ctx, config, vapp_resource, org, catalog, template)
if template['cleanup']:
click.secho('Deleting vApp template \'%s\' ' %
template['temp_vapp'],
fg='green')
vdc.reload()
task = vdc.delete_vapp(template['temp_vapp'], force=True)
stdout(task, ctx)
