class Euca4869(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): # Try and deregister a malforemd imageId (ie: emi, efi, eri followed by 8 chars) self.runSysCmd("euca-deregister emi-1234567") # Check for new error (Invalid id: "emi-1234567") self.new = str(self.out).count("Invalid id") # We should see the new error and not the old. if self.new > 0: self.tester.debug("SUCCESS new error logged") pass else: self.fail("FAIL old error logged")
class Euca4750(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): # Set modify the property with a null value self.runSysCmd("euca-modify-property -p www.httpproxyhost=") self.runSysCmd("euca-describe-properties") # Check euca-describe-properties output for property self.count = str(self.out).count("www.httpproxyhost") # reset property to original value self.runSysCmd("euca-modify-property -r www.httpproxyhost") if self.count == 1: self.tester.debug( "SUCCESS property with null value modified correctly") pass else: self.fail("FAIL value null value not modified correctly")
class EucaTest(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.OK = '\033[1m\033[37m\033[42m' self.ENDC = '\033[0m' def tearDown(self): self.tester.modify_property('dns.tcp.timeout_seconds' , '30' ) self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def print_time(self, start): elapsed = time.time() - start minutes = int(elapsed / 60) seconds = int(elapsed % 60) print self.OK + "Elapsed time = " + str(minutes) + ' min ' + str(seconds) + ' sec ' + self.ENDC def test(self): # Set the timeout the default is 30 self.tester.modify_property('dns.tcp.timeout_seconds' , '10' ) self.start = time.time() # The DNS TCP HANDLER should timeout before the ssh timeout=120 self.tester.sys("nc -w 120 " + str(self.tester.clc.hostname) + " 53",timeout=120) self.print_time(self.start)
class Euca4869(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops( config_file=self.conf, password="******" ) self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): # Try and deregister a malforemd imageId (ie: emi, efi, eri followed by 8 chars) self.runSysCmd("euca-deregister emi-1234567") # Check for new error (Invalid id: "emi-1234567") self.new = str(self.out).count("Invalid id") # We should see the new error and not the old. if self.new > 0 : self.tester.debug("SUCCESS new error logged") pass else: self.fail("FAIL old error logged")
class Euca4735(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops( config_file=self.conf, password="******" ) self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): self.emi = self.tester.get_emi(root_device_type='instance-store') self.ins= self.tester.run_image(image=self.emi, keypair=self.keypair, max=4, monitor_to_running=False, clean_on_fail=True) for i in self.ins: print 'killing instance: '+ str(i.id) i.terminate() print self.ins
class EucaTest(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.STARTC = '\033[1m\033[1m\033[42m' self.ENDC = '\033[0m' def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def test(self): canonicalID = str(self.tester.s3.get_canonical_user_id()) count = len(canonicalID) print self.STARTC + "canonicalId = " + canonicalID + self.ENDC print self.STARTC + "canonicalId size = " + str(count) + self.ENDC # make sure it is valid 64 character canonicalID if count == 64 : self.tester.debug("SUCCESS") pass else: self.fail("FAIL")
class EucaTest(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.clc1 = self.tester.service_manager.get_enabled_clc() def tearDown(self): self.tester.cleanup_artifacts() shutil.rmtree(self.tester.credpath) def check_for_error_msg(self, error): self.logFile = self.tester.eucapath + "/var/log/eucalyptus/cloud-error.log" if self.clc1.machine.found(" grep " + error + " " + self.logFile, error): self.fail("FAILURE! Maximum message size exceeded. error thrown.") else: self.tester.debug("SUCCESS! No error logged!") def test(self): # send message that excceeds 1024 bytes (admin_cred.zip could be any file that exceeds 1024 bytes) self.tester.sys("nc " + str(self.tester.clc.hostname) + " 53 < admin_cred.zip") # Check make sure error is not there. self.check_for_error_msg( "Maximum message size exceeded. Ignoring request.")
class Euca3933(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.fakeId = "OOO000000000" self.cmdMod = " euca-modify-image-attribute --launch-permission " self.tester = Eucaops(config_file=self.conf, password="******") self.source = "source " + self.tester.credpath + "/eucarc && " self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testValidation(self): self.emi = self.tester.get_emi() # Try and add --launch-permission with a bad userId self.out = self.tester.sys(self.source + self.cmdMod + " -a " + self.fakeId + " " + self.emi.id) # Check output self.count = str(self.out).count("Not a valid userId") if self.count == 1: self.tester.debug( "SUCCESS --launch-permission validation error thrown") pass else: self.fail("FAIL no error with bad userID") pass
class Euca2198(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.OK = '\033[1m\033[37m\033[42m' self.ENDC = '\033[0m' def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): self.runSysCmd('euca-describe-regions') if not str(self.out).count('Walrus'): print self.OK + str(self.out) + self.ENDC else : self.fail( 'Walrus listed in output')
class EucaTest(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.STARTC = '\033[1m\033[1m\033[42m' self.ENDC = '\033[0m' self.cc = self.tester.service_manager.get_all_cluster_controllers()[3] self.orig_name = self.cc.name def tearDown(self): # deregister cluster self.runSysCmd( "/opt/eucalyptus/usr/sbin/euca_conf --deregister-cluster --partition " + self.cc.partition + " --host " + self.cc.hostname + " --component " + self.cc.name + '_TEST') # register cluster self.runSysCmd( "/opt/eucalyptus/usr/sbin/euca_conf --register-cluster --partition " + self.cc.partition + " --host " + self.cc.hostname + " --component " + self.orig_name) self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def test(self): # deregister cluster self.runSysCmd( "/opt/eucalyptus/usr/sbin/euca_conf --deregister-cluster --partition " + self.cc.partition + " --host " + self.cc.hostname + " --component " + self.cc.name) # register cluster self.runSysCmd( "/opt/eucalyptus/usr/sbin/euca_conf --register-cluster --partition " + self.cc.partition + " --host " + self.cc.hostname + " --component " + self.cc.name + '_TEST') # Sleep for 10 seconds while cluster Enables print self.STARTC + " Sleep for 10 seconds while cluster Enables. " + self.ENDC self.tester.sleep(10) # Make sure newly registered cluster with a different name is ENABLED try: check_cc = self.tester.service_manager.get_all_cluster_controllers( hostname=self.cc.hostname, state="ENABLED", use_cached_list=False)[0] print self.STARTC + "Success " + str( check_cc.name) + " ENABLED " + self.ENDC pass except Exception, e: self.fail("Renamed cluster not enabled!")
class EucaTest(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.STARTC = "\033[1m\033[1m\033[42m" self.ENDC = "\033[0m" def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def test(self): canonicalID = str(self.tester.s3.get_canonical_user_id()) count = len(canonicalID) print self.STARTC + "canonicalId = " + canonicalID + self.ENDC print self.STARTC + "canonicalId size = " + str(count) + self.ENDC # make sure it is valid 64 character canonicalID if count == 64: self.tester.debug("SUCCESS") pass else: self.fail("FAIL")
class ConsoleCleanUp(EutesterTestCase): def __init__(self, extra_args= None, **kwargs): self.setuptestcase() self.setup_parser() if extra_args: for arg in extra_args: self.parser.add_argument(arg) self.get_args() for kwarg in kwargs: self.args[kwarg] = kwarg[kwarg] # Setup basic eutester object if self.args.region: self.tester = EC2ops( credpath=self.args.credpath, region=self.args.region) else: self.tester = Eucaops( credpath=self.args.credpath, config_file=self.args.config,password=self.args.password) self.tester.poll_count = 120 def scan_and_clean_all_existing_resources(self): self.tester.test_resources['addresses']=self.tester.ec2.get_all_addresses() self.tester.test_resources['auto-scaling-groups']=self.tester.autoscale.get_all_groups() self.tester.test_resources['volumes']=self.tester.ec2.get_all_volumes() self.tester.test_resources['keypairs']=self.tester.ec2.get_all_key_pairs() self.tester.test_resources['snapshots']=self.tester.ec2.get_all_snapshots() self.tester.test_resources['security-groups']=self.tester.ec2.get_all_security_groups() self.tester.test_resources['reservations']=self.tester.ec2.get_all_instances() self.tester.test_resources['launch-configurations']=self.tester.autoscale.get_all_launch_configurations() self.tester.debug("Attempting to clean up:\n" + str(self.tester.test_resources)) self.tester.cleanup_artifacts()
class Euca5845(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.OK = "\033[1m\033[37m\033[42m" self.ENDC = "\033[0m" def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self, groupName): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group(groupName) self.tester.authorize_group(self.group) def testName(self): # Group name with NON ASCII Character badGroupName = "lin¢ux" try: self.doAuth(badGroupName) except Exception as err: if str(err).count("InvalidParameterValue") > 0: print self.OK + err.args[2] + self.ENDC pass else: self.fail("FAILED : NON ASCII Character allowed.") print "SUCCESS"
class Euca6559(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): self.emi = self.tester.get_emi() self.new_emi = self.tester.register_manifest(self.emi.location) self.tester.deregister_image(self.new_emi); self.runSysCmd('euca-describe-images ' + self.new_emi.id); ### make sure that the images in the deregistered state are not output to user. if str(self.out).count('deregistered') == 0 : self.tester.debug("SUCCESS") pass else: self.fail("FAIL")
class LoadBalancing(EutesterTestCase): def __init__(self, extra_args= None): self.setuptestcase() self.setup_parser() if extra_args: for arg in extra_args: self.parser.add_argument(arg) self.get_args() # Setup basic eutester object if self.args.region: self.tester = ELBops( credpath=self.args.credpath, region=self.args.region) else: self.tester = Eucaops( credpath=self.args.credpath, config_file=self.args.config,password=self.args.password) self.tester.poll_count = 120 ### Add and authorize a group for the instance self.group = self.tester.add_group(group_name="group-" + str(int(time.time()))) self.tester.authorize_group_by_name(group_name=self.group.name ) self.tester.authorize_group_by_name(group_name=self.group.name, port=-1, protocol="icmp" ) ### Generate a keypair for the instance self.keypair = self.tester.add_keypair( "keypair-" + str(int(time.time()))) self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name) ### Get an image self.image = self.args.emi if not self.image: self.image = self.tester.get_emi(root_device_type="instance-store", not_platform="windows") ### Populate available zones zones = self.tester.ec2.get_all_zones() self.zone = random.choice(zones).name self.load_balancer_port = 80 (self.web_servers, self.filename) = self.tester.create_web_servers(keypair=self.keypair, group=self.group, zone=self.zone, port=self.load_balancer_port, filename='instance-name', image=self.image) self.load_balancer = self.tester.create_load_balancer(zones=[self.zone], name="test-" + str(int(time.time())), load_balancer_port=self.load_balancer_port) assert isinstance(self.load_balancer, LoadBalancer) self.tester.register_lb_instances(self.load_balancer.name, self.web_servers.instances) def clean_method(self): self.tester.cleanup_artifacts() def GenerateRequests(self): """ This will test the most basic use case for a load balancer. Uses to backend instances with httpd servers. """ dns = self.tester.service_manager.get_enabled_dns() lb_ip = dns.resolve(self.load_balancer.dns_name) lb_url = "http://{0}:{1}/instance-name".format(lb_ip, self.load_balancer_port) self.tester.generate_http_requests(url=lb_url, count=1000)
class ResourceGeneration(EutesterTestCase): def __init__(self,extra_args = None): self.setuptestcase() self.setup_parser() if extra_args: for arg in extra_args: self.parser.add_argument(arg) self.get_args() # Setup basic eutester object self.tester = Eucaops( credpath=self.args.credpath, config_file=self.args.config, password=self.args.password) self.testers = [] def clean_method(self): self.tester.cleanup_artifacts() def CreateResources(self): users = self.tester.get_all_users() self.testers.append(self.tester) for user in users: user_name = user['user_name'] user_account = user['account_name'] if not re.search("eucalyptus", user_account ): self.tester.debug("Creating access key for " + user_name + " in account " + user_account) keys = self.tester.create_access_key(user_name=user_name, delegate_account=user_account) access_key = keys['access_key_id'] secret_key = keys['secret_access_key'] self.tester.debug("Creating Eucaops object with access key " + access_key + " and secret key " + secret_key) new_tester = Eucaops(aws_access_key_id=access_key, aws_secret_access_key=secret_key, ec2_ip=self.tester.ec2.host, s3_ip=self.tester.s3.host,username=user_name, account=user_account) self.testers.append(new_tester) self.tester.debug("Created a total of " + str(len(self.testers)) + " testers" ) for resource_tester in self.testers: import random assert isinstance(resource_tester, Eucaops) zone = random.choice(resource_tester.get_zones()) keypair = resource_tester.add_keypair(resource_tester.id_generator()) group = resource_tester.add_group(resource_tester.id_generator()) resource_tester.authorize_group_by_name(group_name=group.name) resource_tester.authorize_group_by_name(group_name=group.name, port=-1, protocol="icmp" ) reservation = resource_tester.run_instance(keypair=keypair.name,group=group.name,zone=zone) instance = reservation.instances[0] assert isinstance(instance, EuInstance) if not instance.ip_address == instance.private_ip_address: address = resource_tester.allocate_address() resource_tester.associate_address(instance=instance, address=address) resource_tester.disassociate_address_from_instance(instance) resource_tester.release_address(address) self.tester.sleep(5) instance.update() instance.reset_ssh_connection() volume = resource_tester.create_volume(size=1, zone=zone) instance.attach_volume(volume) snapshot = resource_tester.create_snapshot(volume_id=volume.id) volume_from_snap = resource_tester.create_volume(snapshot=snapshot, zone=zone) bucket = resource_tester.create_bucket(resource_tester.id_generator(12, string.ascii_lowercase + string.digits)) key = resource_tester.upload_object(bucket_name= bucket.name, key_name= resource_tester.id_generator(12, string.ascii_lowercase + string.digits), contents= resource_tester.id_generator(200)) resource_tester.terminate_instances(reservation)
class Euca4750(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops( config_file=self.conf, password="******" ) self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): # Set modify the property with a null value self.runSysCmd("euca-modify-property -p www.httpproxyhost=") self.runSysCmd("euca-describe-properties") # Check euca-describe-properties output for property self.count = str(self.out).count("www.httpproxyhost") # reset property to original value self.runSysCmd("euca-modify-property -r www.httpproxyhost") if self.count == 1: self.tester.debug("SUCCESS property with null value modified correctly") pass else: self.fail("FAIL value null value not modified correctly")
class Euca3933(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.fakeId = "OOO000000000" self.cmdMod = " euca-modify-image-attribute --launch-permission " self.tester = Eucaops( config_file=self.conf, password="******" ) self.source = "source " + self.tester.credpath + "/eucarc && " self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testValidation(self): self.emi = self.tester.get_emi() # Try and add --launch-permission with a bad userId self.out = self.tester.sys(self.source + self.cmdMod + " -a " + self.fakeId + " " + self.emi.id) # Check output self.count = str(self.out).count("Not a valid accountId") if self.count==1: self.tester.debug("SUCCESS --launch-permission validation error thrown") pass else: self.fail("FAIL no error with bad userID") pass
class Euca(unittest.TestCase): def setUp(self): self.conf = "../cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.STARTC = '\033[1m\033[1m\033[42m' self.ENDC = '\033[0m' self.account = "9959-account" self.groupname = "9959-group" self.username = "******" def tearDown(self): self.tester.delete_account(self.account, recursive=True) self.tester.sys('rm -rf role-describe-instances-principle.json') self.tester.sys('rm -rf role-trust.json') self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def test(self): # create account, group and user self.tester.create_account(account_name=self.account) self.tester.create_group(self.groupname, "/", self.account) self.tester.create_user(self.username, "/", self.account) self.tester.add_user_to_group(self.groupname, self.username, self.account) # copy json to clc self.clc_ip = str(self.tester.clc.hostname) os.system('scp role-describe-instances-principle.json root@' + self.clc_ip + ':role-describe-instances-principle.json') os.system('scp role-trust.json root@' + self.clc_ip + ':role-trust.json') # create user role self.runSysCmd( "euare-rolecreate -r describe-instances -f role-trust.json --region " + self.account + "-" + self.username) self.runSysCmd( "euare-roleuploadpolicy -r describe-instances -p describe-instances-policy -f role-describe-instances-principle.json --region " + self.account + "-" + self.username) print self.STARTC + "Success " + str( self.out) + " ENABLED " + self.ENDC # Check to see that the error message was thrown and not the text from the json file. count = str( self.out).count("Policy document should not specify a principal.") if count > 0: self.tester.debug("SUCCESS") pass else: self.fail("FAILED : correct error message not thrown")
class Euca4268(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.cond = 1 self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runInstances(self): #Start instance self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group, min=2, max=2, is_reachable=False) # Make sure the instance is running self.count = 0 for instance in self.reservation.instances: self.count += 1 if instance.state == "running": if self.count == 1: self.ip_one = instance.public_dns_name self.instanceid_one = instance.id else: self.ip_two = instance.public_dns_name self.instanceid_two = instance.id def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) self.tester.authorize_group(self.group, port=-1, protocol="icmp") def testName(self): self.runInstances() self.tester.ping(self.ip_one, 1) self.tester.ping(self.ip_two, 1) #make sure instance is reachable self.cmd = 'euca-reboot-instances ' + self.instanceid_one + " " + self.instanceid_two self.runSysCmd(self.cmd) #wait for reboot self.tester.sleep(2) self.pingable1 = self.tester.ping(self.ip_one, 1) self.pingable2 = self.tester.ping(self.ip_two, 1) if self.pingable1 == False and self.pingable2 == False: self.tester.debug("SUCCESS both instances were rebooted") pass else: self.fail("FAIL both instances not rebooted")
class CloudFormationTemplateURLTests(EutesterTestCase): def __init__(self, extra_args=None): self.setuptestcase() self.setup_parser() self.parser.add_argument('--template_urls', dest='template_urls', help='comma separated list of template_urls', default=None) self.parser.add_argument('--timeout', dest='timeout', help='number of seconds to wait for stacks to complete', default=300) if extra_args: for arg in extra_args: self.parser.add_argument(arg) self.get_args() self.show_args() self.template_urls = self.args.template_urls.split(',') self.timeout = int(self.args.timeout) # Setup basic eutester object if self.args.region: self.tester = CFNops(credpath=self.args.credpath, region=self.args.region) else: self.tester = Eucaops(credpath=self.args.credpath, config_file=self.args.config, password=self.args.password) # Generate a keypair for the instance self.keypair = self.tester.add_keypair("keypair-" + str(time.time())) self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name) self.stacks = [] def Stack_Template_URL_Test(self): for url in self.template_urls: # get template name from URL, remove file extension and any "-" template = os.path.splitext(url.rsplit('/', 1)[1])[0].replace("-", "") self.stack_name = template + str(os.urandom(8).encode('hex')) self.stacks.append(self.stack_name) self.template_parameters = [('KeyName', self.keypair.name), ('ImageId', self.tester.get_emi().id)] self.tester.create_stack(stack_name=self.stack_name, template_body=None, template_url=url, parameters=self.template_parameters) def stack_completed(): stack_status = False if len(self.tester.cloudformation.describe_stack_events(self.stack_name)) > 0: stack_info = self.tester.cloudformation.describe_stack_events(self.stack_name) for inf in stack_info: if (inf.logical_resource_id == self.stack_name) and (inf.resource_status == "CREATE_COMPLETE"): self.debug("Stack Logical Resource: " + inf.logical_resource_id) self.debug("Stack Resource Status: " + inf.resource_status) stack_status = True return stack_status self.tester.wait_for_result(stack_completed, True, timeout=self.timeout) def clean_method(self): self.tester.cleanup_artifacts() for stack in self.stacks: self.tester.delete_stack(stack)
class Euca4268(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops( config_file=self.conf, password="******" ) self.cond = 1 self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runInstances(self): #Start instance self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group,min=2,max=2,is_reachable=False) # Make sure the instance is running self.count = 0; for instance in self.reservation.instances: self.count += 1 if instance.state == "running": if self.count == 1 : self.ip_one = instance.public_dns_name self.instanceid_one = instance.id else: self.ip_two = instance.public_dns_name self.instanceid_two = instance.id def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) self.tester.authorize_group(self.group, port=-1, protocol="icmp") def testName(self): self.runInstances() self.tester.ping(self.ip_one, 1) self.tester.ping(self.ip_two, 1) #make sure instance is reachable self.cmd = 'euca-reboot-instances ' + self.instanceid_one + " " + self.instanceid_two self.runSysCmd(self.cmd) #wait for reboot self.tester.sleep(2) self.pingable1 = self.tester.ping(self.ip_one, 1) self.pingable2 = self.tester.ping(self.ip_two, 1) if self.pingable1 == False and self.pingable2 == False : self.tester.debug("SUCCESS both instances were rebooted") pass else: self.fail("FAIL both instances not rebooted")
class Euca3949(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.cond = 1 self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.clc1 = self.tester.service_manager.get_enabled_clc() self.IP = self.tester.get_ec2_ip() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runInstances(self, numMax): #Start instance self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group, min=1, max=numMax, is_reachable=False) # Make sure the instance is running for instance in self.reservation.instances: if instance.state == "running": self.instance = instance def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def check_for_error_msg(self, error): self.logFile = self.tester.eucapath + "/var/log/eucalyptus/cloud-output.log" if self.clc1.machine.found(" grep " + error + " " + self.logFile, error): self.fail("FAILURE! PersistentObjectException error thrown.") else: self.tester.debug("SUCCESS! No confusing error logged!") def testName(self): self.emi = self.tester.get_emi() self.runInstances(1) self.tester.terminate_single_instance(self.instance) self.runSysCmd("euca-describe-instances") #check log file to see if PersistentObjectException error was thrown self.check_for_error_msg("PersistentObjectException") pass
class InstanceRestore(EutesterTestCase): def __init__(self): self.setuptestcase() self.setup_parser() self.get_args() # Setup basic eutester object self.tester = Eucaops(config_file=self.args.config_file, password=self.args.password) self.tester.poll_count = 120 ### Add and authorize a group for the instance self.group = self.tester.add_group(group_name="group-" + str(time.time())) self.tester.authorize_group_by_name(group_name=self.group.name) self.tester.authorize_group_by_name(group_name=self.group.name, port=-1, protocol="icmp") ### Generate a keypair for the instance self.keypair = self.tester.add_keypair("keypair-" + str(time.time())) self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name) self.image = self.tester.get_emi(root_device_type="instance-store") self.reservation = None self.private_addressing = False zones = self.tester.ec2.get_all_zones() self.zone = random.choice(zones).name clcs = self.tester.get_component_machines("clc") if len(clcs) is 0: raise Exception("No CLC found") else: self.clc = clcs[0] self.cur_time = str(int(time.time())) self.ncs = self.tester.get_component_machines("nc") def clean_method(self): ncs = self.tester.get_component_machines("nc") for nc in ncs: nc.sys("service eucalyptus-nc start") ### RESET vmstate properties self.tester.modify_property("cloud.vmstate.instance_timeout", "60") self.tester.modify_property("cloud.vmstate.terminated_time", "60") for nc in self.ncs: nc.sys("service eucalyptus-nc start") self.tester.cleanup_artifacts() try: image = self.tester.get_emi(self.image) except Exception, e: self.tester.register_image( image_location=self.image.location, ramdisk=self.image.ramdisk_id, kernel=self.image.kernel_id, virtualization_type=self.image.virtualization_type)
class Euca(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.OK = '\033[1m\033[37m\033[42m' self.ENDC = '\033[0m' def tearDown(self): self.runSysCmd( 'euca-modify-property --property-to-reset authentication.ldap_integration_configuration' ) self.tester.delete_account('account-euca5876', recursive=True) self.tester.sys('rm -rf euca5876.lic') self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = 'export EUCALYPTUS=' + self.tester.eucapath + " && source " + self.tester.credpath + "/eucarc && " + self.tester.eucapath + "/usr/sbin/" self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def test(self): self.clc_ip = str(self.tester.clc.hostname) os.system('scp euca5876.lic root@' + self.clc_ip + ':euca5876.lic') self.runSysCmd( 'euca-modify-property --property-to-reset authentication.ldap_integration_configuration' ) self.runSysCmd( 'euca-lictool --password password --custom euca5876.lic --out euca5876.lic --nocomment' ) self.runSysCmd( 'euca-modify-property -f authentication.ldap_integration_configuration=euca5876.lic' ) # Wait for LDAP to sync self.tester.sleep(20) # Count the numbers of users in the euca5876 group and make sure it is over 100 self.out = str( self.tester.sys( 'euare-grouplistusers -g euca5876 --as-account account-euca5876' )).count('arn:aws:iam::') print self.OK + 'Number of users created = ' + str( self.out) + self.ENDC assert self.out > 100
class Euca(unittest.TestCase): def setUp(self): self.conf = "../cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.STARTC = '\033[1m\033[1m\033[42m' self.ENDC = '\033[0m' self.account = "9959-account" self.groupname = "9959-group" self.username ="******" def tearDown(self): self.tester.delete_account(self.account, recursive=True) self.tester.sys('rm -rf role-describe-instances-principle.json') self.tester.sys('rm -rf role-trust.json') self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def test(self): # create account, group and user self.tester.create_account(account_name=self.account) self.tester.create_group(self.groupname, "/", self.account) self.tester.create_user(self.username, "/", self.account) self.tester.add_user_to_group(self.groupname,self.username,self.account) # copy json to clc self.clc_ip = str(self.tester.clc.hostname) os.system('scp role-describe-instances-principle.json root@' + self.clc_ip + ':role-describe-instances-principle.json') os.system('scp role-trust.json root@' + self.clc_ip + ':role-trust.json') # create user role self.runSysCmd("euare-rolecreate -r describe-instances -f role-trust.json --region " + self.account + "-" + self.username) self.runSysCmd("euare-roleuploadpolicy -r describe-instances -p describe-instances-policy -f role-describe-instances-principle.json --region " + self.account + "-" + self.username) print self.STARTC + "Success " + str(self.out) + " ENABLED " + self.ENDC # Check to see that the error message was thrown and not the text from the json file. count = str(self.out).count("Policy document should not specify a principal.") if count > 0 : self.tester.debug("SUCCESS") pass else: self.fail("FAILED : correct error message not thrown")
class Euca2264(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops( config_file=self.conf, password="******" ) self.doAuth() def tearDown(self): self.runSysCmd("euca-terminate-instances " + self.instanceid) self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " # Save command output in self.out self.out = self.tester.sys(self.source + cmd) def testName(self): self.emi = self.tester.get_emi() # start instances with multiple block devices self.runSysCmd("euca-run-instances " + self.emi.id + " -b /dev/sda2=:20 -b /dev/sda3=:20") # Search for error message self.count = str(self.out).count("412 Precondition Failed:") # Get instance id self.index = str(self.out).find("i-") self.instanceid = str(self.out)[self.index:self.index + 10] # if error not found pass else fail if self.count == 0 : self.index = str(self.out).find("i-") self.instanceid = str(self.out)[self.index:self.index + 10] self.time = 0 #Wait for instance to start while(self.count != 1 and self.time < 60): self.tester.sleep(5) self.time = self.time + 5 self.runSysCmd("euca-describe-instances " + self.instanceid) self.count = str(self.out).count('running') self.tester.debug("Elapsed time " + str(self.time) + " seconds.") self.tester.debug("SUCCESS") pass else: self.fail("FAIL 412 Precondition Failed:")
class EucaTest(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.OK = '\033[1m\033[37m\033[42m' self.ENDC = '\033[0m' def tearDown(self): self.tester.cleanup_artifacts() self.tester.modify_property('bootstrap.webservices.use_instance_dns', 'false') self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runInstances(self, numMax): self.emi = self.tester.get_emi(root_device_type='ebs') #Start instance self.reservation = self.tester.run_instance(self.emi, keypair=self.keypair.name, group=self.group, min=1, max=numMax, is_reachable=False) # Make sure the instance is running for instance in self.reservation.instances: if instance.state == "running": self.ip = instance.public_dns_name self.instanceid = instance.id def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def test(self): self.tester.modify_property('bootstrap.webservices.use_instance_dns', 'true') self.runInstances(1) self.tester.stop_instances(self.reservation) self.runSysCmd('euca-describe-instances ' + self.instanceid) # make sure publicdnsname and privatednsname fields are empty in euca-descibe-instances output assert str(self.out).count('eucalyptus.internal') == 0 assert str(self.out).count('eucalyptus.localhost') == 0 print self.OK + 'SUCCESS: publicdns and privatedns fields are empty in euca-descibe-instances output' + self.ENDC
class Euca2264(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() def tearDown(self): self.runSysCmd("euca-terminate-instances " + self.instanceid) self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " # Save command output in self.out self.out = self.tester.sys(self.source + cmd) def testName(self): self.emi = self.tester.get_emi() # start instances with multiple block devices self.runSysCmd("euca-run-instances " + self.emi.id + " -b /dev/sda2=:20 -b /dev/sda3=:20") # Search for error message self.count = str(self.out).count("412 Precondition Failed:") # Get instance id self.index = str(self.out).find("i-") self.instanceid = str(self.out)[self.index:self.index + 10] # if error not found pass else fail if self.count == 0: self.index = str(self.out).find("i-") self.instanceid = str(self.out)[self.index:self.index + 10] self.time = 0 #Wait for instance to start while (self.count != 1 and self.time < 60): self.tester.sleep(5) self.time = self.time + 5 self.runSysCmd("euca-describe-instances " + self.instanceid) self.count = str(self.out).count('running') self.tester.debug("Elapsed time " + str(self.time) + " seconds.") self.tester.debug("SUCCESS") pass else: self.fail("FAIL 412 Precondition Failed:")
class InstanceBasicsTest(EutesterTestCase): def __init__(self): #### Pre-conditions self.setuptestcase() self.setup_parser() self.parser.add_argument("--test-zone", default="PARTI00") self.parser.add_argument("--test-emi", default=None) self.parser.add_argument("--build-number", default='') self.get_args() # Setup basic eutester object if not self.args.credpath: self.tester = Eucaops(config_file=self.args.config, password=self.args.password) else: self.tester = Eucaops(credpath=self.args.credpath) self.reservation = None ### Generate a group for the instance self.group = self.tester.add_group( group_name="inst-kvm-grp-" + str(time.time()).replace(".", "") + self.tester.id_generator() + "-" + self.args.build_number) self.tester.authorize_group_by_name(group_name=self.group.name) self.tester.authorize_group_by_name(group_name=self.group.name, port=-1, protocol="icmp") self.keypair = self.tester.add_keypair( "inst-kvm-" + str(time.time()).replace(".", "") + self.tester.id_generator() + "-" + self.args.build_number) if not self.args.emi: self.image = self.tester.get_emi(root_device_type="instance-store") else: self.image = self.tester.get_emi(self.args.test_emi) def clean_method(self): """ Description: Attempts to clean up resources created in this test """ self.tester.cleanup_artifacts() def stress_instance_test(self): self.reservation = self.tester.run_image(self.image, zone=self.args.test_zone, min=1, max=1, keypair=self.keypair.name, group=self.group, timeout=600)
class Euca5338(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.startDate = date.today() self.endDate = date.today() + timedelta(days=1) self.dates = "-s " + str(self.startDate) + " -e " + str(self.endDate) self.cmd = "eureport-generate-report " + self.dates + " --time-unit=seconds --format=csv -t volume" self.source = "source " + self.tester.credpath + "/eucarc && " def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): # Get availibility zone self.zone = self.tester.get_zones().pop() # Create and delete a volume self.volume = self.tester.create_volume(self.zone) self.tester.delete_volume(self.volume) # run report, save output and wait 10 seconds self.out1 = self.tester.sys(self.source + self.cmd) self.tester.sleep(10) # run report again self.out2 = self.tester.sys(self.source + self.cmd) # Get the string index for the volume specific information from the report self.index = str(self.out1).find(self.volume.id) # get the newly created/deleted volume information from the two reports self.volStringOne = str(self.out1)[self.index:self.index + 21] self.volStringTwo = str(self.out2)[self.index:self.index + 21] # Compare strings to make sure the GB-Secs is not increasing for the deleted volume. self.tester.debug("Report 1 = " + self.volStringOne + " Report 2 = " + self.volStringTwo) if self.volStringOne == self.volStringTwo: self.tester.debug( "SUCCESS the GB-Secs did not increase for deleted volume " + self.volume.id) pass else: self.fail("FAIL GB-Secs increased for deleted volume " + self.volume.id)
class Euca2184(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testOutput(self): # Get the existing EBS emi self.emi = self.tester.get_emi(root_device_type='ebs') # Start instance self.reservation = self.tester.run_instance(self.emi, keypair=self.keypair.name, group=self.group, is_reachable=False) # Make sure the instance is running set instance variables for instance in self.reservation.instances: if instance.state == "running": self.dns = instance.public_dns_name self.pub_ip = instance.ip_address self.priv_ip = instance.private_ip_address # Stop Instance self.tester.stop_instances(self.reservation) for instance in self.reservation.instances: if instance.state == "stopped": self.instance = instance self.pub_ip = instance.ip_address self.priv_ip = instance.private_ip_address self.tester.debug("Public IP = " + self.pub_ip) self.tester.debug("Private IP = " + self.priv_ip) # Check Ip address to make sure they are empty if (len(self.pub_ip) == 0 and len(self.priv_ip) == 0): self.tester.debug("Success ips are empty.") pass else: self.fail("Fail ip addresses still displayed.")
class EucaTest(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.STARTC = '\033[1m\033[1m\033[42m' self.ENDC = '\033[0m' self.cc= self.tester.service_manager.get_all_cluster_controllers()[3] self.orig_name = self.cc.name def tearDown(self): # deregister cluster self.runSysCmd("/opt/eucalyptus/usr/sbin/euca_conf --deregister-cluster --partition " + self.cc.partition + " --host " + self.cc.hostname + " --component " + self.cc.name + '_TEST' ) # register cluster self.runSysCmd("/opt/eucalyptus/usr/sbin/euca_conf --register-cluster --partition " + self.cc.partition + " --host " + self.cc.hostname + " --component " + self.orig_name) self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def test(self): # deregister cluster self.runSysCmd("/opt/eucalyptus/usr/sbin/euca_conf --deregister-cluster --partition " + self.cc.partition + " --host " + self.cc.hostname + " --component " + self.cc.name) # register cluster self.runSysCmd("/opt/eucalyptus/usr/sbin/euca_conf --register-cluster --partition " + self.cc.partition + " --host " + self.cc.hostname + " --component " + self.cc.name + '_TEST' ) # Sleep for 10 seconds while cluster Enables print self.STARTC + " Sleep for 10 seconds while cluster Enables. " + self.ENDC self.tester.sleep(10) # Make sure newly registered cluster with a different name is ENABLED try : check_cc = self.tester.service_manager.get_all_cluster_controllers(hostname=self.cc.hostname, state="ENABLED", use_cached_list=False)[0] print self.STARTC + "Success " + str(check_cc.name) + " ENABLED " + self.ENDC pass except Exception, e: self.fail("Renamed cluster not enabled!")
class Euca3949(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.cond = 1 self.tester = Eucaops( config_file=self.conf, password="******" ) self.doAuth() self.clc1 = self.tester.service_manager.get_enabled_clc() self.IP = self.tester.get_ec2_ip() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runInstances(self, numMax): #Start instance self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group, min=1, max=numMax, is_reachable=False) # Make sure the instance is running for instance in self.reservation.instances: if instance.state == "running": self.instance = instance def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def check_for_error_msg(self, error): self.logFile = self.tester.eucapath + "/var/log/eucalyptus/cloud-output.log" if self.clc1.machine.found(" grep " + error + " " + self.logFile, error) : self.fail("FAILURE! PersistentObjectException error thrown.") else : self.tester.debug("SUCCESS! No confusing error logged!") def testName(self): self.emi = self.tester.get_emi() self.runInstances(1) self.tester.terminate_single_instance(self.instance) self.runSysCmd("euca-describe-instances") #check log file to see if PersistentObjectException error was thrown self.check_for_error_msg("PersistentObjectException") pass
class Euca5338(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops( config_file=self.conf, password="******" ) self.doAuth() self.startDate = date.today() self.endDate = date.today() + timedelta(days=1) self.dates = "-s " + str(self.startDate) + " -e " + str(self.endDate) self.cmd = "eureport-generate-report " + self.dates + " --time-unit=seconds --format=csv -t volume" self.source = "source " + self.tester.credpath + "/eucarc && " def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): # Get availibility zone self.zone = self.tester.get_zones().pop() # Create and delete a volume self.volume = self.tester.create_volume(self.zone) self.tester.delete_volume(self.volume) # run report, save output and wait 10 seconds self.out1 = self.tester.sys(self.source + self.cmd) self.tester.sleep(10) # run report again self.out2 = self.tester.sys(self.source + self.cmd) # Get the string index for the volume specific information from the report self.index = str(self.out1).find(self.volume.id) # get the newly created/deleted volume information from the two reports self.volStringOne = str(self.out1)[self.index:self.index + 21] self.volStringTwo = str(self.out2)[self.index:self.index + 21] # Compare strings to make sure the GB-Secs is not increasing for the deleted volume. self.tester.debug("Report 1 = " + self.volStringOne + " Report 2 = " + self.volStringTwo) if self.volStringOne == self.volStringTwo : self.tester.debug("SUCCESS the GB-Secs did not increase for deleted volume " + self.volume.id) pass else: self.fail("FAIL GB-Secs increased for deleted volume " + self.volume.id)
class Euca2185(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.clc1 = self.tester.service_manager.get_enabled_clc() # Enable DNS self.source = "source " + self.tester.credpath + "/eucarc && " self.sbin = self.tester.eucapath + "/usr/sbin/" self.cmd = "euca-modify-property -p bootstrap.webservices.use_instance_dns=" self.tester.sys(self.source + self.sbin + self.cmd + "true") self.doAuth() def tearDown(self): # Restore default dns self.tester.sys(self.source + self.sbin + self.cmd + "false") self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): self.emi = self.tester.get_emi() # Start instance self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group, is_reachable=False) # Make sure the instance is running for instance in self.reservation.instances: if instance.state == "running": self.dns = instance.public_dns_name self.instanceid = instance.id self.out = self.tester.sys(self.source + "euca-describe-instances " + self.instanceid) # Count the number of times the public dns is in the return string self.count = str(self.out).count(str(self.dns)) # The public dns name should only be listed once with the fix not twice if self.count == 1: pass else: self.fail(" euca-describe-instances instance ip=" + self.dns)
class InstanceRestore(EutesterTestCase): def __init__(self): self.setuptestcase() self.setup_parser() self.get_args() # Setup basic eutester object self.tester = Eucaops( config_file=self.args.config_file, password=self.args.password) self.tester.poll_count = 120 ### Add and authorize a group for the instance self.group = self.tester.add_group(group_name="group-" + str(time.time())) self.tester.authorize_group_by_name(group_name=self.group.name ) self.tester.authorize_group_by_name(group_name=self.group.name, port=-1, protocol="icmp" ) ### Generate a keypair for the instance self.keypair = self.tester.add_keypair( "keypair-" + str(time.time())) self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name) self.image = self.tester.get_emi(root_device_type="instance-store") self.reservation = None self.private_addressing = False zones = self.tester.ec2.get_all_zones() self.zone = random.choice(zones).name clcs = self.tester.get_component_machines("clc") if len(clcs) is 0: raise Exception("No CLC found") else: self.clc = clcs[0] self.cur_time = str(int(time.time())) self.ncs = self.tester.get_component_machines("nc") def clean_method(self): ncs = self.tester.get_component_machines("nc") for nc in ncs: nc.sys("service eucalyptus-nc start") ### RESET vmstate properties self.tester.modify_property("cloud.vmstate.instance_timeout","60") self.tester.modify_property("cloud.vmstate.terminated_time","60") for nc in self.ncs: nc.sys("service eucalyptus-nc start") self.tester.cleanup_artifacts() try: image = self.tester.get_emi(self.image) except Exception,e: self.tester.register_image(image_location=self.image.location, ramdisk=self.image.ramdisk_id, kernel=self.image.kernel_id, virtualization_type=self.image.virtualization_type)
class Euca2184(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops( config_file=self.conf, password="******" ) self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testOutput(self): # Get the existing EBS emi self.emi = self.tester.get_emi(root_device_type='ebs') # Start instance self.reservation = self.tester.run_instance(self.emi, keypair=self.keypair.name, group=self.group, is_reachable=False) # Make sure the instance is running set instance variables for instance in self.reservation.instances: if instance.state == "running": self.dns = instance.public_dns_name self.pub_ip = instance.ip_address self.priv_ip = instance.private_ip_address # Stop Instance self.tester.stop_instances(self.reservation) for instance in self.reservation.instances: if instance.state == "stopped": self.instance = instance self.pub_ip = instance.ip_address self.priv_ip = instance.private_ip_address self.tester.debug("Public IP = " + self.pub_ip) self.tester.debug("Private IP = " + self.priv_ip) # Check Ip address to make sure they are empty if(len(self.pub_ip) == 0 and len(self.priv_ip) == 0): self.tester.debug("Success ips are empty.") pass else: self.fail("Fail ip addresses still displayed.")
class Euca(unittest.TestCase): def setUp(self): self.conf = "../cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.STARTC = '\033[1m\033[1m\033[42m' self.ENDC = '\033[0m' def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runInstances(self, numMax): self.emi = self.tester.get_emi() #Start instance self.reservation = self.tester.run_instance(self.emi, keypair=self.keypair.name, group=self.group, min=1, max=numMax, is_reachable=False) # Make sure the instance is running for instance in self.reservation.instances: if instance.state == "running": self.ip = instance.public_dns_name self.instanceid = instance.id def runSysCmd(self, cmd): self.source = 'export EUCALYPTUS=' + self.tester.eucapath + " && source " + self.tester.credpath + "/eucarc && " + self.tester.eucapath + "/usr/sbin/" self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def test(self): self.runSysCmd('euca-describe-components') count = str(self.out).count("PRIMORDIAL") print self.STARTC + " The number of components listed in the PRIMORDIAL state = " + str(count) + self.ENDC #Fail if there are any components listed in the PRIMORDIAL state if count == 0 : self.tester.debug("SUCCESS") pass else: self.fail("FAILED : components listed in the PRIMORDIAL state")
class EucaTest(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.OK = '\033[1m\033[37m\033[42m' self.ENDC = '\033[0m' def tearDown(self): self.tester.cleanup_artifacts() self.tester.modify_property('bootstrap.webservices.use_instance_dns' , 'false') self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runInstances(self, numMax): self.emi = self.tester.get_emi(root_device_type='ebs') #Start instance self.reservation = self.tester.run_instance(self.emi, keypair=self.keypair.name, group=self.group, min=1, max=numMax, is_reachable=False) # Make sure the instance is running for instance in self.reservation.instances: if instance.state == "running": self.ip = instance.public_dns_name self.instanceid = instance.id def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def test(self): self.tester.modify_property('bootstrap.webservices.use_instance_dns' , 'true') self.runInstances(1) self.tester.stop_instances(self.reservation) self.runSysCmd('euca-describe-instances ' + self.instanceid) # make sure publicdnsname and privatednsname fields are empty in euca-descibe-instances output assert str(self.out).count('eucalyptus.internal') == 0 assert str(self.out).count('eucalyptus.localhost') == 0 print self.OK + 'SUCCESS: publicdns and privatedns fields are empty in euca-descibe-instances output' + self.ENDC
class CloudFormations(EutesterTestCase): def __init__(self, extra_args= None): self.setuptestcase() self.setup_parser() if extra_args: for arg in extra_args: self.parser.add_argument(arg) self.get_args() # Setup basic eutester object if self.args.region: self.tester = CFNops( credpath=self.args.credpath, region=self.args.region) else: self.tester = Eucaops( credpath=self.args.credpath, config_file=self.args.config,password=self.args.password) self.group = self.tester.add_group(group_name="group-" + str(time.time())) self.tester.authorize_group_by_name(group_name=self.group.name) self.tester.authorize_group_by_name(group_name=self.group.name, port=-1, protocol="icmp") ### Generate a keypair for the instance self.keypair = self.tester.add_keypair("keypair-" + str(time.time())) self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name) def InstanceVolumeTemplate(self): self.stack_name = "volumeTest{0}".format(int(time.time())) template = Template() keyname_param = template.add_parameter(Parameter("KeyName", Description="Name of an existing EC2 KeyPair " "to enable SSH access to the instance", Type="String",)) template.add_mapping('RegionMap', {"": {"AMI": self.tester.get_emi().id}}) for i in xrange(2): ec2_instance = template.add_resource(ec2.Instance("Instance{0}".format(i), ImageId=FindInMap("RegionMap", Ref("AWS::Region"), "AMI"), InstanceType="t1.micro", KeyName=Ref(keyname_param), SecurityGroups=[self.group.name], UserData=Base64("80"))) vol = template.add_resource(ec2.Volume("Volume{0}".format(i), Size="8", AvailabilityZone=GetAtt("Instance{0}".format(i), "AvailabilityZone"))) mount = template.add_resource(ec2.VolumeAttachment("MountPt{0}".format(i), InstanceId=Ref("Instance{0}".format(i)), VolumeId=Ref("Volume{0}".format(i)), Device="/dev/vdc")) stack = self.tester.create_stack(self.stack_name, template.to_json(), parameters=[("KeyName",self.keypair.name)]) def stack_completed(): return self.tester.cloudformation.describe_stacks(self.stack_name).status == "CREATE_COMPLETE" self.tester.wait_for_result(stack_completed, True, timeout=600) self.tester.delete_stack(self.stack_name) def clean_method(self): self.tester.cleanup_artifacts()
class InstanceBasicsTest(EutesterTestCase): def __init__(self): #### Pre-conditions self.setuptestcase() self.setup_parser() self.parser.add_argument("--test-zone", default="PARTI00") self.parser.add_argument("--test-emi", default=None) self.parser.add_argument("--build-number", default='') self.get_args() # Setup basic eutester object if not self.args.credpath: self.tester = Eucaops(config_file=self.args.config, password=self.args.password) else: self.tester = Eucaops(credpath=self.args.credpath) self.reservation = None ### Generate a group for the instance self.group = self.tester.add_group(group_name="inst-kvm-grp-" + str(time.time()).replace(".", "") + self.tester.id_generator() + "-" + self.args.build_number) self.tester.authorize_group_by_name(group_name=self.group.name) self.tester.authorize_group_by_name(group_name=self.group.name, port=-1, protocol="icmp") self.keypair = self.tester.add_keypair("inst-kvm-" + str(time.time()).replace(".", "") + self.tester.id_generator() + "-" + self.args.build_number) if not self.args.emi: self.image = self.tester.get_emi(root_device_type="instance-store") else: self.image = self.tester.get_emi(self.args.test_emi) def clean_method(self): """ Description: Attempts to clean up resources created in this test """ self.tester.cleanup_artifacts() def stress_instance_test(self): self.reservation = self.tester.run_image(self.image, zone=self.args.test_zone, min=1, max=1, keypair=self.keypair.name, group=self.group, timeout=600)
class Euca3932(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.acctName = "test-account" self.cmdMod = " euca-modify-image-attribute --launch-permission " self.cmdDes = " euca-describe-image-attribute --launch-permission " self.tester = Eucaops( config_file=self.conf, password="******" ) self.out = self.tester.create_account(self.acctName) self.source = "source " + self.tester.credpath + "/eucarc && " self.doAuth() def tearDown(self): self.tester.delete_account(self.acctName,recursive=True) self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testLaunchPermission(self): self.emi = self.tester.get_emi() #Get new userId (AccountId) self.outAccts = self.tester.get_all_accounts(account_name=self.acctName) for u in self.outAccts: self.testAccountId = u.account_id # Add --launch-permission self.tester.sys(self.source + self.cmdMod + " -a " + self.testAccountId + " " + self.emi.id) # Describe --launch-permissions self.outDes = self.tester.sys(self.source + self.cmdDes + self.emi.id) # Check --launch-permissions for added userId self.count = str(self.outDes).count(self.testAccountId) # Remove added --launch-permission self.tester.sys(self.source + self.cmdMod + " -r " + self.testAccountId + " " + self.emi.id) if self.count==1: self.tester.debug("SUCCESS The --launch-permission for " + self.testAccountId + " was added.") pass else: self.fail("FAIL The --launch-permission for " + self.testAccountId + " not added.")
class EucaTest(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.clc1 = self.tester.service_manager.get_enabled_clc() def tearDown(self): self.tester.cleanup_artifacts() shutil.rmtree(self.tester.credpath) def check_for_error_msg(self, error): self.logFile = self.tester.eucapath + "/var/log/eucalyptus/cloud-error.log" if self.clc1.machine.found(" grep " + error + " " + self.logFile, error) : self.fail("FAILURE! Maximum message size exceeded. error thrown.") else : self.tester.debug("SUCCESS! No error logged!") def test(self): # send message that excceeds 1024 bytes (admin_cred.zip could be any file that exceeds 1024 bytes) self.tester.sys("nc " + str(self.tester.clc.hostname) + " 53 < admin_cred.zip" ) # Check make sure error is not there. self.check_for_error_msg("Maximum message size exceeded. Ignoring request.")
class Euca5033(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.device = "/dev/sda1" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testEBS(self): # Get the existing EBS emi self.emi = self.tester.get_emi(root_device_type='ebs') # Start instance self.reservation = self.tester.run_instance(self.emi, keypair=self.keypair.name, group=self.group, is_reachable=False) # Make sure the instance is running set instance variables for instance in self.reservation.instances: if instance.state == "running": self.instance = instance self.zone = instance.placement # Run test self.rootVolume = self.tester.get_volume(attached_dev=self.device) self.tester.stop_instances(self.reservation) # EBS Instance now in stopped state, try and detach/attach root volume. self.tester.detach_volume(self.rootVolume) self.tester.attach_volume(self.instance, self.rootVolume, self.device) # Make sure instance will start. self.tester.start_instances(self.reservation) pass
class Euca5033(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.device = "/dev/sda1" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testEBS(self): # Get the existing EBS emi self.emi = self.tester.get_emi(root_device_type="ebs") # Start instance self.reservation = self.tester.run_instance( self.emi, keypair=self.keypair.name, group=self.group, is_reachable=False ) # Make sure the instance is running set instance variables for instance in self.reservation.instances: if instance.state == "running": self.instance = instance self.zone = instance.placement # Run test self.rootVolume = self.tester.get_volume(attached_dev=self.device) self.tester.stop_instances(self.reservation) # EBS Instance now in stopped state, try and detach/attach root volume. self.tester.detach_volume(self.rootVolume) self.tester.attach_volume(self.instance, self.rootVolume, self.device) # Make sure instance will start. self.tester.start_instances(self.reservation) pass
class Euca(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() self.OK = '\033[1m\033[37m\033[42m' self.ENDC = '\033[0m' def tearDown(self): self.runSysCmd('euca-modify-property --property-to-reset authentication.ldap_integration_configuration') self.tester.delete_account('account-euca5876', recursive=True) self.tester.sys('rm -rf euca5876.lic') self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = 'export EUCALYPTUS=' + self.tester.eucapath + " && source " + self.tester.credpath + "/eucarc && " + self.tester.eucapath + "/usr/sbin/" self.out = self.tester.sys(self.source + cmd) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def test(self): self.clc_ip = str(self.tester.clc.hostname) os.system('scp euca5876.lic root@' + self.clc_ip + ':euca5876.lic') self.runSysCmd('euca-modify-property --property-to-reset authentication.ldap_integration_configuration') self.runSysCmd('euca-lictool --password password --custom euca5876.lic --out euca5876.lic --nocomment') self.runSysCmd('euca-modify-property -f authentication.ldap_integration_configuration=euca5876.lic') # Wait for LDAP to sync self.tester.sleep(20) # Count the numbers of users in the euca5876 group and make sure it is over 100 self.out = str(self.tester.sys('euare-grouplistusers -g euca5876 --as-account account-euca5876')).count('arn:aws:iam::') print self.OK + 'Number of users created = ' + str(self.out) + self.ENDC assert self.out > 100
class Euca2366(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops( config_file=self.conf, password="******" ) self.cond = 1 self.doAuth() self.props = EucaProperties(self.tester) def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): # Get availibility zone self.zone = self.tester.get_zones().pop() # Default Max volume size self.max_volume_size = int(self.props.get_property('storage.maxvolumesizeingb')[0]) # Try and create volume larger than max_volume_size try: self.tester.create_volume(self.zone, self.max_volume_size + 1, timeout=10) except Exception as detail: print detail self.cond = str(detail).count('Max Volume Size Limit Exceeded') if self.cond >= 1: self.tester.debug("SUCCESS") pass else: self.fail("FAIL")
class EucaTest(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.tester = Eucaops(config_file=self.conf, password="******") def tearDown(self): self.tester.cleanup_artifacts() self.runSysCmd("euca-terminate-instances " + self.instanceid) shutil.rmtree(self.tester.credpath) def runSysCmd(self, cmd): self.source = "source " + self.tester.credpath + "/eucarc && " self.out = self.tester.sys(self.source + cmd) def test(self): self.emi = self.tester.get_emi() self.runSysCmd("euca-run-instances --debug " + self.emi.id ) self.count1 = str(self.out).count('<keypair/>') self.runSysCmd("euca-describe-instances --debug ") self.count2 = str(self.out).count('<keypair/>') self.instanceid = str(self.tester.get_last_instance_id()) # Make sure <keypair/> in not in either response assert self.count1 == 0 and self.count2 == 0
class Euca5430(unittest.TestCase): def setUp(self): self.conf = "cloud.conf" self.cond = 1 self.tester = Eucaops(config_file=self.conf, password="******") self.doAuth() def tearDown(self): self.tester.cleanup_artifacts() self.tester.delete_keypair(self.keypair) self.tester.local("rm " + self.keypair.name + ".pem") shutil.rmtree(self.tester.credpath) def doAuth(self): self.keypair = self.tester.add_keypair() self.group = self.tester.add_group() self.tester.authorize_group(self.group) def testName(self): #create the testGroup try: self.out = self.tester.create_group('Euca5430group') except Exception as detail: print str(detail) #try and create the testGroup again and check the error try: self.out = self.tester.create_group('Euca5430group') except Exception as detail: self.cond = str(detail).count('already exists') if self.cond >= 1: self.tester.debug("SUCCESS") pass else: self.fail("FAIL")
class SSLTermination(EutesterTestCase): def __init__(self, extra_args=None): self.cert_name = "elb-ssl-test-" + str(time.time()) self.setuptestcase() self.setup_parser() if extra_args: for arg in extra_args: self.parser.add_argument(arg) self.get_args() # Setup basic eutester object if self.args.region: self.tester = ELBops(credpath=self.args.credpath, region=self.args.region) else: self.tester = Eucaops(credpath=self.args.credpath, config_file=self.args.config, password=self.args.password) self.tester.poll_count = 120 ### Add and authorize a group for the instance self.group = self.tester.add_group(group_name="group-" + str(time.time())) self.tester.authorize_group_by_name(group_name=self.group.name) self.tester.authorize_group_by_name(group_name=self.group.name, port=-1, protocol="icmp") ### Generate a keypair for the instance self.keypair = self.tester.add_keypair("keypair-" + str(time.time())) self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name) ### Get an image self.image = self.args.emi if not self.image: self.image = self.tester.get_emi(root_device_type="instance-store") ### Populate available zones zones = self.tester.ec2.get_all_zones() self.zone = random.choice(zones).name self.load_balancer_port = 80 (self.web_servers, self.filename) = self.tester.create_web_servers( keypair=self.keypair, group=self.group, zone=self.zone, port=self.load_balancer_port, filename='instance-name', image=self.image, count=1) self.load_balancer = self.tester.create_load_balancer( zones=[self.zone], name="test-" + str(time.time()), load_balancer_port=self.load_balancer_port) assert isinstance(self.load_balancer, LoadBalancer) self.tester.register_lb_instances(self.load_balancer.name, self.web_servers.instances) def ssl_termination(self): """ This will test ELB with HTTPS listener. @raise Exception: """ self.debug("ELB SSl test") """get ELB ip info and setup url""" dns = self.tester.service_manager.get_enabled_dns() lb_ip = dns.resolve(self.load_balancer.dns_name) lb_url = "https://{0}/instance-name".format(lb_ip) """upload server certificate""" self.tester.add_server_cert(cert_name=self.cert_name) """create a new listener on HTTPS port 443 and remove listener on port 80""" cert_arn = self.tester.get_server_cert(self.cert_name).arn listener = (443, 80, "HTTPS", cert_arn) self.tester.add_lb_listener(lb_name=self.load_balancer.name, listener=listener) self.tester.remove_lb_listener(lb_name=self.load_balancer.name, port=self.load_balancer_port) """perform https requests to LB""" self.tester.generate_http_requests(url=lb_url, count=10) def clean_method(self): self.tester.delete_server_cert(self.cert_name) self.tester.cleanup_artifacts()