def test_compare_console_output(self):
key_name = data_utils.rand_name('testkey')
pkey = self.create_key_pair(key_name)
sec_group_name = self.create_standard_security_group()
instance_id = self.run_instance(KeyName=key_name,
SecurityGroups=[sec_group_name])
data_to_check = data_utils.rand_uuid()
ip_address = self.get_instance_ip(instance_id)
ssh_client = ssh.Client(ip_address, CONF.aws.image_user, pkey=pkey)
cmd = 'sudo sh -c "echo \\"%s\\" >/dev/console"' % data_to_check
ssh_client.exec_command(cmd)
waiter = base.EC2Waiter(self.client.get_console_output)
waiter.wait_no_exception(InstanceId=instance_id)
def _compare_console_output():
data = self.client.get_console_output(InstanceId=instance_id)
self.assertEqual(instance_id, data['InstanceId'])
self.assertIsNotNone(data['Timestamp'])
self.assertIn('Output', data)
self.assertIn(data_to_check, data['Output'])
waiter = base.EC2Waiter(_compare_console_output)
waiter.wait_no_exception()
def test_run_and_ping_registered_image(self):
image_name = data_utils.rand_name("ami-name")
data = self.client.register_image(
Name=image_name, ImageLocation=CONF.aws.ami_image_location)
image_id = data['ImageId']
self.addResourceCleanUp(self.client.deregister_image, ImageId=image_id)
self.get_image_waiter().wait_available(image_id)
# launch this image
sec_group_name = self.create_standard_security_group()
instance_id = self.run_instance(ImageId=image_id,
SecurityGroups=[sec_group_name])
waiter = base.EC2Waiter(self.client.get_console_output)
waiter.wait_no_exception(InstanceId=instance_id)
def _compare_console_output():
data = self.client.get_console_output(InstanceId=instance_id)
self.assertEqual(instance_id, data['InstanceId'])
self.assertIsNotNone(data['Timestamp'])
self.assertIn('Output', data)
self.assertNotEqual('', data['Output'])
waiter = base.EC2Waiter(_compare_console_output)
waiter.wait_no_exception()
# check ping
ip_address = self.get_instance_ip(instance_id)
def _ping():
response = os.system("ping -c 1 " + ip_address + " > /dev/null")
self.assertEqual(0, response)
waiter = base.EC2Waiter(_ping)
waiter.wait_no_exception()
def _test_instances(self, subnet_size):
cidr = netaddr.IPNetwork('10.20.0.0/8')
cidr.prefixlen = subnet_size
vpc_id, subnet_id = self.create_vpc_and_subnet(str(cidr))
gw_id = self.create_and_attach_internet_gateway(vpc_id)
self.prepare_vpc_default_security_group(vpc_id)
self.prepare_route(vpc_id, gw_id)
key_name = data_utils.rand_name('testkey')
pkey = self.create_key_pair(key_name)
first_ip = str(netaddr.IPAddress(cidr.first + 4))
last_ip = str(netaddr.IPAddress(cidr.last - 1))
instance_id1 = self.run_instance(KeyName=key_name,
SubnetId=subnet_id,
PrivateIpAddress=first_ip)
instance_id2 = self.run_instance(KeyName=key_name,
SubnetId=subnet_id,
PrivateIpAddress=last_ip)
instance = self.get_instance(instance_id1)
self.assertEqual(first_ip, instance['PrivateIpAddress'])
instance = self.get_instance(instance_id2)
self.assertEqual(last_ip, instance['PrivateIpAddress'])
ip_address = self.get_instance_ip(instance_id1)
ssh_client = ssh.Client(ip_address, CONF.aws.image_user, pkey=pkey)
waiter = base.EC2Waiter(ssh_client.exec_command)
waiter.wait_no_exception('ping %s -c 1' % last_ip)
def test_reboot_instance(self):
key_name = data_utils.rand_name('testkey')
pkey = self.create_key_pair(key_name)
sec_group_name = self.create_standard_security_group()
instance_id = self.run_instance(KeyName=key_name,
ImageId=CONF.aws.image_id_ubuntu,
SecurityGroups=[sec_group_name])
ip_address = self.get_instance_ip(instance_id)
ssh_client = ssh.Client(ip_address, CONF.aws.image_user_ubuntu,
pkey=pkey)
last_lines = ssh_client.exec_command('last -x').split('\n')
self.client.reboot_instances(InstanceIds=[instance_id])
def _last_state():
current = ssh_client.exec_command('last -x').split('\n')
if len(current) > len(last_lines):
return
raise Exception()
waiter = base.EC2Waiter(_last_state)
waiter.wait_no_exception()
data = ssh_client.exec_command('last -x')
self.assertIn("shutdown", data)
def setUpClass(cls):
super(SnapshotPagingTest, cls).setUpClass()
if 'amazon' in CONF.aws.ec2_url:
raise cls.skipException('Paging is broken in Amazon.')
zone = CONF.aws.aws_zone
data = cls.client.create_volume(Size=1, AvailabilityZone=zone)
volume_id = data['VolumeId']
cls.addResourceCleanUpStatic(cls.client.delete_volume,
VolumeId=volume_id)
cls.get_volume_waiter().wait_available(volume_id)
def _create_snapshot():
try:
return cls.client.create_snapshot(VolumeId=volume_id)
except botocore.exceptions.ClientError as e:
code = (e.response.get('ResponseMetadata',
{}).get('HTTPStatusCode'))
if not code or code != 500:
raise
waiter = base.EC2Waiter(_create_snapshot)
cls.ids = list()
while len(cls.ids) < cls.SNAPSHOTS_COUNT:
time.sleep(10)
data = waiter.wait_for_result()
snapshot_id = data['SnapshotId']
cls.addResourceCleanUpStatic(cls.client.delete_snapshot,
SnapshotId=snapshot_id)
cls.get_snapshot_waiter().wait_available(snapshot_id,
final_set=('completed'))
cls.ids.append(snapshot_id)
def test_get_password_data_and_console_output(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
data = self.client.get_password_data(InstanceId=instance_id)
self.assertEqual(instance_id, data['InstanceId'])
self.assertIsNotNone(data['Timestamp'])
self.assertIn('PasswordData', data)
def _wait_for_output(*args, **kwargs):
data = self.client.get_console_output(*args, **kwargs)
self.assertIn('Output', data)
waiter = base.EC2Waiter(_wait_for_output)
waiter.wait_no_exception(InstanceId=instance_id)
data = self.client.get_console_output(InstanceId=instance_id)
self.assertEqual(instance_id, data['InstanceId'])
self.assertIsNotNone(data['Timestamp'])
self.assertIn('Output', data)
self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
def test_get_password_data_and_console_output(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
resp, data = self.client.RunInstances(
ImageId=image_id,
InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone},
MinCount=1,
MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
resp, data = self.client.GetPasswordData(InstanceId=instance_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(instance_id, data['InstanceId'])
self.assertIsNotNone(data['Timestamp'])
self.assertIn('PasswordData', data)
waiter = base.EC2Waiter(self.client.GetConsoleOutput)
waiter.wait_no_exception(InstanceId=instance_id)
resp, data = self.client.GetConsoleOutput(InstanceId=instance_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(instance_id, data['InstanceId'])
self.assertIsNotNone(data['Timestamp'])
self.assertIn('Output', data)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
