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 MyTestCase(EutesterTestCase):
def __init__(self, config_file=None, password=None):
self.setuptestcase()
# Setup basic eutester object
self.tester = Eucaops( config_file=config_file, password=password)
self.reservation = None
### 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()))
### Get an image to work with
self.image = self.tester.get_emi(root_device_type="instance-store")
self.clean_method = self.cleanup
def cleanup(self):
if self.reservation:
self.assertTrue(self.tester.terminate_instances(self.reservation), "Unable to terminate instance(s)")
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
def MyTestUnit(self):
"""
A test description must go here......
This test will simply run an instance and check that it is reachable via ssh
"""
self.reservation = self.tester.run_instance(self.image, keypair=self.keypair.name, group=self.group.name)
for instance in self.reservation.instances:
instance.sys("uname -r")
class HAtests(InstanceBasics, BucketTestSuite):
def __init__(self, config_file="cloud.conf", password="******"):
self.tester = Eucaops(config_file=config_file, password=password)
self.servman = self.tester.service_manager
self.tester.poll_count = 120
### Add and authorize a group for the instance
self.start_time = str(int(time.time()))
self.group = self.tester.add_group(group_name="group-" +
self.start_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-" + self.start_time)
self.keypath = os.curdir + "/" + self.keypair.name + ".pem"
self.image = self.tester.get_emi(root_device_type="instance-store")
self.reservation = None
self.private_addressing = False
self.bucket_prefix = "buckettestsuite-" + self.start_time + "-"
self.test_user_id = self.tester.s3.get_canonical_user_id()
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
### Create standing resources that will be checked after all failures
### Instance, volume, buckets
###
self.standing_reservation = self.tester.run_instance(
keypair=self.keypair.name, group=self.group.name, zone=self.zone)
self.volume = self.tester.create_volume(self.zone)
self.device = self.standing_reservation.instances[0].attach_volume(
self.volume)
self.standing_bucket_name = "failover-bucket-" + self.start_time
self.standing_bucket = self.tester.create_bucket(
self.standing_bucket_name)
self.standing_key_name = "failover-key-" + self.start_time
self.standing_key = self.tester.upload_object(
self.standing_bucket_name, self.standing_key_name)
self.standing_key = self.tester.get_objects_by_prefix(
self.standing_bucket_name, self.standing_key_name)
def run_testcase(self, testcase_callback, **kwargs):
poll_count = 20
poll_interval = 20
while (poll_count > 0):
try:
testcase_callback(**kwargs)
break
except Exception, e:
self.tester.debug("Attempt failed due to: " + str(e) +
"\nRetrying testcase in " +
str(poll_interval))
self.tester.sleep(poll_interval)
poll_count = poll_count - 1
if poll_count is 0:
self.fail("Could not run an instance after " + str(poll_count) +
" tries with " + str(poll_interval) +
"s sleep in between")
class InstanceBasics(unittest.TestCase):
def setUp(self, credpath=None):
# Setup basic eutester object
if credpath is None:
credpath = arg_credpath
self.tester = Eucaops(credpath=credpath)
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 = os.curdir + "/" + self.keypair.name + ".pem"
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
def tearDown(self):
if self.reservation is not None:
self.assertTrue(self.tester.terminate_instances(self.reservation),
"Unable to terminate instance(s)")
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
self.reservation = None
self.group = None
self.keypair = None
self.tester = None
self.ephemeral = None
def create_attach_volume(self, instance, size):
self.volume = self.tester.create_volume(instance.placement, size)
device_path = "/dev/" + instance.block_device_prefix + "j"
before_attach = instance.get_dev_dir()
try:
self.assertTrue(
self.tester.attach_volume(instance, self.volume, device_path),
"Failure attaching volume")
except AssertionError, e:
self.assertTrue(self.tester.delete_volume(self.volume))
return False
after_attach = instance.get_dev_dir()
new_devices = self.tester.diff(after_attach, before_attach)
if len(new_devices) is 0:
return False
self.volume_device = "/dev/" + new_devices[0].strip()
instance.assertFilePresent(self.volume_device)
return True
class HAtests(InstanceBasics, BucketTestSuite):
def __init__(self):
self.setuptestcase()
self.setup_parser()
self.get_args()
self.tester = Eucaops(config_file=self.args.config_file,
password=self.args.password)
self.servman = self.tester.service_manager
self.tester.poll_count = 120
### Add and authorize a group for the instance
self.start_time = str(int(time.time()))
try:
self.group = self.tester.add_group(group_name="group-" +
self.start_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-" +
self.start_time)
self.keypath = os.curdir + "/" + self.keypair.name + ".pem"
self.image = self.tester.get_emi(root_device_type="instance-store")
self.reservation = None
self.private_addressing = False
self.bucket_prefix = "buckettestsuite-" + self.start_time + "-"
self.test_user_id = self.tester.s3.get_canonical_user_id()
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.tester.clc = self.tester.service_manager.get_enabled_clc(
).machine
self.version = self.tester.clc.sys(
"cat " + self.tester.eucapath +
"/etc/eucalyptus/eucalyptus-version")[0]
### Create standing resources that will be checked after all failures
### Instance, volume, buckets
###
self.standing_reservation = self.tester.run_instance(
keypair=self.keypair.name,
group=self.group.name,
zone=self.zone)
self.volume = self.tester.create_volume(self.zone)
self.device = self.standing_reservation.instances[0].attach_volume(
self.volume)
self.standing_bucket_name = "failover-bucket-" + self.start_time
self.standing_bucket = self.tester.create_bucket(
self.standing_bucket_name)
self.standing_key_name = "failover-key-" + self.start_time
self.standing_key = self.tester.upload_object(
self.standing_bucket_name, self.standing_key_name)
self.standing_key = self.tester.get_objects_by_prefix(
self.standing_bucket_name, self.standing_key_name)
except Exception, e:
self.clean_method()
class InstanceBasics(unittest.TestCase):
def setUp(self):
# Setup basic eutester object
eucarc_regex = re.compile("eucarc-")
eucarc_dirs = [path for path in os.listdir(".") if eucarc_regex.search(path)]
eucarc_path = None
if len(eucarc_dirs) > 0:
eucarc_path = eucarc_dirs[0]
self.tester = Eucaops( config_file="../input/2b_tested.lst", password="******", credpath=eucarc_path)
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 = os.curdir + "/" + self.keypair.name + ".pem"
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
def tearDown(self):
if self.reservation is not None:
self.assertTrue(self.tester.terminate_instances(self.reservation), "Unable to terminate instance(s)")
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
self.reservation = None
self.group = None
self.keypair = None
self.tester = None
self.ephemeral = None
def create_attach_volume(self, instance, size):
self.volume = self.tester.create_volume(instance.placement, size)
device_path = "/dev/" + instance.block_device_prefix +"j"
before_attach = instance.get_dev_dir()
try:
self.assertTrue(self.tester.attach_volume(instance, self.volume, device_path), "Failure attaching volume")
except AssertionError, e:
self.assertTrue( self.tester.delete_volume(self.volume))
return False
after_attach = instance.get_dev_dir()
new_devices = self.tester.diff(after_attach, before_attach)
if len(new_devices) is 0:
return False
self.volume_device = "/dev/" + new_devices[0].strip()
instance.assertFilePresent(self.volume_device)
return True
class HAtests(InstanceBasics, BucketTestSuite):
def __init__(self):
self.setuptestcase()
self.setup_parser()
self.get_args()
if not boto.config.has_section('Boto'):
boto.config.add_section('Boto')
boto.config.set('Boto', 'num_retries', '1')
boto.config.set('Boto', 'http_socket_timeout', '20')
self.tester = Eucaops( config_file=self.args.config_file, password=self.args.password)
self.tester.ec2.connection.timeout = 30
self.servman = self.tester.service_manager
self.instance_timeout = 120
### Add and authorize a group for the instance
self.start_time = str(int(time.time()))
try:
self.group = self.tester.add_group(group_name="group-" + self.start_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-" + self.start_time)
self.keypath = os.curdir + "/" + self.keypair.name + ".pem"
if self.args.emi:
self.image = self.tester.get_emi(self.args.emi)
else:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.reservation = None
self.private_addressing = False
self.bucket_prefix = "buckettestsuite-" + self.start_time + "-"
self.test_user_id = self.tester.s3.get_canonical_user_id()
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.tester.clc = self.tester.service_manager.get_enabled_clc().machine
self.version = self.tester.clc.sys("cat " + self.tester.eucapath + "/etc/eucalyptus/eucalyptus-version")[0]
### Create standing resources that will be checked after all failures
### Instance, volume, buckets
###
self.standing_reservation = self.tester.run_instance(image=self.image ,keypair=self.keypair.name,group=self.group.name, zone=self.zone)
self.volume = self.tester.create_volume(self.zone)
self.device = self.standing_reservation.instances[0].attach_volume(self.volume)
for instance in self.standing_reservation.instances:
instance.sys("echo " + instance.id + " > " + self.device)
self.standing_bucket_name = "failover-bucket-" + self.start_time
self.standing_bucket = self.tester.create_bucket(self.standing_bucket_name)
self.standing_key_name = "failover-key-" + self.start_time
self.standing_key = self.tester.upload_object(self.standing_bucket_name, self.standing_key_name)
self.standing_key = self.tester.get_objects_by_prefix(self.standing_bucket_name, self.standing_key_name)
self.run_instance_params = {'image': self.image, 'keypair': self.keypair.name, 'group': self.group.name,
'zone': self.zone, 'timeout': self.instance_timeout}
except Exception, e:
self.clean_method()
raise Exception("Init for testcase failed. Reason: " + str(e))
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 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 HAtests(InstanceBasics, BucketTestSuite):
def __init__(self, config_file="cloud.conf", password="******"):
self.tester = Eucaops( config_file=config_file, password=password)
self.servman = self.tester.service_manager
self.tester.poll_count = 120
### Add and authorize a group for the instance
self.start_time = str(int(time.time()))
self.group = self.tester.add_group(group_name="group-" + self.start_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-" + self.start_time)
self.keypath = os.curdir + "/" + self.keypair.name + ".pem"
self.image = self.tester.get_emi(root_device_type="instance-store")
self.reservation = None
self.private_addressing = False
self.bucket_prefix = "buckettestsuite-" + self.start_time + "-"
self.test_user_id = self.tester.s3.get_canonical_user_id()
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
### Create standing resources that will be checked after all failures
### Instance, volume, buckets
###
self.standing_reservation = self.tester.run_instance(keypair=self.keypair.name,group=self.group.name, zone=self.zone)
self.volume = self.tester.create_volume(self.zone)
self.device = self.standing_reservation.instances[0].attach_volume(self.volume)
self.standing_bucket_name = "failover-bucket-" + self.start_time
self.standing_bucket = self.tester.create_bucket(self.standing_bucket_name)
self.standing_key_name = "failover-key-" + self.start_time
self.standing_key = self.tester.upload_object(self.standing_bucket_name, self.standing_key_name)
self.standing_key = self.tester.get_objects_by_prefix(self.standing_bucket_name, self.standing_key_name)
def run_testcase(self, testcase_callback, **kwargs):
poll_count = 20
poll_interval = 20
while (poll_count > 0):
try:
testcase_callback(**kwargs)
break
except Exception, e:
self.tester.debug("Attempt failed due to: " + str(e) + "\nRetrying testcase in " + str(poll_interval) )
self.tester.sleep(poll_interval)
poll_count = poll_count - 1
if poll_count is 0:
self.fail("Could not run an instance after " + str(poll_count) +" tries with " + str(poll_interval) + "s sleep in between")
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 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 HAtests(InstanceBasics, BucketTestSuite):
def __init__(self):
self.setuptestcase()
self.setup_parser()
self.get_args()
self.tester = Eucaops( config_file=self.args.config_file, password=self.args.password)
self.servman = self.tester.service_manager
self.tester.poll_count = 120
### Add and authorize a group for the instance
self.start_time = str(int(time.time()))
self.group = self.tester.add_group(group_name="group-" + self.start_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-" + self.start_time)
self.keypath = os.curdir + "/" + self.keypair.name + ".pem"
self.image = self.tester.get_emi(root_device_type="instance-store")
self.reservation = None
self.private_addressing = False
self.bucket_prefix = "buckettestsuite-" + self.start_time + "-"
self.test_user_id = self.tester.s3.get_canonical_user_id()
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.tester.clc = self.tester.service_manager.get_enabled_clc().machine
self.old_version = self.tester.clc.sys("cat " + self.tester.eucapath + "/etc/eucalyptus/eucalyptus-version")[0]
### Create standing resources that will be checked after all failures
### Instance, volume, buckets
###
self.standing_reservation = self.tester.run_instance(keypair=self.keypair.name,group=self.group.name, zone=self.zone)
self.volume = self.tester.create_volume(self.zone)
self.device = self.standing_reservation.instances[0].attach_volume(self.volume)
self.standing_bucket_name = "failover-bucket-" + self.start_time
self.standing_bucket = self.tester.create_bucket(self.standing_bucket_name)
self.standing_key_name = "failover-key-" + self.start_time
self.standing_key = self.tester.upload_object(self.standing_bucket_name, self.standing_key_name)
self.standing_key = self.tester.get_objects_by_prefix(self.standing_bucket_name, self.standing_key_name)
def clean_method(self):
try:
self.tester.terminate_instances()
except Exception, e:
self.tester.critical("Unable to terminate all instances")
self.servman.start_all()
class MyTestCase(EutesterTestCase):
def __init__(self, config_file=None, password=None):
self.setuptestcase()
# Setup basic eutester object
self.tester = Eucaops(config_file=config_file, password=password)
self.reservation = None
### 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()))
### Get an image to work with
self.image = self.tester.get_emi(root_device_type="instance-store")
self.clean_method = self.cleanup
def cleanup(self):
if self.reservation:
self.assertTrue(self.tester.terminate_instances(self.reservation),
"Unable to terminate instance(s)")
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
def MyTestUnit(self):
"""
A test description must go here......
This test will simply run an instance and check that it is reachable via ssh
"""
self.reservation = self.tester.run_instance(self.image,
keypair=self.keypair.name,
group=self.group.name)
for instance in self.reservation.instances:
instance.sys("uname -r")
class InstanceBasics(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 = EC2ops( credpath=self.args.credpath, region=self.args.region)
else:
self.tester = Eucaops(config_file=self.args.config, password=self.args.password, credpath=self.args.credpath)
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.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.address = None
self.volume = None
self.private_addressing = False
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.reservation = None
def clean_method(self):
if self.reservation:
self.assertTrue(self.tester.terminate_instances(self.reservation), "Unable to terminate instance(s)")
if self.address:
assert isinstance(self.address,Address)
self.tester.release_address(self.address)
if self.volume:
self.tester.delete_volume(self.volume)
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
def BasicInstanceChecks(self, zone = None):
"""
This case was developed to run through a series of basic instance tests.
The tests are as follows:
- execute run_instances command
- make sure that public DNS name and private IP aren't the same
(This is for Managed/Managed-NOVLAN networking modes)
- test to see if instance is ping-able
- test to make sure that instance is accessible via ssh
(ssh into instance and run basic ls command)
If any of these tests fail, the test case will error out, logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(self.image, keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
self.assertTrue( self.tester.wait_for_reservation(self.reservation) ,'Instance did not go to running')
self.assertNotEqual( instance.public_dns_name, instance.private_ip_address, 'Public and private IP are the same')
self.assertTrue( self.tester.ping(instance.public_dns_name), 'Could not ping instance')
self.assertFalse( instance.found("ls -1 /dev/" + instance.rootfs_device + "2", "No such file or directory"), 'Did not find ephemeral storage at ' + instance.rootfs_device + "2")
return self.reservation
def ElasticIps(self, zone = None):
"""
This case was developed to test elastic IPs in Eucalyptus. This test case does
not test instances that are launched using private-addressing option.
The test case executes the following tests:
- allocates an IP, associates the IP to the instance, then pings the instance.
- disassociates the allocated IP, then pings the instance.
- releases the allocated IP address
If any of the tests fail, the test case will error out, logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group.name,zone=zone)
for instance in self.reservation.instances:
self.address = self.tester.allocate_address()
self.assertTrue(self.address,'Unable to allocate address')
self.tester.associate_address(instance, self.address)
instance.update()
self.assertTrue( self.tester.ping(instance.public_dns_name), "Could not ping instance with new IP")
self.tester.disassociate_address_from_instance(instance)
self.tester.release_address(self.address)
self.address = None
instance.update()
self.assertTrue( self.tester.ping(instance.public_dns_name), "Could not ping after dissassociate")
return self.reservation
def MaxSmallInstances(self, available_small=None,zone = None):
"""
This case was developed to test the maximum number of m1.small vm types a configured
cloud can run. The test runs the maximum number of m1.small vm types allowed, then
tests to see if all the instances reached a running state. If there is a failure,
the test case errors out; logging the results.
"""
if self.reservation:
self.tester.terminate_instances(self.reservation)
if available_small is None:
available_small = self.tester.get_available_vms()
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,keypair=self.keypair.name, group=self.group.name,min=available_small, max=available_small, zone=zone)
self.assertTrue( self.tester.wait_for_reservation(self.reservation) ,'Not all instances went to running')
return self.reservation
def LargestInstance(self, zone = None):
"""
This case was developed to test the maximum number of c1.xlarge vm types a configured
cloud can run. The test runs the maximum number of c1.xlarge vm types allowed, then
tests to see if all the instances reached a running state. If there is a failure,
the test case errors out; logging the results.
"""
if zone is None:
zone = self.zone
if self.reservation:
self.tester.terminate_instances(self.reservation)
self.reservation = self.tester.run_instance(self.image,keypair=self.keypair.name, group=self.group.name,type="c1.xlarge",zone=zone)
self.assertTrue( self.tester.wait_for_reservation(self.reservation) ,'Not all instances went to running')
return self.reservation
def MetaData(self, zone=None):
"""
This case was developed to test the metadata service of an instance for consistency.
The following meta-data attributes are tested:
- public-keys/0/openssh-key
- security-groups
- instance-id
- local-ipv4
- public-ipv4
- ami-id
- ami-launch-index
- reservation-id
- placement/availability-zone
- kernel-id
- public-hostname
- local-hostname
- hostname
- ramdisk-id
- instance-type
- any bad metadata that shouldn't be present.
Missing nodes
['block-device-mapping/', 'ami-manifest-path']
If any of these tests fail, the test case will error out; logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(self.image,keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
## Need to verify the public key (could just be checking for a string of a certain length)
self.assertTrue(re.match(instance.get_metadata("public-keys/0/openssh-key")[0].split('eucalyptus.')[-1], self.keypair.name), 'Incorrect public key in metadata')
self.assertTrue(re.match(instance.get_metadata("security-groups")[0], self.group.name), 'Incorrect security group in metadata')
# Need to validate block device mapping
#self.assertTrue(re.search(instance_ssh.get_metadata("block-device-mapping/")[0], ""))
self.assertTrue(re.match(instance.get_metadata("instance-id")[0], instance.id), 'Incorrect instance id in metadata')
self.assertTrue(re.match(instance.get_metadata("local-ipv4")[0] , instance.private_ip_address), 'Incorrect private ip in metadata')
self.assertTrue(re.match(instance.get_metadata("public-ipv4")[0] , instance.ip_address), 'Incorrect public ip in metadata')
self.assertTrue(re.match(instance.get_metadata("ami-id")[0], instance.image_id), 'Incorrect ami id in metadata')
self.assertTrue(re.match(instance.get_metadata("ami-launch-index")[0], instance.ami_launch_index), 'Incorrect launch index in metadata')
self.assertTrue(re.match(instance.get_metadata("reservation-id")[0], self.reservation.id), 'Incorrect reservation in metadata')
self.assertTrue(re.match(instance.get_metadata("placement/availability-zone")[0], instance.placement), 'Incorrect availability-zone in metadata')
self.assertTrue(re.match(instance.get_metadata("kernel-id")[0], instance.kernel), 'Incorrect kernel id in metadata')
self.assertTrue(re.match(instance.get_metadata("public-hostname")[0], instance.public_dns_name), 'Incorrect public host name in metadata')
self.assertTrue(re.match(instance.get_metadata("local-hostname")[0], instance.private_dns_name), 'Incorrect private host name in metadata')
self.assertTrue(re.match(instance.get_metadata("hostname")[0], instance.dns_name), 'Incorrect host name in metadata')
self.assertTrue(re.match(instance.get_metadata("ramdisk-id")[0], instance.ramdisk ), 'Incorrect ramdisk in metadata') #instance-type
self.assertTrue(re.match(instance.get_metadata("instance-type")[0], instance.instance_type ), 'Incorrect instance type in metadata')
BAD_META_DATA_KEYS = ['foobar']
for key in BAD_META_DATA_KEYS:
self.assertTrue(re.search("Not Found", "".join(instance.get_metadata(key))), 'No fail message on invalid meta-data node')
return self.reservation
def DNSResolveCheck(self, zone=None):
"""
This case was developed to test DNS resolution information for public/private DNS
names and IP addresses. The tested DNS resolution behavior is expected to follow
AWS EC2. The following tests are ran using the associated meta-data attributes:
- check to see if Eucalyptus Dynamic DNS is configured
- nslookup on hostname; checks to see if it matches local-ipv4
- nslookup on local-hostname; check to see if it matches local-ipv4
- nslookup on local-ipv4; check to see if it matches local-hostname
- nslookup on public-hostname; check to see if it matches local-ipv4
- nslookup on public-ipv4; check to see if it matches public-host
If any of these tests fail, the test case will error out; logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(self.image,keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
# Test to see if Dynamic DNS has been configured #
if re.match("internal", instance.private_dns_name.split('eucalyptus.')[-1]):
# Per AWS standard, resolution should have private hostname or private IP as a valid response
# Perform DNS resolution against private IP and private DNS name
# Check to see if nslookup was able to resolve
self.assertTrue(re.search('answer\:', instance.sys("nslookup " + instance.get_metadata("hostname")[0])[3]), "DNS lookup failed for hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on local-hostname returns local-ipv4 address
self.assertTrue(re.search(instance.get_metadata("local-ipv4")[0], instance.sys("nslookup " + instance.get_metadata("hostname")[0])[5]), "Incorrect DNS resolution for hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(re.search('answer\:', instance.sys("nslookup " + instance.get_metadata("local-hostname")[0])[3]), "DNS lookup failed for private hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on local-hostname returns local-ipv4 address
self.assertTrue(re.search(instance.get_metadata("local-ipv4")[0], instance.sys("nslookup " + instance.get_metadata("local-hostname")[0])[5]), "Incorrect DNS resolution for private hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(re.search('answer\:', instance.sys("nslookup " + instance.get_metadata("local-ipv4")[0])[3]), "DNS lookup failed for private IP address.")
# Since nslookup was able to resolve, now check to see if nslookup on local-ipv4 address returns local-hostname
self.assertTrue(re.search(instance.get_metadata("local-hostname")[0], instance.sys("nslookup " + instance.get_metadata("local-ipv4")[0])[4]), "Incorrect DNS resolution for private IP address")
# Perform DNS resolution against public IP and public DNS name
# Check to see if nslookup was able to resolve
self.assertTrue(re.search('answer\:', instance.sys("nslookup " + instance.get_metadata("public-hostname")[0])[3]), "DNS lookup failed for public-hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on public-hostname returns local-ipv4 address
self.assertTrue(re.search(instance.get_metadata("local-ipv4")[0], instance.sys("nslookup " + instance.get_metadata("public-hostname")[0])[5]), "Incorrect DNS resolution for public-hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(re.search('answer\:', instance.sys("nslookup " + instance.get_metadata("public-ipv4")[0])[3]), "DNS lookup failed for public IP address.")
# Since nslookup was able to resolve, now check to see if nslookup on public-ipv4 address returns public-hostname
self.assertTrue(re.search(instance.get_metadata("public-hostname")[0], instance.sys("nslookup " + instance.get_metadata("public-ipv4")[0])[4]), "Incorrect DNS resolution for public IP address")
return self.reservation
def DNSCheck(self, zone=None):
"""
This case was developed to test to make sure Eucalyptus Dynamic DNS reports correct
information for public/private IP address and DNS names passed to meta-data service.
The following tests are ran using the associated meta-data attributes:
- check to see if Eucalyptus Dynamic DNS is configured
- check to see if local-ipv4 and local-hostname are not the same
- check to see if public-ipv4 and public-hostname are not the same
If any of these tests fail, the test case will error out; logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(self.image,keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
# Test to see if Dynamic DNS has been configured #
if re.match("internal", instance.private_dns_name.split('eucalyptus.')[-1]):
# Make sure that private_ip_address is not the same as local-hostname
self.assertFalse(re.match(instance.private_ip_address, instance.private_dns_name), 'local-ipv4 and local-hostname are the same with DNS on')
# Make sure that ip_address is not the same as public-hostname
self.assertFalse(re.match(instance.ip_address, instance.public_dns_name), 'public-ipv4 and public-hostname are the same with DNS on')
return self.reservation
def Reboot(self, zone=None):
"""
This case was developed to test IP connectivity and volume attachment after
instance reboot. The following tests are done for this test case:
- creates a 1 gig EBS volume, then attach volume
- reboot instance
- attempts to connect to instance via ssh
- checks to see if EBS volume is attached
- detaches volume
- deletes volume
If any of these tests fail, the test case will error out; logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(self.image, keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
### Create 1GB volume in first AZ
self.volume = self.tester.create_volume(instance.placement, 1)
self.volume_device = instance.attach_volume(self.volume)
### Reboot instance
instance.reboot_instance_and_verify(waitconnect=20)
instance.detach_euvolume(self.volume)
self.tester.delete_volume(self.volume)
self.volume = None
return self.reservation
def run_terminate(self):
reservation = None
try:
reservation = self.tester.run_instance(image=self.image,zone=self.zone, keypair=self.keypair.name, group=self.group.name)
self.tester.terminate_instances(reservation)
return 0
except Exception, e:
if reservation:
self.tester.terminate_instances(reservation)
return 1
class AutoScalingBasics(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.emi:
self.tester = Eucaops(credpath=self.args.credpath, region=self.args.region)
else:
self.tester = Eucaops(credpath=self.args.credpath)
### 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.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.address = None
def clean_method(self):
### DELETE group
self.tester.delete_group(self.group)
### Delete keypair in cloud and from filesystem
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
def AutoScalingBasics(self):
### test create and describe launch config
self.launch_config_name = 'Test-Launch-Config-' + str(time.time())
self.tester.create_launch_config(name=self.launch_config_name,
image_id=self.image.id,
key_name=self.keypair.name,
security_groups=[self.group.name])
if len(self.tester.describe_launch_config([self.launch_config_name])) != 1:
raise Exception('Launch Config not created')
self.debug('**** Created Launch Config: ' +
self.tester.describe_launch_config([self.launch_config_name])[0].name)
### test create and describe auto scale group
self.initial_size = len(self.tester.describe_as_group())
self.auto_scaling_group_name = 'ASG-' + str(time.time())
self.tester.create_as_group(group_name=self.auto_scaling_group_name,
launch_config=self.launch_config_name,
availability_zones=self.tester.get_zones(),
min_size=0,
max_size=5,
connection=self.tester.autoscale)
if len(self.tester.describe_as_group([self.auto_scaling_group_name])) != 1:
raise Exception('Auto Scaling Group not created')
self.debug("**** Created Auto Scaling Group: " +
self.tester.describe_as_group([self.auto_scaling_group_name])[0].name)
### Test Create and describe Auto Scaling Policy
self.up_policy_name = "Up-Policy-" + str(time.time())
self.up_size = 4
self.tester.create_as_policy(name=self.up_policy_name,
adjustment_type="ChangeInCapacity",
as_name=self.auto_scaling_group_name,
scaling_adjustment=4,
cooldown=120)
self.down_policy_name = "Down-Policy-" + str(time.time())
self.down_size = -50
self.tester.create_as_policy(name=self.down_policy_name,
adjustment_type="PercentChangeInCapacity",
as_name=self.auto_scaling_group_name,
scaling_adjustment=self.down_size,
cooldown=120)
self.exact_policy_name = "Exact-Policy-" + str(time.time())
self.exact_size = 0
self.tester.create_as_policy(name=self.exact_policy_name,
adjustment_type="ExactCapacity",
as_name=self.auto_scaling_group_name,
scaling_adjustment=self.exact_size,
cooldown=120)
### Test all policies added to group
if len(self.tester.autoscale.get_all_policies()) != 3:
raise Exception('Auto Scaling policies not created')
self.debug("**** Created Auto Scaling Policies: " + self.up_policy_name + " " + self.down_policy_name + " " +
self.exact_policy_name)
### Test Execute ChangeInCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.up_policy_name, as_group=self.auto_scaling_group_name)
if self.tester.describe_as_group([self.auto_scaling_group_name])[0].desired_capacity != self.up_size:
raise Exception("Auto Scale Up not executed")
self.debug("Executed ChangeInCapacity policy, increased desired capacity to: " +
str(self.tester.describe_as_group([self.auto_scaling_group_name])[0].desired_capacity))
### Test Execute PercentChangeInCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.down_policy_name, as_group=self.auto_scaling_group_name)
if self.tester.describe_as_group([self.auto_scaling_group_name])[0].desired_capacity != 0.5 * self.up_size:
raise Exception("Auto Scale down percentage not executed")
self.debug("Executed PercentChangeInCapacity policy, decreased desired capacity to: " +
str(self.tester.describe_as_group([self.auto_scaling_group_name])[0].desired_capacity))
### Test Execute ExactCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.exact_policy_name, as_group=self.auto_scaling_group_name)
if self.tester.describe_as_group([self.auto_scaling_group_name])[0].desired_capacity != self.exact_size:
raise Exception("Auto Scale down percentage not executed")
self.debug("Executed ExactCapacity policy, exact capacity is: " +
str(self.tester.describe_as_group([self.auto_scaling_group_name])[0].desired_capacity))
### Test Delete all Auto Scaling Policies
for policy in self.tester.autoscale.get_all_policies():
self.tester.delete_as_policy(policy_name=policy.name, autoscale_group=policy.as_name)
if len(self.tester.autoscale.get_all_policies()) != 0:
raise Exception('Auto Scaling policy not deleted')
self.debug("**** Deleted Auto Scaling Policy: " + self.up_policy_name + " " + self.down_policy_name + " " +
self.exact_policy_name)
### Test Delete Auto Scaling Group
self.tester.delete_as_group(names=self.auto_scaling_group_name)
if len(self.tester.describe_as_group([self.auto_scaling_group_name])) != 0:
raise Exception('Auto Scaling Group not deleted')
self.debug('**** Deleted Auto Scaling Group: ' + self.auto_scaling_group_name)
### pause for Auto scaling group to be deleted
# TODO write wait/poll op for auto scaling groups
# time.sleep(5)
### Test delete launch config
self.tester.delete_launch_config(self.launch_config_name)
if len(self.tester.describe_launch_config([self.launch_config_name])) != 0:
raise Exception('Launch Config not deleted')
self.debug('**** Deleted Launch Config: ' + self.launch_config_name)
def AutoScalingInstanceBasics(self):
"""
This case will test DescribeAutoScalingInstances, SetInstanceHealth and TerminateInstanceInAutoScalingGroup
"""
pass
def too_many_launch_configs_test(self):
"""
AWS enforces a 100 LC per account limit this tests what happens if we create more
"""
for i in range(101):
self.launch_config_name = 'Test-Launch-Config-' + str(i + 1)
self.tester.create_launch_config(name=self.launch_config_name,
image_id=self.image.id)
if len(self.tester.describe_launch_config()) > 100:
raise Exception("More then 100 launch configs exist in 1 account")
for lc in self.tester.describe_launch_config():
self.tester.delete_launch_config(lc.name)
def too_many_policies_test(self):
launch_config_name = 'LC-' + str(time.time())
self.tester.create_launch_config(name=launch_config_name,
image_id=self.image.id,
key_name=self.keypair.name,
security_groups=[self.group.name])
asg = 'ASG-' + str(time.time())
self.tester.create_as_group(group_name=asg,
launch_config=launch_config_name,
availability_zones=self.tester.get_zones(),
min_size=0,
max_size=5,
connection=self.tester.autoscale)
for i in range(26):
policy_name = "Policy-" + str(i + 1)
self.tester.create_as_policy(name=policy_name,
adjustment_type="ExactCapacity",
as_name=asg,
scaling_adjustment=0,
cooldown=120)
if len(self.tester.autoscale.get_all_policies()) > 25:
raise Exception("More than 25 policies exist for 1 auto scaling group")
self.tester.delete_as_group(names=asg)
def too_many_as_groups(self):
"""
AWS imposes a 20 ASG/acct limit
"""
pass
def clear_all(self):
self.tester.delete_all_autoscaling_groups()
self.tester.delete_all_launch_configs()
class ReportingBasics(EutesterTestCase):
def __init__(self, config_file=None, password=None):
self.setuptestcase()
# Setup basic eutester object
self.tester = Eucaops( config_file=config_file, password=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.volume = None
self.bucket = None
self.private_addressing = False
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.clean_method = self.cleanup
self.cur_time = str(int(time.time()))
date_fields = time.localtime()
self.date = str(date_fields.tm_year) + "-" + str(date_fields.tm_mon) + "-31"
clcs = self.tester.get_component_machines("clc")
if len(clcs) is 0:
raise Exception("No CLC found")
else:
self.clc = clcs[0]
poll_interval = 1
write_interval = 1
size_time_size_unit = "MB"
size_time_time_unit = "MINS"
size_unit = "MB"
time_unit = "MINS"
self.modify_property(property="reporting.default_poll_interval_mins",value=poll_interval)
self.modify_property(property="reporting.default_write_interval_mins",value=write_interval)
self.modify_property(property="reporting.default_size_time_size_unit",value=size_time_size_unit)
self.modify_property(property="reporting.default_size_time_time_unit",value=size_time_time_unit)
self.modify_property(property="reporting.default_size_unit",value=size_unit)
self.modify_property(property="reporting.default_time_unit",value=time_unit)
def cleanup(self):
if self.reservation:
self.assertTrue(self.tester.terminate_instances(self.reservation), "Unable to terminate instance(s)")
if self.volume:
self.tester.delete_volume(self.volume)
if self.bucket:
self.tester.clear_bucket(self.bucket)
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
def instance(self):
self.reservation = self.tester.run_instance(self.image, keypair=self.keypair.name, group=self.group.name, zone=self.zone)
file_size_in_mb = 500
for instance in self.reservation.instances:
assert isinstance(instance, EuInstance)
self.volume = self.tester.create_volume(zone=self.zone, size=4)
device_path = instance.attach_volume(self.volume)
instance.sys("mkfs.ext3 -F " + device_path)
instance.sys("mount " + device_path + " /mnt")
### Write to root fs
instance.sys("dd if=/dev/zero of=/tmp/test.img count=" + str(file_size_in_mb) + " bs=1M")
### Write to volume
instance.sys("dd if=/dev/zero of=/mnt/test.img count=" + str(file_size_in_mb) + " bs=1M")
self.tester.sleep(180)
for instance in self.reservation.instances:
report_output = self.generate_report("instance","csv", self.date)
instance_lines = self.tester.grep(instance.id, report_output)
for line in instance_lines:
instance_data = self.parse_instance_line(line)
#if not re.search( instance.id +",m1.small,1,9,0.2,0,0,0,0,93,200,0.2,0.0,0,1", line):
if not re.match(instance_data.type, "m1.small"):
raise Exception("Failed to find proper output for " + str(instance) + " type. Received: " + instance_data.type )
if not int(instance_data.number) == 1:
raise Exception("Failed to find proper output for " + str(instance) + " number. Received: " + instance_data.number )
if not int(instance_data.unit_time) > 2 :
raise Exception("Failed to find proper output for " + str(instance) + " unit_time. Received: " + instance_data.unit_time )
if not int(instance_data.disk_write) > 1000:
raise Exception("Failed to find proper output for " + str(instance) + " disk_write. Received: " + instance_data.disk_write )
if not int(instance_data.disk_time_write) > 200:
raise Exception("Failed to find proper output for " + str(instance) + " disk_time_write. Received: " + instance_data.disk_time_write )
def parse_instance_line(self, line):
InstanceData = namedtuple('InstanceData', 'id type number unit_time cpu net_total_in net_total_out '
'net_extern_in net_extern_out disk_read disk_write disk_iops_read '
'disk_iops_write disk_time_read disk_time_write')
values = line.split(",")
return InstanceData(values[0],values[1],values[2],values[3],values[4],values[5],values[6],values[7],
values[8],values[9],values[10],values[11],values[12],values[13],values[14])
def s3(self):
self.bucket = self.tester.create_bucket(bucket_name="reporting-bucket-" + self.cur_time)
key_size = 10
self.tester.debug("Creating random " + str(key_size) + "MB of data")
rand_string = self.tester.id_generator(size=1024*1024*10)
self.tester.upload_object(self.bucket.name, "reporting-key" ,contents=rand_string)
self.tester.sleep(120)
report_output = self.generate_report("s3", "csv",self.date)
bucket_lines = self.tester.grep(self.bucket.name, report_output)
for line in bucket_lines:
bucket_data = self.parse_bucket_line(line)
if not int(bucket_data.size) == 10:
raise Exception('Failed to find proper size for %s' % str(self.bucket))
if not int(bucket_data.keys) == 1:
raise Exception('Failed to find proper number of keys for %s' % str(self.bucket))
if not int(bucket_data.unit_time) > 16:
raise Exception('Failed to find proper amount of usage for %s' % str(self.bucket))
def parse_bucket_line(self, line):
BucketData = namedtuple('BucketData', 'name keys size unit_time')
values = line.split(",")
return BucketData(values[0],values[1],values[2],values[3] )
def generate_report(self, type, format, end_date):
return self.clc.sys("source " + self.tester.credpath + "/eucarc && eureport-generate-report -t " +
str(type) +" -f " + str(format) + " -e " + str(end_date) )
def modify_property(self, property, value):
"""
Modify a eucalyptus property through the command line euca-modify-property tool
property Property to modify
value Value to set it too
"""
command = "source " + self.tester.credpath + "/eucarc && " + self.tester.eucapath + "/usr/sbin/euca-modify-property -p " + str(property) + "=" + str(value)
if self.clc.found(command, property):
self.debug("Properly modified property " + property)
else:
raise Exception("Setting property " + property + " failed")
class AutoScalingBasics(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 = Eucaops(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)
### 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.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store",
not_location="loadbalancer")
self.address = None
self.asg = None
def clean_method(self):
if self.asg:
self.tester.wait_for_result(self.gracefully_delete, True)
self.tester.delete_as_group(self.asg.name, force=True)
self.tester.cleanup_artifacts()
def AutoScalingBasics(self):
### create launch configuration
self.launch_config_name = 'Test-Launch-Config-' + str(time.time())
self.tester.create_launch_config(name=self.launch_config_name,
image_id=self.image.id,
instance_type="m1.small",
key_name=self.keypair.name,
security_groups=[self.group.name])
### create auto scale group
self.auto_scaling_group_name = 'ASG-' + str(time.time())
self.asg = self.tester.create_as_group(
group_name=self.auto_scaling_group_name,
availability_zones=self.tester.get_zones(),
launch_config=self.launch_config_name,
min_size=0,
max_size=5)
### Test Create and describe Auto Scaling Policy
self.up_policy_name = "Up-Policy-" + str(time.time())
self.up_size = 4
self.tester.create_as_policy(name=self.up_policy_name,
adjustment_type="ChangeInCapacity",
scaling_adjustment=4,
as_name=self.auto_scaling_group_name,
cooldown=120)
if len(
self.tester.autoscale.get_all_policies(
policy_names=[self.up_policy_name])) != 1:
raise Exception('Auto Scaling policies: ' + self.up_policy_name +
' not created')
self.down_policy_name = "Down-Policy-" + str(time.time())
self.down_size = -50
self.tester.create_as_policy(name=self.down_policy_name,
adjustment_type="PercentChangeInCapacity",
scaling_adjustment=self.down_size,
as_name=self.auto_scaling_group_name,
cooldown=120)
if len(
self.tester.autoscale.get_all_policies(
policy_names=[self.down_policy_name])) != 1:
raise Exception('Auto Scaling policies: ' + self.down_policy_name +
' not created')
self.exact_policy_name = "Exact-Policy-" + str(time.time())
self.exact_size = 0
self.tester.create_as_policy(name=self.exact_policy_name,
adjustment_type="ExactCapacity",
scaling_adjustment=self.exact_size,
as_name=self.auto_scaling_group_name,
cooldown=120)
if len(
self.tester.autoscale.get_all_policies(
policy_names=[self.exact_policy_name])) != 1:
raise Exception('Auto Scaling policies: ' +
self.exact_policy_name + ' not created')
self.debug("**** Created Auto Scaling Policies: " +
self.up_policy_name + " " + self.down_policy_name + " " +
self.exact_policy_name)
self.tester.wait_for_result(self.scaling_activities_complete,
True,
timeout=180)
### Test Execute ChangeInCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.up_policy_name,
as_group=self.auto_scaling_group_name,
honor_cooldown=False)
if self.tester.describe_as_group(
self.auto_scaling_group_name).desired_capacity != self.up_size:
raise Exception("Auto Scale Up not executed")
self.debug(
"Executed ChangeInCapacity policy, increased desired capacity to: "
+ str(
self.tester.describe_as_group(
self.auto_scaling_group_name).desired_capacity))
self.tester.wait_for_result(self.scaling_activities_complete,
True,
timeout=180)
### Test Execute PercentChangeInCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.down_policy_name,
as_group=self.auto_scaling_group_name,
honor_cooldown=False)
if self.tester.describe_as_group(
self.auto_scaling_group_name
).desired_capacity != 0.5 * self.up_size:
raise Exception("Auto Scale down percentage not executed")
self.debug(
"Executed PercentChangeInCapacity policy, decreased desired capacity to: "
+ str(
self.tester.describe_as_group(
self.auto_scaling_group_name).desired_capacity))
self.tester.wait_for_result(self.scaling_activities_complete,
True,
timeout=180)
### Test Execute ExactCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.exact_policy_name,
as_group=self.auto_scaling_group_name,
honor_cooldown=False)
if self.tester.describe_as_group(self.auto_scaling_group_name
).desired_capacity != self.exact_size:
raise Exception("Auto Scale down percentage not executed")
self.debug("Executed ExactCapacity policy, exact capacity is: " + str(
self.tester.describe_as_group(
self.auto_scaling_group_name).desired_capacity))
self.tester.wait_for_result(self.scaling_activities_complete,
True,
timeout=180)
### Test Delete all Auto Scaling Policies
self.tester.delete_all_policies()
### Test Delete Auto Scaling Group
self.tester.wait_for_result(self.gracefully_delete, True)
self.asg = None
### Test delete launch config
self.tester.delete_launch_config(self.launch_config_name)
def scaling_activities_complete(self):
activities = self.asg.get_activities()
for activity in activities:
assert isinstance(activity, Activity)
if activity.progress != 100:
return False
return True
def AutoScalingInstanceBasics(self):
"""
This case will test DescribeAutoScalingInstances, SetInstanceHealth and TerminateInstanceInAutoScalingGroup
"""
pass
def too_many_launch_configs_test(self):
"""
AWS enforces a 100 LC per account limit this tests what happens if we create more
"""
for i in range(101):
self.launch_config_name = 'Test-Launch-Config-' + str(i + 1)
self.tester.create_launch_config(name=self.launch_config_name,
image_id=self.image.id)
if len(self.tester.describe_launch_config()) > 100:
raise Exception(
"More then 100 launch configs exist in 1 account")
for lc in self.tester.describe_launch_config():
self.tester.delete_launch_config(lc.name)
def too_many_policies_test(self):
"""
AWS enforces a 25 policy per account limit this tests what happens if we create more
"""
launch_config_name = 'LC-' + str(time.time())
self.tester.create_launch_config(name=launch_config_name,
image_id=self.image.id,
instance_type="m1.small",
key_name=self.keypair.name,
security_groups=[self.group.name])
asg_name = 'ASG-' + str(time.time())
self.asg = self.tester.create_as_group(
group_name=asg_name,
launch_config=launch_config_name,
availability_zones=self.tester.get_zones(),
min_size=0,
max_size=5)
for i in range(26):
policy_name = "Policy-" + str(i + 1)
self.tester.create_as_policy(name=policy_name,
adjustment_type="ExactCapacity",
as_name=asg_name,
scaling_adjustment=0,
cooldown=120)
if len(self.tester.autoscale.get_all_policies()) > 25:
raise Exception(
"More than 25 policies exist for 1 auto scaling group")
self.tester.wait_for_result(self.gracefully_delete, True)
self.asg = None
def too_many_as_groups(self):
"""
AWS imposes a 20 ASG/acct limit
"""
pass
def clear_all(self):
"""
remove ALL scaling policies, auto scaling groups and launch configs
"""
self.tester.delete_all_policies()
self.tester.delete_all_autoscaling_groups()
self.tester.delete_all_launch_configs()
def change_config(self):
### create initial launch configuration
first_launch_config = 'First-Launch-Config-' + str(time.time())
self.tester.create_launch_config(name=first_launch_config,
image_id=self.image.id,
instance_type="m1.small")
# create a replacement LC with different instance type
second_launch_config = 'Second-Launch-Config-' + str(time.time())
self.tester.create_launch_config(name=second_launch_config,
image_id=self.image.id,
instance_type="m1.large")
### create auto scale group
auto_scaling_group_name = 'ASG-' + str(time.time())
self.asg = self.tester.create_as_group(
group_name=auto_scaling_group_name,
launch_config=first_launch_config,
availability_zones=self.tester.get_zones(),
min_size=1,
max_size=4,
desired_capacity=1)
assert isinstance(self.asg, AutoScalingGroup)
self.tester.update_as_group(group_name=self.asg.name,
launch_config=second_launch_config,
availability_zones=self.tester.get_zones(),
min_size=1,
max_size=4)
def wait_for_instances(number=1):
self.asg = self.tester.describe_as_group(self.asg.name)
instances = self.asg.instances
if not instances:
self.tester.debug("No instances in ASG")
return False
if len(self.asg.instances) != number:
self.tester.debug("Instances not yet allocated")
return False
for instance in instances:
assert isinstance(instance, Instance)
instance = self.tester.get_instances(
idstring=instance.instance_id)[0]
if instance.state != "running":
self.tester.debug("Instance: " + str(instance) +
" still in " + instance.state + " state")
return False
else:
self.tester.debug("Instance: " + str(instance) +
" now running")
return True
self.tester.wait_for_result(wait_for_instances, True, timeout=360)
### Set desired capacity
new_desired = 2
self.asg.set_capacity(new_desired)
self.tester.wait_for_result(wait_for_instances,
True,
number=new_desired,
timeout=360)
#wait briefly before changing capacity
# TODO get new instance ID and get it's type verify correct type
### Delete Auto Scaling Group
last_instance = self.tester.get_instances(
idstring=self.tester.get_last_instance_id())[0]
assert last_instance.instance_type == "m1.large"
self.tester.wait_for_result(self.gracefully_delete, True)
self.asg = None
### delete launch configs
self.tester.delete_launch_config(first_launch_config)
self.tester.delete_launch_config(second_launch_config)
def gracefully_delete(self, asg=None):
if not asg:
asg = self.asg
assert isinstance(asg, AutoScalingGroup)
try:
self.tester.delete_as_group(name=asg.name, force=True)
except BotoServerError, e:
if e.status == 400 and e.reason == "ScalingActivityInProgress":
return False
return True
class StickinessBasics(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()
### 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)
return self.tester.generate_http_requests(url=lb_url, count=100, worker_threads=1)
def session_affinity_test(self):
lbpolicy = "LB-Policy"
self.tester.create_lb_cookie_stickiness_policy(cookie_expiration_period=300,
lb_name=self.load_balancer.name,
policy_name=lbpolicy)
acpolicy = "AC-Policy"
self.tester.create_app_cookie_stickiness_policy(name="test-cookie",
lb_name=self.load_balancer.name,
policy_name=acpolicy)
"""test lb stickiness"""
self.tester.sleep(2)
self.tester.set_lb_policy(lb_name=self.load_balancer.name, lb_port=80, policy_name=lbpolicy)
responses = self.GenerateRequests()
host = responses[0]
for response in responses:
if response != host:
raise Exception(
"Expected same response due to load balancer stickiness policy. Got initial response: " + host +
" subsequent response: " + response)
"""test app cookie stickiness"""
self.tester.set_lb_policy(lb_name=self.load_balancer.name, lb_port=80, policy_name=acpolicy)
responses = self.GenerateRequests()
host = responses[0]
for response in responses:
if response != host:
raise Exception(
"Expected same response due to app cookie stickiness policy. Got initial response: " + host +
" subsequent response: " + response)
return
class InstanceBasics(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)
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.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.address = None
self.volume = None
self.private_addressing = False
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.reservation = None
def clean_method(self):
if self.reservation:
self.assertTrue(self.tester.terminate_instances(self.reservation),
"Unable to terminate instance(s)")
if self.address:
assert isinstance(self.address, Address)
self.tester.release_address(self.address)
if self.volume:
self.tester.delete_volume(self.volume)
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
def BasicInstanceChecks(self, zone=None):
"""
This case was developed to run through a series of basic instance tests.
The tests are as follows:
- execute run_instances command
- make sure that public DNS name and private IP aren't the same
(This is for Managed/Managed-NOVLAN networking modes)
- test to see if instance is ping-able
- test to make sure that instance is accessible via ssh
(ssh into instance and run basic ls command)
If any of these tests fail, the test case will error out, logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(
self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=zone)
for instance in self.reservation.instances:
self.assertTrue(self.tester.wait_for_reservation(self.reservation),
'Instance did not go to running')
self.assertNotEqual(instance.public_dns_name,
instance.private_ip_address,
'Public and private IP are the same')
self.assertTrue(self.tester.ping(instance.public_dns_name),
'Could not ping instance')
self.assertFalse(
instance.found("ls -1 /dev/" + instance.rootfs_device + "2",
"No such file or directory"),
'Did not find ephemeral storage at ' + instance.rootfs_device +
"2")
return self.reservation
def ElasticIps(self, zone=None):
"""
This case was developed to test elastic IPs in Eucalyptus. This test case does
not test instances that are launched using private-addressing option.
The test case executes the following tests:
- allocates an IP, associates the IP to the instance, then pings the instance.
- disassociates the allocated IP, then pings the instance.
- releases the allocated IP address
If any of the tests fail, the test case will error out, logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(
keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
self.address = self.tester.allocate_address()
self.assertTrue(self.address, 'Unable to allocate address')
self.tester.associate_address(instance, self.address)
instance.update()
self.assertTrue(self.tester.ping(instance.public_dns_name),
"Could not ping instance with new IP")
self.tester.disassociate_address_from_instance(instance)
self.tester.release_address(self.address)
self.address = None
instance.update()
self.assertTrue(self.tester.ping(instance.public_dns_name),
"Could not ping after dissassociate")
return self.reservation
def MaxSmallInstances(self, available_small=None, zone=None):
"""
This case was developed to test the maximum number of m1.small vm types a configured
cloud can run. The test runs the maximum number of m1.small vm types allowed, then
tests to see if all the instances reached a running state. If there is a failure,
the test case errors out; logging the results.
"""
if self.reservation:
self.tester.terminate_instances(self.reservation)
if available_small is None:
available_small = self.tester.get_available_vms()
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,
keypair=self.keypair.name,
group=self.group.name,
min=available_small,
max=available_small,
zone=zone)
self.assertTrue(self.tester.wait_for_reservation(self.reservation),
'Not all instances went to running')
return self.reservation
def LargestInstance(self, zone=None):
"""
This case was developed to test the maximum number of c1.xlarge vm types a configured
cloud can run. The test runs the maximum number of c1.xlarge vm types allowed, then
tests to see if all the instances reached a running state. If there is a failure,
the test case errors out; logging the results.
"""
if zone is None:
zone = self.zone
if self.reservation:
self.tester.terminate_instances(self.reservation)
self.reservation = self.tester.run_instance(self.image,
keypair=self.keypair.name,
group=self.group.name,
type="c1.xlarge",
zone=zone)
self.assertTrue(self.tester.wait_for_reservation(self.reservation),
'Not all instances went to running')
return self.reservation
def MetaData(self, zone=None):
"""
This case was developed to test the metadata service of an instance for consistency.
The following meta-data attributes are tested:
- public-keys/0/openssh-key
- security-groups
- instance-id
- local-ipv4
- public-ipv4
- ami-id
- ami-launch-index
- reservation-id
- placement/availability-zone
- kernel-id
- public-hostname
- local-hostname
- hostname
- ramdisk-id
- instance-type
- any bad metadata that shouldn't be present.
Missing nodes
['block-device-mapping/', 'ami-manifest-path']
If any of these tests fail, the test case will error out; logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(
self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=zone)
for instance in self.reservation.instances:
## Need to verify the public key (could just be checking for a string of a certain length)
self.assertTrue(
re.match(
instance.get_metadata("public-keys/0/openssh-key")
[0].split('eucalyptus.')[-1], self.keypair.name),
'Incorrect public key in metadata')
self.assertTrue(
re.match(
instance.get_metadata("security-groups")[0],
self.group.name), 'Incorrect security group in metadata')
# Need to validate block device mapping
#self.assertTrue(re.search(instance_ssh.get_metadata("block-device-mapping/")[0], ""))
self.assertTrue(
re.match(instance.get_metadata("instance-id")[0], instance.id),
'Incorrect instance id in metadata')
self.assertTrue(
re.match(
instance.get_metadata("local-ipv4")[0],
instance.private_ip_address),
'Incorrect private ip in metadata')
self.assertTrue(
re.match(
instance.get_metadata("public-ipv4")[0],
instance.ip_address), 'Incorrect public ip in metadata')
self.assertTrue(
re.match(
instance.get_metadata("ami-id")[0], instance.image_id),
'Incorrect ami id in metadata')
self.assertTrue(
re.match(
instance.get_metadata("ami-launch-index")[0],
instance.ami_launch_index),
'Incorrect launch index in metadata')
self.assertTrue(
re.match(
instance.get_metadata("reservation-id")[0],
self.reservation.id), 'Incorrect reservation in metadata')
self.assertTrue(
re.match(
instance.get_metadata("placement/availability-zone")[0],
instance.placement),
'Incorrect availability-zone in metadata')
self.assertTrue(
re.match(
instance.get_metadata("kernel-id")[0], instance.kernel),
'Incorrect kernel id in metadata')
self.assertTrue(
re.match(
instance.get_metadata("public-hostname")[0],
instance.public_dns_name),
'Incorrect public host name in metadata')
self.assertTrue(
re.match(
instance.get_metadata("local-hostname")[0],
instance.private_dns_name),
'Incorrect private host name in metadata')
self.assertTrue(
re.match(
instance.get_metadata("hostname")[0], instance.dns_name),
'Incorrect host name in metadata')
self.assertTrue(
re.match(
instance.get_metadata("ramdisk-id")[0], instance.ramdisk),
'Incorrect ramdisk in metadata') #instance-type
self.assertTrue(
re.match(
instance.get_metadata("instance-type")[0],
instance.instance_type),
'Incorrect instance type in metadata')
BAD_META_DATA_KEYS = ['foobar']
for key in BAD_META_DATA_KEYS:
self.assertTrue(
re.search("Not Found",
"".join(instance.get_metadata(key))),
'No fail message on invalid meta-data node')
return self.reservation
def DNSResolveCheck(self, zone=None):
"""
This case was developed to test DNS resolution information for public/private DNS
names and IP addresses. The tested DNS resolution behavior is expected to follow
AWS EC2. The following tests are ran using the associated meta-data attributes:
- check to see if Eucalyptus Dynamic DNS is configured
- nslookup on hostname; checks to see if it matches local-ipv4
- nslookup on local-hostname; check to see if it matches local-ipv4
- nslookup on local-ipv4; check to see if it matches local-hostname
- nslookup on public-hostname; check to see if it matches local-ipv4
- nslookup on public-ipv4; check to see if it matches public-host
If any of these tests fail, the test case will error out; logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(
self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=zone)
for instance in self.reservation.instances:
# Test to see if Dynamic DNS has been configured #
if re.match("internal",
instance.private_dns_name.split('eucalyptus.')[-1]):
# Per AWS standard, resolution should have private hostname or private IP as a valid response
# Perform DNS resolution against private IP and private DNS name
# Check to see if nslookup was able to resolve
self.assertTrue(
re.search(
'answer\:',
instance.sys("nslookup " +
instance.get_metadata("hostname")[0])[3]),
"DNS lookup failed for hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on local-hostname returns local-ipv4 address
self.assertTrue(
re.search(
instance.get_metadata("local-ipv4")[0],
instance.sys("nslookup " +
instance.get_metadata("hostname")[0])[5]),
"Incorrect DNS resolution for hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(
re.search(
'answer\:',
instance.sys(
"nslookup " +
instance.get_metadata("local-hostname")[0])[3]),
"DNS lookup failed for private hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on local-hostname returns local-ipv4 address
self.assertTrue(
re.search(
instance.get_metadata("local-ipv4")[0],
instance.sys(
"nslookup " +
instance.get_metadata("local-hostname")[0])[5]),
"Incorrect DNS resolution for private hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(
re.search(
'answer\:',
instance.sys("nslookup " +
instance.get_metadata("local-ipv4")[0])
[3]), "DNS lookup failed for private IP address.")
# Since nslookup was able to resolve, now check to see if nslookup on local-ipv4 address returns local-hostname
self.assertTrue(
re.search(
instance.get_metadata("local-hostname")[0],
instance.sys("nslookup " +
instance.get_metadata("local-ipv4")[0])
[4]),
"Incorrect DNS resolution for private IP address")
# Perform DNS resolution against public IP and public DNS name
# Check to see if nslookup was able to resolve
self.assertTrue(
re.search(
'answer\:',
instance.sys(
"nslookup " +
instance.get_metadata("public-hostname")[0])[3]),
"DNS lookup failed for public-hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on public-hostname returns local-ipv4 address
self.assertTrue(
re.search(
instance.get_metadata("local-ipv4")[0],
instance.sys(
"nslookup " +
instance.get_metadata("public-hostname")[0])[5]),
"Incorrect DNS resolution for public-hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(
re.search(
'answer\:',
instance.sys("nslookup " +
instance.get_metadata("public-ipv4")[0])
[3]), "DNS lookup failed for public IP address.")
# Since nslookup was able to resolve, now check to see if nslookup on public-ipv4 address returns public-hostname
self.assertTrue(
re.search(
instance.get_metadata("public-hostname")[0],
instance.sys("nslookup " +
instance.get_metadata("public-ipv4")[0])
[4]), "Incorrect DNS resolution for public IP address")
return self.reservation
def DNSCheck(self, zone=None):
"""
This case was developed to test to make sure Eucalyptus Dynamic DNS reports correct
information for public/private IP address and DNS names passed to meta-data service.
The following tests are ran using the associated meta-data attributes:
- check to see if Eucalyptus Dynamic DNS is configured
- check to see if local-ipv4 and local-hostname are not the same
- check to see if public-ipv4 and public-hostname are not the same
If any of these tests fail, the test case will error out; logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(
self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=zone)
for instance in self.reservation.instances:
# Test to see if Dynamic DNS has been configured #
if re.match("internal",
instance.private_dns_name.split('eucalyptus.')[-1]):
# Make sure that private_ip_address is not the same as local-hostname
self.assertFalse(
re.match(instance.private_ip_address,
instance.private_dns_name),
'local-ipv4 and local-hostname are the same with DNS on')
# Make sure that ip_address is not the same as public-hostname
self.assertFalse(
re.match(instance.ip_address, instance.public_dns_name),
'public-ipv4 and public-hostname are the same with DNS on')
return self.reservation
def Reboot(self, zone=None):
"""
This case was developed to test IP connectivity and volume attachment after
instance reboot. The following tests are done for this test case:
- creates a 1 gig EBS volume, then attach volume
- reboot instance
- attempts to connect to instance via ssh
- checks to see if EBS volume is attached
- detaches volume
- deletes volume
If any of these tests fail, the test case will error out; logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
self.reservation = self.tester.run_instance(
self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=zone)
for instance in self.reservation.instances:
### Create 1GB volume in first AZ
self.volume = self.tester.create_volume(instance.placement, 1)
self.volume_device = instance.attach_volume(self.volume)
### Reboot instance
instance.reboot_instance_and_verify(waitconnect=20)
instance.detach_euvolume(self.volume)
self.tester.delete_volume(self.volume)
self.volume = None
return self.reservation
def run_terminate(self):
reservation = None
try:
reservation = self.tester.run_instance(image=self.image,
zone=self.zone,
keypair=self.keypair.name,
group=self.group.name)
self.tester.terminate_instances(reservation)
return 0
except Exception, e:
if reservation:
self.tester.terminate_instances(reservation)
return 1
class StickinessBasics(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()
### 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)
return self.tester.generate_http_requests(url=lb_url,
count=100,
worker_threads=1)
def session_affinity_test(self):
lbpolicy = "LB-Policy"
self.tester.create_lb_cookie_stickiness_policy(
cookie_expiration_period=300,
lb_name=self.load_balancer.name,
policy_name=lbpolicy)
acpolicy = "AC-Policy"
self.tester.create_app_cookie_stickiness_policy(
name="test-cookie",
lb_name=self.load_balancer.name,
policy_name=acpolicy)
"""test lb stickiness"""
self.tester.sleep(2)
self.tester.set_lb_policy(lb_name=self.load_balancer.name,
lb_port=80,
policy_name=lbpolicy)
responses = self.GenerateRequests()
host = responses[0]
for response in responses:
if response != host:
raise Exception(
"Expected same response due to load balancer stickiness policy. Got initial response: "
+ host + " subsequent response: " + response)
"""test app cookie stickiness"""
self.tester.set_lb_policy(lb_name=self.load_balancer.name,
lb_port=80,
policy_name=acpolicy)
responses = self.GenerateRequests()
host = responses[0]
for response in responses:
if response != host:
raise Exception(
"Expected same response due to app cookie stickiness policy. Got initial response: "
+ host + " subsequent response: " + response)
return
class ReportingBasics(EutesterTestCase):
def __init__(self, config_file=None, password=None):
self.setuptestcase()
# Setup basic eutester object
self.tester = Eucaops(config_file=config_file, password=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.volume = None
self.bucket = None
self.private_addressing = False
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.clean_method = self.cleanup
self.cur_time = str(int(time.time()))
date_fields = time.localtime()
self.date = str(date_fields.tm_year) + "-" + str(
date_fields.tm_mon) + "-31"
clcs = self.tester.get_component_machines("clc")
if len(clcs) is 0:
raise Exception("No CLC found")
else:
self.clc = clcs[0]
poll_interval = 1
write_interval = 1
size_time_size_unit = "MB"
size_time_time_unit = "MINS"
size_unit = "MB"
time_unit = "MINS"
self.modify_property(property="reporting.default_poll_interval_mins",
value=poll_interval)
self.modify_property(property="reporting.default_write_interval_mins",
value=write_interval)
self.modify_property(property="reporting.default_size_time_size_unit",
value=size_time_size_unit)
self.modify_property(property="reporting.default_size_time_time_unit",
value=size_time_time_unit)
self.modify_property(property="reporting.default_size_unit",
value=size_unit)
self.modify_property(property="reporting.default_time_unit",
value=time_unit)
def cleanup(self):
if self.reservation:
self.assertTrue(self.tester.terminate_instances(self.reservation),
"Unable to terminate instance(s)")
if self.volume:
self.tester.delete_volume(self.volume)
if self.bucket:
self.tester.clear_bucket(self.bucket)
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
def instance(self):
self.reservation = self.tester.run_instance(self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=self.zone)
file_size_in_mb = 500
for instance in self.reservation.instances:
assert isinstance(instance, EuInstance)
self.volume = self.tester.create_volume(azone=self.zone, size=4)
device_path = instance.attach_volume(self.volume)
instance.sys("mkfs.ext3 -F " + device_path)
instance.sys("mount " + device_path + " /mnt")
### Write to root fs
instance.sys("dd if=/dev/zero of=/tmp/test.img count=" +
str(file_size_in_mb) + " bs=1M")
### Write to volume
instance.sys("dd if=/dev/zero of=/mnt/test.img count=" +
str(file_size_in_mb) + " bs=1M")
self.tester.sleep(180)
for instance in self.reservation.instances:
report_output = self.generate_report("instance", "csv", self.date)
instance_lines = self.tester.grep(instance.id, report_output)
for line in instance_lines:
instance_data = self.parse_instance_line(line)
#if not re.search( instance.id +",m1.small,1,9,0.2,0,0,0,0,93,200,0.2,0.0,0,1", line):
if not re.match(instance_data.type, "m1.small"):
raise Exception("Failed to find proper output for " +
str(instance) + " type. Received: " +
instance_data.type)
if not int(instance_data.number) == 1:
raise Exception("Failed to find proper output for " +
str(instance) + " number. Received: " +
instance_data.number)
if not int(instance_data.unit_time) > 2:
raise Exception("Failed to find proper output for " +
str(instance) + " unit_time. Received: " +
instance_data.unit_time)
if not int(instance_data.disk_write) > 1000:
raise Exception("Failed to find proper output for " +
str(instance) + " disk_write. Received: " +
instance_data.disk_write)
if not int(instance_data.disk_time_write) > 200:
raise Exception("Failed to find proper output for " +
str(instance) +
" disk_time_write. Received: " +
instance_data.disk_time_write)
def parse_instance_line(self, line):
InstanceData = namedtuple(
'InstanceData',
'id type number unit_time cpu net_total_in net_total_out '
'net_extern_in net_extern_out disk_read disk_write disk_iops_read '
'disk_iops_write disk_time_read disk_time_write')
values = line.split(",")
return InstanceData(values[0], values[1], values[2], values[3],
values[4], values[5], values[6], values[7],
values[8], values[9], values[10], values[11],
values[12], values[13], values[14])
def s3(self):
self.bucket = self.tester.create_bucket(
bucket_name="reporting-bucket-" + self.cur_time)
key_size = 10
self.tester.debug("Creating random " + str(key_size) + "MB of data")
rand_string = self.tester.id_generator(size=1024 * 1024 * 10)
self.tester.upload_object(self.bucket.name,
"reporting-key",
contents=rand_string)
self.tester.sleep(120)
report_output = self.generate_report("s3", "csv", self.date)
bucket_lines = self.tester.grep(self.bucket.name, report_output)
for line in bucket_lines:
bucket_data = self.parse_bucket_line(line)
if not int(bucket_data.size) == 10:
raise Exception('Failed to find proper size for %s' %
str(self.bucket))
if not int(bucket_data.keys) == 1:
raise Exception('Failed to find proper number of keys for %s' %
str(self.bucket))
if not int(bucket_data.unit_time) > 16:
raise Exception(
'Failed to find proper amount of usage for %s' %
str(self.bucket))
def parse_bucket_line(self, line):
BucketData = namedtuple('BucketData', 'name keys size unit_time')
values = line.split(",")
return BucketData(values[0], values[1], values[2], values[3])
def generate_report(self, type, format, end_date):
return self.clc.sys("source " + self.tester.credpath +
"/eucarc && eureport-generate-report -t " +
str(type) + " -f " + str(format) + " -e " +
str(end_date))
def modify_property(self, property, value):
"""
Modify a eucalyptus property through the command line euca-modify-property tool
property Property to modify
value Value to set it too
"""
command = "source " + self.tester.credpath + "/eucarc && " + self.tester.eucapath + "/usr/sbin/euca-modify-property -p " + str(
property) + "=" + str(value)
if self.clc.found(command, property):
self.debug("Properly modified property " + property)
else:
raise Exception("Setting property " + property + " failed")
class PopulateUpgrade(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.tester.poll_count = 120
self.security_groups = []
### 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.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.address = None
self.volume = None
self.snapshot = None
self.private_addressing = False
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.reservation = None
def clean_method(self):
pass
def Instances(self, type="instance-store"):
"""
This case was developed to run through a series of basic instance tests.
The tests are as follows:
- execute run_instances command
- make sure that public DNS name and private IP aren't the same
(This is for Managed/Managed-NOVLAN networking modes)
- test to see if instance is ping-able
- test to make sure that instance is accessible via ssh
(ssh into instance and run basic ls command)
If any of these tests fail, the test case will error out, logging the results.
"""
test_image = self.tester.get_emi(root_device_type=type)
### 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" )
self.security_groups.append(self.group)
# Test: INSTANCESTORE VOLATTACH:no ADDR:user
instance_1 = self.tester.run_instance(test_image, keypair=self.keypair.name, group=self.group.name).instances[0]
instance_1_address = self.tester.allocate_address()
self.tester.associate_address(instance=instance_1, address=instance_1_address)
# Test: INSTANCESTORE VOLATTACH:no ADDR:system
instance_2 = self.tester.run_instance(test_image, keypair=self.keypair.name, group=self.group.name).instances[0]
# Test: INSTANCESTORE VOLATTACH:no ADDR:system
instance_3 = self.tester.run_instance(test_image, group=self.group.name, private_addressing=True, is_reachable=False).instances[0]
# Test: INSTANCESTORE VOLATTACH:yes ADDR:user
instance_4 = self.tester.run_instance(test_image, keypair=self.keypair.name, group=self.group.name).instances[0]
instance_4_address = self.tester.allocate_address()
self.tester.associate_address(instance=instance_4, address=instance_4_address)
volume = self.tester.create_volume(zone=self.zone)
instance_4.attach_volume(volume=volume)
# Test: INSTANCESTORE VOLATTACH:yes ADDR:system
instance_5 = self.tester.run_instance(test_image, keypair=self.keypair.name, group=self.group.name).instances[0]
volume = self.tester.create_volume(zone=self.zone)
instance_5.attach_volume(volume=volume)
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" )
self.security_groups.append(self.group)
# Test: INSTANCESTORE VOLATTACH:yes ADDR:system
instance_6 = self.tester.run_instance(test_image, group=self.group.name, private_addressing=True, is_reachable=False).instances[0]
def PopulateAll(self):
self.Instances("instance-store")
self.Instances("ebs")
class ClusterBasics(unittest.TestCase):
def setUp(self):
if options.config_file:
self.tester = Eucaops(config_file=options.config_file,
password=options.clc_password)
else:
print "\tNeed to pass --config_file option. Try --help for more information\n"
exit(1)
## If specific image wants to be tested, use that; if not, use any instance-store backed image.
if options.image:
self.image = self.tester.get_emi(emi=options.image)
else:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.keypair = self.tester.add_keypair(options.prefix + "-" +
str(time.time()))
self.keypath = os.curdir + "/" + self.keypair.name + ".pem"
### Identify type of instance to run
if options.type == "random":
options.type = random.choice([
"m1.small", "c1.medium", "m1.large", "m1.xlarge", "c1.xlarge"
])
### Identify number of instances to run (i.e. number of security groups)
self.num_vms = self.tester.get_available_vms(options.type)
if self.num_vms >= options.number:
self.available = options.number
else:
options.type = "m1.small"
avail_vms = self.tester.get_available_vms(options.type)
if avail_vms < options.number:
self.tester.fail(
"Not enough m1.small vm types to run test with minimal of 3 security groups."
)
else:
self.available = options.number
self.security_groups = []
self.reservations = []
def tearDown(self):
### Clean up after running test case
for reservation in self.reservations:
self.tester.terminate_instances(reservation)
for security_group in self.security_groups:
self.tester.delete_group(security_group)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
self.keypath = None
self.keypair = None
self.image = None
self.num_vms = None
self.available = None
self.security_groups = None
self.tester = None
### Test Cases ###
def iptables_Cruft(self):
### Launch number of instances based upon number of security groups wanting to be tested.
### Take snapshot of iptables before creating security groups and launching instances.
### Use service manager to get to enabled CC to get iptables rules
partition = self.tester.service_manager.partitions.keys()
part = list(partition)[0]
main_part = self.tester.service_manager.partitions.get(part)
cc_machine = main_part.get_enabled_cc()
cc_shell = self.tester.create_ssh(hostname=cc_machine.hostname,
password=options.cc_password)
pre_stdin, pre_iptables, pre_stderr = cc_shell.exec_command(
"iptables-save | grep -v \"#\" | grep -v \"\:PRE\" | grep -v \"\:POST\" | grep -v \"\:INPUT\" | grep -v \"\:FORWARD\" | grep -v \"\:OUT\""
)
self.pre_iptables = list(pre_iptables)
self.assertTrue(pre_stderr, "pre_Iptables_Snapshot failed.")
### Create security group for number of security groups we want to test.
while self.available > 0:
### Create unique security group and authorize SSH and PING
sec_group = self.tester.add_group(group_name=options.prefix + "-" +
str(time.time()))
self.assertNotEqual(len(sec_group.name), 0,
"Could not create group.")
self.assertTrue(
self.tester.authorize_group_by_name(group_name=sec_group.name),
"Could not authorize group for SSH")
self.assertTrue(
self.tester.authorize_group_by_name(group_name=sec_group.name,
port=-1,
protocol="icmp"),
"Could not authorize group for PING")
self.security_groups.append(sec_group)
### Launch instance for the unique security group
try:
reservation = self.tester.run_instance(
self.image,
keypair=self.keypair.name,
group=sec_group.name,
type=options.type)
except Exception, e:
self.fail("Caught an exception when running the instance: " +
str(e))
self.reservations.append(reservation)
### Decrement count of security groups and instances left to create
self.available -= 1
### Take snapshot of iptables after deleting security groups and terminating instances.
### Use service manager to get to enabled CC to get iptables rules
partition = self.tester.service_manager.partitions.keys()
part = list(partition)[0]
main_part = self.tester.service_manager.partitions.get(part)
cc_machine = main_part.get_enabled_cc()
cc_shell = self.tester.create_ssh(hostname=cc_machine.hostname,
password=options.cc_password)
post_stdin, post_iptables, post_stderr = cc_shell.exec_command(
"iptables-save | grep -v \"#\" | grep -v \"\:PRE\" | grep -v \"\:POST\" | grep -v \"\:INPUT\" | grep -v \"\:FORWARD\" | grep -v \"\:OUT\""
)
self.post_iptables = list(post_iptables)
self.assertTrue(post_stderr, "post_Iptables_Snapshot failed.")
### Evaluate pre and post iptables outputs to see if there is a difference.
if (len(self.pre_iptables) != len(self.post_iptables)):
## Get different lines and print them
iptables_diff = set(self.post_iptables) - set(self.pre_iptables)
pp = pprint.PrettyPrinter(indent=4)
self.tester.critical("\n======================================\n")
self.tester.critical("Diffences between iptables snapshots: ")
self.tester.critical("PRE-IPTABLES SNAPSHOT LENGTH: %i",
len(self.pre_iptables))
self.tester.critical("POST-IPTABLES SNAPSHOT LENGTH: %i",
len(self.post_iptables))
self.tester.critical("\n---------------------------------------\n")
pp.pprint(list(iptables_diff))
self.tester.critical("\n======================================\n")
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()
class InstanceBasics(EutesterTestCase):
def __init__(self, extra_args=None):
self.setuptestcase()
self.setup_parser()
self.parser.add_argument("--region", default=None)
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 = 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
### 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.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.address = None
self.volume = None
self.snapshot = None
self.private_addressing = False
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.reservation = None
def clean_method(self):
### Terminate the reservation if it is still up
if self.reservation:
self.assertTrue(self.tester.terminate_instances(self.reservation),
"Unable to terminate instance(s)")
### DELETE group
self.tester.delete_group(self.group)
### Delete keypair in cloud and from filesystem
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
def MyTest(self):
"""
This case was developed to run through a series of basic instance tests.
The tests are as follows:
- execute run_instances command
- make sure that public DNS name and private IP aren't the same
(This is for Managed/Managed-NOVLAN networking modes)
- test to see if instance is ping-able
- test to make sure that instance is accessible via ssh
(ssh into instance and run basic ls command)
If any of these tests fail, the test case will error out, logging the results.
"""
if not self.reservation:
self.reservation = self.tester.run_instance(
self.image, keypair=self.keypair.name, group=self.group.name)
for instance in self.reservation.instances:
self.assertTrue(self.tester.wait_for_reservation(self.reservation),
'Instance did not go to running')
self.assertNotEqual(instance.public_dns_name,
instance.private_ip_address,
'Public and private IP are the same')
self.assertTrue(self.tester.ping(instance.public_dns_name),
'Could not ping instance')
self.assertFalse(
instance.found("ls -1 /dev/" + instance.rootfs_device + "2",
"No such file or directory"),
'Did not find ephemeral storage at ' + instance.rootfs_device +
"2")
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(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)
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)
### Populate resources we will use and cleanup
self.address = None
self.volume = None
self.snapshot = None
self.reservation = None
self.load_balancer = None
def clean_method(self):
### Terminate the reservation if it is still up
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
"""
lb_url = self.load_balancer.dns_name + ":" + self.load_balancer_port
self.tester.generate_http_requests(url=lb_url, count=100)
class AutoScalingBasics(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.emi:
self.tester = Eucaops(credpath=self.args.credpath,
region=self.args.region)
else:
self.tester = Eucaops(credpath=self.args.credpath)
### 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.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.address = None
def clean_method(self):
### DELETE group
self.tester.delete_group(self.group)
### Delete keypair in cloud and from filesystem
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
def AutoScalingBasics(self):
### test create and describe launch config
self.launch_config_name = 'Test-Launch-Config-' + str(time.time())
self.tester.create_launch_config(name=self.launch_config_name,
image_id=self.image.id,
key_name=self.keypair.name,
security_groups=[self.group.name])
if len(self.tester.describe_launch_config([self.launch_config_name
])) != 1:
raise Exception('Launch Config not created')
self.debug('**** Created Launch Config: ' +
self.tester.describe_launch_config(
[self.launch_config_name])[0].name)
### test create and describe auto scale group
self.initial_size = len(self.tester.describe_as_group())
self.auto_scaling_group_name = 'ASG-' + str(time.time())
self.tester.create_as_group(group_name=self.auto_scaling_group_name,
launch_config=self.launch_config_name,
availability_zones=self.tester.get_zones(),
min_size=0,
max_size=5,
connection=self.tester.autoscale)
if len(self.tester.describe_as_group([self.auto_scaling_group_name
])) != 1:
raise Exception('Auto Scaling Group not created')
self.debug("**** Created Auto Scaling Group: " +
self.tester.describe_as_group(
[self.auto_scaling_group_name])[0].name)
### Test Create and describe Auto Scaling Policy
self.up_policy_name = "Up-Policy-" + str(time.time())
self.up_size = 4
self.tester.create_as_policy(name=self.up_policy_name,
adjustment_type="ChangeInCapacity",
as_name=self.auto_scaling_group_name,
scaling_adjustment=4,
cooldown=120)
self.down_policy_name = "Down-Policy-" + str(time.time())
self.down_size = -50
self.tester.create_as_policy(name=self.down_policy_name,
adjustment_type="PercentChangeInCapacity",
as_name=self.auto_scaling_group_name,
scaling_adjustment=self.down_size,
cooldown=120)
self.exact_policy_name = "Exact-Policy-" + str(time.time())
self.exact_size = 0
self.tester.create_as_policy(name=self.exact_policy_name,
adjustment_type="ExactCapacity",
as_name=self.auto_scaling_group_name,
scaling_adjustment=self.exact_size,
cooldown=120)
### Test all policies added to group
if len(self.tester.autoscale.get_all_policies()) != 3:
raise Exception('Auto Scaling policies not created')
self.debug("**** Created Auto Scaling Policies: " +
self.up_policy_name + " " + self.down_policy_name + " " +
self.exact_policy_name)
### Test Execute ChangeInCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.up_policy_name,
as_group=self.auto_scaling_group_name)
if self.tester.describe_as_group([
self.auto_scaling_group_name
])[0].desired_capacity != self.up_size:
raise Exception("Auto Scale Up not executed")
self.debug(
"Executed ChangeInCapacity policy, increased desired capacity to: "
+ str(
self.tester.describe_as_group([self.auto_scaling_group_name])
[0].desired_capacity))
### Test Execute PercentChangeInCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.down_policy_name,
as_group=self.auto_scaling_group_name)
if self.tester.describe_as_group([
self.auto_scaling_group_name
])[0].desired_capacity != 0.5 * self.up_size:
raise Exception("Auto Scale down percentage not executed")
self.debug(
"Executed PercentChangeInCapacity policy, decreased desired capacity to: "
+ str(
self.tester.describe_as_group([self.auto_scaling_group_name])
[0].desired_capacity))
### Test Execute ExactCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.exact_policy_name,
as_group=self.auto_scaling_group_name)
if self.tester.describe_as_group([
self.auto_scaling_group_name
])[0].desired_capacity != self.exact_size:
raise Exception("Auto Scale down percentage not executed")
self.debug("Executed ExactCapacity policy, exact capacity is: " + str(
self.tester.describe_as_group([self.auto_scaling_group_name])
[0].desired_capacity))
### Test Delete all Auto Scaling Policies
for policy in self.tester.autoscale.get_all_policies():
self.tester.delete_as_policy(policy_name=policy.name,
autoscale_group=policy.as_name)
if len(self.tester.autoscale.get_all_policies()) != 0:
raise Exception('Auto Scaling policy not deleted')
self.debug("**** Deleted Auto Scaling Policy: " + self.up_policy_name +
" " + self.down_policy_name + " " + self.exact_policy_name)
### Test Delete Auto Scaling Group
self.tester.delete_as_group(names=self.auto_scaling_group_name)
if len(self.tester.describe_as_group([self.auto_scaling_group_name
])) != 0:
raise Exception('Auto Scaling Group not deleted')
self.debug('**** Deleted Auto Scaling Group: ' +
self.auto_scaling_group_name)
### pause for Auto scaling group to be deleted
# TODO write wait/poll op for auto scaling groups
# time.sleep(5)
### Test delete launch config
self.tester.delete_launch_config(self.launch_config_name)
if len(self.tester.describe_launch_config([self.launch_config_name
])) != 0:
raise Exception('Launch Config not deleted')
self.debug('**** Deleted Launch Config: ' + self.launch_config_name)
def AutoScalingInstanceBasics(self):
"""
This case will test DescribeAutoScalingInstances, SetInstanceHealth and TerminateInstanceInAutoScalingGroup
"""
pass
def too_many_launch_configs_test(self):
"""
AWS enforces a 100 LC per account limit this tests what happens if we create more
"""
for i in range(101):
self.launch_config_name = 'Test-Launch-Config-' + str(i + 1)
self.tester.create_launch_config(name=self.launch_config_name,
image_id=self.image.id)
if len(self.tester.describe_launch_config()) > 100:
raise Exception(
"More then 100 launch configs exist in 1 account")
for lc in self.tester.describe_launch_config():
self.tester.delete_launch_config(lc.name)
def too_many_policies_test(self):
launch_config_name = 'LC-' + str(time.time())
self.tester.create_launch_config(name=launch_config_name,
image_id=self.image.id,
key_name=self.keypair.name,
security_groups=[self.group.name])
asg = 'ASG-' + str(time.time())
self.tester.create_as_group(group_name=asg,
launch_config=launch_config_name,
availability_zones=self.tester.get_zones(),
min_size=0,
max_size=5,
connection=self.tester.autoscale)
for i in range(26):
policy_name = "Policy-" + str(i + 1)
self.tester.create_as_policy(name=policy_name,
adjustment_type="ExactCapacity",
as_name=asg,
scaling_adjustment=0,
cooldown=120)
if len(self.tester.autoscale.get_all_policies()) > 25:
raise Exception(
"More than 25 policies exist for 1 auto scaling group")
self.tester.delete_as_group(names=asg)
def too_many_as_groups(self):
"""
AWS imposes a 20 ASG/acct limit
"""
pass
def clear_all(self):
self.tester.delete_all_autoscaling_groups()
self.tester.delete_all_launch_configs()
class EbsTestSuite(EutesterTestCase):
tester = None
zonelist = []
snaps = []
keypair = None
group = None
multicluster = False
image = None
def __init__(
self,
tester=None,
zone=None,
config_file="../input/2b_tested.lst",
password="******",
credpath=None,
volumes=None,
keypair=None,
group=None,
image=None,
vmtype=None,
eof=1,
):
if tester is None:
self.tester = Eucaops(config_file=config_file, password=password, credpath=credpath)
else:
self.tester = tester
self.tester.exit_on_fail = eof
self.testlist = []
self.image = image
self.vmtype = vmtype
self.zone = None
self.zonelist = []
# create some zone objects and append them to the zonelist
if self.zone is not None:
partition = self.tester.service_manager.partitions.get(zone)
self.zone = TestZone(zone)
self.zonelist.append(self.zone)
else:
self.setup_testzones()
# If the list of volumes passed in looks good, sort them into the zones
if self.volumes_list_check(volumes):
self.sort_volumes(volumes)
# Setup our security group for later use
if group is not None:
self.group = group
else:
group_name = "EbsTestGroup"
try:
self.group = self.tester.add_group(group_name)
self.tester.authorize_group_by_name(self.group.name)
self.tester.authorize_group_by_name(self.group.name, protocol="icmp", port=-1)
except Exception, e:
raise Exception("Error when setting up group:" + str(group_name) + ", Error:" + str(e))
# Setup the keypairs for later use
try:
if keypair is not None:
self.keypair = keypair
else:
keys = self.tester.get_all_current_local_keys()
if keys != []:
self.keypair = keys[0]
else:
self.keypair = keypair = self.tester.add_keypair("ebs_test_key-" + str(time.time()))
except Exception, ke:
raise Exception("Failed to find/create a keypair, error:" + str(ke))
#Number of ping attempts used to test instance state, before giving up on a running instance
ping_retry=100
#The eutester cloud tester object
tester = Eucaops( password=password, config_file=config, credpath=credpath)
#sets tester to throw exception upon failure
if (options.eof):
tester.exit_on_fail = 1
else:
tester.exit_on_fail = 0
try:
### Create security group if it does not exist. Add ssh authorization to it.
try:
group = tester.add_group(group_name)
tester.authorize_group_by_name(group.name)
tester.authorize_group_by_name(group.name,protocol="icmp",port=-1)
except Exception, e:
raise Exception("Error when setting up group:"+str(group_name)+", Error:"+str(e))
#Get the remote file size from the http header of the url given
try:
url = url.replace('http://','')
host = url.split('/')[0]
path = url.replace(host,'')
pmsg("get_remote_file, host("+host+") path("+path+")")
conn=httplib.HTTPConnection(host)
conn.request("HEAD", path)
res=conn.getresponse()
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 MigrationTest(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.parser.add_argument('--imgurl',
help="BFEBS Image to splat down", default=None)
self.get_args()
self.tester = Eucaops( config_file=self.args.config, password=self.args.password)
self.numberOfNodes = self.tester.service_manager.get_all_node_controllers()
if len(self.numberOfNodes) < 2:
exit("Not enough NCs to test instance migration.")
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" )
self.keypair = self.tester.add_keypair( "keypair-" + str(time.time()))
self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name)
self.image = self.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.numberOfResources = 3
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
try:
self.tester.get_emi(root_device_type="ebs")
except:
bfebs = self.do_with_args(BFEBSBasics)
bfebs.RegisterImage()
def clean_method(self):
self.tester.cleanup_artifacts()
def MigrationBasic(self, volume=None):
enabled_clc = self.tester.service_manager.get_enabled_clc().machine
self.reservation = self.tester.run_instance(self.image, username=self.args.instance_user, keypair=self.keypair.name, group=self.group.name, zone=self.zone)
instance = self.reservation.instances[0]
assert isinstance(instance, EuInstance)
volume_device = None
if volume is not None:
volume_device = instance.attach_euvolume(volume)
self.tester.service_manager.populate_nodes()
source_nc = self.tester.service_manager.get_all_node_controllers(instance_id=instance.id)[0]
enabled_clc.sys( "source " + self.tester.credpath + "/eucarc &&" +
self.tester.eucapath + "/usr/sbin/euca-migrate-instances -i " + instance.id )
def wait_for_new_nc():
self.tester.service_manager.populate_nodes()
destination_nc = self.tester.service_manager.get_all_node_controllers(instance_id=instance.id)[0]
return source_nc.hostname == destination_nc.hostname
self.tester.wait_for_result(wait_for_new_nc, False, timeout=600, poll_wait=60)
self.assertTrue(self.tester.ping(instance.public_dns_name), 'Could not ping instance')
if volume_device:
instance.sys("ls " + volume_device, code=0)
destination_nc = self.tester.service_manager.get_all_node_controllers(instance_id=instance.id)[0]
if destination_nc.machine.distro.name is not "vmware":
destination_nc.machine.sys("virsh list | grep " + instance.id, code=0)
else:
destination_nc.machine.sys("esxcli vm process list | grep " + instance.id, code=0)
self.tester.terminate_instances(reservation=self.reservation)
if volume is not None:
self.tester.delete_volume(volume)
def MigrationInstanceStoreWithVol(self):
volume = self.tester.create_volume(zone=self.zone)
assert isinstance(volume, EuVolume)
self.MigrationBasic(volume)
def MigrationBasicEBSBacked(self, volume=None):
self.image = self.tester.get_emi(root_device_type="ebs")
self.MigrationBasic(volume)
def MigrationBasicEBSBackedWithVol(self):
volume = self.tester.create_volume(zone=self.zone)
assert isinstance(volume, EuVolume)
self.MigrationBasicEBSBacked(volume)
def MigrateToDest(self):
enabled_clc = self.tester.service_manager.get_enabled_clc().machine
self.reservation = self.tester.run_instance(self.image, username=self.args.instance_user, keypair=self.keypair.name, group=self.group.name, zone=self.zone)
instance = self.reservation.instances[0]
self.tester.service_manager.populate_nodes()
self.source_nc = self.tester.service_manager.get_all_node_controllers(instance_id=instance.id)[0]
all_nc = self.tester.service_manager.get_all_node_controllers()
self.destination_nc = None
for nc in all_nc:
if nc.machine.hostname != self.source_nc.machine.hostname:
self.destination_nc = nc
enabled_clc.sys("source " + self.tester.credpath + "/eucarc && " +
self.tester.eucapath + "/usr/sbin/euca-migrate-instances -i " +
instance.id + " --dest " + self.destination_nc.machine.hostname)
def wait_for_new_nc():
self.tester.service_manager.populate_nodes()
self.instance_node = self.tester.service_manager.get_all_node_controllers(instance_id=instance.id)[0]
return self.instance_node.hostname == self.destination_nc.hostname
self.tester.wait_for_result(wait_for_new_nc, True, timeout=600, poll_wait=60)
self.assertTrue( self.tester.ping(instance.public_dns_name), 'Could not ping instance')
# migrate the instance to it's original source node
self.destination_nc = self.source_nc
enabled_clc.sys("source " + self.tester.credpath + "/eucarc && " +
self.tester.eucapath + "/usr/sbin/euca-migrate-instances -i " +
instance.id + " --dest " + self.destination_nc.machine.hostname)
self.tester.wait_for_result(wait_for_new_nc, True, timeout=600, poll_wait=60)
self.assertTrue(self.tester.ping(instance.public_dns_name), 'Could not ping instance')
self.tester.terminate_instances(reservation=self.reservation)
def MigrationToDestEBSBacked(self):
self.image = self.tester.get_emi(root_device_type="ebs")
self.MigrateToDest()
def EvacuateNC(self, volume_list = []):
instance_list = []
enabled_clc = self.tester.service_manager.get_enabled_clc().machine
self.nodes = self.tester.service_manager.populate_nodes()
# pop out one NC to fill in
self.source_nc = self.nodes.pop()
def set_state(node, state):
# retrying, see EUCA-6389
while node.state != state:
self.tester.debug(node.hostname + ": SET STATE TO " + state)
enabled_clc.sys("euca-modify-service -s " + state + " " + node.hostname)
self.tester.sleep(10)
tmpnodes = self.tester.service_manager.populate_nodes()
for tmpnode in tmpnodes:
if tmpnode.hostname == node.hostname:
node = tmpnode
# stop all the NCs
for node in self.nodes:
set_state(node, "STOPPED")
self.image = self.tester.get_emi(root_device_type="instance-store")
self.reservation = self.tester.run_instance(self.image, min=3, max=3, username=self.args.instance_user, keypair=self.keypair.name, group=self.group.name, zone=self.zone)
for i in xrange(3):
instance = self.reservation.instances[i]
instance_list.append(instance)
assert isinstance(instance, EuInstance)
volume_device = None
if volume_list:
volume_device = instance.attach_euvolume(volume_list[i])
self.nodes = self.tester.service_manager.populate_nodes()
# start all the NCs
for node in self.nodes:
if node.hostname is not self.source_nc.hostname:
set_state(node, "ENABLED")
self.nodes = self.tester.service_manager.populate_nodes()
# evacuate source NC
enabled_clc.sys("source " + self.tester.credpath + "/eucarc && " +
self.tester.eucapath + "/usr/sbin/euca-migrate-instances --source " +
self.source_nc.machine.hostname)
def wait_for_evacuation():
self.tester.service_manager.populate_nodes()
if self.source_nc.machine.distro.name is "vmware":
emptyNC = self.source_nc.sys("esxcli vm process list | grep 'Display Name' | awk '{print $3}'")
else:
emptyNC = self.source_nc.get_virsh_list()
return len(emptyNC) == 0
self.tester.wait_for_result(wait_for_evacuation, True, timeout=600, poll_wait=60)
for inst in instance_list:
self.assertTrue(self.tester.ping(inst.public_dns_name), 'Could not ping instance')
self.tester.terminate_instances(reservation=self.reservation)
if volume_list:
self.tester.delete_volumes(volume_list)
def EvacuateNCWithVol(self):
volume_list = []
for i in xrange(self.numberOfResources):
volume = self.tester.create_volume(zone=self.zone)
assert isinstance(volume, EuVolume)
volume_list.append(volume)
self.EvacuateNC(volume_list)
def EvacuateNCAllEBS(self):
self.image = self.tester.get_emi(root_device_type="ebs")
self.EvacuateNC()
class StickinessBasics(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)
# test resource hash
self.test_hash = str(int(time.time()))
# Add and authorize a group for the instances
self.group = self.tester.add_group(group_name="group-" + self.test_hash)
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.tester.authorize_group_by_name(group_name=self.group.name, port=80, protocol="tcp")
# Generate a keypair for the instances
self.keypair = self.tester.add_keypair("keypair-" + self.test_hash)
self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name)
# User data file
self.user_data = "./testcases/cloud_user/elb/test_data/webserver_user_data.sh"
# Get an image
self.image = self.args.emi
if not self.image:
self.image = self.tester.get_emi()
# Populate available zones
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
# create base load balancer
self.load_balancer_port = 80
self.load_balancer = self.tester.create_load_balancer(zones=[self.zone],
name="elb-" + self.test_hash,
load_balancer_port=self.load_balancer_port)
assert isinstance(self.load_balancer, LoadBalancer)
# create autoscaling group of webservers that register to the load balancer
self.count = 2
(self.web_servers) = self.tester.create_as_webservers(name=self.test_hash,
keypair=self.keypair.name,
group=self.group.name,
zone=self.zone,
image=self.image.id,
count=self.count,
user_data=self.user_data,
load_balancer=self.load_balancer.name)
# web servers scaling group
self.asg = self.tester.describe_as_group(name="asg-"+self.test_hash)
# wait until scaling instances are InService with the load balancer before continuing - 5 min timeout
assert self.tester.wait_for_result(self.tester.wait_for_lb_instances, True, timeout=300,
lb=self.load_balancer.name, number=self.count)
def clean_method(self):
self.tester.cleanup_artifacts()
if self.tester.test_resources["security-groups"]:
for group in self.tester.test_resources["security-groups"]:
self.tester.wait_for_result(self.tester.gracefully_delete_group, True, timeout=60, group=group)
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)
return self.tester.generate_http_requests(url=lb_url, count=100, worker_threads=1)
def lb_cookie_session_affinity_test(self):
lbpolicy = "LB-Policy"
self.tester.create_lb_cookie_stickiness_policy(cookie_expiration_period=300,
lb_name=self.load_balancer.name,
policy_name=lbpolicy)
# test lb stickiness
self.tester.sleep(2)
self.debug("Testing LB cookie stickiness")
self.tester.set_lb_policy(lb_name=self.load_balancer.name, lb_port=80, policy_name=lbpolicy)
responses = self.GenerateRequests()
host = responses[0]
for response in responses:
if response != host:
raise Exception(
"Expected same response due to load balancer stickiness policy. Got initial response: " + host +
" subsequent response: " + response)
return
def app_cookie_session_affinity_test(self):
acpolicy = "AC-Policy"
self.tester.create_app_cookie_stickiness_policy(name="test-cookie",
lb_name=self.load_balancer.name,
policy_name=acpolicy)
# test app cookie stickiness
self.tester.set_lb_policy(lb_name=self.load_balancer.name, lb_port=80, policy_name=acpolicy)
self.debug("Testing App Cookie stickiness")
responses = self.GenerateRequests()
# since we use the same cookie name on the backing elb instances, the first contacts with the ELB can possibly
# result in hitting different back ends. After the first 2 calls they should all ony go to 1 backend.
host = responses[2]
for response in responses[2:]:
if response != host:
raise Exception(
"Expected same response due to app cookie stickiness policy. Got initial response: " + host +
" subsequent response: " + response)
return
class PopulateUpgrade(EutesterTestCase):
def __init__(self, extra_args=None):
self.setuptestcase()
self.setup_parser()
self.parser.add_argument("--region", default=None)
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 = 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
self.security_groups = []
### 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.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.address = None
self.volume = None
self.snapshot = None
self.private_addressing = False
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.reservation = None
def clean_method(self):
pass
def Instances(self, type="instance-store"):
"""
This case was developed to run through a series of basic instance tests.
The tests are as follows:
- execute run_instances command
- make sure that public DNS name and private IP aren't the same
(This is for Managed/Managed-NOVLAN networking modes)
- test to see if instance is ping-able
- test to make sure that instance is accessible via ssh
(ssh into instance and run basic ls command)
If any of these tests fail, the test case will error out, logging the results.
"""
test_image = self.tester.get_emi(root_device_type=type)
### 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")
self.security_groups.append(self.group)
# Test: INSTANCESTORE VOLATTACH:no ADDR:user
instance_1 = self.tester.run_instance(
test_image, keypair=self.keypair.name,
group=self.group.name).instances[0]
instance_1_address = self.tester.allocate_address()
self.tester.associate_address(instance=instance_1,
address=instance_1_address)
# Test: INSTANCESTORE VOLATTACH:no ADDR:system
instance_2 = self.tester.run_instance(
test_image, keypair=self.keypair.name,
group=self.group.name).instances[0]
# Test: INSTANCESTORE VOLATTACH:no ADDR:system
instance_3 = self.tester.run_instance(test_image,
group=self.group.name,
private_addressing=True,
is_reachable=False).instances[0]
# Test: INSTANCESTORE VOLATTACH:yes ADDR:user
instance_4 = self.tester.run_instance(
test_image, keypair=self.keypair.name,
group=self.group.name).instances[0]
instance_4_address = self.tester.allocate_address()
self.tester.associate_address(instance=instance_4,
address=instance_4_address)
volume = self.tester.create_volume(zone=self.zone)
instance_4.attach_volume(volume=volume)
# Test: INSTANCESTORE VOLATTACH:yes ADDR:system
instance_5 = self.tester.run_instance(
test_image, keypair=self.keypair.name,
group=self.group.name).instances[0]
volume = self.tester.create_volume(zone=self.zone)
instance_5.attach_volume(volume=volume)
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")
self.security_groups.append(self.group)
# Test: INSTANCESTORE VOLATTACH:yes ADDR:system
instance_6 = self.tester.run_instance(test_image,
group=self.group.name,
private_addressing=True,
is_reachable=False).instances[0]
def PopulateAll(self):
self.Instances("instance-store")
self.Instances("ebs")
class TaggingBasics(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 = EC2ops( credpath=self.args.credpath, region=self.args.region)
else:
self.tester = Eucaops(config_file=self.args.config, password=self.args.password, credpath=self.args.credpath)
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.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.address = None
self.volume = None
self.snapshot = None
self.private_addressing = False
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.reservation = None
def clean_method(self):
### Terminate the reservation if it is still up
if self.reservation:
self.assertTrue(self.tester.terminate_instances(self.reservation), "Unable to terminate instance(s)")
if self.volume:
self.tester.delete_volume(self.volume,timeout=600)
if self.snapshot:
self.tester.delete_snapshot(self.snapshot)
### DELETE group
self.tester.delete_group(self.group)
### Delete keypair in cloud and from filesystem
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
def InstanceTagging(self):
"""
This case was developed to exercise tagging of an instance resource
"""
if not self.reservation:
self.reservation = self.tester.run_instance(self.image, keypair=self.keypair.name, group=self.group.name)
test_instance = None
tags = { u'name': 'instance-tag-test', u'location' : 'over there'}
for instance in self.reservation.instances:
instance.create_tags(tags)
test_instance = instance
### Test Filtering , u'tag:location' : 'over there'
tag_filter = { u'tag:name': u'instance-tag-test'}
reservations = self.tester.ec2.get_all_instances(filters=tag_filter)
if len(reservations) != 1:
raise Exception('Filter for instances returned too many results')
reservation = reservations[0]
if self.reservation.id not in reservation.id:
raise Exception('Wrong instance id returned after filtering, Expected: ' + self.reservation.id + ' Received: ' + reservation.id )
### Test non-tag Filtering
### Filters can be found here, most will be tested manually, but a spot check should be added
### http://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ApiReference-cmd-DescribeInstances.html
new_group = self.tester.add_group("filter-test")
self.tester.authorize_group_by_name(group_name=new_group.name )
self.tester.authorize_group_by_name(group_name=new_group.name, port=-1, protocol="icmp" )
filter_test_reservation = self.tester.run_instance(self.image, keypair=self.keypair.name, group=new_group.name)
keypair_filter = {u'key-name': self.keypair.name}
group_filter = {u'group-name': new_group.name}
keypair_match = self.tester.ec2.get_all_instances(filters=keypair_filter)
group_match = self.tester.ec2.get_all_instances(filters=group_filter)
self.tester.terminate_instances(filter_test_reservation)
self.tester.delete_group(new_group)
self.tester.delete_keypair(self.keypair)
if len(group_match) != 1:
raise Exception("Non-tag Filtering of instances by group name: " + str(len(group_match)) + " expected: 1")
if len(keypair_match) != 2:
raise Exception("Non-tag Filtering of instances by keypair name: " + str(len(keypair_match)) + " expected: 2")
### Test Deletion
test_instance.delete_tags(tags)
instances = self.tester.ec2.get_all_instances(filters=tag_filter)
if len(instances) != 0:
raise Exception('Filter returned instances when there shouldnt be any')
if all(item in test_instance.tags.items() for item in tags.items()):
raise Exception('Tags still returned after deletion')
#self.test_restrictions(test_instance)
#self.test_in_series(test_instance)
self.tester.terminate_instances(self.reservation)
self.reservation = None
def VolumeTagging(self):
"""
This case was developed to exercise tagging of an instance resource
"""
self.volume = self.tester.create_volume(zone=self.zone)
tag_id = 'volume-tag-test-' + str(int(time.time()))
tags = { u'name': tag_id, u'location' : 'datacenter'}
self.volume.create_tags(tags)
### Test Filtering
tag_filter = { u'tag:name': tag_id}
volumes = self.tester.ec2.get_all_volumes(filters=tag_filter)
if len(volumes) is 0:
raise Exception('Filter for volumes returned no results:"{0}", filter:"{1}"'
.format(volumes, tag_filter))
if len(volumes) is not 1:
raise Exception('Filter for volumes returned too many results:"{0}", filter:"{1}"'
.format(volumes, tag_filter))
if volumes[0].id != self.volume.id:
raise Exception('Wrong volume ID returned after filtering:"{0}", filter:"{1}"'
.format(volumes, tag_filter))
### Test non-tag Filtering
### Filters can be found here, most will be tested manually, but a spot check should be added
### http://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ApiReference-cmd-DescribeImages.html
vol_size = 3
filter_test_volume_1 = self.tester.create_volume(zone=self.zone, size=vol_size)
filter_test_volume_2 = self.tester.create_volume(zone=self.zone, size=vol_size)
size_filter = {u'size': vol_size }
id_filter = {u'volume-id': self.volume.id}
size_match = self.tester.ec2.get_all_volumes(filters=size_filter)
id_match = self.tester.ec2.get_all_volumes(filters=id_filter)
self.tester.delete_volume(filter_test_volume_1)
self.tester.delete_volume(filter_test_volume_2)
for sz_vol in size_match:
if sz_vol.size != vol_size:
try:
self.debug('Size filter returned the following volumes:{0}'.format(size_match))
except:
pass
raise Exception('Filtering of volumes by size:"{0}" returned a volume of '
'wrong size. vol:{1}, size:{2}'
.format(vol_size, sz_vol, sz_vol.size ))
if len(id_match) != 1:
try:
self.debug('Id filter returned the following volumes:{0}'.format(id_match))
except:
pass
raise Exception("Filtering of volumes by id:'{0}' returned {1} volumes, expected 1"
.format(self.volume.id, len(id_match or [])))
### Test Deletion
self.volume.delete_tags(tags)
volumes = self.tester.ec2.get_all_volumes(filters=tag_filter)
if len(volumes) != 0:
raise Exception('Filter returned volumes when there shouldnt be any')
if self.volume.tags != {}:
raise Exception('Tags still returned after deleting them from volume')
#self.test_restrictions(self.volume)
#self.test_in_series(self.volume)
def SnapshotTagging(self):
"""
This case was developed to exercise tagging of an instance resource
"""
if not self.volume:
self.volume = self.tester.create_volume(zone=self.zone)
self.snapshot = self.tester.create_snapshot_from_volume(self.volume)
tags = { u'name': 'snapshot-tag-test', u'location' : 'over there'}
self.snapshot.create_tags(tags)
### Test Filtering , u'tag:location' : 'over there'
tag_filter = { u'tag:name': 'snapshot-tag-test'}
snapshots = self.tester.ec2.get_all_snapshots(filters=tag_filter)
if len(snapshots) != 1:
raise Exception('Filter for instances returned too many results')
if snapshots[0].id != self.snapshot.id:
raise Exception('Wrong instance id returned after filtering')
### Test non-tag Filtering
### Filters can be found here, most will be tested manually, but a spot check should be added
### http://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ApiReference-cmd-DescribeSnapshots.html
filter_description = "filtering" + str(int(time.time()))
filter_test_snapshot = self.tester.create_snapshot_from_volume(self.volume, description=filter_description)
description_filter = {u'description': filter_description }
volume_filter = {u'volume-id': self.volume.id}
description_match = self.tester.ec2.get_all_snapshots(filters=description_filter)
volume_match = self.tester.ec2.get_all_snapshots(filters=volume_filter)
self.tester.delete_snapshot(filter_test_snapshot)
if len(description_match) != 1:
raise Exception("Non-tag Filtering of snapshots by volume description: " + str(len(description_match)) + " expected: 1")
if len(volume_match) != 2:
raise Exception("Non-tag Filtering of snapshots by volume id returned: " + str(len(volume_match)) + " expected: 2")
### Test Deletion
self.snapshot.delete_tags(tags)
snapshots= self.tester.ec2.get_all_snapshots(filters=tag_filter)
if len(snapshots) != 0:
raise Exception('Filter returned snapshots when there shouldnt be any')
if self.snapshot.tags != {}:
raise Exception('Tags still returned after deleting them from volume')
#self.test_restrictions(self.snapshot)
#self.test_in_series(self.snapshot)
self.tester.delete_snapshot(self.snapshot)
self.snapshot = None
def ImageTagging(self):
"""
This case was developed to exercise tagging of an instance resource
"""
nametag = u'ImageTaggingName'
locationtag = u'ImageTaggingLocation'
tags = { nametag: 'image-tag-test', locationtag : 'over there'}
orig_image_tags = self.image.tags
self.tester.create_tags([self.image.id], tags)
### Test Tag Filtering , u'tag:location' : 'over there'
tag_filter = { u'tag:'+nametag: 'image-tag-test'}
images = self.tester.ec2.get_all_images(filters=tag_filter)
if len(images) != 1:
raise Exception('Filter for instances returned too many results')
if images[0].id != self.image.id:
raise Exception('Wrong instance id returned after filtering')
### Test non-tag Filtering
### Filters can be found here, most will be tested manually, but a spot check should be added
### http://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ApiReference-cmd-DescribeImages.html
image_description = "image-filtering"
filter_image_id = self.tester.register_image(
image_location=self.image.location,
description=image_description,
virtualization_type="hvm")
description_filter = {u'description': image_description }
location_filter = {u'manifest-location': self.image.location}
description_match = self.tester.ec2.get_all_images(filters=description_filter)
location_match = self.tester.ec2.get_all_images(filters=location_filter)
filter_image = self.tester.get_emi(emi=filter_image_id)
self.tester.deregister_image(filter_image)
if len(description_match) != 1:
raise Exception("Non-tag Filtering of volumes by size: " + str(len(description_match)) + " expected: 1")
if len(location_match) != 2:
raise Exception("Non-tag Filtering of volumes by zone: " + str(len(location_match)) + " expected: 2")
### Test Deletion
self.tester.delete_tags([self.image.id], tags)
images = self.tester.ec2.get_all_images(filters=tag_filter)
if len(images) != 0:
raise Exception('Filter returned images when there shouldnt be any')
for tag in tags:
if tag in self.image.tags:
raise Exception('Tags still returned after deleting them from image: ' + str(self.image.tags))
#self.test_restrictions(self.image)
#self.test_in_series(self.image)
def SecurityGroupTagging(self):
"""
This case was developed to exercise tagging of an security group resource
"""
tags = { u'name': 'security-tag-test', u'location' : 'over there'}
self.debug("Security group ID: " + self.group.id)
self.tester.create_tags([self.group.id], tags)
### Test Tag Filtering , u'tag:location' : 'over there'
tag_filter = { u'tag:name': 'security-tag-test'}
groups = self.tester.ec2.get_all_security_groups(filters=tag_filter)
if len(groups) != 1:
raise Exception('Filter for groups returned too many results')
if groups[0].id != self.group.id:
raise Exception('Wrong group id returned after filtering')
### Test non-tag Filtering
### Filters can be found here, most will be tested manually, but a spot check should be added
### http://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ApiReference-cmd-DescribeSecurityGroups.html
group_name = "filter-test"
group_description = "group-filtering"
filter_group = self.tester.add_group(group_name=group_name, description=group_description)
filter_group_2 = self.tester.add_group(group_name=group_name + "2", description=group_description)
description_filter = {u'description': group_description }
group_id_filter = {u'group-id': filter_group.id}
description_match = self.tester.ec2.get_all_security_groups(filters=description_filter)
self.debug("Groups matching description:" + str(description_match))
group_id_match = self.tester.ec2.get_all_security_groups(filters=group_id_filter)
self.debug("Groups matching owner-id (" + group_id_filter[u'group-id'] + "):" + str(group_id_match))
self.tester.delete_group(filter_group)
self.tester.delete_group(filter_group_2)
if len(description_match) != 2:
raise Exception("Non-tag Filtering of security groups by description: " + str(len(description_match)) + " expected: 2")
if len(group_id_match) != 1:
raise Exception("Non-tag Filtering of security groups by id: " + str(len(group_id_match)) + " expected: 1")
### Test Deletion
self.tester.delete_tags([self.group.id], tags)
groups = self.tester.ec2.get_all_security_groups(filters=tag_filter)
if len(groups) != 0:
raise Exception('Filter returned security groups when there shouldnt be any')
if self.group.tags != {}:
raise Exception('Tags still returned after deleting them from '
'security group:' + str(self.group.tags) )
#self.test_restrictions(self.group)
#self.test_in_series(self.group)
def test_restrictions(self, resource):
max_tags_number = 10
max_tags = {}
for i in xrange(max_tags_number):
max_tags[u'key' + str(i)] = 'value' + str(i)
self.test_tag_creation(max_tags, resource=resource, fail_message="Failure when trying to add max allowable tags (" + str(max_tags_number) + ")", expected_outcome=True)
self.test_tag_deletion(max_tags, resource=resource,fail_message="Failure when trying to delete max allowable tags (" + str(max_tags_number) + ")", expected_outcome=True)
too_many_tags = {}
for i in xrange(max_tags_number + 1):
too_many_tags[u'key' + str(i)] = 'value' + str(i)
self.test_tag_creation(too_many_tags, resource=resource,fail_message="Allowed too many tags to be created", expected_outcome=False)
max_key = u'0' * 127
maximum_key_length = { max_key : 'my value'}
self.test_tag_creation(maximum_key_length, resource=resource, fail_message="Unable to use a key with " + str(max_key) + " characters", expected_outcome=True)
self.test_tag_deletion(maximum_key_length, resource=resource, fail_message="Unable to delete a key with " + str(max_key) + " characters", expected_outcome=True)
key_too_large = { max_key + u'0' : 'my value'}
self.test_tag_creation(key_too_large, resource=resource, fail_message="Allowed key with more than " + str(max_key) + " chars", expected_outcome=False)
maximum_value = '0' * 255
maximum_value_length = { u'my_key': maximum_value}
self.test_tag_creation(maximum_value_length, resource=resource, fail_message="Unable to use a value with " + str(maximum_value) + " characters", expected_outcome=True)
self.test_tag_deletion(maximum_value_length, resource=resource, fail_message="Unable to delete a value with " + str(maximum_value) + " characters", expected_outcome=True)
value_too_large = { u'my_key': maximum_value + '0'}
self.test_tag_creation(value_too_large, resource=resource, fail_message="Allowed value with more than " + str(maximum_value) + " chars", expected_outcome=False)
aws_key_prefix = { u'aws:something': 'asdfadsf'}
self.test_tag_creation(aws_key_prefix, resource=resource, fail_message="Allowed key with 'aws:' prefix'", expected_outcome=False)
aws_value_prefix = { u'my_key': 'aws:somethingelse'}
self.test_tag_creation(aws_value_prefix, resource=resource, fail_message="Did not allow creation value with 'aws:' prefix'", expected_outcome=True)
self.test_tag_creation(aws_value_prefix, resource=resource, fail_message="Did not allow deletion of value with 'aws:' prefix'", expected_outcome=True)
lower_case = {u'case': 'value'}
upper_case = {u'CASE': 'value'}
self.test_tag_creation(lower_case, resource=resource, fail_message="Unable to add key with all lower case", expected_outcome=True)
self.test_tag_creation(upper_case, resource=resource, fail_message="Case sensitivity not enforced, unable to create tag with different capitalization", expected_outcome=True)
self.test_tag_deletion(lower_case, resource=resource, fail_message="Unable to delete a tag, when testing case sensitivity", expected_outcome=True)
self.test_tag_deletion(upper_case, resource=resource, fail_message="Unable to delete a tag, when testing case sensitivity", expected_outcome=True)
def test_tag_creation(self, tags, resource, fail_message, expected_outcome=True, timeout=600):
actual_outcome = None
exception = None
try:
resource.create_tags(tags, timeout=timeout)
actual_outcome = True
except Exception, e:
exception = e
actual_outcome = False
finally:
class NCAdmin(EutesterTestCase, InstanceBasics):
def __init__(self, config_file="cloud.conf", password="******"):
self.tester = Eucaops( config_file=config_file, password=password)
self.servman = self.tester.service_manager
self.nc_list = self.tester.get_component_machines("nc")
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")
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.reservation = None
self.conf_file = '%s/etc/eucalyptus/eucalyptus.conf' % self.tester.eucapath
self.nc_restart_time = 30
def restart_nc(self):
## Use reboot testcase to ensure we are able to attach volumes and run instances
testcase = self.create_testcase_from_method(self.Reboot)
## run at least as many instances as there are NCs
for i in xrange(len(self.nc_list)):
testcase.run()
for nc in self.nc_list:
nc.sys('service eucalyptus-nc restart')
## Wait for ncs to come back up
self.tester.sleep(self.nc_restart_time)
## rerun testcase
for i in xrange(len(self.nc_list)):
testcase.run()
def replace_conf_property(self, nc, property, replacement):
self.default_conf_property(nc, property)
nc.sys('echo "' + property + '=' + replacement + '" >> ' + self.conf_file)
def default_conf_property(self,nc, property):
nc.sys('sed -i \'s/^' + property + '/#' + property +'/g\' ' + self.conf_file)
def disable_caching(self):
## Use basic instance testcase testcase to ensure we are able to attach volumes and run instances
testcase = self.create_testcase_from_method(self.BasicInstanceChecks)
property = 'NC_CACHE_SIZE'
## run at least as many instances as there are NCs
for i in xrange(len(self.nc_list)):
testcase.run()
for nc in self.nc_list:
self.replace_conf_property(nc, property, "0")
command_list = ['service eucalyptus-nc stop',
'rm -rf {0}/var/lib/eucalyptus/instances/cache/*'.format(self.tester.eucapath),
'service eucalyptus-nc start']
for command in command_list:
nc.sys(command)
## Wait for ncs to come back up
self.tester.sleep(self.nc_restart_time)
testcase = self.create_testcase_from_method(self.Churn)
## rerun testcase
testcase.run()
for nc in self.nc_list:
self.default_conf_property(nc, property)
def cleanup(self):
self.tester.cleanup_artifacts()
def run_suite(self):
self.testlist = []
testlist = self.testlist
#testlist.append(self.create_testcase_from_method(self.restart_nc))
testlist.append(self.create_testcase_from_method(self.disable_caching))
self.run_test_case_list(testlist)
self.cleanup()
class AutoScalingBasics(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 = Eucaops(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)
### 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.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store", not_location="loadbalancer")
self.address = None
self.asg = None
def clean_method(self):
if self.asg:
self.tester.wait_for_result(self.gracefully_delete, True)
self.tester.delete_as_group(self.asg.name, force=True)
self.tester.cleanup_artifacts()
def AutoScalingBasics(self):
### create launch configuration
self.launch_config_name = 'Test-Launch-Config-' + str(time.time())
self.tester.create_launch_config(name=self.launch_config_name,
image_id=self.image.id,
instance_type="m1.small",
key_name=self.keypair.name,
security_groups=[self.group.name])
### create auto scale group
self.auto_scaling_group_name = 'ASG-' + str(time.time())
self.asg = self.tester.create_as_group(group_name=self.auto_scaling_group_name,
availability_zones=self.tester.get_zones(),
launch_config=self.launch_config_name,
min_size=0,
max_size=5)
### Test Create and describe Auto Scaling Policy
self.up_policy_name = "Up-Policy-" + str(time.time())
self.up_size = 4
self.tester.create_as_policy(name=self.up_policy_name,
adjustment_type="ChangeInCapacity",
scaling_adjustment=4,
as_name=self.auto_scaling_group_name,
cooldown=120)
if len(self.tester.autoscale.get_all_policies(policy_names=[self.up_policy_name])) != 1:
raise Exception('Auto Scaling policies: ' + self.up_policy_name +' not created')
self.down_policy_name = "Down-Policy-" + str(time.time())
self.down_size = -50
self.tester.create_as_policy(name=self.down_policy_name,
adjustment_type="PercentChangeInCapacity",
scaling_adjustment=self.down_size,
as_name=self.auto_scaling_group_name,
cooldown=120)
if len(self.tester.autoscale.get_all_policies(policy_names=[self.down_policy_name])) != 1:
raise Exception('Auto Scaling policies: ' + self.down_policy_name +' not created')
self.exact_policy_name = "Exact-Policy-" + str(time.time())
self.exact_size = 0
self.tester.create_as_policy(name=self.exact_policy_name,
adjustment_type="ExactCapacity",
scaling_adjustment=self.exact_size,
as_name=self.auto_scaling_group_name,
cooldown=120)
if len(self.tester.autoscale.get_all_policies(policy_names=[self.exact_policy_name])) != 1:
raise Exception('Auto Scaling policies: ' + self.exact_policy_name +' not created')
self.debug("**** Created Auto Scaling Policies: " + self.up_policy_name + " " + self.down_policy_name + " " +
self.exact_policy_name)
self.tester.wait_for_result(self.scaling_activities_complete, True, timeout=180)
### Test Execute ChangeInCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.up_policy_name,
as_group=self.auto_scaling_group_name,
honor_cooldown=False)
if self.tester.describe_as_group(self.auto_scaling_group_name).desired_capacity != self.up_size:
raise Exception("Auto Scale Up not executed")
self.debug("Executed ChangeInCapacity policy, increased desired capacity to: " +
str(self.tester.describe_as_group(self.auto_scaling_group_name).desired_capacity))
self.tester.wait_for_result(self.scaling_activities_complete, True, timeout=180)
### Test Execute PercentChangeInCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.down_policy_name,
as_group=self.auto_scaling_group_name,
honor_cooldown=False)
if self.tester.describe_as_group(self.auto_scaling_group_name).desired_capacity != 0.5 * self.up_size:
raise Exception("Auto Scale down percentage not executed")
self.debug("Executed PercentChangeInCapacity policy, decreased desired capacity to: " +
str(self.tester.describe_as_group(self.auto_scaling_group_name).desired_capacity))
self.tester.wait_for_result(self.scaling_activities_complete, True, timeout=180)
### Test Execute ExactCapacity Auto Scaling Policy
self.tester.execute_as_policy(policy_name=self.exact_policy_name,
as_group=self.auto_scaling_group_name,
honor_cooldown=False)
if self.tester.describe_as_group(self.auto_scaling_group_name).desired_capacity != self.exact_size:
raise Exception("Auto Scale down percentage not executed")
self.debug("Executed ExactCapacity policy, exact capacity is: " +
str(self.tester.describe_as_group(self.auto_scaling_group_name).desired_capacity))
self.tester.wait_for_result(self.scaling_activities_complete, True, timeout=180)
### Test Delete all Auto Scaling Policies
self.tester.delete_all_policies()
### Test Delete Auto Scaling Group
self.tester.wait_for_result(self.gracefully_delete, True)
self.asg = None
### Test delete launch config
self.tester.delete_launch_config(self.launch_config_name)
def scaling_activities_complete(self):
activities = self.asg.get_activities()
for activity in activities:
assert isinstance(activity,Activity)
if activity.progress != 100:
return False
return True
def AutoScalingInstanceBasics(self):
"""
This case will test DescribeAutoScalingInstances, SetInstanceHealth and TerminateInstanceInAutoScalingGroup
"""
pass
def too_many_launch_configs_test(self):
"""
AWS enforces a 100 LC per account limit this tests what happens if we create more
"""
for i in range(101):
self.launch_config_name = 'Test-Launch-Config-' + str(i + 1)
self.tester.create_launch_config(name=self.launch_config_name,
image_id=self.image.id)
if len(self.tester.describe_launch_config()) > 100:
raise Exception("More then 100 launch configs exist in 1 account")
for lc in self.tester.describe_launch_config():
self.tester.delete_launch_config(lc.name)
def too_many_policies_test(self):
"""
AWS enforces a 25 policy per account limit this tests what happens if we create more
"""
launch_config_name = 'LC-' + str(time.time())
self.tester.create_launch_config(name=launch_config_name,
image_id=self.image.id,
instance_type="m1.small",
key_name=self.keypair.name,
security_groups=[self.group.name])
asg_name = 'ASG-' + str(time.time())
self.asg = self.tester.create_as_group(group_name=asg_name,
launch_config=launch_config_name,
availability_zones=self.tester.get_zones(),
min_size=0,
max_size=5)
for i in range(26):
policy_name = "Policy-" + str(i + 1)
self.tester.create_as_policy(name=policy_name,
adjustment_type="ExactCapacity",
as_name=asg_name,
scaling_adjustment=0,
cooldown=120)
if len(self.tester.autoscale.get_all_policies()) > 25:
raise Exception("More than 25 policies exist for 1 auto scaling group")
self.tester.wait_for_result(self.gracefully_delete, True)
self.asg = None
def too_many_as_groups(self):
"""
AWS imposes a 20 ASG/acct limit
"""
pass
def clear_all(self):
"""
remove ALL scaling policies, auto scaling groups and launch configs
"""
self.tester.delete_all_policies()
self.tester.delete_all_autoscaling_groups()
self.tester.delete_all_launch_configs()
def change_config(self):
### create initial launch configuration
first_launch_config = 'First-Launch-Config-' + str(time.time())
self.tester.create_launch_config(name=first_launch_config, image_id=self.image.id, instance_type="m1.small")
# create a replacement LC with different instance type
second_launch_config = 'Second-Launch-Config-' + str(time.time())
self.tester.create_launch_config(name=second_launch_config, image_id=self.image.id, instance_type="m1.large")
### create auto scale group
auto_scaling_group_name = 'ASG-' + str(time.time())
self.asg = self.tester.create_as_group(group_name=auto_scaling_group_name,
launch_config=first_launch_config,
availability_zones=self.tester.get_zones(),
min_size=1,
max_size=4,
desired_capacity=1)
assert isinstance(self.asg, AutoScalingGroup)
self.tester.update_as_group(group_name=self.asg.name,
launch_config=second_launch_config,
availability_zones=self.tester.get_zones(),
min_size=1,
max_size=4)
def wait_for_instances(number=1):
self.asg = self.tester.describe_as_group(self.asg.name)
instances = self.asg.instances
if not instances:
self.tester.debug("No instances in ASG")
return False
if len(self.asg.instances) != number:
self.tester.debug("Instances not yet allocated")
return False
for instance in instances:
assert isinstance(instance, Instance)
instance = self.tester.get_instances(idstring=instance.instance_id)[0]
if instance.state != "running":
self.tester.debug("Instance: " + str(instance) + " still in " + instance.state + " state")
return False
else:
self.tester.debug("Instance: " + str(instance) + " now running")
return True
self.tester.wait_for_result(wait_for_instances, True ,timeout=360)
### Set desired capacity
new_desired = 2
self.asg.set_capacity(new_desired)
self.tester.wait_for_result(wait_for_instances, True, number=new_desired, timeout=360)
#wait briefly before changing capacity
# TODO get new instance ID and get it's type verify correct type
### Delete Auto Scaling Group
last_instance = self.tester.get_instances(idstring=self.tester.get_last_instance_id())[0]
assert last_instance.instance_type == "m1.large"
self.tester.wait_for_result(self.gracefully_delete, True)
self.asg = None
### delete launch configs
self.tester.delete_launch_config(first_launch_config)
self.tester.delete_launch_config(second_launch_config)
def gracefully_delete(self, asg = None):
if not asg:
asg = self.asg
assert isinstance(asg, AutoScalingGroup)
try:
self.tester.delete_as_group(name=asg.name, force=True)
except BotoServerError, e:
if e.status == 400 and e.reason == "ScalingActivityInProgress":
return False
return True
class ClusterBasics(unittest.TestCase):
def setUp(self):
if options.config_file:
self.tester = Eucaops(config_file=options.config_file, password=options.clc_password)
else:
print "\tNeed to pass --config_file option. Try --help for more information\n"
exit(1)
## If specific image wants to be tested, use that; if not, use any instance-store backed image.
if options.image:
self.image = self.tester.get_emi(emi=options.image)
else:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.keypair = self.tester.add_keypair(options.prefix + "-" + str(time.time()))
self.keypath = os.curdir + "/" + self.keypair.name + ".pem"
### Identify type of instance to run
if options.type == "random":
options.type = random.choice(["m1.small", "c1.medium", "m1.large", "m1.xlarge", "c1.xlarge"])
### Identify number of instances to run (i.e. number of security groups)
self.num_vms = self.tester.get_available_vms(options.type)
if self.num_vms >= options.number:
self.available = options.number
else:
options.type = "m1.small"
avail_vms = self.tester.get_available_vms(options.type)
if avail_vms < options.number:
self.tester.fail("Not enough m1.small vm types to run test with minimal of 3 security groups.")
else:
self.available = options.number
if options.print_debug:
self.tester.start_euca_logs()
self.security_groups = []
self.reservations = []
def tearDown(self):
### Clean up after running test case
for reservation in self.reservations:
self.tester.terminate_instances(reservation)
for security_group in security_groups:
self.tester.delete_group(security_group.name)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
self.keypath = None
self.keypair = None
self.image = None
self.num_vms = None
self.available = None
self.security_groups = None
if options.print_debug:
self.tester.stop_euca_logs()
self.tester.save_euca_logs()
self.tester = None
### Test Cases ###
def iptables_Cruft(self):
### Launch number of instances based upon number of security groups wanting to be tested.
### Take snapshot of iptables before creating security groups and launching instances.
### Use service manager to get to enabled CC to get iptables rules
partition = self.tester.service_manager.partitions.keys()
part = list(partition)[0]
main_part = self.tester.service_manager.partitions.get(part)
cc_machine = main_part.get_enabled_cc()
cc_shell = self.tester.create_ssh(hostname=cc_machine.hostname, password=options.cc_password)
pre_stdin, pre_iptables, pre_stderr = cc_shell.exec_command(
'iptables-save | grep -v "#" | grep -v "\:PRE" | grep -v "\:POST" | grep -v "\:INPUT" | grep -v "\:FORWARD" | grep -v "\:OUT"'
)
self.pre_iptables = list(pre_iptables)
self.assertTrue(pre_stderr, "pre_Iptables_Snapshot failed.")
### Create security group for number of security groups we want to test.
while self.available > 0:
### Create unique security group and authorize SSH and PING
sec_group = self.tester.add_group(group_name=options.prefix + "-" + str(time.time()))
self.assertNotEqual(len(sec_group.name), 0, "Could not create group.")
self.assertTrue(
self.tester.authorize_group_by_name(group_name=sec_group.name), "Could not authorize group for SSH"
)
self.assertTrue(
self.tester.authorize_group_by_name(group_name=sec_group.name, port=-1, protocol="icmp"),
"Could not authorize group for PING",
)
self.security_groups.append(sec_group)
### Launch instance for the unique security group
try:
reservation = self.tester.run_instance(
self.image, keypair=self.keypair.name, group=sec_group.name, type=options.type
)
except Exception, e:
self.fail("Caught an exception when running the instance: " + str(e))
self.reservations.append(reservation)
### Decrement count of security groups and instances left to create
self.available -= 1
### Loop through and terminate instances
### Grab total number of instances ran from by test case
### Terminate each instance
for reservation in self.reservations:
self.assertTrue(self.tester.terminate_instances(reservation), "Failure when terminating instance.")
### Loop through and delete security groups
for group in self.security_groups:
self.assertTrue(self.tester.delete_group(group), "Failure when deleting group " + group.name)
### Take snapshot of iptables after deleting security groups and terminating instances.
### Use service manager to get to enabled CC to get iptables rules
partition = self.tester.service_manager.partitions.keys()
part = list(partition)[0]
main_part = self.tester.service_manager.partitions.get(part)
cc_machine = main_part.get_enabled_cc()
cc_shell = self.tester.create_ssh(hostname=cc_machine.hostname, password=options.cc_password)
post_stdin, post_iptables, post_stderr = cc_shell.exec_command(
'iptables-save | grep -v "#" | grep -v "\:PRE" | grep -v "\:POST" | grep -v "\:INPUT" | grep -v "\:FORWARD" | grep -v "\:OUT"'
)
self.post_iptables = list(post_iptables)
self.assertTrue(post_stderr, "post_Iptables_Snapshot failed.")
### Evaluate pre and post iptables outputs to see if there is a difference.
if len(self.pre_iptables) != len(self.post_iptables):
## Get different lines and print them
iptables_diff = set(self.post_iptables) - set(self.pre_iptables)
pp = pprint.PrettyPrinter(indent=4)
self.tester.critical("\n======================================\n")
self.tester.critical("Diffences between iptables snapshots: ")
self.tester.critical("PRE-IPTABLES SNAPSHOT LENGTH: %i", len(self.pre_iptables))
self.tester.critical("POST-IPTABLES SNAPSHOT LENGTH: %i", len(self.post_iptables))
self.tester.critical("\n---------------------------------------\n")
pp.pprint(list(iptables_diff))
self.tester.critical("\n======================================\n")
class HAtests(InstanceBasics, BucketTestSuite):
def __init__(self):
self.setuptestcase()
self.setup_parser()
self.get_args()
if not boto.config.has_section('Boto'):
boto.config.add_section('Boto')
boto.config.set('Boto', 'num_retries', '1')
boto.config.set('Boto', 'http_socket_timeout', '20')
self.tester = Eucaops(config_file=self.args.config_file,
password=self.args.password)
self.tester.ec2.connection.timeout = 30
self.servman = self.tester.service_manager
self.instance_timeout = 120
### Add and authorize a group for the instance
self.start_time = str(int(time.time()))
try:
self.group = self.tester.add_group(group_name="group-" +
self.start_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-" +
self.start_time)
self.keypath = os.curdir + "/" + self.keypair.name + ".pem"
if self.args.emi:
self.image = self.tester.get_emi(self.args.emi)
else:
self.image = self.tester.get_emi(
root_device_type="instance-store")
self.reservation = None
self.private_addressing = False
self.bucket_prefix = "buckettestsuite-" + self.start_time + "-"
self.test_user_id = self.tester.s3.get_canonical_user_id()
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.tester.clc = self.tester.service_manager.get_enabled_clc(
).machine
self.version = self.tester.clc.sys(
"cat " + self.tester.eucapath +
"/etc/eucalyptus/eucalyptus-version")[0]
### Create standing resources that will be checked after all failures
### Instance, volume, buckets
###
self.standing_reservation = self.tester.run_instance(
image=self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=self.zone)
self.volume = self.tester.create_volume(self.zone)
self.device = self.standing_reservation.instances[0].attach_volume(
self.volume)
for instance in self.standing_reservation.instances:
instance.sys("echo " + instance.id + " > " + self.device)
self.standing_bucket_name = "failover-bucket-" + self.start_time
self.standing_bucket = self.tester.create_bucket(
self.standing_bucket_name)
self.standing_key_name = "failover-key-" + self.start_time
self.standing_key = self.tester.upload_object(
self.standing_bucket_name, self.standing_key_name)
self.standing_key = self.tester.get_objects_by_prefix(
self.standing_bucket_name, self.standing_key_name)
self.run_instance_params = {
'image': self.image,
'keypair': self.keypair.name,
'group': self.group.name,
'zone': self.zone,
'timeout': self.instance_timeout
}
except Exception, e:
self.clean_method()
raise Exception("Init for testcase failed. Reason: " + str(e))
class MigrationTest(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.parser.add_argument('--imgurl',
help="BFEBS Image to splat down",
default=None)
self.get_args()
self.tester = Eucaops(config_file=self.args.config,
password=self.args.password)
self.clusters = self.tester.service_manager.get_all_cluster_controllers(
)
for cluster in self.clusters:
self.nodes = self.tester.service_manager.get_all_node_controllers(
part_name=cluster.partition)
if len(self.nodes) < 2:
self.tester.debug("Not enough NCs in partition '" +
cluster.partition +
"' to test instance migration.")
exit(0)
# TODO
if len(self.clusters) > 1:
self.tester.debug(
"TBD: handle multiple clusters during instance migration tests"
)
exit(0)
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")
self.keypair = self.tester.add_keypair("keypair-" + str(time.time()))
self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name)
self.image = self.args.emi
if not self.image:
self.image = self.tester.get_emi(root_device_type="instance-store")
self.numberOfResources = 3
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
try:
self.tester.get_emi(root_device_type="ebs")
except:
bfebs = self.do_with_args(BFEBSBasics)
bfebs.RegisterImage()
def clean_method(self):
self.tester.cleanup_artifacts()
def MigrationBasic(self, volume=None):
enabled_clc = self.tester.service_manager.get_enabled_clc().machine
self.reservation = self.tester.run_instance(
self.image,
username=self.args.instance_user,
keypair=self.keypair.name,
group=self.group.name,
zone=self.zone)
instance = self.reservation.instances[0]
assert isinstance(instance, EuInstance)
volume_device = None
if volume is not None:
volume_device = instance.attach_euvolume(volume)
self.tester.service_manager.populate_nodes()
source_nc = self.tester.service_manager.get_all_node_controllers(
instance_id=instance.id)[0]
enabled_clc.sys("source " + self.tester.credpath + "/eucarc &&" +
" euserv-migrate-instances -i " + instance.id,
code=0)
def wait_for_new_nc():
self.tester.service_manager.populate_nodes()
destination_nc = self.tester.service_manager.get_all_node_controllers(
instance_id=instance.id)[0]
return source_nc.hostname == destination_nc.hostname
self.tester.wait_for_result(wait_for_new_nc,
False,
timeout=600,
poll_wait=60)
self.assertTrue(self.tester.ping(instance.public_dns_name),
'Could not ping instance')
if volume_device:
instance.sys("ls " + volume_device, code=0)
destination_nc = self.tester.service_manager.get_all_node_controllers(
instance_id=instance.id)[0]
if destination_nc.machine.distro.name is not "vmware":
destination_nc.machine.sys("virsh list | grep " + instance.id,
code=0)
else:
destination_nc.machine.sys("esxcli vm process list | grep " +
instance.id,
code=0)
self.tester.terminate_instances(reservation=self.reservation)
if volume is not None:
self.tester.delete_volume(volume)
def MigrationInstanceStoreWithVol(self):
volume = self.tester.create_volume(zone=self.zone)
assert isinstance(volume, EuVolume)
self.MigrationBasic(volume)
def MigrationBasicEBSBacked(self, volume=None):
self.image = self.tester.get_emi(root_device_type="ebs")
self.MigrationBasic(volume)
def MigrationBasicEBSBackedWithVol(self):
volume = self.tester.create_volume(zone=self.zone)
assert isinstance(volume, EuVolume)
self.MigrationBasicEBSBacked(volume)
def MigrateToDest(self):
enabled_clc = self.tester.service_manager.get_enabled_clc().machine
self.reservation = self.tester.run_instance(
self.image,
username=self.args.instance_user,
keypair=self.keypair.name,
group=self.group.name,
zone=self.zone)
instance = self.reservation.instances[0]
self.tester.service_manager.populate_nodes()
self.source_nc = self.tester.service_manager.get_all_node_controllers(
instance_id=instance.id)[0]
all_nc = self.tester.service_manager.get_all_node_controllers()
self.destination_nc = None
for nc in all_nc:
if nc.machine.hostname != self.source_nc.machine.hostname:
self.destination_nc = nc
enabled_clc.sys(
"source " + self.tester.credpath + "/eucarc && " +
" euserv-migrate-instances -i " + instance.id +
" --include-dest " + self.destination_nc.machine.hostname,
code=0)
def wait_for_new_nc():
self.tester.service_manager.populate_nodes()
self.instance_node = self.tester.service_manager.get_all_node_controllers(
instance_id=instance.id)[0]
return self.instance_node.hostname == self.destination_nc.hostname
self.tester.wait_for_result(wait_for_new_nc,
True,
timeout=600,
poll_wait=60)
self.assertTrue(self.tester.ping(instance.public_dns_name),
'Could not ping instance')
# migrate the instance to it's original source node
self.destination_nc = self.source_nc
enabled_clc.sys("source " + self.tester.credpath + "/eucarc && " +
" euserv-migrate-instances -i " + instance.id +
" --include-dest " +
self.destination_nc.machine.hostname,
code=0)
self.tester.wait_for_result(wait_for_new_nc,
True,
timeout=600,
poll_wait=60)
self.assertTrue(self.tester.ping(instance.public_dns_name),
'Could not ping instance')
self.tester.terminate_instances(reservation=self.reservation)
def MigrationToDestEBSBacked(self):
self.image = self.tester.get_emi(root_device_type="ebs")
self.MigrateToDest()
def EvacuateNC(self, volume_list=[]):
instance_list = []
enabled_clc = self.tester.service_manager.get_enabled_clc().machine
self.nodes = self.tester.service_manager.populate_nodes()
# pop out one NC to fill in
self.source_nc = self.nodes.pop()
def set_state(node, state):
# retrying, see EUCA-6389
while node.state != state:
self.tester.debug(node.hostname + ": SET STATE TO " + state)
enabled_clc.sys("euca-modify-service -s " + state + " " +
node.hostname,
code=0)
self.tester.sleep(10)
tmpnodes = self.tester.service_manager.populate_nodes()
for tmpnode in tmpnodes:
if tmpnode.hostname == node.hostname:
node = tmpnode
# stop all the NCs
for node in self.nodes:
set_state(node, "STOPPED")
self.image = self.tester.get_emi(root_device_type="instance-store")
self.reservation = self.tester.run_instance(
self.image,
min=3,
max=3,
username=self.args.instance_user,
keypair=self.keypair.name,
group=self.group.name,
zone=self.zone)
for i in xrange(3):
instance = self.reservation.instances[i]
instance_list.append(instance)
assert isinstance(instance, EuInstance)
volume_device = None
if volume_list:
volume_device = instance.attach_euvolume(volume_list[i])
self.nodes = self.tester.service_manager.populate_nodes()
# start all the NCs
for node in self.nodes:
if node.hostname is not self.source_nc.hostname:
set_state(node, "ENABLED")
self.nodes = self.tester.service_manager.populate_nodes()
# evacuate source NC
enabled_clc.sys("source " + self.tester.credpath + "/eucarc && " +
" euserv-migrate-instances -s " +
self.source_nc.machine.hostname,
code=0)
def wait_for_evacuation():
self.tester.service_manager.populate_nodes()
if self.source_nc.machine.distro.name is "vmware":
emptyNC = self.source_nc.sys(
"esxcli vm process list | grep 'Display Name' | awk '{print $3}'"
)
else:
emptyNC = self.source_nc.get_virsh_list()
return len(emptyNC) == 0
self.tester.wait_for_result(wait_for_evacuation,
True,
timeout=600,
poll_wait=60)
for inst in instance_list:
self.assertTrue(self.tester.ping(inst.public_dns_name),
'Could not ping instance')
self.tester.terminate_instances(reservation=self.reservation)
if volume_list:
self.tester.delete_volumes(volume_list)
def EvacuateNCWithVol(self):
volume_list = []
for i in xrange(self.numberOfResources):
volume = self.tester.create_volume(zone=self.zone)
assert isinstance(volume, EuVolume)
volume_list.append(volume)
self.EvacuateNC(volume_list)
def EvacuateNCAllEBS(self):
self.image = self.tester.get_emi(root_device_type="ebs")
self.EvacuateNC()
#Number of ping attempts used to test instance state, before giving up on a running instance
ping_retry = 100
#The eutester cloud tester object
tester = Eucaops(password=password, config_file=config, credpath=credpath)
#sets tester to throw exception upon failure
if (options.eof):
tester.exit_on_fail = 1
else:
tester.exit_on_fail = 0
try:
### Create security group if it does not exist. Add ssh authorization to it.
try:
group = tester.add_group(group_name)
tester.authorize_group_by_name(group.name)
tester.authorize_group_by_name(group.name,
protocol="icmp",
port=-1)
except Exception, e:
raise Exception("Error when setting up group:" + str(group_name) +
", Error:" + str(e))
#Get the remote file size from the http header of the url given
try:
url = url.replace('http://', '')
host = url.split('/')[0]
path = url.replace(host, '')
pmsg("get_remote_file, host(" + host + ") path(" + path + ")")
conn = httplib.HTTPConnection(host)
conn.request("HEAD", path)
class InstanceRestore(EutesterTestCase):
def __init__(self, config_file=None, password=None):
self.setuptestcase()
# Setup basic eutester object
self.tester = Eucaops( config_file=config_file, password=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")
if self.reservation:
self.assertTrue(self.tester.terminate_instances(self.reservation), "Unable to terminate instance(s)")
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
### RESET vmstate properties
self.modify_property("cloud.vmstate.instance_timeout","60")
self.modify_property("cloud.vmstate.terminated_time","60")
for nc in self.ncs:
nc.sys("service eucalyptus-nc start")
def restore_logic(self):
self.modify_property("cloud.vmstate.instance_timeout","1")
self.modify_property("cloud.vmstate.terminated_time","1")
self.reservation = self.tester.run_instance(self.image, keypair=self.keypair.name, group=self.group.name, zone=self.zone)
for nc in self.ncs:
nc.sys("service eucalyptus-nc stop")
### Wait for instance to show up as terminating
self.tester.wait_for_reservation(self.reservation, state="terminated", timeout=600)
### Wait for reservation to disappear
while len(self.tester.get_instances(reservation=self.reservation)) > 0:
self.tester.sleep(30)
self.tester.deregister_image(self.image, clear=True)
for nc in self.ncs:
nc.sys("service eucalyptus-nc start")
self.tester.wait_for_reservation(self.reservation, state="running", timeout=600)
for instance in self.reservation.instances:
instance.sys("uname -r", code=0)
def modify_property(self, property, value):
"""
Modify a eucalyptus property through the command line euca-modify-property tool
property Property to modify
value Value to set it too
"""
command = "source " + self.tester.credpath + "/eucarc && " + self.tester.eucapath + "/usr/sbin/euca-modify-property -p " + str(property) + "=" + str(value)
if self.clc.found(command, property):
self.debug("Properly modified property " + property)
else:
raise Exception("Setting property " + property + " failed")
class InstanceBasics(EutesterTestCase):
def __init__(self):
#### Pre-conditions
self.setuptestcase()
self.setup_parser()
self.get_args()
# Setup basic eutester object
self.tester = Eucaops(credpath=self.args.credpath)
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")
self.reservation = None
def clean_method(self):
### Terminate the reservation if it is still up
if self.reservation:
self.assertTrue(self.tester.terminate_instances(self.reservation), "Unable to terminate instance(s)")
### DELETE group
self.tester.delete_group(self.group)
### Delete keypair in cloud and from filesystem
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
def MyTest(self):
"""
This case was developed to run through a series of basic instance tests.
The tests are as follows:
- execute run_instances command
- make sure that public DNS name and private IP aren't the same
(This is for Managed/Managed-NOVLAN networking modes)
- test to see if instance is ping-able
- test to make sure that instance is accessible via ssh
(ssh into instance and run basic ls command)
If any of these tests fail, the test case will error out, logging the results.
"""
if not self.reservation:
self.reservation = self.tester.run_instance(self.image, keypair=self.keypair.name, group=self.group.name)
for instance in self.reservation.instances:
self.assertTrue(self.tester.wait_for_reservation(self.reservation), "Instance did not go to running")
self.assertNotEqual(
instance.public_dns_name, instance.private_ip_address, "Public and private IP are the same"
)
self.assertTrue(self.tester.ping(instance.public_dns_name), "Could not ping instance")
self.assertFalse(
instance.found("ls -1 /dev/" + instance.rootfs_device + "2", "No such file or directory"),
"Did not find ephemeral storage at " + instance.rootfs_device + "2",
)
class InstanceBasics(unittest.TestCase):
def setUp(self, credpath=None):
# Setup basic eutester object
if credpath is None:
credpath = arg_credpath
self.tester = Eucaops(credpath=credpath)
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
def tearDown(self):
if self.reservation is not None:
self.assertTrue(self.tester.terminate_instances(self.reservation),
"Unable to terminate instance(s)")
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
self.reservation = None
self.group = None
self.keypair = None
self.tester = None
self.ephemeral = None
def BasicInstanceChecks(self, zone=None):
"""Instance checks including reachability and ephemeral storage"""
if zone is None:
zone = self.zone
if self.reservation is None:
self.reservation = self.tester.run_instance(
self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=zone)
for instance in self.reservation.instances:
self.assertTrue(self.tester.wait_for_reservation(self.reservation),
'Instance did not go to running')
self.assertNotEqual(instance.public_dns_name,
instance.private_ip_address,
'Public and private IP are the same')
self.assertTrue(self.tester.ping(instance.public_dns_name),
'Could not ping instance')
self.assertFalse(
instance.found("ls -1 /dev/" + instance.rootfs_device + "2",
"No such file or directory"),
'Did not find ephemeral storage at ' + instance.rootfs_device +
"2")
return self.reservation
def ElasticIps(self, zone=None):
""" Basic test for elastic IPs
Allocate an IP, associate it with an instance, ping the instance
Disassociate the IP, ping the instance
Release the address"""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(keypair=self.keypair.name,
group=self.group.name,
zone=zone)
for instance in self.reservation.instances:
address = self.tester.allocate_address()
self.assertTrue(address, 'Unable to allocate address')
self.tester.associate_address(instance, address)
instance.update()
self.assertTrue(self.tester.ping(instance.public_dns_name),
"Could not ping instance with new IP")
self.tester.disassociate_address_from_instance(instance)
self.tester.release_address(address)
instance.update()
self.assertTrue(self.tester.ping(instance.public_dns_name),
"Could not ping after dissassociate")
return self.reservation
def MaxSmallInstances(self, available_small=None, zone=None):
"""Run the maximum m1.smalls available"""
if available_small is None:
available_small = self.tester.get_available_vms()
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,
keypair=self.keypair.name,
group=self.group.name,
min=available_small,
max=available_small,
zone=zone)
self.assertTrue(self.tester.wait_for_reservation(self.reservation),
'Not all instances went to running')
return self.reservation
def LargestInstance(self, zone=None):
"""Run 1 of the largest instance c1.xlarge"""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,
keypair=self.keypair.name,
group=self.group.name,
type="c1.xlarge",
zone=zone)
self.assertTrue(self.tester.wait_for_reservation(self.reservation),
'Not all instances went to running')
return self.reservation
def MetaData(self, zone=None):
"""Check metadata for consistency"""
# Missing nodes
# ['block-device-mapping/', 'ami-manifest-path']
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=zone)
for instance in self.reservation.instances:
## Need to verify the public key (could just be checking for a string of a certain length)
self.assertTrue(
re.match(
instance.get_metadata("public-keys/0/openssh-key")
[0].split('eucalyptus.')[-1], self.keypair.name),
'Incorrect public key in metadata')
self.assertTrue(
re.match(
instance.get_metadata("security-groups")[0],
self.group.name), 'Incorrect security group in metadata')
# Need to validate block device mapping
#self.assertTrue(re.search(instance_ssh.get_metadata("block-device-mapping/")[0], ""))
self.assertTrue(
re.match(instance.get_metadata("instance-id")[0], instance.id),
'Incorrect instance id in metadata')
self.assertTrue(
re.match(
instance.get_metadata("local-ipv4")[0],
instance.private_ip_address),
'Incorrect private ip in metadata')
self.assertTrue(
re.match(
instance.get_metadata("public-ipv4")[0],
instance.ip_address), 'Incorrect public ip in metadata')
self.assertTrue(
re.match(
instance.get_metadata("ami-id")[0], instance.image_id),
'Incorrect ami id in metadata')
self.assertTrue(
re.match(
instance.get_metadata("ami-launch-index")[0],
instance.ami_launch_index),
'Incorrect launch index in metadata')
self.assertTrue(
re.match(
instance.get_metadata("reservation-id")[0],
self.reservation.id), 'Incorrect reservation in metadata')
self.assertTrue(
re.match(
instance.get_metadata("placement/availability-zone")[0],
instance.placement),
'Incorrect availability-zone in metadata')
self.assertTrue(
re.match(
instance.get_metadata("kernel-id")[0], instance.kernel),
'Incorrect kernel id in metadata')
self.assertTrue(
re.match(
instance.get_metadata("public-hostname")[0],
instance.public_dns_name),
'Incorrect public host name in metadata')
self.assertTrue(
re.match(
instance.get_metadata("local-hostname")[0],
instance.private_dns_name),
'Incorrect private host name in metadata')
self.assertTrue(
re.match(
instance.get_metadata("hostname")[0], instance.dns_name),
'Incorrect host name in metadata')
self.assertTrue(
re.match(
instance.get_metadata("ramdisk-id")[0], instance.ramdisk),
'Incorrect ramdisk in metadata') #instance-type
self.assertTrue(
re.match(
instance.get_metadata("instance-type")[0],
instance.instance_type),
'Incorrect instance type in metadata')
BAD_META_DATA_KEYS = ['foobar']
for key in BAD_META_DATA_KEYS:
self.assertTrue(
re.search("Not Found",
"".join(instance.get_metadata(key))),
'No fail message on invalid meta-data node')
return self.reservation
def DNSResolveCheck(self, zone=None):
"""Check DNS resolution information for public/private DNS names and IP addresses. The DNS resolution behavior follows AWS EC2."""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=zone)
for instance in self.reservation.instances:
# Test to see if Dynamic DNS has been configured #
if re.match("internal",
instance.private_dns_name.split('eucalyptus.')[-1]):
# Per AWS standard, resolution should have private hostname or private IP as a valid response
# Perform DNS resolution against private IP and private DNS name
# Check to see if nslookup was able to resolve
self.assertTrue(
re.search(
'answer\:',
instance.sys("nslookup " +
instance.get_metadata("hostname")[0])[3]),
"DNS lookup failed for hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on local-hostname returns local-ipv4 address
self.assertTrue(
re.search(
instance.get_metadata("local-ipv4")[0],
instance.sys("nslookup " +
instance.get_metadata("hostname")[0])[5]),
"Incorrect DNS resolution for hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(
re.search(
'answer\:',
instance.sys(
"nslookup " +
instance.get_metadata("local-hostname")[0])[3]),
"DNS lookup failed for private hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on local-hostname returns local-ipv4 address
self.assertTrue(
re.search(
instance.get_metadata("local-ipv4")[0],
instance.sys(
"nslookup " +
instance.get_metadata("local-hostname")[0])[5]),
"Incorrect DNS resolution for private hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(
re.search(
'answer\:',
instance.sys("nslookup " +
instance.get_metadata("local-ipv4")[0])
[3]), "DNS lookup failed for private IP address.")
# Since nslookup was able to resolve, now check to see if nslookup on local-ipv4 address returns local-hostname
self.assertTrue(
re.search(
instance.get_metadata("local-hostname")[0],
instance.sys("nslookup " +
instance.get_metadata("local-ipv4")[0])
[4]),
"Incorrect DNS resolution for private IP address")
# Perform DNS resolution against public IP and public DNS name
# Check to see if nslookup was able to resolve
self.assertTrue(
re.search(
'answer\:',
instance.sys(
"nslookup " +
instance.get_metadata("public-hostname")[0])[3]),
"DNS lookup failed for public-hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on public-hostname returns local-ipv4 address
self.assertTrue(
re.search(
instance.get_metadata("local-ipv4")[0],
instance.sys(
"nslookup " +
instance.get_metadata("public-hostname")[0])[5]),
"Incorrect DNS resolution for public-hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(
re.search(
'answer\:',
instance.sys("nslookup " +
instance.get_metadata("public-ipv4")[0])
[3]), "DNS lookup failed for public IP address.")
# Since nslookup was able to resolve, now check to see if nslookup on public-ipv4 address returns public-hostname
self.assertTrue(
re.search(
instance.get_metadata("public-hostname")[0],
instance.sys("nslookup " +
instance.get_metadata("public-ipv4")[0])
[4]), "Incorrect DNS resolution for public IP address")
return self.reservation
def DNSCheck(self, zone=None):
"""Check to make sure Dynamic DNS reports correct information for public/private IP address and DNS names"""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=zone)
for instance in self.reservation.instances:
# Test to see if Dynamic DNS has been configured #
if re.match("internal",
instance.private_dns_name.split('eucalyptus.')[-1]):
# Make sure that private_ip_address is not the same as local-hostname
self.assertFalse(
re.match(instance.private_ip_address,
instance.private_dns_name),
'local-ipv4 and local-hostname are the same with DNS on')
# Make sure that ip_address is not the same as public-hostname
self.assertFalse(
re.match(instance.ip_address, instance.public_dns_name),
'public-ipv4 and public-hostname are the same with DNS on')
return self.reservation
def Reboot(self, zone=None):
"""Reboot instance ensure IP connectivity and volumes stay attached"""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,
keypair=self.keypair.name,
group=self.group.name,
zone=zone)
for instance in self.reservation.instances:
### Create 1GB volume in first AZ
self.volume = self.tester.create_volume(instance.placement, 1)
euvolume = EuVolume.make_euvol_from_vol(self.volume)
self.volume_device = instance.attach_euvolume(euvolume)
### Reboot instance
instance.reboot_instance_and_verify(waitconnect=20)
instance.detach_euvolume(euvolume)
return self.reservation
def Churn(self, testcase="BasicInstanceChecks"):
"""Start instances and stop them before they are running, increase time to terminate on each iteration"""
from multiprocessing import Process
from multiprocessing import Queue
### Increase time to terminate by step seconds on each iteration
step = 10
## Run through count iterations of test
count = self.tester.get_available_vms("m1.small") / 2
thread_pool = []
queue_pool = []
## Start asynchronous activity
## Run 5 basic instance check instances 10s apart
for i in xrange(count):
q = Queue()
queue_pool.append(q)
p = Process(target=self.run_testcase_thread,
args=(q, step * i, testcase))
thread_pool.append(p)
self.tester.debug("Starting Thread " + str(i) + " in " +
str(step * i))
p.start()
### While the other tests are running, run and terminate count instances with a 10s sleep in between
for i in xrange(count):
self.reservation = self.image.run()
self.tester.debug("Sleeping for " + str(step) +
" seconds before terminating instances")
self.tester.sleep(step)
for instance in self.reservation.instances:
instance.terminate()
self.assertTrue(
self.tester.wait_for_instance(instance, "terminated"),
"Instance did not go to terminated")
### Once the previous test is complete rerun the BasicInstanceChecks test case
### Wait for an instance to become available
count = self.tester.get_available_vms("m1.small")
poll_count = 30
while poll_count > 0:
self.tester.sleep(5)
count = self.tester.get_available_vms("m1.small")
if count > 0:
self.tester.debug(
"There is an available VM to use for final test")
break
poll_count -= 1
fail_count = 0
### Block until the script returns a result
for queue in queue_pool:
test_result = queue.get(True)
self.tester.debug("Got Result: " + str(test_result))
fail_count += test_result
for thread in thread_pool:
thread.join()
if fail_count > 0:
raise Exception("Failure detected in one of the " + str(count) +
" Basic Instance tests")
self.tester.debug("Successfully completed churn test")
def PrivateIPAddressing(self, zone=None):
"""Basic test to run an instance with Private only IP
and later allocate/associate/diassociate/release
an Elastic IP. In the process check after diassociate
the instance has only got private IP or new Public IP
gets associated to it"""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(keypair=self.keypair.name,
group=self.group.name,
private_addressing=True,
zone=zone)
for instance in self.reservation.instances:
address = self.tester.allocate_address()
self.assertTrue(address, 'Unable to allocate address')
self.assertTrue(self.tester.associate_address(instance, address))
self.tester.sleep(30)
instance.update()
self.assertTrue(self.tester.ping(instance.public_dns_name),
"Could not ping instance with new IP")
address.disassociate()
self.tester.sleep(30)
instance.update()
self.assertFalse(
self.tester.ping(instance.public_dns_name),
"Was able to ping instance that should have only had a private IP"
)
address.release()
if instance.public_dns_name != instance.private_dns_name:
self.fail("Instance received a new public IP: " +
instance.public_dns_name)
return self.reservation
def ReuseAddresses(self, zone=None):
""" Run instances in series and ensure they get the same address"""
prev_address = None
if zone is None:
zone = self.zone
### Run the test 5 times in a row
for i in xrange(5):
self.reservation = self.tester.run_instance(
keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
if prev_address is not None:
self.assertTrue(
re.search(str(prev_address),
str(instance.public_dns_name)),
str(prev_address) +
" Address did not get reused but rather " +
str(instance.public_dns_name))
prev_address = instance.public_dns_name
self.tester.terminate_instances(self.reservation)
def run_testcase_thread(self, queue, delay=20, name="MetaData"):
### Thread that runs a testcase (function) and returns its pass or fail result
self.tester.sleep(delay)
try:
result = unittest.TextTestRunner(verbosity=2).run(
InstanceBasics(name))
except Exception, e:
queue.put(1)
raise e
if result.wasSuccessful():
self.tester.debug("Passed test: " + name)
queue.put(0)
return False
else:
self.tester.debug("Failed test: " + name)
queue.put(1)
return True
class Instances(unittest.TestCase):
def setUp(self):
# Setup basic eutester object
self.tester = Eucaops( config_file="../input/2b_tested.lst", password="******", credpath="../credentials")
self.tester.poll_count = 240
self.tester.start_euca_logs()
### Determine whether virtio drivers are being used
self.device_prefix = "sd"
if self.tester.hypervisor == "kvm":
self.device_prefix = "vd"
self.ephemeral = "/dev/" + self.device_prefix + "a2"
### Adda 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 = os.curdir + "/" + self.keypair.name + ".pem"
self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group.name)
self.tester.sleep(10)
def tearDown(self):
"""Stop Euca logs"""
self.assertTrue(self.tester.terminate_instances(self.reservation), "Unable to terminate instance(s)")
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
self.tester.stop_euca_logs()
self.tester.save_euca_logs()
self.reservation = None
self.group = None
self.keypair = None
self.tester = None
self.ephemeral = None
def test1_Instance(self):
"""Instance checks including reachability and ephemeral storage"""
for instance in self.reservation.instances:
self.assertTrue( self.tester.wait_for_reservation(self.reservation) ,'Instance did not go to running')
self.assertNotEqual( instance.public_dns_name, instance.private_ip_address, 'Public and private IP are the same')
self.assertTrue( self.tester.ping(instance.public_dns_name), 'Could not ping instance')
instance_ssh = Eucaops( hostname=instance.public_dns_name, keypath= self.keypath)
self.assertTrue( instance_ssh.found("ls -1 " + self.ephemeral, self.ephemeral), 'Did not find ephemeral storage at ' + self.ephemeral)
self.assertTrue( self.tester.terminate_instances(self.reservation), 'Failure when terminating instance')
def test2_ElasticIps(self):
""" Basic test for elastic IPs"""
for instance in self.reservation.instances:
address = self.tester.allocate_address()
self.assertTrue(address,'Unable to allocate address')
self.assertTrue(self.tester.associate_address(instance, address))
self.tester.sleep(30)
instance.update()
self.assertTrue( self.tester.ping(instance.public_dns_name), "Could not ping instance with new IP")
address.disassociate()
self.tester.sleep(30)
instance.update()
self.assertTrue( self.tester.ping(instance.public_dns_name), "Could not ping instance with new IP")
self.tester.release_address()
def test3_MaxInstances(self):
"""Run the maximum m1.smalls available"""
self.assertTrue(self.tester.terminate_instances(self.reservation), "Was not able to terminate original instance")
available_small = self.tester.get_available_vms()
self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group.name,min=available_small, max=available_small)
self.assertTrue( self.tester.wait_for_reservation(self.reservation) ,'Not all instances went to running')
def test4_LargeInstance(self):
"""Run 1 of the largest instance c1.xlarge"""
self.assertTrue(self.tester.terminate_instances(self.reservation), "Was not able to terminate original instance")
self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group.name,type="c1.xlarge")
self.assertTrue( self.tester.wait_for_reservation(self.reservation) ,'Not all instances went to running')
def test5_MetaData(self):
"""Check metadata for consistency"""
# Missing nodes
# ['block-device-mapping/', 'ami-manifest-path' , 'hostname', 'placement/']
for instance in self.reservation.instances:
instance_ssh = Eucaops( hostname=instance.public_dns_name, keypath= self.keypath)
### Check metadata service
self.assertTrue(re.search(instance_ssh.get_metadata("public-keys/0/")[0], self.keypair.name))
self.assertTrue(re.search(instance_ssh.get_metadata("security-groups")[0], self.group))
#self.assertTrue(re.search(instance_ssh.get_metadata("block-device-mapping/")[0], ""))
self.assertTrue(re.search(instance_ssh.get_metadata("instance-id")[0], instance.id))
self.assertTrue(re.search(instance_ssh.get_metadata("local-ipv4")[0] , instance.private_ip_address))
self.assertTrue(re.search(instance_ssh.get_metadata("public-ipv4")[0] , instance.ip_address))
self.assertTrue(re.search(instance_ssh.get_metadata("ami-id")[0], instance.image_id))
self.assertTrue(re.search(instance_ssh.get_metadata("ami-launch-index")[0], instance.ami_launch_index))
self.assertTrue(re.search(instance_ssh.get_metadata("reservation-id")[0], self.reservation.id))
self.assertTrue(re.search(instance_ssh.get_metadata("kernel-id")[0], instance.kernel))
self.assertTrue(re.search(instance_ssh.get_metadata("public-hostname")[0], instance.public_dns_name))
self.assertTrue(re.search(instance_ssh.get_metadata("ramdisk-id")[0], instance.ramdisk )) #instance-type
self.assertTrue(re.search(instance_ssh.get_metadata("instance-type")[0], instance.instance_type ))
def test6_Reboot(self):
"""Reboot instance ensure IP connectivity and volumes stay attached"""
for instance in self.reservation.instances:
### Create 1GB volume in first AZ
volume = self.tester.create_volume(self.tester.ec2.get_all_zones()[0].name)
### Pass in check the devices on the instance before the attachment
device_path = "/dev/" + self.device_prefix +"j"
instance_ssh = Eucaops( hostname=instance.public_dns_name, keypath= self.keypath)
before_attach = instance_ssh.sys("ls -1 /dev/ | grep " + self.device_prefix)
### Attach the volume to the instance
self.assertTrue(self.tester.attach_volume(instance, volume, device_path), "Failure attaching volume")
### Check devices after attachment
after_attach = instance_ssh.sys("ls -1 /dev/ | grep " + self.device_prefix)
new_devices = self.tester.diff(after_attach, before_attach)
### Check for device in instance
self.assertTrue(instance_ssh.check_device("/dev/" + new_devices[0]), "Did not find device on instance before reboot")
### Reboot instance
instance.reboot()
self.tester.sleep(30)
### Check for device in instance
instance_ssh = Eucaops( hostname=instance.public_dns_name, keypath= self.keypath)
self.assertTrue(instance_ssh.check_device("/dev/" + new_devices[0]), "Did not find device on instance after reboot")
self.assertTrue(self.tester.detach_volume(volume), "Unable to detach volume")
self.assertTrue(self.tester.delete_volume(volume), "Unable to delete volume")
def suite():
tests = ['test1_Instance', 'test2_ElasticIps', 'test3_MaxInstances', 'test4_LargeInstance','test5_MetaData', 'test6_Reboot']
return unittest.TestSuite(map(Instances, tests))
class SSLTermination(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)
# test resource hash
self.test_hash = str(int(time.time()))
# test resources dir
self.resource_dir = "./testcases/cloud_user/elb/test_data"
# User data file
self.user_data = self.resource_dir+"/webserver_user_data.sh"
# Add and authorize a group for the instances
self.group = self.tester.add_group(group_name="group-" + self.test_hash)
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.tester.authorize_group_by_name(group_name=self.group.name, port=80, protocol="tcp")
self.tester.authorize_group_by_name(group_name=self.group.name, port=443, protocol="tcp")
# Generate a keypair for the instances
self.keypair = self.tester.add_keypair("keypair-" + self.test_hash)
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()
# Populate available zones
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
# create base load balancer
self.load_balancer_port = 80
self.load_balancer = self.tester.create_load_balancer(zones=[self.zone],
name="elb-" + self.test_hash,
load_balancer_port=self.load_balancer_port)
assert isinstance(self.load_balancer, LoadBalancer)
# create autoscaling group of webservers that register to the load balancer
self.count = 1
(self.web_servers) = self.tester.create_as_webservers(name=self.test_hash,
keypair=self.keypair.name,
group=self.group.name,
zone=self.zone,
image=self.image.id,
count=self.count,
user_data=self.user_data,
load_balancer=self.load_balancer.name)
# web servers scaling group
self.asg = self.tester.describe_as_group(name="asg-"+self.test_hash)
# wait until scaling instances are InService with the load balancer before continuing - 5 min timeout
assert self.tester.wait_for_result(self.tester.wait_for_lb_instances, True, timeout=300,
lb=self.load_balancer.name, number=self.count)
def ssl_termination(self):
"""
This will test ELB with HTTPS listener for the front end elb connection.
@raise Exception:
"""
self.debug("ELB SSl test")
# get ELB ip info and setup url (also verifies DNS lookup)
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
frontend_cert_name = "elb-ssl-test-"+str(int(time.time()))
self.tester.add_server_cert(cert_name=frontend_cert_name)
# remove any existing listeners
self.remove_all_listeners(lb_name=self.load_balancer.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", "HTTP", 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)
self.tester.update_listener(lb=self.load_balancer,
lb_port=443,
lb_protocol="HTTPS",
instance_port=80,
instance_protocol="HTTP",
cert_arn=frontend_cert_arn)
# perform https requests to LB
self.tester.sleep(10)
self.tester.generate_http_requests(url=lb_url, count=10)
def end_to_end_ssl_termination(self):
"""
Test for
https://eucalyptus.atlassian.net/browse/EUCA-10477
This will test ELB end to end encryption.
@raise Exception:
"""
self.debug("ELB End To End SSl test")
# get ELB url
lb_url = "https://"+self.load_balancer.dns_name+"/instance-name"
# upload server certificate
frontend_cert_name = "elb-e2e-ssl-test-"+str(int(time.time()))
self.tester.add_server_cert(cert_name=frontend_cert_name)
# get the arn of the certificate
frontend_cert_arn = self.tester.get_server_cert(frontend_cert_name).arn
# remove any existing listeners
self.remove_all_listeners(lb_name=self.load_balancer.name)
# update listener
self.tester.update_listener(lb=self.load_balancer,
lb_port=443,
lb_protocol="HTTPS",
instance_port=443,
instance_protocol="HTTPS",
cert_arn=frontend_cert_arn)
# ssl certfile
cert_file = "ssl_server_certs_basics.crt"
# PublicKeyPolicy
cert_body = open(join(self.resource_dir, cert_file)).read()
publickey_policy_attributes = {'PublicKey': cert_body}
publickey_policy_name = "snakecert"
self.tester.create_lb_policy(lb_name=self.load_balancer.name,
policy_name=publickey_policy_name,
policy_type="PublicKeyPolicyType",
policy_attributes=publickey_policy_attributes)
# BackendServerAuthenticationPolicy
backend_policy_attributes = {'PublicKeyPolicyName': publickey_policy_name}
backend_policy_name = "snakeauth"
self.tester.create_lb_policy(lb_name=self.load_balancer.name,
policy_name=backend_policy_name,
policy_type="BackendServerAuthenticationPolicyType",
policy_attributes=backend_policy_attributes)
self.tester.set_lb_policy_for_back_end_server(lb_name=self.load_balancer.name,
instance_port=443,
policy_name=backend_policy_name)
# perform https requests to LB
self.tester.sleep(15)
self.tester.generate_http_requests(url=lb_url, count=10)
def only_back_end_authentication(self):
"""
Test for
https://eucalyptus.atlassian.net/browse/EUCA-10477
This will test HTTP connection to ELB front end with back end encryption of traffic to the registered instances.
@raise Exception:
"""
self.debug("ELB Back End SSl test")
# get ELB url
lb_url = "http://"+self.load_balancer.dns_name+"/instance-name"
# remove any existing listeners
self.remove_all_listeners(lb_name=self.load_balancer.name)
# update listener
self.tester.update_listener(lb=self.load_balancer,
lb_port=80,
lb_protocol="HTTP",
instance_port=443,
instance_protocol="HTTPS")
# ssl certfile
cert_file = "ssl_server_certs_basics.crt"
# PublicKeyPolicy
cert_body = open(join(self.resource_dir, cert_file)).read()
publickey_policy_attributes = {'PublicKey': cert_body}
publickey_policy_name = "snakecert-backend-only"
self.tester.create_lb_policy(lb_name=self.load_balancer.name,
policy_name=publickey_policy_name,
policy_type="PublicKeyPolicyType",
policy_attributes=publickey_policy_attributes)
# BackendServerAuthenticationPolicy
backend_policy_attributes = {'PublicKeyPolicyName': publickey_policy_name}
backend_policy_name = "snakeauth-back-end-only"
self.tester.create_lb_policy(lb_name=self.load_balancer.name,
policy_name=backend_policy_name,
policy_type="BackendServerAuthenticationPolicyType",
policy_attributes=backend_policy_attributes)
self.tester.set_lb_policy_for_back_end_server(lb_name=self.load_balancer.name,
instance_port=443,
policy_name=backend_policy_name)
# perform https requests to LB
self.tester.sleep(15)
self.tester.generate_http_requests(url=lb_url, count=10)
def invalid_backend_authentication(self):
"""
Test for
https://eucalyptus.atlassian.net/browse/EUCA-10477
This is a negative test for ELB backend auth. Policy has invalid cert for backend authentication. We expect an
HTTP 503 error returned
@raise Exception:
"""
self.debug("ELB Back End SSl Negative test")
# get ELB url
lb_url = "http://"+self.load_balancer.dns_name+"/instance-name"
# remove any existing listeners
self.remove_all_listeners(lb_name=self.load_balancer.name)
# update listener
self.tester.update_listener(lb=self.load_balancer,
lb_port=80,
lb_protocol="HTTP",
instance_port=443,
instance_protocol="HTTPS")
# ssl certfile
cert_file = "bad_cert.crt"
# PublicKeyPolicy
cert_body = open(join(self.resource_dir, cert_file)).read()
publickey_policy_attributes = {'PublicKey': cert_body}
publickey_policy_name = "snakecertBAD"
self.tester.create_lb_policy(lb_name=self.load_balancer.name,
policy_name=publickey_policy_name,
policy_type="PublicKeyPolicyType",
policy_attributes=publickey_policy_attributes)
# BackendServerAuthenticationPolicy
backend_policy_attributes = {'PublicKeyPolicyName': publickey_policy_name}
backend_policy_name = "snakeauthBAD"
self.tester.create_lb_policy(lb_name=self.load_balancer.name,
policy_name=backend_policy_name,
policy_type="BackendServerAuthenticationPolicyType",
policy_attributes=backend_policy_attributes)
self.tester.set_lb_policy_for_back_end_server(lb_name=self.load_balancer.name,
instance_port=443,
policy_name=backend_policy_name)
# perform https requests to LB
self.tester.sleep(15)
got_expected_error = False
try:
self.tester.generate_http_requests(url=lb_url, count=10)
except HTTPError as e:
self.debug("PASSED, received expected error: " + str(e.getcode()) + " " + e.msg)
got_expected_error = True
assert got_expected_error, "Did not get expected HTTP 503 ERROR response"
def remove_all_listeners(self, lb_name):
for listener in self.tester.describe_lb_listeners(lb_name):
self.debug("Found existing listener: " + str(listener))
self.tester.remove_lb_listener(lb_name=lb_name, port=listener.load_balancer_port)
def clean_method(self):
try:
self.tester.delete_all_server_certs()
except:
self.debug("Delete certificates went awry")
finally:
self.tester.cleanup_artifacts()
if self.tester.test_resources["security-groups"]:
for group in self.tester.test_resources["security-groups"]:
self.tester.wait_for_result(self.tester.gracefully_delete_group, True, timeout=60, group=group)
class ImageCreator(EutesterTestCase):
def __init__(self):
extra_args = ['--size', '--repo-url', '--packages', '--user-data']
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 = EC2ops(credpath=self.args.credpath,
region=self.args.region)
else:
self.tester = Eucaops(config_file=self.args.config,
password=self.args.password,
credpath=self.args.credpath)
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)
if not self.args.emi:
raise Exception(
"Must pass base image id to use as parameter --emi")
self.image = self.tester.get_emi(self.args.emi)
self.address = None
self.volume = None
self.private_addressing = False
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.reservation = None
def clean_method(self):
if self.reservation:
self.tester.terminate_instances(self.reservation)
self.reservation = None
if self.volume:
self.tester.delete_volume(self.volume)
def CreateImage(self, zone=None):
'''Register a BFEBS snapshot'''
if zone is None:
zone = self.zone
user_data = open(self.args.user_data, mode="r").read()
self.reservation = self.tester.run_instance(image=self.args.emi,
keypair=self.keypair.name,
group=self.group.name,
zone=zone,
user_data=user_data)
for instance in self.reservation.instances:
if instance.root_device_type == "ebs":
self.CreateEBS(instance)
else:
self.CreateInstanceStore(instance)
self.tester.terminate_instances(self.reservation)
self.reservation = None
def get_machine(self, instance):
assert isinstance(instance, EuInstance)
distro = instance.sys('head -1 /etc/issue')[0]
if re.search("CentOS", distro):
return Machine(instance.ip_address,
keypath=self.keypath,
distro="CENTOS",
distro_ver="6")
elif re.search("Ubuntu", distro):
return Machine(instance.ip_address,
keypath=self.keypath,
distro="UBUNTU",
distro_ver="PRECISE")
raise Exception("Unable to find supported distro on image")
def CreateEBS(self, instance):
machine = self.get_machine(instance)
if hasattr(self.args, 'repo'):
machine.package_manager.add_repo(self.args.repo_url)
if hasattr(self.args, 'packages'):
machine.package_manager.install(self.args.packages)
volume = self.tester.get_volumes(attached_instance=instance.id)[0]
snapshot = self.tester.create_snapshot(volume.id)
self.tester.register_snapshot(snapshot)
def CreateInstanceStore(self, instance):
machine = self.get_machine(instance)
if hasattr(self.args, 'repo'):
machine.package_manager.add_repo(self.args.repo_url)
if hasattr(self.args, 'packages'):
machine.package_manager.install(self.args.packages)
mount_point = "/mnt"
instance.sys("mfks.ext3 -F /dev/" + instance.rootfs_device + "2")
instance.sys("mount " + "/dev/" + instance.rootfs_device + "2 " +
mount_point)
image_file_name = "server.img"
remote_image_file = mount_point + "/" + image_file_name
instance.sys("dd bs=1M if=/dev/" + instance.rootfs_device + "1 of=" +
remote_image_file,
timeout=600)
machine.sftp.get(remote_image_file, image_file_name)
def find_filesystem(self, machine, block_device):
for device in machine.sys('ls -1 ' + block_device + "*"):
if machine.found('file -s ' + device, "filesystem"):
return device
raise Exception("Unable to find a filesystem on block device:" +
block_device)
class EbsTestSuite(EutesterTestCase):
tester = None
zonelist = []
snaps = []
keypair = None
group = None
multicluster=False
image = None
def __init__(self,
name=None,
args=None,
tester=None,
zone=None,
config_file='../input/2b_tested.lst',
password="******",
inst_pass=None,
credpath=None,
volumes=None,
keypair=None,
group=None,
emi=None,
root_device_type='instance-store',
vmtype='c1.medium',
eof=1):
self.args = args
self.setuptestcase(name)
if tester is None:
self.tester = Eucaops( config_file=config_file,password=password,credpath=credpath)
else:
self.tester = tester
self.tester.exit_on_fail = eof
self.testlist =[]
self.inst_pass=inst_pass
if emi:
self.image = self.tester.get_emi(emi=emi)
else:
self.image = self.tester.get_emi(root_device_type=root_device_type, not_location='windows')
self.vmtype = vmtype
self.zone = None
self.zonelist = []
#create some zone objects and append them to the zonelist
if self.zone:
self.zone = TestZone(zone)
self.zonelist.append(self.zone)
else:
self.setup_testzones()
#If the list of volumes passed in looks good, sort them into the zones
if self.volumes_list_check(volumes):
self.sort_volumes(volumes)
#Setup our security group for later use
if (group is not None):
self.group = group
else:
group_name='EbsTestGroup'
try:
self.group = self.tester.add_group(group_name,fail_if_exists=False)
self.tester.authorize_group_by_name(self.group.name)
self.tester.authorize_group_by_name(self.group.name,protocol="icmp",port=-1)
except Exception, e:
self.debug(self.tester.get_traceback())
raise Exception("Error when setting up group:"+str(group_name)+", Error:"+str(e))
#Setup the keypairs for later use
if not self.inst_pass:
try:
if (keypair is not None):
self.keypair = keypair
else:
keys = self.tester.get_all_current_local_keys()
if keys != []:
self.keypair = keys[0]
else:
self.keypair = keypair = self.tester.add_keypair('ebs_test_key-' + str(time.time()))
except Exception, ke:
raise Exception("Failed to find/create a keypair, error:" + str(ke))
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)
# test resource hash
self.test_hash = str(int(time.time()))
# Add and authorize a group for the instances
self.group = self.tester.add_group(group_name="group-" +
self.test_hash)
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.tester.authorize_group_by_name(group_name=self.group.name,
port=80,
protocol="tcp")
# Generate a keypair for the instances
self.keypair = self.tester.add_keypair("keypair-" + self.test_hash)
self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name)
# User data file
self.user_data = "./testcases/cloud_user/elb/test_data/webserver_user_data.sh"
# Get an image
self.image = self.args.emi
if not self.image:
self.image = self.tester.get_emi()
# Populate available zones
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
# create base load balancer
self.load_balancer_port = 80
self.load_balancer = self.tester.create_load_balancer(
zones=[self.zone],
name="elb-" + self.test_hash,
load_balancer_port=self.load_balancer_port)
assert isinstance(self.load_balancer, LoadBalancer)
# create autoscaling group of webservers that register to the load balancer
self.count = 2
(self.web_servers) = self.tester.create_as_webservers(
name=self.test_hash,
keypair=self.keypair.name,
group=self.group.name,
zone=self.zone,
image=self.image.id,
count=self.count,
user_data=self.user_data,
load_balancer=self.load_balancer.name)
# web servers scaling group
self.asg = self.tester.describe_as_group(name="asg-" + self.test_hash)
# wait until scaling instances are InService with the load balancer before continuing - 5 min timeout
assert self.tester.wait_for_result(self.tester.wait_for_lb_instances,
True,
timeout=300,
lb=self.load_balancer.name,
number=self.count)
def clean_method(self):
self.tester.cleanup_artifacts()
if self.tester.test_resources["security-groups"]:
for group in self.tester.test_resources["security-groups"]:
self.tester.wait_for_result(
self.tester.gracefully_delete_group,
True,
timeout=60,
group=group)
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 EbsTestSuite(EutesterTestCase):
tester = None
zonelist = []
snaps = []
keypair = None
group = None
multicluster = False
image = None
def __init__(self,
tester=None,
zone=None,
config_file='../input/2b_tested.lst',
password="******",
credpath=None,
volumes=None,
keypair=None,
group=None,
image=None,
eof=1):
if tester is None:
self.tester = Eucaops(config_file=config_file,
password=password,
credpath=credpath)
else:
self.tester = tester
self.tester.exit_on_fail = eof
self.testlist = []
self.image = image
#create some zone objects and append them to the zonelist
if zone is not None:
self.zone = TestZone(zone)
self.zonelist.append(self.zone)
else:
for zone in self.tester.service_manager.partitions.keys():
partition = self.tester.service_manager.partitions.get(zone)
tzone = TestZone(partition)
self.zonelist.append(tzone)
self.multicluster = True
#If the list of volumes passed in looks good, sort them into the zones
if self.volumes_list_check(volumes):
self.sort_volumes(volumes)
#Setup our security group for later use
if (group is not None):
self.group = group
else:
group_name = 'EbsTestGroup'
try:
self.group = self.tester.add_group(group_name)
self.tester.authorize_group_by_name(self.group.name)
self.tester.authorize_group_by_name(self.group.name,
protocol="icmp",
port=-1)
except Exception, e:
raise Exception("Error when setting up group:" +
str(group_name) + ", Error:" + str(e))
#Setup the keypairs for later use
try:
if (keypair is not None):
self.keypair = keypair
else:
keys = self.tester.get_all_current_local_keys()
if keys != []:
self.keypair = keys[0]
else:
self.keypair = keypair = self.tester.add_keypair(
'ebs_test_key-' + str(time.time()))
except Exception, ke:
raise Exception("Failed to find/create a keypair, error:" +
str(ke))
class ImageCreator(EutesterTestCase):
def __init__(self):
extra_args = ['--size', '--repo-url', '--packages', '--user-data']
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 = EC2ops( credpath=self.args.credpath, region=self.args.region)
else:
self.tester = Eucaops(config_file=self.args.config, password=self.args.password, credpath=self.args.credpath)
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)
if not self.args.emi:
raise Exception("Must pass base image id to use as parameter --emi")
self.image = self.tester.get_emi(self.args.emi)
self.address = None
self.volume = None
self.private_addressing = False
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
self.reservation = None
def clean_method(self):
if self.reservation:
self.tester.terminate_instances(self.reservation)
self.reservation = None
if self.volume:
self.tester.delete_volume(self.volume)
def CreateImage(self, zone= None):
'''Register a BFEBS snapshot'''
if zone is None:
zone = self.zone
user_data = open(self.args.user_data, mode="r").read()
self.reservation = self.tester.run_instance(image=self.args.emi,keypair=self.keypair.name, group=self.group.name,
zone=zone, user_data=user_data)
for instance in self.reservation.instances:
if instance.root_device_type == "ebs":
self.CreateEBS(instance)
else:
self.CreateInstanceStore(instance)
self.tester.terminate_instances(self.reservation)
self.reservation = None
def get_machine(self, instance):
assert isinstance(instance, EuInstance)
distro = instance.sys('head -1 /etc/issue')[0]
if re.search("CentOS", distro):
return Machine(instance.ip_address, keypath=self.keypath, distro="CENTOS", distro_ver="6")
elif re.search("Ubuntu", distro):
return Machine(instance.ip_address, keypath=self.keypath, distro="UBUNTU", distro_ver="PRECISE")
raise Exception("Unable to find supported distro on image")
def CreateEBS(self, instance):
machine = self.get_machine(instance)
if hasattr(self.args, 'repo'):
machine.package_manager.add_repo(self.args.repo_url)
if hasattr(self.args, 'packages'):
machine.package_manager.install(self.args.packages)
volume = self.tester.get_volumes(attached_instance=instance.id)[0]
snapshot = self.tester.create_snapshot(volume.id)
self.tester.register_snapshot(snapshot)
def CreateInstanceStore(self, instance):
machine = self.get_machine(instance)
if hasattr(self.args, 'repo'):
machine.package_manager.add_repo(self.args.repo_url)
if hasattr(self.args, 'packages'):
machine.package_manager.install(self.args.packages)
mount_point = "/mnt"
instance.sys("mfks.ext3 -F /dev/" + instance.rootfs_device + "2" )
instance.sys("mount " + "/dev/" + instance.rootfs_device + "2 " + mount_point )
image_file_name = "server.img"
remote_image_file = mount_point + "/" + image_file_name
instance.sys("dd bs=1M if=/dev/" + instance.rootfs_device + "1 of=" + remote_image_file, timeout=600)
machine.sftp.get(remote_image_file, image_file_name)
def find_filesystem(self, machine, block_device):
for device in machine.sys('ls -1 ' + block_device + "*"):
if machine.found('file -s ' + device, "filesystem"):
return device
raise Exception("Unable to find a filesystem on block device:" + block_device)
class InstanceBasics(EutesterTestCase):
def __init__(self,
name="InstanceBasics",
credpath=None,
region=None,
config_file=None,
password=None,
emi=None,
zone=None,
user_data=None,
instance_user=None,
**kwargs):
"""
EC2 API tests focused on instance store instances
:param credpath: Path to directory containing eucarc file
:param region: EC2 Region to run testcase in
:param config_file: Configuration file path
:param password: SSH password for bare metal machines if config is passed and keys arent synced
:param emi: Image id to use for test
:param zone: Availability Zone to run test in
:param user_data: User Data to pass to instance
:param instance_user: User to login to instance as
:param kwargs: Additional arguments
"""
super(InstanceBasics, self).__init__(name=name)
if region:
self.tester = EC2ops(credpath=credpath, region=region)
else:
self.tester = Eucaops(config_file=config_file,
password=password,
credpath=credpath)
self.instance_timeout = 600
### 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)
if emi:
self.image = emi
else:
self.image = self.tester.get_emi(root_device_type="instance-store",
not_platform="windows")
self.address = None
self.volume = None
self.private_addressing = False
if not zone:
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
else:
self.zone = zone
self.reservation = None
self.reservation_lock = threading.Lock()
self.run_instance_params = {
'image': self.image,
'user_data': user_data,
'username': instance_user,
'keypair': self.keypair.name,
'group': self.group.name,
'zone': self.zone,
'timeout': self.instance_timeout
}
self.managed_network = True
### If I have access to the underlying infrastructure I can look
### at the network mode and only run certain tests where it makes sense
if hasattr(self.tester, "service_manager"):
cc = self.tester.get_component_machines("cc")[0]
network_mode = cc.sys(
"cat " + self.tester.eucapath +
"/etc/eucalyptus/eucalyptus.conf | grep MODE")[0]
if re.search("(SYSTEM|STATIC)", network_mode):
self.managed_network = False
def set_reservation(self, reservation):
self.reservation_lock.acquire()
self.reservation = reservation
self.reservation_lock.release()
def clean_method(self):
self.tester.cleanup_artifacts()
def BasicInstanceChecks(self):
"""
This case was developed to run through a series of basic instance tests.
The tests are as follows:
- execute run_instances command
- make sure that public DNS name and private IP aren't the same
(This is for Managed/Managed-NOVLAN networking modes)
- test to see if instance is ping-able
- test to make sure that instance is accessible via ssh
(ssh into instance and run basic ls command)
If any of these tests fail, the test case will error out, logging the results.
"""
reservation = self.tester.run_instance(**self.run_instance_params)
for instance in reservation.instances:
self.assertTrue(self.tester.wait_for_reservation(reservation),
'Instance did not go to running')
self.assertTrue(self.tester.ping(instance.ip_address),
'Could not ping instance')
if self.image.virtualization_type == "paravirtual":
paravirtual_ephemeral = "/dev/" + instance.rootfs_device + "2"
self.assertFalse(
instance.found("ls -1 " + paravirtual_ephemeral,
"No such file or directory"),
"Did not find ephemeral storage at " +
paravirtual_ephemeral)
elif self.image.virtualization_type == "hvm":
hvm_ephemeral = "/dev/" + instance.block_device_prefix + "b"
self.assertFalse(
instance.found("ls -1 " + hvm_ephemeral,
"No such file or directory"),
"Did not find ephemeral storage at " + hvm_ephemeral)
self.set_reservation(reservation)
return reservation
def ElasticIps(self):
"""
This case was developed to test elastic IPs in Eucalyptus. This test case does
not test instances that are launched using private-addressing option.
The test case executes the following tests:
- allocates an IP, associates the IP to the instance, then pings the instance.
- disassociates the allocated IP, then pings the instance.
- releases the allocated IP address
If any of the tests fail, the test case will error out, logging the results.
"""
if not self.reservation:
reservation = self.tester.run_instance(**self.run_instance_params)
else:
reservation = self.reservation
for instance in reservation.instances:
if instance.ip_address == instance.private_ip_address:
self.tester.debug(
"WARNING: System or Static mode detected, skipping ElasticIps"
)
return reservation
self.address = self.tester.allocate_address()
self.assertTrue(self.address, 'Unable to allocate address')
self.tester.associate_address(instance, self.address)
instance.update()
self.assertTrue(self.tester.ping(instance.ip_address),
"Could not ping instance with new IP")
self.tester.disassociate_address_from_instance(instance)
self.tester.release_address(self.address)
self.address = None
assert isinstance(instance, EuInstance)
self.tester.sleep(5)
instance.update()
self.assertTrue(self.tester.ping(instance.ip_address),
"Could not ping after dissassociate")
self.set_reservation(reservation)
return reservation
def MultipleInstances(self):
"""
This case was developed to test the maximum number of m1.small vm types a configured
cloud can run. The test runs the maximum number of m1.small vm types allowed, then
tests to see if all the instances reached a running state. If there is a failure,
the test case errors out; logging the results.
"""
if self.reservation:
self.tester.terminate_instances(self.reservation)
self.set_reservation(None)
reservation = self.tester.run_instance(min=2,
max=2,
**self.run_instance_params)
self.assertTrue(self.tester.wait_for_reservation(reservation),
'Not all instances went to running')
self.set_reservation(reservation)
return reservation
def LargestInstance(self):
"""
This case was developed to test the maximum number of c1.xlarge vm types a configured
cloud can run. The test runs the maximum number of c1.xlarge vm types allowed, then
tests to see if all the instances reached a running state. If there is a failure,
the test case errors out; logging the results.
"""
if self.reservation:
self.tester.terminate_instances(self.reservation)
self.set_reservation(None)
reservation = self.tester.run_instance(type="c1.xlarge",
**self.run_instance_params)
self.assertTrue(self.tester.wait_for_reservation(reservation),
'Not all instances went to running')
self.set_reservation(reservation)
return reservation
def MetaData(self):
"""
This case was developed to test the metadata service of an instance for consistency.
The following meta-data attributes are tested:
- public-keys/0/openssh-key
- security-groups
- instance-id
- local-ipv4
- public-ipv4
- ami-id
- ami-launch-index
- reservation-id
- placement/availability-zone
- kernel-id
- public-hostname
- local-hostname
- hostname
- ramdisk-id
- instance-type
- any bad metadata that shouldn't be present.
Missing nodes
['block-device-mapping/', 'ami-manifest-path']
If any of these tests fail, the test case will error out; logging the results.
"""
if not self.reservation:
reservation = self.tester.run_instance(**self.run_instance_params)
else:
reservation = self.reservation
for instance in reservation.instances:
## Need to verify the public key (could just be checking for a string of a certain length)
self.assertTrue(
re.match(
instance.get_metadata("public-keys/0/openssh-key")
[0].split('eucalyptus.')[-1], self.keypair.name),
'Incorrect public key in metadata')
self.assertTrue(
re.match(
instance.get_metadata("security-groups")[0],
self.group.name), 'Incorrect security group in metadata')
# Need to validate block device mapping
#self.assertTrue(re.search(instance_ssh.get_metadata("block-device-mapping/")[0], ""))
self.assertTrue(
re.match(instance.get_metadata("instance-id")[0], instance.id),
'Incorrect instance id in metadata')
self.assertTrue(
re.match(
instance.get_metadata("local-ipv4")[0],
instance.private_ip_address),
'Incorrect private ip in metadata')
self.assertTrue(
re.match(
instance.get_metadata("public-ipv4")[0],
instance.ip_address), 'Incorrect public ip in metadata')
self.assertTrue(
re.match(
instance.get_metadata("ami-id")[0], instance.image_id),
'Incorrect ami id in metadata')
self.assertTrue(
re.match(
instance.get_metadata("ami-launch-index")[0],
instance.ami_launch_index),
'Incorrect launch index in metadata')
self.assertTrue(
re.match(
instance.get_metadata("reservation-id")[0],
reservation.id), 'Incorrect reservation in metadata')
self.assertTrue(
re.match(
instance.get_metadata("placement/availability-zone")[0],
instance.placement),
'Incorrect availability-zone in metadata')
if self.image.virtualization_type == "paravirtual":
self.assertTrue(
re.match(
instance.get_metadata("kernel-id")[0],
instance.kernel), 'Incorrect kernel id in metadata')
self.assertTrue(
re.match(
instance.get_metadata("ramdisk-id")[0],
instance.ramdisk), 'Incorrect ramdisk in metadata')
self.assertTrue(
re.match(
instance.get_metadata("public-hostname")[0],
instance.public_dns_name),
'Incorrect public host name in metadata')
self.assertTrue(
re.match(
instance.get_metadata("local-hostname")[0],
instance.private_dns_name),
'Incorrect private host name in metadata')
self.assertTrue(
re.match(
instance.get_metadata("hostname")[0],
instance.private_dns_name),
'Incorrect host name in metadata')
self.assertTrue(
re.match(
instance.get_metadata("instance-type")[0],
instance.instance_type),
'Incorrect instance type in metadata')
bad_meta_data_keys = ['foobar']
for key in bad_meta_data_keys:
self.assertTrue(
re.search("Not Found",
"".join(instance.get_metadata(key))),
'No fail message on invalid meta-data node')
self.set_reservation(reservation)
return reservation
def DNSResolveCheck(self):
"""
This case was developed to test DNS resolution information for public/private DNS
names and IP addresses. The tested DNS resolution behavior is expected to follow
AWS EC2. The following tests are ran using the associated meta-data attributes:
- check to see if Eucalyptus Dynamic DNS is configured
- nslookup on hostname; checks to see if it matches local-ipv4
- nslookup on local-hostname; check to see if it matches local-ipv4
- nslookup on local-ipv4; check to see if it matches local-hostname
- nslookup on public-hostname; check to see if it matches local-ipv4
- nslookup on public-ipv4; check to see if it matches public-host
If any of these tests fail, the test case will error out; logging the results.
"""
if not self.reservation:
reservation = self.tester.run_instance(**self.run_instance_params)
else:
reservation = self.reservation
for instance in reservation.instances:
if not re.search("internal", instance.private_dns_name):
self.tester.debug(
"Did not find instance DNS enabled, skipping test")
self.set_reservation(reservation)
return reservation
# Test to see if Dynamic DNS has been configured #
# Per AWS standard, resolution should have private hostname or private IP as a valid response
# Perform DNS resolution against public IP and public DNS name
# Perform DNS resolution against private IP and private DNS name
# Check to see if nslookup was able to resolve
assert isinstance(instance, EuInstance)
# Check nslookup to resolve public DNS Name to local-ipv4 address
self.assertTrue(
instance.found("nslookup " + instance.public_dns_name,
instance.private_ip_address),
"Incorrect DNS resolution for hostname.")
# Check nslookup to resolve public-ipv4 address to public DNS name
if self.managed_network:
self.assertTrue(
instance.found("nslookup " + instance.ip_address,
instance.public_dns_name),
"Incorrect DNS resolution for public IP address")
# Check nslookup to resolve private DNS Name to local-ipv4 address
if self.managed_network:
self.assertTrue(
instance.found("nslookup " + instance.private_dns_name,
instance.private_ip_address),
"Incorrect DNS resolution for private hostname.")
# Check nslookup to resolve local-ipv4 address to private DNS name
self.assertTrue(
instance.found("nslookup " + instance.private_ip_address,
instance.private_dns_name),
"Incorrect DNS resolution for private IP address")
self.assertTrue(self.tester.ping(instance.public_dns_name))
self.set_reservation(reservation)
return reservation
def Reboot(self):
"""
This case was developed to test IP connectivity and volume attachment after
instance reboot. The following tests are done for this test case:
- creates a 1 gig EBS volume, then attach volume
- reboot instance
- attempts to connect to instance via ssh
- checks to see if EBS volume is attached
- detaches volume
- deletes volume
If any of these tests fail, the test case will error out; logging the results.
"""
if not self.reservation:
reservation = self.tester.run_instance(**self.run_instance_params)
else:
reservation = self.reservation
for instance in reservation.instances:
### Create 1GB volume in first AZ
volume = self.tester.create_volume(instance.placement,
size=1,
timepergig=180)
instance.attach_volume(volume)
### Reboot instance
instance.reboot_instance_and_verify(waitconnect=20)
instance.detach_euvolume(volume)
self.tester.delete_volume(volume)
self.set_reservation(reservation)
return reservation
def Churn(self):
"""
This case was developed to test robustness of Eucalyptus by starting instances,
stopping them before they are running, and increase the time to terminate on each
iteration. This test case leverages the BasicInstanceChecks test case. The
following steps are ran:
- runs BasicInstanceChecks test case 5 times, 10 second apart.
- While each test is running, run and terminate instances with a 10sec sleep in between.
- When a test finishes, rerun BasicInstanceChecks test case.
If any of these tests fail, the test case will error out; logging the results.
"""
if self.reservation:
self.tester.terminate_instances(self.reservation)
self.set_reservation(None)
try:
available_instances_before = self.tester.get_available_vms(
zone=self.zone)
if available_instances_before > 4:
count = 4
else:
count = available_instances_before
except IndexError, e:
self.debug("Running as non-admin, defaulting to 4 VMs")
available_instances_before = count = 4
future_instances = []
with ThreadPoolExecutor(max_workers=count) as executor:
## Start asynchronous activity
## Run 5 basic instance check instances 10s apart
for i in xrange(count):
future_instances.append(
executor.submit(self.BasicInstanceChecks))
self.tester.sleep(10)
with ThreadPoolExecutor(max_workers=count) as executor:
## Start asynchronous activity
## Terminate all instances
for future in future_instances:
executor.submit(self.tester.terminate_instances,
future.result())
def available_after_greater():
return self.tester.get_available_vms(
zone=self.zone) >= available_instances_before
self.tester.wait_for_result(available_after_greater,
result=True,
timeout=360)
class InstanceBasics(unittest.TestCase):
def setUp(self, credpath=None):
# Setup basic eutester object
if credpath is None:
credpath = arg_credpath
self.tester = Eucaops( credpath=credpath)
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)
### Use a random instance-store backed EMI if no cli option set
if arg_emi is False:
self.image = self.tester.get_emi(root_device_type="instance-store")
else:
self.image = self.tester.get_emi(arg_emi)
self.reservation = None
self.private_addressing = False
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
def tearDown(self):
if self.reservation is not None:
self.assertTrue(self.tester.terminate_instances(self.reservation), "Unable to terminate instance(s)")
self.tester.delete_group(self.group)
self.tester.delete_keypair(self.keypair)
os.remove(self.keypath)
self.reservation = None
self.group = None
self.keypair = None
self.tester = None
self.ephemeral = None
def BasicInstanceChecks(self, zone = None):
"""Instance checks including reachability and ephemeral storage"""
if zone is None:
zone = self.zone
if self.reservation is None:
self.reservation = self.tester.run_instance(self.image, keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
self.assertTrue( self.tester.wait_for_reservation(self.reservation) ,'Instance did not go to running')
self.assertNotEqual( instance.public_dns_name, instance.private_ip_address, 'Public and private IP are the same')
self.assertTrue( self.tester.ping(instance.public_dns_name), 'Could not ping instance')
self.assertFalse( instance.found("ls -1 /dev/" + instance.rootfs_device + "2", "No such file or directory"), 'Did not find ephemeral storage at ' + instance.rootfs_device + "2")
return self.reservation
def ElasticIps(self, zone = None):
""" Basic test for elastic IPs
Allocate an IP, associate it with an instance, ping the instance
Disassociate the IP, ping the instance
Release the address"""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group.name,zone=zone)
for instance in self.reservation.instances:
address = self.tester.allocate_address()
self.assertTrue(address,'Unable to allocate address')
self.tester.associate_address(instance, address)
instance.update()
self.assertTrue( self.tester.ping(instance.public_dns_name), "Could not ping instance with new IP")
self.tester.disassociate_address_from_instance(instance)
self.tester.release_address(address)
instance.update()
self.assertTrue( self.tester.ping(instance.public_dns_name), "Could not ping after dissassociate")
return self.reservation
def MaxSmallInstances(self, available_small=None,zone = None):
"""Run the maximum m1.smalls available"""
if available_small is None:
available_small = self.tester.get_available_vms()
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,keypair=self.keypair.name, group=self.group.name,min=available_small, max=available_small, zone=zone)
self.assertTrue( self.tester.wait_for_reservation(self.reservation) ,'Not all instances went to running')
return self.reservation
def LargestInstance(self, zone = None):
"""Run 1 of the largest instance c1.xlarge"""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,keypair=self.keypair.name, group=self.group.name,type="c1.xlarge",zone=zone)
self.assertTrue( self.tester.wait_for_reservation(self.reservation) ,'Not all instances went to running')
return self.reservation
def MetaData(self, zone=None):
"""Check metadata for consistency"""
# Missing nodes
# ['block-device-mapping/', 'ami-manifest-path']
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
## Need to verify the public key (could just be checking for a string of a certain length)
self.assertTrue(re.match(instance.get_metadata("public-keys/0/openssh-key")[0].split('eucalyptus.')[-1], self.keypair.name), 'Incorrect public key in metadata')
self.assertTrue(re.match(instance.get_metadata("security-groups")[0], self.group.name), 'Incorrect security group in metadata')
# Need to validate block device mapping
#self.assertTrue(re.search(instance_ssh.get_metadata("block-device-mapping/")[0], ""))
self.assertTrue(re.match(instance.get_metadata("instance-id")[0], instance.id), 'Incorrect instance id in metadata')
self.assertTrue(re.match(instance.get_metadata("local-ipv4")[0] , instance.private_ip_address), 'Incorrect private ip in metadata')
self.assertTrue(re.match(instance.get_metadata("public-ipv4")[0] , instance.ip_address), 'Incorrect public ip in metadata')
self.assertTrue(re.match(instance.get_metadata("ami-id")[0], instance.image_id), 'Incorrect ami id in metadata')
self.assertTrue(re.match(instance.get_metadata("ami-launch-index")[0], instance.ami_launch_index), 'Incorrect launch index in metadata')
self.assertTrue(re.match(instance.get_metadata("reservation-id")[0], self.reservation.id), 'Incorrect reservation in metadata')
self.assertTrue(re.match(instance.get_metadata("placement/availability-zone")[0], instance.placement), 'Incorrect availability-zone in metadata')
self.assertTrue(re.match(instance.get_metadata("kernel-id")[0], instance.kernel), 'Incorrect kernel id in metadata')
self.assertTrue(re.match(instance.get_metadata("public-hostname")[0], instance.public_dns_name), 'Incorrect public host name in metadata')
self.assertTrue(re.match(instance.get_metadata("local-hostname")[0], instance.private_dns_name), 'Incorrect private host name in metadata')
self.assertTrue(re.match(instance.get_metadata("hostname")[0], instance.dns_name), 'Incorrect host name in metadata')
self.assertTrue(re.match(instance.get_metadata("ramdisk-id")[0], instance.ramdisk ), 'Incorrect ramdisk in metadata') #instance-type
self.assertTrue(re.match(instance.get_metadata("instance-type")[0], instance.instance_type ), 'Incorrect instance type in metadata')
BAD_META_DATA_KEYS = ['foobar']
for key in BAD_META_DATA_KEYS:
self.assertTrue(re.search("Not Found", "".join(instance.get_metadata(key))), 'No fail message on invalid meta-data node')
return self.reservation
def DNSResolveCheck(self, zone=None):
"""Check DNS resolution information for public/private DNS names and IP addresses. The DNS resolution behavior follows AWS EC2."""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
# Test to see if Dynamic DNS has been configured #
if re.match("internal", instance.private_dns_name.split('eucalyptus.')[-1]):
# Per AWS standard, resolution should have private hostname or private IP as a valid response
# Perform DNS resolution against private IP and private DNS name
# Check to see if nslookup was able to resolve
self.assertTrue(re.search('answer\:', instance.sys("nslookup " + instance.get_metadata("hostname")[0])[3]), "DNS lookup failed for hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on local-hostname returns local-ipv4 address
self.assertTrue(re.search(instance.get_metadata("local-ipv4")[0], instance.sys("nslookup " + instance.get_metadata("hostname")[0])[5]), "Incorrect DNS resolution for hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(re.search('answer\:', instance.sys("nslookup " + instance.get_metadata("local-hostname")[0])[3]), "DNS lookup failed for private hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on local-hostname returns local-ipv4 address
self.assertTrue(re.search(instance.get_metadata("local-ipv4")[0], instance.sys("nslookup " + instance.get_metadata("local-hostname")[0])[5]), "Incorrect DNS resolution for private hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(re.search('answer\:', instance.sys("nslookup " + instance.get_metadata("local-ipv4")[0])[3]), "DNS lookup failed for private IP address.")
# Since nslookup was able to resolve, now check to see if nslookup on local-ipv4 address returns local-hostname
self.assertTrue(re.search(instance.get_metadata("local-hostname")[0], instance.sys("nslookup " + instance.get_metadata("local-ipv4")[0])[4]), "Incorrect DNS resolution for private IP address")
# Perform DNS resolution against public IP and public DNS name
# Check to see if nslookup was able to resolve
self.assertTrue(re.search('answer\:', instance.sys("nslookup " + instance.get_metadata("public-hostname")[0])[3]), "DNS lookup failed for public-hostname.")
# Since nslookup was able to resolve, now check to see if nslookup on public-hostname returns local-ipv4 address
self.assertTrue(re.search(instance.get_metadata("local-ipv4")[0], instance.sys("nslookup " + instance.get_metadata("public-hostname")[0])[5]), "Incorrect DNS resolution for public-hostname.")
# Check to see if nslookup was able to resolve
self.assertTrue(re.search('answer\:', instance.sys("nslookup " + instance.get_metadata("public-ipv4")[0])[3]), "DNS lookup failed for public IP address.")
# Since nslookup was able to resolve, now check to see if nslookup on public-ipv4 address returns public-hostname
self.assertTrue(re.search(instance.get_metadata("public-hostname")[0], instance.sys("nslookup " + instance.get_metadata("public-ipv4")[0])[4]), "Incorrect DNS resolution for public IP address")
return self.reservation
def DNSCheck(self, zone=None):
"""Check to make sure Dynamic DNS reports correct information for public/private IP address and DNS names"""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image,keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
# Test to see if Dynamic DNS has been configured #
if re.match("internal", instance.private_dns_name.split('eucalyptus.')[-1]):
# Make sure that private_ip_address is not the same as local-hostname
self.assertFalse(re.match(instance.private_ip_address, instance.private_dns_name), 'local-ipv4 and local-hostname are the same with DNS on')
# Make sure that ip_address is not the same as public-hostname
self.assertFalse(re.match(instance.ip_address, instance.public_dns_name), 'public-ipv4 and public-hostname are the same with DNS on')
return self.reservation
def Reboot(self, zone=None):
"""Reboot instance ensure IP connectivity and volumes stay attached"""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(self.image, keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
### Create 1GB volume in first AZ
self.volume = self.tester.create_volume(instance.placement, 1)
euvolume = EuVolume.make_euvol_from_vol(self.volume)
self.volume_device = instance.attach_euvolume(euvolume)
### Reboot instance
instance.reboot_instance_and_verify(waitconnect=20)
instance.detach_euvolume(euvolume)
return self.reservation
def Churn(self, testcase="BasicInstanceChecks"):
"""Start instances and stop them before they are running, increase time to terminate on each iteration"""
from multiprocessing import Process
from multiprocessing import Queue
### Increase time to terminate by step seconds on each iteration
step = 10
## Run through count iterations of test
count = self.tester.get_available_vms("m1.small") / 2
thread_pool = []
queue_pool = []
## Start asynchronous activity
## Run 5 basic instance check instances 10s apart
for i in xrange(count):
q = Queue()
queue_pool.append(q)
p = Process(target=self.run_testcase_thread, args=(q, step * i,testcase))
thread_pool.append(p)
self.tester.debug("Starting Thread " + str(i) +" in " + str(step * i))
p.start()
### While the other tests are running, run and terminate count instances with a 10s sleep in between
for i in xrange(count):
self.reservation = self.image.run()
self.tester.debug("Sleeping for " + str(step) + " seconds before terminating instances")
self.tester.sleep(step )
for instance in self.reservation.instances:
instance.terminate()
self.assertTrue(self.tester.wait_for_instance(instance, "terminated"), "Instance did not go to terminated")
### Once the previous test is complete rerun the BasicInstanceChecks test case
### Wait for an instance to become available
count = self.tester.get_available_vms("m1.small")
poll_count = 30
while poll_count > 0:
self.tester.sleep(5)
count = self.tester.get_available_vms("m1.small")
if count > 0:
self.tester.debug("There is an available VM to use for final test")
break
poll_count -= 1
fail_count = 0
### Block until the script returns a result
for queue in queue_pool:
test_result = queue.get(True)
self.tester.debug("Got Result: " + str(test_result) )
fail_count += test_result
for thread in thread_pool:
thread.join()
if fail_count > 0:
raise Exception("Failure detected in one of the " + str(count) + " Basic Instance tests")
self.tester.debug("Successfully completed churn test")
def PrivateIPAddressing(self, zone = None):
"""Basic test to run an instance with Private only IP
and later allocate/associate/diassociate/release
an Elastic IP. In the process check after diassociate
the instance has only got private IP or new Public IP
gets associated to it"""
if zone is None:
zone = self.zone
self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group.name, private_addressing=True, zone=zone)
for instance in self.reservation.instances:
address = self.tester.allocate_address()
self.assertTrue(address,'Unable to allocate address')
self.assertTrue(self.tester.associate_address(instance, address))
self.tester.sleep(30)
instance.update()
self.assertTrue( self.tester.ping(instance.public_dns_name), "Could not ping instance with new IP")
address.disassociate()
self.tester.sleep(30)
instance.update()
self.assertFalse( self.tester.ping(instance.public_dns_name), "Was able to ping instance that should have only had a private IP")
address.release()
if instance.public_dns_name != instance.private_dns_name:
self.fail("Instance received a new public IP: " + instance.public_dns_name)
return self.reservation
def ReuseAddresses(self, zone = None):
""" Run instances in series and ensure they get the same address"""
prev_address = None
if zone is None:
zone = self.zone
### Run the test 5 times in a row
for i in xrange(5):
self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group.name, zone=zone)
for instance in self.reservation.instances:
if prev_address is not None:
self.assertTrue(re.search(str(prev_address) ,str(instance.public_dns_name)), str(prev_address) +" Address did not get reused but rather " + str(instance.public_dns_name))
prev_address = instance.public_dns_name
self.tester.terminate_instances(self.reservation)
def run_testcase_thread(self, queue,delay = 20, name="MetaData"):
### Thread that runs a testcase (function) and returns its pass or fail result
self.tester.sleep(delay)
try:
result = unittest.TextTestRunner(verbosity=2).run(InstanceBasics(name))
except Exception, e:
queue.put(1)
raise e
if result.wasSuccessful():
self.tester.debug("Passed test: " + name)
queue.put(0)
return False
else:
self.tester.debug("Failed test: " + name)
queue.put(1)
return True
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()
class InstanceBasics(EutesterTestCase):
def __init__( self, name="InstanceBasics", credpath=None, region=None, config_file=None, password=None, emi=None, zone=None,
user_data=None, instance_user=None, **kwargs):
"""
EC2 API tests focused on instance store instances
:param credpath: Path to directory containing eucarc file
:param region: EC2 Region to run testcase in
:param config_file: Configuration file path
:param password: SSH password for bare metal machines if config is passed and keys arent synced
:param emi: Image id to use for test
:param zone: Availability Zone to run test in
:param user_data: User Data to pass to instance
:param instance_user: User to login to instance as
:param kwargs: Additional arguments
"""
super(InstanceBasics, self).__init__(name=name)
if region:
self.tester = EC2ops(credpath=credpath, region=region)
else:
self.tester = Eucaops(config_file=config_file, password=password, credpath=credpath)
self.instance_timeout = 480
### 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)
if emi:
self.image = emi
else:
self.image = self.tester.get_emi(root_device_type="instance-store",not_location="loadbalancer")
self.address = None
self.volume = None
self.private_addressing = False
if not zone:
zones = self.tester.ec2.get_all_zones()
self.zone = random.choice(zones).name
else:
self.zone = zone
self.reservation = None
self.reservation_lock = threading.Lock()
self.run_instance_params = {'image': self.image, 'user_data': user_data, 'username': instance_user,
'keypair': self.keypair.name, 'group': self.group.name,'zone': self.zone,
'timeout': self.instance_timeout}
self.managed_network = True
### If I have access to the underlying infrastructure I can look
### at the network mode and only run certain tests where it makes sense
if hasattr(self.tester,"service_manager"):
cc = self.tester.get_component_machines("cc")[0]
network_mode = cc.sys("cat " + self.tester.eucapath + "/etc/eucalyptus/eucalyptus.conf | grep MODE")[0]
if re.search("(SYSTEM|STATIC)", network_mode):
self.managed_network = False
def set_reservation(self, reservation):
self.reservation_lock.acquire()
self.reservation = reservation
self.reservation_lock.release()
def clean_method(self):
self.tester.cleanup_artifacts()
def BasicInstanceChecks(self):
"""
This case was developed to run through a series of basic instance tests.
The tests are as follows:
- execute run_instances command
- make sure that public DNS name and private IP aren't the same
(This is for Managed/Managed-NOVLAN networking modes)
- test to see if instance is ping-able
- test to make sure that instance is accessible via ssh
(ssh into instance and run basic ls command)
If any of these tests fail, the test case will error out, logging the results.
"""
reservation = self.tester.run_instance(**self.run_instance_params)
for instance in reservation.instances:
self.assertTrue( self.tester.wait_for_reservation(reservation) ,'Instance did not go to running')
self.assertTrue( self.tester.ping(instance.ip_address), 'Could not ping instance')
self.assertFalse( instance.found("ls -1 /dev/" + instance.rootfs_device + "2", "No such file or directory"), 'Did not find ephemeral storage at ' + instance.rootfs_device + "2")
self.set_reservation(reservation)
return reservation
def ElasticIps(self):
"""
This case was developed to test elastic IPs in Eucalyptus. This test case does
not test instances that are launched using private-addressing option.
The test case executes the following tests:
- allocates an IP, associates the IP to the instance, then pings the instance.
- disassociates the allocated IP, then pings the instance.
- releases the allocated IP address
If any of the tests fail, the test case will error out, logging the results.
"""
if not self.reservation:
reservation = self.tester.run_instance(**self.run_instance_params)
else:
reservation = self.reservation
for instance in reservation.instances:
if instance.ip_address == instance.private_ip_address:
self.tester.debug("WARNING: System or Static mode detected, skipping ElasticIps")
return reservation
self.address = self.tester.allocate_address()
self.assertTrue(self.address,'Unable to allocate address')
self.tester.associate_address(instance, self.address)
instance.update()
self.assertTrue( self.tester.ping(instance.ip_address), "Could not ping instance with new IP")
self.tester.disassociate_address_from_instance(instance)
self.tester.release_address(self.address)
self.address = None
assert isinstance(instance, EuInstance)
self.tester.sleep(5)
instance.update()
self.assertTrue( self.tester.ping(instance.ip_address), "Could not ping after dissassociate")
self.set_reservation(reservation)
return reservation
def MultipleInstances(self):
"""
This case was developed to test the maximum number of m1.small vm types a configured
cloud can run. The test runs the maximum number of m1.small vm types allowed, then
tests to see if all the instances reached a running state. If there is a failure,
the test case errors out; logging the results.
"""
if self.reservation:
self.tester.terminate_instances(self.reservation)
self.set_reservation(None)
reservation = self.tester.run_instance(min=2, max=2, **self.run_instance_params)
self.assertTrue(self.tester.wait_for_reservation(reservation) ,'Not all instances went to running')
self.set_reservation(reservation)
return reservation
def LargestInstance(self):
"""
This case was developed to test the maximum number of c1.xlarge vm types a configured
cloud can run. The test runs the maximum number of c1.xlarge vm types allowed, then
tests to see if all the instances reached a running state. If there is a failure,
the test case errors out; logging the results.
"""
if self.reservation:
self.tester.terminate_instances(self.reservation)
self.set_reservation(None)
reservation = self.tester.run_instance(type="c1.xlarge", **self.run_instance_params)
self.assertTrue( self.tester.wait_for_reservation(reservation) ,'Not all instances went to running')
self.set_reservation(reservation)
return reservation
def MetaData(self):
"""
This case was developed to test the metadata service of an instance for consistency.
The following meta-data attributes are tested:
- public-keys/0/openssh-key
- security-groups
- instance-id
- local-ipv4
- public-ipv4
- ami-id
- ami-launch-index
- reservation-id
- placement/availability-zone
- kernel-id
- public-hostname
- local-hostname
- hostname
- ramdisk-id
- instance-type
- any bad metadata that shouldn't be present.
Missing nodes
['block-device-mapping/', 'ami-manifest-path']
If any of these tests fail, the test case will error out; logging the results.
"""
if not self.reservation:
reservation = self.tester.run_instance(**self.run_instance_params)
else:
reservation = self.reservation
for instance in reservation.instances:
## Need to verify the public key (could just be checking for a string of a certain length)
self.assertTrue(re.match(instance.get_metadata("public-keys/0/openssh-key")[0].split('eucalyptus.')[-1], self.keypair.name), 'Incorrect public key in metadata')
self.assertTrue(re.match(instance.get_metadata("security-groups")[0], self.group.name), 'Incorrect security group in metadata')
# Need to validate block device mapping
#self.assertTrue(re.search(instance_ssh.get_metadata("block-device-mapping/")[0], ""))
self.assertTrue(re.match(instance.get_metadata("instance-id")[0], instance.id), 'Incorrect instance id in metadata')
self.assertTrue(re.match(instance.get_metadata("local-ipv4")[0] , instance.private_ip_address), 'Incorrect private ip in metadata')
self.assertTrue(re.match(instance.get_metadata("public-ipv4")[0] , instance.ip_address), 'Incorrect public ip in metadata')
self.assertTrue(re.match(instance.get_metadata("ami-id")[0], instance.image_id), 'Incorrect ami id in metadata')
self.assertTrue(re.match(instance.get_metadata("ami-launch-index")[0], instance.ami_launch_index), 'Incorrect launch index in metadata')
self.assertTrue(re.match(instance.get_metadata("reservation-id")[0], reservation.id), 'Incorrect reservation in metadata')
self.assertTrue(re.match(instance.get_metadata("placement/availability-zone")[0], instance.placement), 'Incorrect availability-zone in metadata')
self.assertTrue(re.match(instance.get_metadata("kernel-id")[0], instance.kernel), 'Incorrect kernel id in metadata')
self.assertTrue(re.match(instance.get_metadata("public-hostname")[0], instance.public_dns_name), 'Incorrect public host name in metadata')
self.assertTrue(re.match(instance.get_metadata("local-hostname")[0], instance.private_dns_name), 'Incorrect private host name in metadata')
self.assertTrue(re.match(instance.get_metadata("hostname")[0], instance.private_dns_name), 'Incorrect host name in metadata')
self.assertTrue(re.match(instance.get_metadata("ramdisk-id")[0], instance.ramdisk ), 'Incorrect ramdisk in metadata') #instance-type
self.assertTrue(re.match(instance.get_metadata("instance-type")[0], instance.instance_type ), 'Incorrect instance type in metadata')
BAD_META_DATA_KEYS = ['foobar']
for key in BAD_META_DATA_KEYS:
self.assertTrue(re.search("Not Found", "".join(instance.get_metadata(key))), 'No fail message on invalid meta-data node')
self.set_reservation(reservation)
return reservation
def DNSResolveCheck(self, zone=None):
"""
This case was developed to test DNS resolution information for public/private DNS
names and IP addresses. The tested DNS resolution behavior is expected to follow
AWS EC2. The following tests are ran using the associated meta-data attributes:
- check to see if Eucalyptus Dynamic DNS is configured
- nslookup on hostname; checks to see if it matches local-ipv4
- nslookup on local-hostname; check to see if it matches local-ipv4
- nslookup on local-ipv4; check to see if it matches local-hostname
- nslookup on public-hostname; check to see if it matches local-ipv4
- nslookup on public-ipv4; check to see if it matches public-host
If any of these tests fail, the test case will error out; logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
reservation = self.tester.run_instance(**self.run_instance_params)
else:
reservation = self.reservation
for instance in reservation.instances:
if not re.search("internal", instance.private_dns_name):
self.tester.debug("Did not find instance DNS enabled, skipping test")
self.set_reservation(reservation)
return reservation
# Test to see if Dynamic DNS has been configured #
# Per AWS standard, resolution should have private hostname or private IP as a valid response
# Perform DNS resolution against public IP and public DNS name
# Perform DNS resolution against private IP and private DNS name
# Check to see if nslookup was able to resolve
assert isinstance(instance, EuInstance)
# Check nslookup to resolve public DNS Name to local-ipv4 address
self.assertTrue(instance.found("nslookup " + instance.public_dns_name + " " + self.tester.ec2.host, instance.private_ip_address), "Incorrect DNS resolution for hostname.")
# Check nslookup to resolve public-ipv4 address to public DNS name
if self.managed_network:
self.assertTrue( instance.found("nslookup " + instance.ip_address + " " + self.tester.ec2.host, instance.public_dns_name), "Incorrect DNS resolution for public IP address")
# Check nslookup to resolve private DNS Name to local-ipv4 address
if self.managed_network:
self.assertTrue(instance.found("nslookup " + instance.private_dns_name + " " + self.tester.ec2.host, instance.private_ip_address), "Incorrect DNS resolution for private hostname.")
# Check nslookup to resolve local-ipv4 address to private DNS name
self.assertTrue(instance.found("nslookup " + instance.private_ip_address + " " + self.tester.ec2.host, instance.private_dns_name), "Incorrect DNS resolution for private IP address")
self.assertTrue(self.tester.ping(instance.public_dns_name))
self.set_reservation(reservation)
return reservation
def Reboot(self, zone=None):
"""
This case was developed to test IP connectivity and volume attachment after
instance reboot. The following tests are done for this test case:
- creates a 1 gig EBS volume, then attach volume
- reboot instance
- attempts to connect to instance via ssh
- checks to see if EBS volume is attached
- detaches volume
- deletes volume
If any of these tests fail, the test case will error out; logging the results.
"""
if zone is None:
zone = self.zone
if not self.reservation:
reservation = self.tester.run_instance(**self.run_instance_params)
else:
reservation = self.reservation
for instance in reservation.instances:
### Create 1GB volume in first AZ
volume = self.tester.create_volume(instance.placement, 1)
volume_device = instance.attach_volume(volume)
### Reboot instance
instance.reboot_instance_and_verify(waitconnect=20)
instance.detach_euvolume(volume)
self.tester.delete_volume(volume)
self.set_reservation(reservation)
return reservation
def Churn(self):
"""
This case was developed to test robustness of Eucalyptus by starting instances,
stopping them before they are running, and increase the time to terminate on each
iteration. This test case leverages the BasicInstanceChecks test case. The
following steps are ran:
- runs BasicInstanceChecks test case 5 times, 10 second apart.
- While each test is running, run and terminate instances with a 10sec sleep in between.
- When a test finishes, rerun BasicInstanceChecks test case.
If any of these tests fail, the test case will error out; logging the results.
"""
if self.reservation:
self.tester.terminate_instances(self.reservation)
self.set_reservation(None)
available_instances_before = self.tester.get_available_vms(zone=self.zone)
## Run through count iterations of test
count = 4
future_instances =[]
with ThreadPoolExecutor(max_workers=count) as executor:
## Start asynchronous activity
## Run 5 basic instance check instances 10s apart
for i in xrange(count):
future_instances.append(executor.submit(self.BasicInstanceChecks))
self.tester.sleep(10)
with ThreadPoolExecutor(max_workers=count) as executor:
## Start asynchronous activity
## Terminate all instances
for future in future_instances:
executor.submit(self.tester.terminate_instances,future.result())
def available_after_greater():
return self.tester.get_available_vms(zone=self.zone) >= available_instances_before
self.tester.wait_for_result(available_after_greater, result=True, timeout=360)
def PrivateIPAddressing(self):
"""
This case was developed to test instances that are launched with private-addressing
set to True. The tests executed are as follows:
- run an instance with private-addressing set to True
- allocate/associate/disassociate/release an Elastic IP to that instance
- check to see if the instance went back to private addressing
If any of these tests fail, the test case will error out; logging the results.
"""
if self.reservation:
for instance in self.reservation.instances:
if instance.ip_address == instance.private_ip_address:
self.tester.debug("WARNING: System or Static mode detected, skipping PrivateIPAddressing")
return self.reservation
self.tester.terminate_instances(self.reservation)
self.set_reservation(None)
reservation = self.tester.run_instance(private_addressing=True, **self.run_instance_params)
for instance in reservation.instances:
address = self.tester.allocate_address()
self.assertTrue(address,'Unable to allocate address')
self.tester.associate_address(instance, address)
self.tester.sleep(30)
instance.update()
self.assertTrue( self.tester.ping(instance.ip_address), "Could not ping instance with new IP")
address.disassociate()
self.tester.sleep(30)
instance.update()
self.assertFalse(self.tester.ping(instance.ip_address), "Was able to ping instance that should have only had a private IP")
address.release()
if instance.ip_address != "0.0.0.0" and instance.ip_address != instance.private_ip_address:
self.fail("Instance received a new public IP: " + instance.ip_address)
self.tester.terminate_instances(self.reservation)
self.set_reservation(None)
return reservation
def ReuseAddresses(self):
"""
This case was developed to test when you run instances in a series, and make sure
they get the same address. The test launches an instance, checks the IP information,
then terminates the instance. This test is launched 5 times in a row. If there
is an error, the test case will error out; logging the results.
"""
prev_address = None
if self.reservation:
self.tester.terminate_instances(self.reservation)
self.set_reservation(None)
for i in xrange(5):
reservation = self.tester.run_instance(**self.run_instance_params)
for instance in reservation.instances:
if prev_address is not None:
self.assertTrue(re.search(str(prev_address) ,str(instance.ip_address)), str(prev_address) +" Address did not get reused but rather " + str(instance.public_dns_name))
prev_address = instance.ip_address
self.tester.terminate_instances(reservation)