def test_subscription_list(self):
client = cr.Subscriptions()
with DumpResponse(clients=[client])('subscription_list'):
client.get()
with DumpResponse(clients=[client])('subscription_schema'):
client.get_schema()
def test_pricing(self):
client = cr.Pricing()
with DumpResponse(clients=[client])('pricing_list'):
pricing = client.list(query_params={'limit': 5})
with DumpResponse(clients=[client])('pricing_schema'):
client.get_schema()
def test_server_clone(self):
server = self._create_a_server()
with DumpResponse(clients=[self.client],
name='server_get_clone_source'):
server = self.client.get(server['uuid'])
with DumpResponse(clients=[self.client], name='server_clone'):
clone = self.client.clone(server['uuid'], {
'name': 'test cloned server name',
'random_vnc_password': True
})
self.client.delete(server['uuid'])
self.client.delete(clone['uuid'])
def test_profile(self):
with DumpResponse(name='profile',
clients=[self.client],
resp_data_filter=anonymize_profile):
profile = self.client.get()
profile['company'] = 'Newly Set Company Name'
with DumpResponse(name='profile_update',
clients=[self.client],
resp_data_filter=anonymize_profile,
req_data_filter=anonymize_profile):
self.client.update(profile)
profile['company'] = ''
self.client.update(profile)
def setUp(self):
super(SnapshotsTest, self).setUp()
self.snap_client = cr.Snapshot()
self.drive_client = cr.Drive()
self.dump_response = DumpResponse(
clients=[self.snap_client, self.drive_client]
)
def test_list_limit(self):
servers_to_create = 50
print(f'\nCreating servers ({servers_to_create})')
servers = [
self._create_a_server(
server_req={
'name': 'test server %d' % (i,),
'cpu': 1000,
'mem': 512 * 1024 ** 2,
'vnc_password': '******',
}
) for i in range(servers_to_create)
]
with DumpResponse(clients=[self.client])('server_list'):
servers_list = self.client.list(query_params={'limit': 20})
self.assertEqual(20, len(servers_list))
time.sleep(10)
print('Deleting Servers', end='', flush=True)
for i, server in enumerate(servers):
self.client.delete(server['uuid'])
print(f' {i + 1}', end='', flush=True)
def test_server_fw_rules(self):
policy = self.client.create(self.base_policy)
server_def = {
'name':
'FirewalledServer',
'cpu':
1000,
'mem':
512 * 1024**2,
'vnc_password':
'******',
"nics": [{
"firewall_policy": policy['uuid'],
"ip_v4_conf": {
"ip": None,
"conf": "dhcp"
},
"model": "virtio",
}],
}
server_client = resource.Server()
with DumpResponse(clients=[server_client])("fwpolicy_server_attach"):
server = server_client.create(server_def)
self.assertEqual(server['nics'][0]['firewall_policy']['uuid'],
policy['uuid'])
self.client.delete(policy['uuid'])
server = server_client.get(server['uuid'])
self.assertIsNone(server['nics'][0]['firewall_policy'])
server_client.delete(server['uuid'])
def setUp(self):
unittest.TestCase.setUp(self)
self.client = resource.FirewallPolicy()
self.dump_response = DumpResponse(clients=[self.client])
self.base_policy = {
"name":
"My awesome policy",
"rules": [{
"dst_ip":
"23",
"direction":
"out",
"action":
"drop",
"comment":
"Drop traffic from the VM to IP address 23.0.0.0/32"
}, {
"src_ip":
"172.66.32.0/24",
"ip_proto":
"tcp",
"dst_port":
"22",
"direction":
"in",
"action":
"accept",
"comment":
"Allow SSH traffic to the VM from our office in Dubai"
}, {
"ip_proto": "tcp",
"dst_port": "22",
"direction": "in",
"action": "drop",
"comment": "Drop all other SSH traffic to the VM"
}, {
"src_ip":
"!172.66.32.55",
"ip_proto":
"udp",
"direction":
"in",
"action":
"drop",
"comment":
"Drop all UDP traffic to the VM, not originating from 172.66.32.55"
}, {
"ip_proto":
"tcp",
"dst_port":
"!1:1024",
"direction":
"in",
"action":
"drop",
"comment":
"Drop any traffic, to the VM with destination port not between 1-1024"
}]
}
self._clean_policies()
def setUp(self):
super(tagsTest, self).setUp()
self.client = cr.Tags()
self.dump_response = DumpResponse(clients=[self.client])
tags = self.client.list()
for tag in tags:
self.client.delete(tag['uuid'])
def test_subscription_create(self):
if os.environ.get('TURLO_MANUAL_TESTS', '0') == '0':
raise unittest.SkipTest(
"Subscriptions cannot be deleted by the user so this cannot be cleaned up. Use TURLO_MANUAL_TESTS=1 environment variable"
)
client = cr.Subscriptions()
with DumpResponse(clients=[client])('subscription_create'):
sub = client.create({
"resource": "dssd",
"amount": 1000 * 3 * 10,
"period": "1 month"
})
def test_list_limit(self):
servers = [
self._create_a_server(
server_req={
'name': 'test server %d' % (i, ),
'cpu': 1000,
'mem': 512 * 1024**2,
'vnc_password': '******',
}) for i in range(50)
]
with DumpResponse(clients=[self.client])('server_list'):
servers_list = self.client.list(query_params={'limit': 20})
self.assertEqual(20, len(servers_list))
time.sleep(10)
for server in servers:
self.client.delete(server['uuid'])
def test_libdrive_listing(self):
with self.dump_response('libdrive_list'):
libdrives = self.client.list(query_params={'limit': 5})
# Select the lib drive with most interesting attributes
libdrive_uuid = libdrives[0][
'uuid'] # by default use the first possible
for d in libdrives:
if len(d['licenses']) > 0: # pick a drive with licenses
libdrive_uuid = d['uuid']
break
with self.dump_response('libdrive_get'):
libdrive = self.client.get(libdrive_uuid)
dc = cr.Drive()
with DumpResponse(clients=[dc])('librdrive_get_through_drives'):
libdrive_from_drive_url = dc.get(libdrive_uuid)
self.assertIsNone(libdrive_from_drive_url['owner'])
self.assertEqual(libdrive['uuid'], libdrive_from_drive_url['uuid'])
self.assertEqual(libdrive['name'], libdrive_from_drive_url['name'])
def test_server_state_cycle(self):
"""Test simple server create-start-stop-delete cycle"""
dump_response = DumpResponse(clients=[self.client])
with dump_response('server_create_minimal'):
server = self._create_a_server()
self._verify_list(server, True)
with dump_response('server_start'):
self.client.start(server['uuid'])
self._wait_for_status(server['uuid'], 'running')
with dump_response('server_stop'):
self.client.stop(server['uuid'])
self._wait_for_status(server['uuid'], 'stopped')
with dump_response('server_delete'):
self.client.delete(server['uuid'])
self._verify_list(server, False)
def test_tags(self):
with self.dump_response('tags_schema'):
self.client.get_schema()
sc = cr.Server()
server1 = sc.create({
'name': 'test_server1',
'cpu': 1000,
'mem': 512 * 1024**2,
'vnc_password': '******'
})
server2 = sc.create({
'name': 'test_server2',
'cpu': 1000,
'mem': 512 * 1024**2,
'vnc_password': '******'
})
dc = cr.Drive()
drive = dc.create({
'name': 'test_drive',
'size': 1000**3,
'media': 'disk'
})
ip = cr.IP().list()[0]
vlan = cr.VLAN().list()[0]
with self.dump_response('tags_create'):
tag1 = self.client.create({'name': 'MyGroupOfThings'})
with self.dump_response('tags_create_with_resource'):
tag2 = self.client.create({
'name':
'TagCreatedWithResource',
'resources': [
server1['uuid'], server2['uuid'], drive['uuid'],
ip['uuid'], vlan['uuid']
]
})
with self.dump_response('tags_list'):
self.client.list()
with self.dump_response('tags_list_detail'):
self.client.list_detail()
with self.dump_response('tags_get'):
self.client.get(tag2['uuid'])
with self.dump_response('tags_update_resources'):
self.client.update(
tag2['uuid'], {
'name': 'TagCreatedWithResource',
'resources': [server1['uuid'], drive['uuid']]
})
server2['tags'] = [tag1['uuid'], tag2['uuid']]
with DumpResponse(clients=[sc], name='tags_update_tag_from_resource'):
sc.update(server2['uuid'], server2)
with self.dump_response('tags_list_resource'):
self.client.servers(tag1['uuid'])
time.sleep(30)
dc.delete(drive['uuid'])
sc.delete(server1['uuid'])
sc.delete(server2['uuid'])
with self.dump_response('tags_delete'):
self.client.delete(tag1['uuid'])
self.client.delete(tag2['uuid'])
def test_get_schema(self):
with DumpResponse(name='profile_schema', clients=[self.client]):
self.client.get_schema()
def test_server_runtime(self):
dv = cr.Drive()
drive_def_1 = {
'name': 'test_drive_1',
'size': '1024000000',
'media': 'disk',
}
drive1 = dv.create(drive_def_1)
self._wait_for_status(drive1['uuid'], 'unmounted', client=dv)
server_def = {
'name':
'testServerAcc',
'cpu':
1000,
'mem':
512 * 1024**2,
'vnc_password':
'******',
'drives': [
{
"device": "virtio",
"dev_channel": "0:0",
"drive": drive1['uuid'],
"boot_order": 1
},
],
"nics": [{
"ip_v4_conf": {
"ip": None,
"conf": "dhcp"
},
"model": "virtio",
}],
}
server = self.client.create(server_def)
self._verify_list(server, True)
self.client.start(server['uuid'])
self._wait_for_status(server['uuid'], 'running')
with DumpResponse(clients=[self.client], name='server_get_running'):
server_def = self.client.get(server['uuid'])
self.assertEqual(server_def['runtime']['nics'][0]['interface_type'],
'public')
self.assertIsNotNone(server_def['runtime']['nics'][0]['ip_v4'])
# check runtime call
runtime = self.client.runtime(server['uuid'])
self.assertEqual(runtime['nics'][0]['interface_type'], 'public')
self.assertIsNotNone(runtime['nics'][0]['ip_v4'])
self.client.stop(server['uuid'])
self._wait_for_status(server['uuid'], 'stopped')
self.client.delete(server['uuid'])
self._verify_list(server, False)
dv.delete(drive1['uuid'])
self._wait_deleted(drive1['uuid'], client=dv)
def test_guest_context(self):
dc = cr.Drive()
sc = cr.Server()
gcc = cr.GlobalContext()
dump_response = DumpResponse(clients=[sc, dc, gcc])
# ensure empty global context
gcc.update({})
puuid, p_pass = self._get_persistent_image_uuid_and_pass()
LOG.debug('Clone the persistent image')
d1 = dc.clone(puuid, {'name': 'test_clone_1'})
from uuid import uuid4
g_def = {
"name":
"test_server",
"cpu":
1000,
"mem":
1024**3,
'vnc_password':
str(uuid4())[:18].replace('-', ''),
'drives': [
{
"device": "virtio",
"dev_channel": "0:0",
"drive": d1['uuid'],
"boot_order": 1
},
],
"nics": [
{
"ip_v4_conf": {
"ip": None,
"conf": "dhcp"
},
"model": "virtio",
},
],
"meta": {
"ssh_public_key":
"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy4XpmD3kEfRZ+LCwFh3Xmqrkm7rSiDu8v+ZCTOA3vlNjmy/ZOc3vy9Zr+IhWPP4yipiApkGRsBM63tTgnxqUUn/WU7qkbBNktZBcs5p7Mj/zO4ZHkk4VoTczFzHlPGwuak2P4wTftEj7sU8IRutaAbMoKj4AMuFF50j4sIgF7P5b5FtTIM2b5HSW8BlDz10b67+xsj6s3Jv05xxbBs+RWj+v7D5yjMVeeErXoSui8dlHpUu6QOVKn8LLmdpxvehc6ns8yW7cbQvWmLjOICMnm6BXdVtOKWBncDq9FGLmKF3fUeZZPbv79Z7dyZs+xGZGMHbpaNHpuY9QhNS/hQ5D5 dave@hal"
}
}
LOG.debug('Creating guest with drive')
with dump_response('guest_for_context'):
g1 = sc.create(g_def)
self._wait_for_status(d1['uuid'], 'mounted', client=dc)
sc.start(g1['uuid'])
self._wait_for_status(g1['uuid'], 'running', client=sc)
LOG.debug('Refetch guest configurations')
g1 = sc.get(g1['uuid'])
LOG.debug('Get the assigned ips')
ip1 = g1['nics'][0]['runtime']['ip_v4']["uuid"]
self._wait_for_open_socket(ip1, 22, timeout=60, close_on_success=True)
from fabric.api import settings as fabric_settings
from fabric import tasks, api
fab_kwargs = {
"warn_only": True,
"abort_on_prompts": True,
"use_ssh_config": p_pass is None
}
LOG.debug('Using fabric config {}'.format(fab_kwargs))
if p_pass is not None:
fab_kwargs['password'] = p_pass
LOG.debug(
'Using a password to SSH to the servers ( not using ssh config )'
)
dump_path = dump_response.response_dump.dump_path
#command_template = r"read -t 1 -d $'\004' DISCARD < /dev/ttyS1; " \
# r'echo -en "<\n{}\n>" > /dev/ttyS1 && read -t 3 READVALUE < /dev/ttyS1 && echo $READVALUE'
self.command_template = r'v=$(read -t 13 READVALUE < /dev/ttyS1 && echo $READVALUE & sleep 1; echo -en "<\n{}\n>" > /dev/ttyS1; wait %1); echo $v'
LOG.debug('Test the guest context')
LOG.debug('Check single value retrieval')
self.check_key_retrieval(g_def, 'context_single_value', 'name',
dump_path, fab_kwargs, ip1, fabric_settings,
tasks, api)
##########################################
LOG.debug('Check key retrieval')
self.check_key_retrieval(g_def, 'context_single_value_ssh_key',
'/meta/ssh_public_key', dump_path, fab_kwargs,
ip1, fabric_settings, tasks, api)
##########################################
LOG.debug('Check complete context retrieval')
self.check_all_retrieval(g_def, 'context_all', dump_path, fab_kwargs,
ip1, fabric_settings, tasks, api)
##########################################
##########################################
##########################################
##########################################
LOG.debug('Check context dynamic update')
g_def['name'] += '_renamed'
g_def['meta']['another_key'] = 'a value or something'
upd_res = sc.update(g1['uuid'], g_def)
self.assertEqual(g_def['name'], upd_res['name'])
LOG.debug('Check single value retrieval')
self.check_key_retrieval(g_def, 'context_single_value_dynamic', 'name',
dump_path, fab_kwargs, ip1, fabric_settings,
tasks, api)
##########################################
LOG.debug('Check key retrieval')
self.check_key_retrieval(g_def,
'context_single_value_another_key_dynamic',
'/meta/another_key', dump_path, fab_kwargs,
ip1, fabric_settings, tasks, api)
##########################################
LOG.debug('Check complete context retrieval')
self.check_all_retrieval(g_def, 'context_all_dynamic', dump_path,
fab_kwargs, ip1, fabric_settings, tasks, api)
###########################################
###########################################
###########################################
with dump_response('update_global_context'):
gcc.update({'new_global_key': 'new_global_val'})
LOG.debug('Check global context retrieval')
command = self.command_template.format(
'/global_context/new_global_key')
expected_val = 'new_global_val'
res_string = self.get_single_ctx_val(command, expected_val, fab_kwargs,
ip1, fabric_settings, tasks, api)
self.assertEqual(res_string, expected_val)
self.dump_ctx_command(command, res_string,
'global_context_single_value', dump_path)
self.check_all_retrieval(g_def, 'global_context_all', dump_path,
fab_kwargs, ip1, fabric_settings, tasks, api)
LOG.debug('Stopping guest')
sc.stop(g1['uuid'])
self._wait_for_status(g1['uuid'], 'stopped', client=sc, timeout=40)
LOG.debug('Delete guest')
sc.delete(g1['uuid'])
LOG.debug('Delete drive')
dc.delete(d1['uuid'])
self._wait_deleted(d1['uuid'], client=dc)
def test_licenses(self):
client = cr.Licenses()
with DumpResponse(clients=[client])('licenses_list'):
licenses = client.get()
with DumpResponse(clients=[client])('licenses_schema'):
client.get_schema()
def test_ledger(self):
client = cr.Ledger()
with DumpResponse(clients=[client])('ledger_list'):
ledger = client.get()
with DumpResponse(clients=[client])('ledger_schema'):
client.get_schema()
def test_currentusage(self):
client = cr.CurrentUsage()
with DumpResponse(clients=[client])('currentusage_list'):
currentusage = client.get()
with DumpResponse(clients=[client])('currentusage_schema'):
client.get_schema()
def test_balance(self):
client = cr.Balance()
with DumpResponse(clients=[client])('balance_list'):
balance = client.get()
with DumpResponse(clients=[client])('balance_schema'):
client.get_schema()
def setUp(self):
unittest.TestCase.setUp(self)
self.client = cr.Server() # create a resource handle object
self.dump_response = DumpResponse(clients=[self.client])
def setUp(self):
super(LibraryDriveTest, self).setUp()
self.client = cr.LibDrive()
self.dump_response = DumpResponse(clients=[self.client])
def test_server_nics(self):
server = self._create_a_server()
subs_client = cr.Subscriptions()
vlan_client = cr.VLAN()
vlans = vlan_client.list()
if not vlans:
subs_client.create({
'resource': 'vlan',
'amount': 1,
'period': '1 month'
})
vlans = vlan_client.list()
vlan_uuid = vlans[0]['uuid']
ip_client = cr.IP()
ips = ip_client.list()
free_ips = [ip for ip in ips if ip['server'] is None]
if not free_ips:
subs_client.create({
'resource': 'ip',
'amount': 1,
'period': '1 month'
})
ips = ip_client.list()
free_ips = [ip for ip in ips if ip['server'] is None]
ip_uuid = free_ips[0]['uuid']
server['nics'] = [{'vlan': vlan_uuid}]
with DumpResponse(clients=[self.client],
name='server_add_private_nic'):
server = self.client.update(server['uuid'], server)
server['nics'] = [{'ip_v4_conf': {'conf': 'dhcp'}, 'model': 'e1000'}]
with DumpResponse(clients=[self.client], name='server_add_dhcp_nic'):
server = self.client.update(server['uuid'], server)
server['nics'] = [{
'ip_v4_conf': {
'conf': 'dhcp'
},
'model': 'e1000'
}, {
'vlan': vlan_uuid
}]
server = self.client.update(server['uuid'], server)
with DumpResponse(clients=[self.client], name='server_get_two_nics'):
server = self.client.get(server['uuid'])
server['nics'][0]['ip_v4_conf'] = {'conf': 'static', 'ip': ip_uuid}
with DumpResponse(clients=[self.client],
name='server_change_nic_to_static'):
server = self.client.update(server['uuid'], server)
server['nics'] = [server['nics'][1], server['nics'][0]]
with DumpResponse(clients=[self.client], name='server_rearrange_nics'):
server = self.client.update(server['uuid'], server)
private_mac = server['nics'][0]['mac']
server['nics'] = [{'ip_v4_conf': {'conf': 'dhcp'}, 'mac': private_mac}]
with DumpResponse(clients=[self.client],
name='server_del_and_change_nic'):
server = self.client.update(server['uuid'], server)
server['nics'] = [{'ip_v4_conf': {'conf': 'manual'}}]
with DumpResponse(clients=[self.client], name='server_add_manual_nic'):
server = self.client.update(server['uuid'], server)
self.client.delete(server['uuid'])
def setUp(self):
super(IPBasicTest, self).setUp()
self.client = cr.IP()
self.dump_response = DumpResponse(clients=[self.client])
def test_get_schema(self):
with DumpResponse(clients=[self.client], name='server_schema'):
self.client.get_schema()
def setUp(self):
super(CapabilitiesTest, self).setUp()
self.client = cr.Capabilites()
self.dump_response = DumpResponse(clients=[self.client])
def test_create_full_server(self):
dv = cr.Drive()
dump_response = DumpResponse(clients=[self.client])
drive_def_1 = {
'name': 'test_drive_1',
'size': '1024000000',
'media': 'disk',
}
drive_def_2 = {
'name': 'test_drive_2',
'size': '1024000000',
'media': 'cdrom',
}
drive1 = dv.create(drive_def_1)
drive2 = dv.create(drive_def_2)
self._wait_for_status(drive1['uuid'], 'unmounted', client=dv)
self._wait_for_status(drive2['uuid'], 'unmounted', client=dv)
server_definition = {
"requirements": [],
"name":
"test_acc_full_server",
"cpus_instead_of_cores":
False,
"tags": [],
"mem":
256 * 1024**2,
"nics": [{
"ip_v4_conf": {
"conf": "dhcp"
},
}],
"enable_numa":
False,
"cpu":
1000,
"drives": [
{
"device": "virtio",
"dev_channel": "0:0",
"drive": drive1['uuid'],
"boot_order": 1
},
{
"device": "ide",
"dev_channel": "0:0",
"drive": drive2['uuid'],
},
],
"smp":
1,
"hv_relaxed":
False,
"hv_tsc":
False,
"meta": {
"description": "A full server with description"
},
"vnc_password":
"******",
}
with dump_response('server_create_full'):
server = self.client.create(server_definition)
# TODO: Uncomment this when the guest_drive definition order changes reach production
#self._verify_list(server, True)
self.client.delete(server['uuid'])
self._verify_list(server, False)
dv.delete(drive1['uuid'])
dv.delete(drive2['uuid'])
self._wait_deleted(drive1['uuid'], client=dv)
self._wait_deleted(drive2['uuid'], client=dv)
def test_discount(self):
client = cr.Discount()
with DumpResponse(clients=[client])('discount_list'):
discount = client.get()
with DumpResponse(clients=[client])('discount_schema'):
client.get_schema()