Revision 186428b0 snf-tools/synnefo_tools/burnin.py
b/snf-tools/synnefo_tools/burnin.py | ||
---|---|---|
74 | 74 |
|
75 | 75 |
# -------------------------------------------------------------------- |
76 | 76 |
# Global Variables |
77 |
API = None
|
|
77 |
AUTH_URL = None
|
|
78 | 78 |
TOKEN = None |
79 |
PLANKTON = None |
|
80 | 79 |
PLANKTON_USER = None |
81 |
PITHOS = None |
|
82 |
ASTAKOS = None |
|
83 | 80 |
NO_IPV6 = None |
84 | 81 |
DEFAULT_PLANKTON_USER = "images@okeanos.grnet.gr" |
85 | 82 |
NOFAILFAST = None |
... | ... | |
118 | 115 |
|
119 | 116 |
def _get_user_id(): |
120 | 117 |
"""Authenticate to astakos and get unique users id""" |
121 |
astakos = AstakosClient(ASTAKOS, TOKEN)
|
|
118 |
astakos = AstakosClient(AUTH_URL, TOKEN)
|
|
122 | 119 |
authenticate = astakos.authenticate() |
123 |
if 'uuid' in authenticate: |
|
124 |
return authenticate['uuid'] |
|
125 |
else: |
|
126 |
return authenticate['uniq'] |
|
120 |
return authenticate['access']['user']['id'] |
|
127 | 121 |
|
128 | 122 |
|
129 | 123 |
# -------------------------------------------------------------------- |
... | ... | |
213 | 207 |
"""Test unauthorized access""" |
214 | 208 |
@classmethod |
215 | 209 |
def setUpClass(cls): |
210 |
cls.astakos = AstakosClient(AUTH_URL, TOKEN) |
|
211 |
cls.compute_url = \ |
|
212 |
cls.astakos.get_service_endpoints('compute')['publicURL'] |
|
216 | 213 |
cls.result_dict = dict() |
217 | 214 |
|
218 | 215 |
def test_unauthorized_access(self): |
219 | 216 |
"""Test access without a valid token fails""" |
220 | 217 |
log.info("Authentication test") |
221 | 218 |
falseToken = '12345' |
222 |
c = ComputeClient(API, falseToken)
|
|
219 |
c = ComputeClient(self.compute_url, falseToken)
|
|
223 | 220 |
|
224 | 221 |
with self.assertRaises(ClientError) as cm: |
225 | 222 |
c.list_servers() |
... | ... | |
234 | 231 |
def setUpClass(cls): |
235 | 232 |
"""Initialize kamaki, get (detailed) list of images""" |
236 | 233 |
log.info("Getting simple and detailed list of images") |
237 |
cls.client = ComputeClient(API, TOKEN) |
|
238 |
cls.plankton = ImageClient(PLANKTON, TOKEN) |
|
234 |
cls.astakos_client = AstakosClient(AUTH_URL, TOKEN) |
|
235 |
# Compute Client |
|
236 |
compute_url = \ |
|
237 |
cls.astakos_client.get_service_endpoints('compute')['publicURL'] |
|
238 |
cls.compute_client = ComputeClient(compute_url, TOKEN) |
|
239 |
# Image Client |
|
240 |
image_url = \ |
|
241 |
cls.astakos_client.get_service_endpoints('image')['publicURL'] |
|
242 |
cls.image_client = ImageClient(image_url, TOKEN) |
|
243 |
# Pithos Client |
|
244 |
pithos_url = cls.astakos_client.\ |
|
245 |
get_service_endpoints('object-store')['publicURL'] |
|
246 |
cls.pithos_client = PithosClient(pithos_url, TOKEN) |
|
247 |
|
|
248 |
# Get images |
|
239 | 249 |
cls.images = \ |
240 | 250 |
filter(lambda x: not x['name'].startswith(SNF_TEST_PREFIX), |
241 |
cls.plankton.list_public())
|
|
251 |
cls.image_client.list_public())
|
|
242 | 252 |
cls.dimages = \ |
243 | 253 |
filter(lambda x: not x['name'].startswith(SNF_TEST_PREFIX), |
244 |
cls.plankton.list_public(detail=True))
|
|
254 |
cls.image_client.list_public(detail=True))
|
|
245 | 255 |
cls.result_dict = dict() |
246 | 256 |
# Get uniq user id |
247 | 257 |
cls.uuid = _get_user_id() |
... | ... | |
280 | 290 |
dnames = sorted(map(lambda x: x["name"], self.dimages)) |
281 | 291 |
self.assertEqual(names, dnames) |
282 | 292 |
|
283 |
def test_004_unique_image_names(self): |
|
284 |
"""Test system images have unique names""" |
|
285 |
sys_images = filter(lambda x: x['owner'] == PLANKTON_USER, |
|
286 |
self.dimages) |
|
287 |
names = sorted(map(lambda x: x["name"], sys_images)) |
|
288 |
self.assertEqual(sorted(list(set(names))), names) |
|
293 |
# XXX: Find a way to resolve owner's uuid to username. |
|
294 |
# (maybe use astakosclient) |
|
295 |
# def test_004_unique_image_names(self): |
|
296 |
# """Test system images have unique names""" |
|
297 |
# sys_images = filter(lambda x: x['owner'] == PLANKTON_USER, |
|
298 |
# self.dimages) |
|
299 |
# names = sorted(map(lambda x: x["name"], sys_images)) |
|
300 |
# self.assertEqual(sorted(list(set(names))), names) |
|
289 | 301 |
|
290 | 302 |
def test_005_image_metadata(self): |
291 | 303 |
"""Test every image has specific metadata defined""" |
292 | 304 |
keys = frozenset(["osfamily", "root_partition"]) |
293 |
details = self.client.list_images(detail=True) |
|
305 |
details = self.compute_client.list_images(detail=True)
|
|
294 | 306 |
for i in details: |
295 | 307 |
self.assertTrue(keys.issubset(i["metadata"].keys())) |
296 | 308 |
|
... | ... | |
303 | 315 |
image['location'].replace("://", " ").replace("/", " ").split() |
304 | 316 |
log.info("Download image, with owner %s\n\tcontainer %s, and name %s" |
305 | 317 |
% (image_location[1], image_location[2], image_location[3])) |
306 |
pithos_client = PithosClient(PITHOS, TOKEN, image_location[1])
|
|
307 |
pithos_client.container = image_location[2] |
|
318 |
self.pithos_client.account = image_location[1]
|
|
319 |
self.pithos_client.container = image_location[2]
|
|
308 | 320 |
temp_file = os.path.join(self.temp_dir, self.temp_image_name) |
309 | 321 |
with open(temp_file, "wb+") as f: |
310 |
pithos_client.download_object(image_location[3], f) |
|
322 |
self.pithos_client.download_object(image_location[3], f)
|
|
311 | 323 |
|
312 | 324 |
def test_007_upload_image(self): |
313 | 325 |
"""Upload and register image""" |
314 | 326 |
temp_file = os.path.join(self.temp_dir, self.temp_image_name) |
315 | 327 |
log.info("Upload image to pithos+") |
316 | 328 |
# Create container `images' |
317 |
pithos_client = PithosClient(PITHOS, TOKEN, self.uuid)
|
|
318 |
pithos_client.container = "images" |
|
319 |
pithos_client.container_put() |
|
329 |
self.pithos_client.account = self.uuid
|
|
330 |
self.pithos_client.container = "images"
|
|
331 |
self.pithos_client.container_put()
|
|
320 | 332 |
with open(temp_file, "rb+") as f: |
321 |
pithos_client.upload_object(self.temp_image_name, f) |
|
333 |
self.pithos_client.upload_object(self.temp_image_name, f)
|
|
322 | 334 |
log.info("Register image to plankton") |
323 | 335 |
location = "pithos://" + self.uuid + \ |
324 | 336 |
"/images/" + self.temp_image_name |
325 | 337 |
params = {'is_public': True} |
326 | 338 |
properties = {'OSFAMILY': "linux", 'ROOT_PARTITION': 1} |
327 |
self.plankton.register(self.temp_image_name, location,
|
|
328 |
params, properties)
|
|
339 |
self.image_client.register(
|
|
340 |
self.temp_image_name, location, params, properties)
|
|
329 | 341 |
# Get image id |
330 |
details = self.plankton.list_public(detail=True)
|
|
342 |
details = self.image_client.list_public(detail=True)
|
|
331 | 343 |
detail = filter(lambda x: x['location'] == location, details) |
332 | 344 |
self.assertEqual(len(detail), 1) |
333 | 345 |
cls = type(self) |
... | ... | |
338 | 350 |
"""Cleanup image test""" |
339 | 351 |
log.info("Cleanup image test") |
340 | 352 |
# Remove image from pithos+ |
341 |
pithos_client = PithosClient(PITHOS, TOKEN, self.uuid)
|
|
342 |
pithos_client.container = "images" |
|
343 |
pithos_client.del_object(self.temp_image_name) |
|
353 |
self.pithos_client.account = self.uuid
|
|
354 |
self.pithos_client.container = "images"
|
|
355 |
self.pithos_client.del_object(self.temp_image_name)
|
|
344 | 356 |
|
345 | 357 |
|
346 | 358 |
# -------------------------------------------------------------------- |
... | ... | |
351 | 363 |
def setUpClass(cls): |
352 | 364 |
"""Initialize kamaki, get (detailed) list of flavors""" |
353 | 365 |
log.info("Getting simple and detailed list of flavors") |
354 |
cls.client = ComputeClient(API, TOKEN) |
|
355 |
cls.flavors = cls.client.list_flavors() |
|
356 |
cls.dflavors = cls.client.list_flavors(detail=True) |
|
366 |
cls.astakos_client = AstakosClient(AUTH_URL, TOKEN) |
|
367 |
# Compute Client |
|
368 |
compute_url = \ |
|
369 |
cls.astakos_client.get_service_endpoints('compute')['publicURL'] |
|
370 |
cls.compute_client = ComputeClient(compute_url, TOKEN) |
|
371 |
cls.flavors = cls.compute_client.list_flavors() |
|
372 |
cls.dflavors = cls.compute_client.list_flavors(detail=True) |
|
357 | 373 |
cls.result_dict = dict() |
358 | 374 |
|
359 | 375 |
def test_001_list_flavors(self): |
... | ... | |
380 | 396 |
Where xx is vCPU count, yy is RAM in MiB, zz is Disk in GiB |
381 | 397 |
""" |
382 | 398 |
for f in self.dflavors: |
383 |
flavor = (f["cpu"], f["ram"], f["disk"], f["SNF:disk_template"])
|
|
399 |
flavor = (f["vcpus"], f["ram"], f["disk"], f["SNF:disk_template"])
|
|
384 | 400 |
self.assertEqual("C%dR%dD%d%s" % flavor, |
385 | 401 |
f["name"], |
386 | 402 |
"Flavor %s does not match its specs." % f["name"]) |
... | ... | |
395 | 411 |
"""Initialize kamaki, get (detailed) list of servers""" |
396 | 412 |
log.info("Getting simple and detailed list of servers") |
397 | 413 |
|
398 |
cls.client = ComputeClient(API, TOKEN) |
|
399 |
cls.servers = cls.client.list_servers() |
|
400 |
cls.dservers = cls.client.list_servers(detail=True) |
|
414 |
cls.astakos_client = AstakosClient(AUTH_URL, TOKEN) |
|
415 |
# Compute Client |
|
416 |
compute_url = \ |
|
417 |
cls.astakos_client.get_service_endpoints('compute')['publicURL'] |
|
418 |
cls.compute_client = ComputeClient(compute_url, TOKEN) |
|
419 |
cls.servers = cls.compute_client.list_servers() |
|
420 |
cls.dservers = cls.compute_client.list_servers(detail=True) |
|
401 | 421 |
cls.result_dict = dict() |
402 | 422 |
|
403 | 423 |
# def test_001_list_servers(self): |
... | ... | |
426 | 446 |
cls.uuid = _get_user_id() |
427 | 447 |
log.info("Uniq user id = %s" % cls.uuid) |
428 | 448 |
log.info("Getting list of containers") |
429 |
cls.client = PithosClient(PITHOS, TOKEN, cls.uuid) |
|
430 |
cls.containers = cls.client.list_containers() |
|
449 |
|
|
450 |
cls.astakos_client = AstakosClient(AUTH_URL, TOKEN) |
|
451 |
# Pithos Client |
|
452 |
pithos_url = cls.astakos_client.\ |
|
453 |
get_service_endpoints('object-store')['publicURL'] |
|
454 |
cls.pithos_client = PithosClient(pithos_url, TOKEN, cls.uuid) |
|
455 |
|
|
456 |
cls.containers = cls.pithos_client.list_containers() |
|
431 | 457 |
cls.result_dict = dict() |
432 | 458 |
|
433 | 459 |
def test_001_list_containers(self): |
... | ... | |
449 | 475 |
rand_num = randint(1000, 9999) |
450 | 476 |
rand_name = "%s%s" % (SNF_TEST_PREFIX, rand_num) |
451 | 477 |
# Create container |
452 |
self.client.container = rand_name |
|
453 |
self.client.container_put() |
|
478 |
self.pithos_client.container = rand_name
|
|
479 |
self.pithos_client.container_put()
|
|
454 | 480 |
# Get list of containers |
455 |
new_containers = self.client.list_containers() |
|
481 |
new_containers = self.pithos_client.list_containers()
|
|
456 | 482 |
new_container_names = [n['name'] for n in new_containers] |
457 | 483 |
self.assertIn(rand_name, new_container_names) |
458 | 484 |
|
... | ... | |
463 | 489 |
f.write("This is a temp file") |
464 | 490 |
f.seek(0, 0) |
465 | 491 |
# Where to save file |
466 |
self.client.upload_object("test.txt", f) |
|
492 |
self.pithos_client.upload_object("test.txt", f)
|
|
467 | 493 |
|
468 | 494 |
def test_005_download(self): |
469 | 495 |
"""Test download something from pithos+""" |
... | ... | |
471 | 497 |
tmp_dir = tempfile.mkdtemp() |
472 | 498 |
tmp_file = os.path.join(tmp_dir, "test.txt") |
473 | 499 |
with open(tmp_file, "wb+") as f: |
474 |
self.client.download_object("test.txt", f) |
|
500 |
self.pithos_client.download_object("test.txt", f)
|
|
475 | 501 |
# Read file |
476 | 502 |
f.seek(0, 0) |
477 | 503 |
content = f.read() |
... | ... | |
483 | 509 |
|
484 | 510 |
def test_006_remove(self): |
485 | 511 |
"""Test removing files and containers""" |
486 |
cont_name = self.client.container |
|
487 |
self.client.del_object("test.txt") |
|
488 |
self.client.purge_container() |
|
512 |
cont_name = self.pithos_client.container
|
|
513 |
self.pithos_client.del_object("test.txt")
|
|
514 |
self.pithos_client.purge_container()
|
|
489 | 515 |
# List containers |
490 |
containers = self.client.list_containers() |
|
516 |
containers = self.pithos_client.list_containers()
|
|
491 | 517 |
cont_names = [n['name'] for n in containers] |
492 | 518 |
self.assertNotIn(cont_name, cont_names) |
493 | 519 |
|
... | ... | |
500 | 526 |
def setUpClass(cls): |
501 | 527 |
"""Initialize a kamaki instance""" |
502 | 528 |
log.info("Spawning server for image `%s'" % cls.imagename) |
503 |
cls.client = ComputeClient(API, TOKEN) |
|
504 |
cls.cyclades = CycladesClient(API, TOKEN) |
|
529 |
|
|
530 |
cls.astakos_client = AstakosClient(AUTH_URL, TOKEN) |
|
531 |
# Cyclades Client |
|
532 |
compute_url = \ |
|
533 |
cls.astakos_client.get_service_endpoints('compute')['publicURL'] |
|
534 |
cls.cyclades_client = CycladesClient(compute_url, TOKEN) |
|
535 |
|
|
505 | 536 |
cls.result_dict = dict() |
506 | 537 |
|
507 | 538 |
def _get_ipv4(self, server): |
... | ... | |
511 | 542 |
|
512 | 543 |
for nic in nics: |
513 | 544 |
net_id = nic["network_id"] |
514 |
if self.cyclades.get_network_details(net_id)["public"]: |
|
545 |
if self.cyclades_client.get_network_details(net_id)["public"]:
|
|
515 | 546 |
public_addrs = nic["ipv4"] |
516 | 547 |
|
517 | 548 |
self.assertTrue(public_addrs is not None) |
... | ... | |
525 | 556 |
|
526 | 557 |
for nic in nics: |
527 | 558 |
net_id = nic["network_id"] |
528 |
if self.cyclades.get_network_details(net_id)["public"]: |
|
559 |
if self.cyclades_client.get_network_details(net_id)["public"]:
|
|
529 | 560 |
public_addrs = nic["ipv6"] |
530 | 561 |
|
531 | 562 |
self.assertTrue(public_addrs is not None) |
... | ... | |
543 | 574 |
|
544 | 575 |
def _verify_server_status(self, current_status, new_status): |
545 | 576 |
"""Verify a server has switched to a specified status""" |
546 |
server = self.client.get_server_details(self.serverid) |
|
577 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
547 | 578 |
if server["status"] not in (current_status, new_status): |
548 | 579 |
return None # Do not raise exception, return so the test fails |
549 | 580 |
self.assertEquals(server["status"], new_status) |
... | ... | |
624 | 655 |
msg, self._verify_server_status, |
625 | 656 |
current_status, new_status) |
626 | 657 |
# Ensure the status is actually the expected one |
627 |
server = self.client.get_server_details(self.serverid) |
|
658 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
628 | 659 |
self.assertEquals(server["status"], new_status) |
629 | 660 |
|
630 | 661 |
def _insist_on_ssh_hostname(self, hostip, username, password): |
... | ... | |
673 | 704 |
"""Test submit create server request""" |
674 | 705 |
|
675 | 706 |
log.info("Submit new server request") |
676 |
server = self.client.create_server(self.servername, self.flavorid,
|
|
677 |
self.imageid, self.personality)
|
|
707 |
server = self.cyclades_client.create_server(
|
|
708 |
self.servername, self.flavorid, self.imageid, self.personality)
|
|
678 | 709 |
|
679 | 710 |
log.info("Server id: " + str(server["id"])) |
680 | 711 |
log.info("Server password: " + server["adminPass"]) |
... | ... | |
698 | 729 |
|
699 | 730 |
self.result_dict.clear() |
700 | 731 |
|
701 |
servers = self.client.list_servers(detail=True) |
|
732 |
servers = self.cyclades_client.list_servers(detail=True)
|
|
702 | 733 |
servers = filter(lambda x: x["name"] == self.servername, servers) |
703 | 734 |
|
704 | 735 |
server = servers[0] |
... | ... | |
712 | 743 |
|
713 | 744 |
log.info("Server in BUILD state in details") |
714 | 745 |
|
715 |
server = self.client.get_server_details(self.serverid) |
|
746 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
716 | 747 |
self.assertEqual(server["name"], self.servername) |
717 | 748 |
self.assertEqual(server["flavor"], self.flavorid) |
718 | 749 |
self.assertEqual(server["image"], self.imageid) |
... | ... | |
722 | 753 |
|
723 | 754 |
log.info("Creating server metadata") |
724 | 755 |
|
725 |
image = self.client.get_image_details(self.imageid) |
|
756 |
image = self.cyclades_client.get_image_details(self.imageid)
|
|
726 | 757 |
os_value = image["metadata"]["os"] |
727 | 758 |
users = image["metadata"].get("users", None) |
728 |
self.client.update_server_metadata(self.serverid, OS=os_value) |
|
759 |
self.cyclades_client.update_server_metadata(self.serverid, OS=os_value)
|
|
729 | 760 |
|
730 | 761 |
userlist = users.split() |
731 | 762 |
|
... | ... | |
747 | 778 |
|
748 | 779 |
log.info("Verifying image metadata") |
749 | 780 |
|
750 |
servermeta = self.client.get_server_metadata(self.serverid) |
|
751 |
imagemeta = self.client.get_image_metadata(self.imageid) |
|
781 |
servermeta = self.cyclades_client.get_server_metadata(self.serverid)
|
|
782 |
imagemeta = self.cyclades_client.get_image_metadata(self.imageid)
|
|
752 | 783 |
|
753 | 784 |
self.assertEqual(servermeta["OS"], imagemeta["os"]) |
754 | 785 |
|
... | ... | |
767 | 798 |
http://www.realvnc.com/docs/rfbproto.pdf. |
768 | 799 |
|
769 | 800 |
""" |
770 |
console = self.cyclades.get_server_console(self.serverid) |
|
801 |
console = self.cyclades_client.get_server_console(self.serverid)
|
|
771 | 802 |
self.assertEquals(console['type'], "vnc") |
772 | 803 |
sock = self._insist_on_tcp_connection( |
773 | 804 |
socket.AF_INET, console["host"], console["port"]) |
... | ... | |
803 | 834 |
|
804 | 835 |
log.info("Validate server's IPv4") |
805 | 836 |
|
806 |
server = self.client.get_server_details(self.serverid) |
|
837 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
807 | 838 |
ipv4 = self._get_ipv4(server) |
808 | 839 |
|
809 | 840 |
self.result_dict.clear() |
... | ... | |
817 | 848 |
|
818 | 849 |
log.info("Validate server's IPv6") |
819 | 850 |
|
820 |
server = self.client.get_server_details(self.serverid) |
|
851 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
821 | 852 |
ipv6 = self._get_ipv6(server) |
822 | 853 |
|
823 | 854 |
self.result_dict.clear() |
... | ... | |
831 | 862 |
log.info("Testing if server responds to pings in IPv4") |
832 | 863 |
self.result_dict.clear() |
833 | 864 |
|
834 |
server = self.client.get_server_details(self.serverid) |
|
865 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
835 | 866 |
ip = self._get_ipv4(server) |
836 | 867 |
self._try_until_timeout_expires(self.action_timeout, |
837 | 868 |
self.action_timeout, |
... | ... | |
844 | 875 |
self._skipIf(NO_IPV6, "--no-ipv6 flag enabled") |
845 | 876 |
log.info("Testing if server responds to pings in IPv6") |
846 | 877 |
|
847 |
server = self.client.get_server_details(self.serverid) |
|
878 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
848 | 879 |
ip = self._get_ipv6(server) |
849 | 880 |
self._try_until_timeout_expires(self.action_timeout, |
850 | 881 |
self.action_timeout, |
... | ... | |
857 | 888 |
|
858 | 889 |
log.info("Shutting down server") |
859 | 890 |
|
860 |
self.cyclades.shutdown_server(self.serverid) |
|
891 |
self.cyclades_client.shutdown_server(self.serverid)
|
|
861 | 892 |
|
862 | 893 |
def test_009_server_becomes_stopped(self): |
863 | 894 |
"""Test server becomes STOPPED""" |
... | ... | |
871 | 902 |
|
872 | 903 |
log.info("Starting server") |
873 | 904 |
|
874 |
self.cyclades.start_server(self.serverid) |
|
905 |
self.cyclades_client.start_server(self.serverid)
|
|
875 | 906 |
|
876 | 907 |
def test_011_server_becomes_active(self): |
877 | 908 |
"""Test server becomes ACTIVE again""" |
... | ... | |
891 | 922 |
"""Test SSH to server public IPv4 works, verify hostname""" |
892 | 923 |
|
893 | 924 |
self._skipIf(self.is_windows, "only valid for Linux servers") |
894 |
server = self.client.get_server_details(self.serverid) |
|
925 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
895 | 926 |
self._insist_on_ssh_hostname(self._get_ipv4(server), |
896 | 927 |
self.username, self.passwd) |
897 | 928 |
|
... | ... | |
900 | 931 |
self._skipIf(self.is_windows, "only valid for Linux servers") |
901 | 932 |
self._skipIf(NO_IPV6, "--no-ipv6 flag enabled") |
902 | 933 |
|
903 |
server = self.client.get_server_details(self.serverid) |
|
934 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
904 | 935 |
self._insist_on_ssh_hostname(self._get_ipv6(server), |
905 | 936 |
self.username, self.passwd) |
906 | 937 |
|
907 | 938 |
def test_014_rdp_to_server_IPv4(self): |
908 | 939 |
"Test RDP connection to server public IPv4 works""" |
909 | 940 |
self._skipIf(not self.is_windows, "only valid for Windows servers") |
910 |
server = self.client.get_server_details(self.serverid) |
|
941 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
911 | 942 |
ipv4 = self._get_ipv4(server) |
912 | 943 |
sock = self._insist_on_tcp_connection(socket.AF_INET, ipv4, 3389) |
913 | 944 |
|
... | ... | |
921 | 952 |
self._skipIf(not self.is_windows, "only valid for Windows servers") |
922 | 953 |
self._skipIf(NO_IPV6, "--no-ipv6 flag enabled") |
923 | 954 |
|
924 |
server = self.client.get_server_details(self.serverid) |
|
955 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
925 | 956 |
ipv6 = self._get_ipv6(server) |
926 | 957 |
sock = self._get_tcp_connection(socket.AF_INET6, ipv6, 3389) |
927 | 958 |
|
... | ... | |
936 | 967 |
|
937 | 968 |
log.info("Trying to inject file for personality enforcement") |
938 | 969 |
|
939 |
server = self.client.get_server_details(self.serverid) |
|
970 |
server = self.cyclades_client.get_server_details(self.serverid)
|
|
940 | 971 |
|
941 | 972 |
for inj_file in self.personality: |
942 | 973 |
equal_files = self._check_file_through_ssh(self._get_ipv4(server), |
... | ... | |
951 | 982 |
|
952 | 983 |
log.info("Deleting server") |
953 | 984 |
|
954 |
self.client.delete_server(self.serverid) |
|
985 |
self.cyclades_client.delete_server(self.serverid)
|
|
955 | 986 |
|
956 | 987 |
def test_018_server_becomes_deleted(self): |
957 | 988 |
"""Test server becomes DELETED""" |
... | ... | |
966 | 997 |
|
967 | 998 |
log.info("Test if server is no longer listed") |
968 | 999 |
|
969 |
servers = self.client.list_servers() |
|
1000 |
servers = self.cyclades_client.list_servers()
|
|
970 | 1001 |
self.assertNotIn(self.serverid, [s["id"] for s in servers]) |
971 | 1002 |
|
972 | 1003 |
|
... | ... | |
977 | 1008 |
def setUpClass(cls): |
978 | 1009 |
"Initialize kamaki, get list of current networks" |
979 | 1010 |
|
980 |
cls.client = CycladesClient(API, TOKEN) |
|
981 |
cls.compute = ComputeClient(API, TOKEN) |
|
1011 |
cls.astakos_client = AstakosClient(AUTH_URL, TOKEN) |
|
1012 |
# Cyclades Client |
|
1013 |
compute_url = \ |
|
1014 |
cls.astakos_client.get_service_endpoints('compute')['publicURL'] |
|
1015 |
cls.cyclades_client = CycladesClient(compute_url, TOKEN) |
|
982 | 1016 |
|
983 | 1017 |
cls.servername = "%s%s for %s" % (SNF_TEST_PREFIX, |
984 | 1018 |
TEST_RUN_ID, |
... | ... | |
1003 | 1037 |
|
1004 | 1038 |
for nic in nics: |
1005 | 1039 |
net_id = nic["network_id"] |
1006 |
if self.client.get_network_details(net_id)["public"]: |
|
1040 |
if self.cyclades_client.get_network_details(net_id)["public"]:
|
|
1007 | 1041 |
public_addrs = nic["ipv4"] |
1008 | 1042 |
|
1009 | 1043 |
self.assertTrue(public_addrs is not None) |
... | ... | |
1035 | 1069 |
|
1036 | 1070 |
log.info("Creating test server A") |
1037 | 1071 |
|
1038 |
serverA = self.client.create_server(self.servername, self.flavorid,
|
|
1039 |
self.imageid, personality=None)
|
|
1072 |
serverA = self.cyclades_client.create_server(
|
|
1073 |
self.servername, self.flavorid, self.imageid, personality=None)
|
|
1040 | 1074 |
|
1041 | 1075 |
self.assertEqual(serverA["name"], self.servername) |
1042 | 1076 |
self.assertEqual(serverA["flavor"], self.flavorid) |
... | ... | |
1062 | 1096 |
|
1063 | 1097 |
fail_tmout = time.time() + self.action_timeout |
1064 | 1098 |
while True: |
1065 |
d = self.client.get_server_details(self.serverid['A']) |
|
1099 |
d = self.cyclades_client.get_server_details(self.serverid['A'])
|
|
1066 | 1100 |
status = d['status'] |
1067 | 1101 |
if status == 'ACTIVE': |
1068 | 1102 |
active = True |
... | ... | |
1079 | 1113 |
|
1080 | 1114 |
log.info("Creating test server B") |
1081 | 1115 |
|
1082 |
serverB = self.client.create_server(self.servername, self.flavorid,
|
|
1083 |
self.imageid, personality=None)
|
|
1116 |
serverB = self.cyclades_client.create_server(
|
|
1117 |
self.servername, self.flavorid, self.imageid, personality=None)
|
|
1084 | 1118 |
|
1085 | 1119 |
self.assertEqual(serverB["name"], self.servername) |
1086 | 1120 |
self.assertEqual(serverB["flavor"], self.flavorid) |
... | ... | |
1107 | 1141 |
|
1108 | 1142 |
fail_tmout = time.time() + self.action_timeout |
1109 | 1143 |
while True: |
1110 |
d = self.client.get_server_details(self.serverid['B']) |
|
1144 |
d = self.cyclades_client.get_server_details(self.serverid['B'])
|
|
1111 | 1145 |
status = d['status'] |
1112 | 1146 |
if status == 'ACTIVE': |
1113 | 1147 |
active = True |
... | ... | |
1127 | 1161 |
|
1128 | 1162 |
name = SNF_TEST_PREFIX + TEST_RUN_ID |
1129 | 1163 |
#previous_num = len(self.client.list_networks()) |
1130 |
network = self.client.create_network(name, cidr='10.0.1.0/28',
|
|
1131 |
dhcp=True)
|
|
1164 |
network = self.cyclades_client.create_network(
|
|
1165 |
name, cidr='10.0.1.0/28', dhcp=True)
|
|
1132 | 1166 |
|
1133 | 1167 |
#Test if right name is assigned |
1134 | 1168 |
self.assertEqual(network['name'], name) |
... | ... | |
1142 | 1176 |
|
1143 | 1177 |
#Test if new network is created |
1144 | 1178 |
while True: |
1145 |
d = self.client.get_network_details(network['id']) |
|
1179 |
d = self.cyclades_client.get_network_details(network['id'])
|
|
1146 | 1180 |
if d['status'] == 'ACTIVE': |
1147 | 1181 |
connected = True |
1148 | 1182 |
break |
... | ... | |
1162 | 1196 |
log.info("Connect VMs to private network") |
1163 | 1197 |
self.result_dict.clear() |
1164 | 1198 |
|
1165 |
self.client.connect_server(self.serverid['A'], self.networkid) |
|
1166 |
self.client.connect_server(self.serverid['B'], self.networkid) |
|
1199 |
self.cyclades_client.connect_server(self.serverid['A'], self.networkid)
|
|
1200 |
self.cyclades_client.connect_server(self.serverid['B'], self.networkid)
|
|
1167 | 1201 |
|
1168 | 1202 |
#Insist on connecting until action timeout |
1169 | 1203 |
fail_tmout = time.time() + self.action_timeout |
... | ... | |
1171 | 1205 |
while True: |
1172 | 1206 |
|
1173 | 1207 |
netsA = [x['network_id'] |
1174 |
for x in self.client.get_server_details( |
|
1208 |
for x in self.cyclades_client.get_server_details(
|
|
1175 | 1209 |
self.serverid['A'])['attachments']] |
1176 | 1210 |
netsB = [x['network_id'] |
1177 |
for x in self.client.get_server_details( |
|
1211 |
for x in self.cyclades_client.get_server_details(
|
|
1178 | 1212 |
self.serverid['B'])['attachments']] |
1179 | 1213 |
|
1180 | 1214 |
if (self.networkid in netsA) and (self.networkid in netsB): |
... | ... | |
1189 | 1223 |
cls = type(self) |
1190 | 1224 |
cls.priv_ip = dict() |
1191 | 1225 |
|
1192 |
nicsA = self.client.get_server_details( |
|
1226 |
nicsA = self.cyclades_client.get_server_details(
|
|
1193 | 1227 |
self.serverid['A'])['attachments'] |
1194 |
nicsB = self.client.get_server_details( |
|
1228 |
nicsB = self.cyclades_client.get_server_details(
|
|
1195 | 1229 |
self.serverid['B'])['attachments'] |
1196 | 1230 |
|
1197 | 1231 |
if conn_exists: |
... | ... | |
1214 | 1248 |
|
1215 | 1249 |
log.info("Rebooting server A") |
1216 | 1250 |
|
1217 |
self.client.shutdown_server(self.serverid['A']) |
|
1251 |
self.cyclades_client.shutdown_server(self.serverid['A'])
|
|
1218 | 1252 |
|
1219 | 1253 |
fail_tmout = time.time() + self.action_timeout |
1220 | 1254 |
while True: |
1221 |
d = self.client.get_server_details(self.serverid['A']) |
|
1255 |
d = self.cyclades_client.get_server_details(self.serverid['A'])
|
|
1222 | 1256 |
status = d['status'] |
1223 | 1257 |
if status == 'STOPPED': |
1224 | 1258 |
break |
... | ... | |
1227 | 1261 |
else: |
1228 | 1262 |
time.sleep(self.query_interval) |
1229 | 1263 |
|
1230 |
self.client.start_server(self.serverid['A']) |
|
1264 |
self.cyclades_client.start_server(self.serverid['A'])
|
|
1231 | 1265 |
|
1232 | 1266 |
while True: |
1233 |
d = self.client.get_server_details(self.serverid['A']) |
|
1267 |
d = self.cyclades_client.get_server_details(self.serverid['A'])
|
|
1234 | 1268 |
status = d['status'] |
1235 | 1269 |
if status == 'ACTIVE': |
1236 | 1270 |
active = True |
... | ... | |
1248 | 1282 |
log.info("Testing if server A responds to IPv4 pings ") |
1249 | 1283 |
self.result_dict.clear() |
1250 | 1284 |
|
1251 |
server = self.client.get_server_details(self.serverid['A']) |
|
1285 |
server = self.cyclades_client.get_server_details(self.serverid['A'])
|
|
1252 | 1286 |
ip = self._get_ipv4(server) |
1253 | 1287 |
|
1254 | 1288 |
fail_tmout = time.time() + self.action_timeout |
... | ... | |
1277 | 1311 |
log.info("Rebooting server B") |
1278 | 1312 |
self.result_dict.clear() |
1279 | 1313 |
|
1280 |
self.client.shutdown_server(self.serverid['B']) |
|
1314 |
self.cyclades_client.shutdown_server(self.serverid['B'])
|
|
1281 | 1315 |
|
1282 | 1316 |
fail_tmout = time.time() + self.action_timeout |
1283 | 1317 |
while True: |
1284 |
d = self.client.get_server_details(self.serverid['B']) |
|
1318 |
d = self.cyclades_client.get_server_details(self.serverid['B'])
|
|
1285 | 1319 |
status = d['status'] |
1286 | 1320 |
if status == 'STOPPED': |
1287 | 1321 |
break |
... | ... | |
1290 | 1324 |
else: |
1291 | 1325 |
time.sleep(self.query_interval) |
1292 | 1326 |
|
1293 |
self.client.start_server(self.serverid['B']) |
|
1327 |
self.cyclades_client.start_server(self.serverid['B'])
|
|
1294 | 1328 |
|
1295 | 1329 |
while True: |
1296 |
d = self.client.get_server_details(self.serverid['B']) |
|
1330 |
d = self.cyclades_client.get_server_details(self.serverid['B'])
|
|
1297 | 1331 |
status = d['status'] |
1298 | 1332 |
if status == 'ACTIVE': |
1299 | 1333 |
active = True |
... | ... | |
1311 | 1345 |
log.info("Testing if server B responds to IPv4 pings") |
1312 | 1346 |
self.result_dict.clear() |
1313 | 1347 |
|
1314 |
server = self.client.get_server_details(self.serverid['B']) |
|
1348 |
server = self.cyclades_client.get_server_details(self.serverid['B'])
|
|
1315 | 1349 |
ip = self._get_ipv4(server) |
1316 | 1350 |
|
1317 | 1351 |
fail_tmout = time.time() + self.action_timeout |
... | ... | |
1341 | 1375 |
log.info("Setting up interface eth1 for server A") |
1342 | 1376 |
self.result_dict.clear() |
1343 | 1377 |
|
1344 |
server = self.client.get_server_details(self.serverid['A']) |
|
1345 |
image = self.client.get_image_details(self.imageid) |
|
1378 |
server = self.cyclades_client.get_server_details(self.serverid['A'])
|
|
1379 |
image = self.cyclades_client.get_image_details(self.imageid)
|
|
1346 | 1380 |
os_value = image['metadata']['os'] |
1347 | 1381 |
|
1348 | 1382 |
users = image["metadata"].get("users", None) |
... | ... | |
1375 | 1409 |
|
1376 | 1410 |
log.info("Setting up interface eth1 for server B") |
1377 | 1411 |
|
1378 |
server = self.client.get_server_details(self.serverid['B']) |
|
1379 |
image = self.client.get_image_details(self.imageid) |
|
1412 |
server = self.cyclades_client.get_server_details(self.serverid['B'])
|
|
1413 |
image = self.cyclades_client.get_image_details(self.imageid)
|
|
1380 | 1414 |
os_value = image['metadata']['os'] |
1381 | 1415 |
|
1382 | 1416 |
users = image["metadata"].get("users", None) |
... | ... | |
1409 | 1443 |
|
1410 | 1444 |
log.info("Testing if server A is actually connected to server B") |
1411 | 1445 |
|
1412 |
server = self.client.get_server_details(self.serverid['A']) |
|
1413 |
image = self.client.get_image_details(self.imageid) |
|
1446 |
server = self.cyclades_client.get_server_details(self.serverid['A'])
|
|
1447 |
image = self.cyclades_client.get_image_details(self.imageid)
|
|
1414 | 1448 |
os_value = image['metadata']['os'] |
1415 | 1449 |
hostip = self._get_ipv4(server) |
1416 | 1450 |
|
... | ... | |
1443 | 1477 |
|
1444 | 1478 |
log.info("Disconnecting servers from private network") |
1445 | 1479 |
|
1446 |
prev_state = self.client.get_network_details(self.networkid) |
|
1480 |
prev_state = self.cyclades_client.get_network_details(self.networkid)
|
|
1447 | 1481 |
prev_nics = prev_state['attachments'] |
1448 | 1482 |
#prev_conn = len(prev_nics) |
1449 | 1483 |
|
1450 | 1484 |
nicsA = [x['id'] |
1451 |
for x in self.client.get_server_details( |
|
1485 |
for x in self.cyclades_client.get_server_details(
|
|
1452 | 1486 |
self.serverid['A'])['attachments']] |
1453 | 1487 |
nicsB = [x['id'] |
1454 |
for x in self.client.get_server_details( |
|
1488 |
for x in self.cyclades_client.get_server_details(
|
|
1455 | 1489 |
self.serverid['B'])['attachments']] |
1456 | 1490 |
|
1457 | 1491 |
for nic in prev_nics: |
1458 | 1492 |
if nic in nicsA: |
1459 |
self.client.disconnect_server(self.serverid['A'], nic) |
|
1493 |
self.cyclades_client.disconnect_server(self.serverid['A'], nic)
|
|
1460 | 1494 |
if nic in nicsB: |
1461 |
self.client.disconnect_server(self.serverid['B'], nic) |
|
1495 |
self.cyclades_client.disconnect_server(self.serverid['B'], nic)
|
|
1462 | 1496 |
|
1463 | 1497 |
#Insist on deleting until action timeout |
1464 | 1498 |
fail_tmout = time.time() + self.action_timeout |
1465 | 1499 |
|
1466 | 1500 |
while True: |
1467 | 1501 |
netsA = [x['network_id'] |
1468 |
for x in self.client.get_server_details( |
|
1502 |
for x in self.cyclades_client.get_server_details(
|
|
1469 | 1503 |
self.serverid['A'])['attachments']] |
1470 | 1504 |
netsB = [x['network_id'] |
1471 |
for x in self.client.get_server_details( |
|
1505 |
for x in self.cyclades_client.get_server_details(
|
|
1472 | 1506 |
self.serverid['B'])['attachments']] |
1473 | 1507 |
|
1474 | 1508 |
#connected = (self.client.get_network_details(self.networkid)) |
... | ... | |
1488 | 1522 |
|
1489 | 1523 |
log.info("Submitting delete network request") |
1490 | 1524 |
|
1491 |
self.client.delete_network(self.networkid) |
|
1525 |
self.cyclades_client.delete_network(self.networkid)
|
|
1492 | 1526 |
|
1493 | 1527 |
fail_tmout = time.time() + self.action_timeout |
1494 | 1528 |
|
1495 | 1529 |
while True: |
1496 | 1530 |
|
1497 | 1531 |
curr_net = [] |
1498 |
networks = self.client.list_networks() |
|
1532 |
networks = self.cyclades_client.list_networks()
|
|
1499 | 1533 |
|
1500 | 1534 |
for net in networks: |
1501 | 1535 |
curr_net.append(net['id']) |
... | ... | |
1515 | 1549 |
|
1516 | 1550 |
log.info("Delete servers created for this test") |
1517 | 1551 |
|
1518 |
self.compute.delete_server(self.serverid['A'])
|
|
1519 |
self.compute.delete_server(self.serverid['B'])
|
|
1552 |
self.cyclades_client.delete_server(self.serverid['A'])
|
|
1553 |
self.cyclades_client.delete_server(self.serverid['B'])
|
|
1520 | 1554 |
|
1521 | 1555 |
fail_tmout = time.time() + self.action_timeout |
1522 | 1556 |
|
... | ... | |
1524 | 1558 |
status = dict() |
1525 | 1559 |
|
1526 | 1560 |
while True: |
1527 |
details = self.compute.get_server_details(self.serverid['A']) |
|
1561 |
details = \ |
|
1562 |
self.cyclades_client.get_server_details(self.serverid['A']) |
|
1528 | 1563 |
status['A'] = details['status'] |
1529 |
details = self.compute.get_server_details(self.serverid['B']) |
|
1564 |
details = \ |
|
1565 |
self.cyclades_client.get_server_details(self.serverid['B']) |
|
1530 | 1566 |
status['B'] = details['status'] |
1531 | 1567 |
if (status['A'] == 'DELETED') and (status['B'] == 'DELETED'): |
1532 | 1568 |
deleted = True |
... | ... | |
1782 | 1818 |
# Clean up servers/networks functions |
1783 | 1819 |
def cleanup_servers(timeout, query_interval, delete_stale=False): |
1784 | 1820 |
|
1785 |
c = ComputeClient(API, TOKEN) |
|
1821 |
astakos_client = AstakosClient(AUTH_URL, TOKEN) |
|
1822 |
# Compute Client |
|
1823 |
compute_url = astakos_client.get_service_endpoints('compute')['publicURL'] |
|
1824 |
compute_client = ComputeClient(compute_url, TOKEN) |
|
1786 | 1825 |
|
1787 |
servers = c.list_servers() |
|
1826 |
servers = compute_client.list_servers()
|
|
1788 | 1827 |
stale = [s for s in servers if s["name"].startswith(SNF_TEST_PREFIX)] |
1789 | 1828 |
|
1790 | 1829 |
if len(stale) == 0: |
... | ... | |
1802 | 1841 |
print >> sys.stderr, "Deleting %d stale servers:" % len(stale) |
1803 | 1842 |
fail_tmout = time.time() + timeout |
1804 | 1843 |
for s in stale: |
1805 |
c.delete_server(s["id"]) |
|
1844 |
compute_client.delete_server(s["id"])
|
|
1806 | 1845 |
# Wait for all servers to be deleted |
1807 | 1846 |
while True: |
1808 |
servers = c.list_servers() |
|
1847 |
servers = compute_client.list_servers()
|
|
1809 | 1848 |
stale = [s for s in servers |
1810 | 1849 |
if s["name"].startswith(SNF_TEST_PREFIX)] |
1811 | 1850 |
if len(stale) == 0: |
... | ... | |
1824 | 1863 |
|
1825 | 1864 |
def cleanup_networks(action_timeout, query_interval, delete_stale=False): |
1826 | 1865 |
|
1827 |
c = CycladesClient(API, TOKEN) |
|
1866 |
astakos_client = AstakosClient(AUTH_URL, TOKEN) |
|
1867 |
# Cyclades Client |
|
1868 |
compute_url = astakos_client.get_service_endpoints('compute')['publicURL'] |
|
1869 |
cyclades_client = CycladesClient(compute_url, TOKEN) |
|
1828 | 1870 |
|
1829 |
networks = c.list_networks() |
|
1871 |
networks = cyclades_client.list_networks()
|
|
1830 | 1872 |
stale = [n for n in networks if n["name"].startswith(SNF_TEST_PREFIX)] |
1831 | 1873 |
|
1832 | 1874 |
if len(stale) == 0: |
... | ... | |
1844 | 1886 |
print >> sys.stderr, "Deleting %d stale networks:" % len(stale) |
1845 | 1887 |
fail_tmout = time.time() + action_timeout |
1846 | 1888 |
for n in stale: |
1847 |
c.delete_network(n["id"]) |
|
1889 |
cyclades_client.delete_network(n["id"])
|
|
1848 | 1890 |
# Wait for all networks to be deleted |
1849 | 1891 |
while True: |
1850 |
networks = c.list_networks() |
|
1892 |
networks = cyclades_client.list_networks()
|
|
1851 | 1893 |
stale = [n for n in networks |
1852 | 1894 |
if n["name"].startswith(SNF_TEST_PREFIX)] |
1853 | 1895 |
if len(stale) == 0: |
... | ... | |
1889 | 1931 |
parser = OptionParser(**kw) |
1890 | 1932 |
parser.disable_interspersed_args() |
1891 | 1933 |
|
1892 |
parser.add_option("--api", |
|
1893 |
action="store", type="string", dest="api", |
|
1894 |
help="The API URI to use to reach the Synnefo API", |
|
1895 |
default=None) |
|
1896 |
parser.add_option("--plankton", |
|
1897 |
action="store", type="string", dest="plankton", |
|
1898 |
help="The API URI to use to reach the Plankton API", |
|
1934 |
parser.add_option("--auth-url", |
|
1935 |
action="store", type="string", dest="auth_url", |
|
1936 |
help="The AUTH URI to use to reach the Synnefo API", |
|
1899 | 1937 |
default=None) |
1900 | 1938 |
parser.add_option("--plankton-user", |
1901 | 1939 |
action="store", type="string", dest="plankton_user", |
1902 | 1940 |
help="Owner of system images", |
1903 | 1941 |
default=DEFAULT_PLANKTON_USER) |
1904 |
parser.add_option("--pithos", |
|
1905 |
action="store", type="string", dest="pithos", |
|
1906 |
help="The API URI to use to reach the Pithos API", |
|
1907 |
default=None) |
|
1908 |
parser.add_option("--astakos", |
|
1909 |
action="store", type="string", dest="astakos", |
|
1910 |
help="The API URI to use to reach the Astakos API", |
|
1911 |
default=None) |
|
1912 | 1942 |
parser.add_option("--token", |
1913 | 1943 |
action="store", type="string", dest="token", |
1914 | 1944 |
help="The token to use for authentication to the API") |
... | ... | |
2013 | 2043 |
|
2014 | 2044 |
# `token' is mandatory |
2015 | 2045 |
_mandatory_argument(opts.token, "--token") |
2016 |
# `api' is mandatory
|
|
2017 |
_mandatory_argument(opts.api, "--api")
|
|
2046 |
# `auth_url' is mandatory
|
|
2047 |
_mandatory_argument(opts.auth_url, "--auth-url")
|
|
2018 | 2048 |
|
2019 | 2049 |
if not opts.show_stale: |
2020 | 2050 |
# `image-id' is mandatory |
... | ... | |
2028 | 2058 |
"--image-id. Use a valid id, or `all'." + \ |
2029 | 2059 |
normal |
2030 | 2060 |
sys.exit(1) |
2031 |
# `pithos' is mandatory |
|
2032 |
_mandatory_argument(opts.pithos, "--pithos") |
|
2033 |
# `astakos' is mandatory |
|
2034 |
_mandatory_argument(opts.astakos, "--astakos") |
|
2035 |
# `plankton' is mandatory |
|
2036 |
_mandatory_argument(opts.plankton, "--plankton") |
|
2037 | 2061 |
|
2038 | 2062 |
return (opts, args) |
2039 | 2063 |
|
2040 | 2064 |
|
2041 | 2065 |
def _mandatory_argument(Arg, Str): |
2042 |
if not Arg:
|
|
2066 |
if (Arg is None) or (Arg == ""):
|
|
2043 | 2067 |
print >>sys.stderr, red + \ |
2044 | 2068 |
"The " + Str + " argument is mandatory.\n" + \ |
2045 | 2069 |
normal |
... | ... | |
2063 | 2087 |
(opts, args) = parse_arguments(sys.argv[1:]) |
2064 | 2088 |
|
2065 | 2089 |
# Some global variables |
2066 |
global API, TOKEN, PLANKTON, PLANKTON_USER
|
|
2067 |
global PITHOS, ASTAKOS, NO_IPV6, VERBOSE, NOFAILFAST
|
|
2068 |
API = opts.api
|
|
2090 |
global AUTH_URL, TOKEN, PLANKTON_USER
|
|
2091 |
global NO_IPV6, VERBOSE, NOFAILFAST |
|
2092 |
AUTH_URL = opts.auth_url
|
|
2069 | 2093 |
TOKEN = opts.token |
2070 |
PLANKTON = opts.plankton |
|
2071 | 2094 |
PLANKTON_USER = opts.plankton_user |
2072 |
PITHOS = opts.pithos |
|
2073 |
ASTAKOS = opts.astakos |
|
2074 | 2095 |
NO_IPV6 = opts.no_ipv6 |
2075 | 2096 |
VERBOSE = opts.verbose |
2076 | 2097 |
NOFAILFAST = opts.nofailfast |
... | ... | |
2086 | 2107 |
return 0 |
2087 | 2108 |
|
2088 | 2109 |
# Initialize a kamaki instance, get flavors, images |
2089 |
c = ComputeClient(API, TOKEN) |
|
2090 |
DIMAGES = c.list_images(detail=True) |
|
2091 |
DFLAVORS = c.list_flavors(detail=True) |
|
2110 |
astakos_client = AstakosClient(AUTH_URL, TOKEN) |
|
2111 |
# Compute Client |
|
2112 |
compute_url = astakos_client.get_service_endpoints('compute')['publicURL'] |
|
2113 |
compute_client = ComputeClient(compute_url, TOKEN) |
|
2114 |
DIMAGES = compute_client.list_images(detail=True) |
|
2115 |
DFLAVORS = compute_client.list_flavors(detail=True) |
|
2092 | 2116 |
|
2093 | 2117 |
# FIXME: logging, log, LOG PID, TEST_RUN_ID, arguments |
2094 | 2118 |
# Run them: FIXME: In parallel, FAILEARLY, catchbreak? |
Also available in: Unified diff