def test_provider_vm_terminate(self):
HEADING()
name = str(Name())
Benchmark.Start()
data = provider.destroy(name=name)
Benchmark.Stop()
pprint(data)
termination_timeout = 360
time = 0
while time <= termination_timeout:
sleep(5)
time += 5
if cloud == 'chameleon' and len(provider.info(name=name)) == 0:
break
elif cloud == 'aws' and (len(
provider.info(name=name)) == 0 or provider.info(
name=name)[0]["cm"]["status"] in ['TERMINATED']):
break
elif cloud == 'azure':
try:
provider.info(name=name)
except Exception:
# if there is an exception that means the group has been
# deleted
break
# print(provider.info(name=name))
if cloud == 'chameleon':
assert len(provider.info(name=name)) == 0
elif cloud == 'aws':
assert len(data) == 0 if data else True \
or (data[0]["cm"]["status"] in ['BOOTING', 'TERMINATED']
if data and data[0].get('cm', None) is not None
else True)
elif cloud == 'azure':
try:
provider.info(name=name)
except Exception:
# if there is an exception that means the group has been
# deleted
pass
elif cloud == 'oracle':
info = provider.info(name)
assert info is None or info[0]['_lifecycle_state'] in [
'TERMINATED'
]
else:
raise NotImplementedError
def test_create_with_options(self):
HEADING()
vm_name = f"{self.vm_name_prefix}3"
Benchmark.Start()
result = Shell.execute(
f"cms multipass create {vm_name} --cpus=2 --size=3G --image=bionic --mem=1G",
shell=True)
Benchmark.Stop()
VERBOSE(result)
assert f'Launched: {vm_name}' in result, "Error creating instance"
Benchmark.Status(True)
def test_02_start(self):
HEADING()
Benchmark.Start()
result = Shell.execute(
"cms vm start test_boot_02 --parallel --processors=3 --dryrun",
shell=True)
Benchmark.Stop()
VERBOSE(result)
assert "start nodes ['test_boot_02']" in result
assert "option - pool" in result
assert "processors - 3" in result
def test_provider_volume_delete(self):
HEADING()
Benchmark.Start()
provider.delete(name=name)
Benchmark.Stop()
result = provider.info(name=name)
if cloud == 'oracle':
status = result['lifecycle_state']
assert status in ['TERMINATED']
elif cloud == 'multipass':
status = result['State']
assert status in ['deleted']
else:
assert result is None
def test_provider_create(self):
HEADING()
vm_name = f"{self.vm_name_prefix}2"
provider = Provider(vm_name)
Benchmark.Start()
result = provider.create(vm_name)
Benchmark.Stop()
VERBOSE(result)
assert 'Running' in result['status'], "Error creating instance"
Benchmark.Status(True)
def test_upload_key_to_cloud(self):
HEADING()
if cloud == 'aws':
all_keys = cm.find_all_by_name(KEY, "key")
for k in all_keys:
if 'public_key' in k.keys():
key = k
break
else:
key = cm.find_name(KEY, "key")[0]
pprint(key)
Benchmark.Start()
r = provider.key_upload(key)
Benchmark.Stop()
def test_03_delete(self):
HEADING()
while 'pending' in Shell.execute("cms vm list test_boot_02 --refresh",
shell=True):
time.sleep(1)
Benchmark.Start()
result = Shell.execute("cms vm delete test_boot_02", shell=True)
Benchmark.Stop()
VERBOSE(result)
assert "test_boot_02" in result
def test_01_start(self):
HEADING()
Benchmark.Start()
result = Shell.execute(
f"cms vm start test_boot_02 --cloud={CLOUD} --dryrun",
shell=True)
Benchmark.Stop()
VERBOSE(result)
assert "start nodes ['test_boot_02']" in result
assert "option - iter" in result
assert "processors - None" in result
def test_provider_get(self):
HEADING()
self.provider = Provider()
Benchmark.Start()
result = self.provider.get()
Benchmark.Stop()
VERBOSE(result)
result = str(result)
assert "missing" in result
Benchmark.Status(True)
def test_provider_volume_add_tag(self):
HEADING()
key = "key"
key_value = "value"
params = {"key": key, "value": key_value, 'NAME': name}
Benchmark.Start()
data = provider.add_tag(**params)
Benchmark.Stop()
for entry in data:
if cloud == 'aws':
tags = entry['cm']['tags']
assert tags == [{'Key': key, 'Value': key_value}]
elif cloud == 'multipass':
tags = entry['tags']
assert tags == [{key: key_value}]
def test_vm_status(self):
HEADING()
name = str(Name())
Benchmark.Start()
data = provider.status(name=name)
if type(data) == list:
data = data[0]
print(data)
Benchmark.Stop()
if cloud == 'oracle':
assert data["cm.status"] in ['STARTING', 'RUNNING', 'STOPPING',
'STOPPED']
else:
assert data["cm.status"] in ['ACTIVE', 'BOOTING', 'TERMINATED',
'STOPPED']
def test_googletoawsDir2(self):
HEADING()
sourcecloud = "google"
targetcloud = "aws"
sourceFile = "a1/testfolder/"
targetFile = "a1/testfolder_1/"
Benchmark.Start("GOOGLE_TO_AWS3")
awsProvider = Provider(service=sourcecloud)
testResult = awsProvider.copyFiles(source_cloud=sourcecloud,
source_file=sourceFile,
target_cloud=targetcloud,
target_file=targetFile)
Benchmark.Stop()
def test_googletoaws(self):
HEADING()
sourcecloud = "google"
targetcloud = "aws"
sourceFile = "uploadtest_awsgoogle.txt"
targetFile = "uploadtest_googeaws.txt"
Benchmark.Start("GOOGLE_TO_AWS1")
awsProvider = Provider(service=sourcecloud)
testResult = awsProvider.copyFiles(source_cloud=sourcecloud,
source_file=sourceFile,
target_cloud=targetcloud,
target_file=targetFile)
Benchmark.Stop()
def test_reboot(self):
HEADING()
self.provider = Provider()
#Using 2 VMs to test_created usingn test_create* methods.
vm_names = f"{self.vm_name_prefix}1,{self.vm_name_prefix}3"
Benchmark.Start()
result = Shell.execute(f"cms multipass reboot {vm_names}", shell=True)
Benchmark.Stop()
VERBOSE(result)
assert 'Running' in result, "Error rebooting instance"
def test_cm_find_loop(self):
HEADING()
Benchmark.Start()
entries = []
for kind in ['vm', "image", "flavor"]:
data = cm.find(cloud=f"{cloud}", kind=kind)
if len(data) > 0:
entries.append(data)
if benchmark_print:
pprint(entries)
else:
print(f"Number of entries [{kind}", len(data))
Benchmark.Stop()
assert len(entries) > 0
def test_cm_find_cloud_name_attributes(self):
HEADING()
print()
Benchmark.Start()
entries = cm.find(collection=f"{cloud}-vm",
attributes=['cm.cloud', 'cm.name'])
Benchmark.Stop()
kind = "vm"
if benchmark_print:
print(entries)
else:
print(f"Number of entries [{kind}", len(entries))
assert len(entries) > 0
def test_provider_run_buffer(self):
HEADING()
self.provider = Provider()
Benchmark.Start()
result = self.provider.run(command="uname -a", executor="buffer")
Benchmark.Stop()
VERBOSE(result)
# find a good assertion
result = str(result)
assert "18.04" in result
Benchmark.Status(True)
def test_check(self):
HEADING()
cmd = "cms burn check"
Benchmark.Start()
result = Shell.run(cmd)
Benchmark.Stop()
print(result)
expected = [
'hostname', 'test_host', 'ip', '10.1.1.253/24', 'ssh', 'True',
'auth_key', 'test@test', 'wifi', 'True', 'psk', 'test_pass',
'ssid', 'test_ssid'
]
for val in expected:
assert val in result.split()
assert result.split().count('True') == 2
def test_get_storage_lifecycle_policy(self):
''' Return Storage Lifecycle Policy details '''
HEADING()
Benchmark.Start()
# Execute CMS command
result = Shell.execute(
"cms", ["storagelifecycle", "get", "aws", self.storage_bucket])
# Evaluate result
data = json.loads(result)
assert data["ResponseMetadata"]["HTTPStatusCode"] == 200
Benchmark.Stop()
def test_delete_storage_lifecycle_policy(self):
''' Delete Storage Lifecycle Policy '''
HEADING()
Benchmark.Start()
# Execute CMS command
result = Shell.execute(
"cms", ["storagelifecycle", "delete", "aws", self.storage_bucket])
# Evaluate result (Successful delete = 204)
data = json.loads(result)
assert data["ResponseMetadata"]["HTTPStatusCode"] == 204
Benchmark.Stop()
def test_load(self):
HEADING(color="HEADER")
r = rules.clear()
g = groups.clear()
Benchmark.Start()
examples.load()
Benchmark.Stop()
r = rules.list()
g = groups.list()
assert len(g) == len(examples.secgroups)
assert len(r) == len(examples.secrules)
def test_load(self):
HEADING()
Benchmark.Start()
run("load", "cms sec load")
Benchmark.Stop()
r = rules.list()
g = groups.list()
assert len(r) > 0
assert len(g) > 0
examples = SecgroupExamples()
assert len(g) == len(examples.secgroups)
assert len(r) == len(examples.secrules)
def test_name_counter(self):
HEADING()
n = Name()
Benchmark.Start()
c = n.counter
Benchmark.Stop()
print(n.counter)
assert n.counter == 2
m = Name()
pprint(n.dict())
pprint(m.dict())
print(m)
assert str(n) == str(m)
def test_rule_list(self):
HEADING()
Benchmark.Start()
result = run("cms sec rule list")
Benchmark.stop()
r = rules.list()
g = groups.list()
for entry in r:
name = entry['name']
assert name in result
for entry in g:
name = entry['name']
assert name in result
def test_remove_group():
HEADING()
name = list(examples.secgroups.keys())[0]
original = groups.list()
Benchmark.Start()
groups.remove(name=name)
Benchmark.Stop()
updated = groups.list()
print(len(original), "->", len(updated))
assert len(updated) == len(original) - 1
def test_registry_list_name(self):
HEADING()
Benchmark.Start()
title = spec["info"]["title"]
registry = Registry()
entry = registry.list(name=title)
pprint(entry)
assert entry != None
Benchmark.Stop()
def download_data(
cls,
images_filename: str = 'lfw-funneled.tgz',
images_url: str = 'https://ndownloader.figshare.com/files/5976015',
images_checksum: str = 'b47c8422c8cded889dc5a13418c4bc2a'
'bbda121092b3533a83306f90d900100a',
data_home: str = None,
data_subdir: str = "lfw_home",
image_subdir: str = "lfw_funneled",
target_filenames: list = [],
target_urls: list = [],
target_checksums: list = []):
'''
'''
# this function is based on SKLearn's _check_fetch_lfw function.
Benchmark.Start()
archive = RemoteFileMetadata(images_filename,
images_url,
checksum=(images_checksum))
if target_filenames != []:
target_attributes = zip(target_filenames, target_urls,
target_checksums)
targets = ()
for target in target_attributes:
filename, url, checksum = target
targets = targets + (RemoteFileMetadata(
filename, url, checksum))
data_home = get_data_home(data_home=data_home)
lfw_home = join(data_home, data_subdir)
if not exists(lfw_home):
makedirs(lfw_home)
for target in TARGETS:
target_filepath = join(lfw_home, target.filename)
_fetch_remote(target, dirname=lfw_home)
data_folder_path = join(lfw_home, image_subdir)
archive_path = join(lfw_home, archive.filename)
_fetch_remote(archive, dirname=lfw_home)
import tarfile
tarfile.open(archive_path, "r:gz").extractall(path=lfw_home)
remove(archive_path)
Benchmark.Stop()
return f'Data downloaded to {lfw_home}'
def test_unmount(self):
HEADING()
card = SDCard(card_os="raspberry")
global user
global device
cmd = f"cms burn unmount --device={device}"
Benchmark.Start()
result = os.system(cmd)
Benchmark.Stop()
result = Shell.run(f"ls {card.boot_volume}").strip().splitlines()
assert "No such file or directory" in result[0]
result = Shell.run(f"ls {card.root_volume}").strip().splitlines()
assert "No such file or directory" in result[0]
sys.stdout.flush()
sys.stderr.flush()
def test_set_key(self):
HEADING()
card = SDCard(card_os="raspberry")
test_key = 'ssh-rsa AAAAAAAA test@test'
f = open("test.pub", "w")
f.write(test_key)
f.close()
cmd = 'cms burn set --key=./test.pub'
Benchmark.Start()
os.system(cmd)
Benchmark.Stop()
cmd = f'sudo cat {card.root_volume}/home/pi/.ssh/authorized_keys'
result = Shell.run(cmd)
os.system('rm ./test.pub')
assert test_key in result.strip()
def test_mount(self):
HEADING()
card = SDCard(card_os="raspberry")
global user
global device
cmd = f"cms burn mount --device={device}"
Benchmark.Start()
result = os.system(cmd)
Benchmark.Stop()
result = Shell.run(f"ls {card.boot_volume}").splitlines()
assert len(result) > 0
result = Shell.run(f"ls {card.root_volume}").splitlines()
assert len(result) > 0
sys.stdout.flush()
sys.stderr.flush()
