def setUp(self):
ec2.credentials.ACCESS_KEY_ID = 'abc'
ec2.credentials.SECRET_ACCESS_KEY = 'xyz'
# Build up two reservations, with two instances each, totalling 4 instances
# Two running, two stopped
reservations = []
instance_count = 0
for i in xrange(2):
i1 = Instance()
i1.id = 'i-abc%d' % instance_count
i1._state = RUNNING_STATE
i1.tags = {'Name': 'instance-%d' % instance_count}
instance_count += 1
i2 = Instance()
i2.id = 'i-abc%d' % instance_count
i2._state = STOPPED_STATE
i2.tags = {'Name': 'instance-%d' % instance_count}
instance_count += 1
reservation = MagicMock()
reservation.instances.__iter__ = MagicMock(return_value=iter([i1, i2]))
reservations.append(reservation)
security_groups = []
for i in xrange(2):
sg = SecurityGroup()
sg.id = 'sg-abc%d' % i
sg.name = 'group-%d' % i
sg.description = 'Group %d' % i
security_groups.append(sg)
self.connection = MagicMock()
self.connection.get_all_instances = MagicMock(return_value=reservations)
self.connection.get_all_security_groups = MagicMock(return_value=security_groups)
def setUp(self):
ec2.credentials.ACCESS_KEY_ID = 'abc'
ec2.credentials.SECRET_ACCESS_KEY = 'xyz'
# Build up two reservations, with two instances each, totalling 4 instances
# Two running, two stopped
reservations = []
instance_count = 0
for i in xrange(2):
i1 = Instance()
i1.id = 'i-abc%d' % instance_count
i1.state = 'running'
i1.tags = {'Name': 'instance-%d' % instance_count}
instance_count += 1
i2 = Instance()
i2.id = 'i-abc%d' % instance_count
i2.state = 'stopped'
i2.tags = {'Name': 'instance-%d' % instance_count}
instance_count += 1
reservation = MagicMock()
reservation.instances.__iter__ = MagicMock(
return_value=iter([i1, i2]))
reservations.append(reservation)
self.connection = MagicMock()
self.connection.get_all_instances = MagicMock(
return_value=reservations)
def setUp(self):
ec2.credentials.ACCESS_KEY_ID = 'abc'
ec2.credentials.SECRET_ACCESS_KEY = 'xyz'
# Build up two reservations, with two instances each, totalling 4 instances
# Two running, two stopped
reservations = []
instance_count = 0
for i in xrange(2):
i1 = Instance()
i1.id = 'i-abc%d' % instance_count
i1.state = 'running'
i1.tags = {'Name': 'instance-%d' % instance_count}
instance_count += 1
i2 = Instance()
i2.id = 'i-abc%d' % instance_count
i2.state = 'stopped'
i2.tags = {'Name': 'instance-%d' % instance_count}
instance_count += 1
reservation = MagicMock()
reservation.instances.__iter__ = MagicMock(return_value=iter([i1, i2]))
reservations.append(reservation)
self.connection = MagicMock()
self.connection.get_all_instances = MagicMock(return_value=reservations)
def setUp(self):
(flexmock(EC2Connection)
.should_receive('get_key_pair')
.and_return(None))
(flexmock(EC2Connection)
.should_receive('create_key_pair')
.with_args('bookeyname')
.and_return(KeyPair()))
(flexmock(EC2Connection)
.should_receive('get_all_security_groups')
.and_return([]))
(flexmock(EC2Connection)
.should_receive('create_security_group')
.with_args('boogroup', 'AppScale security group')
.and_return(SecurityGroup()))
(flexmock(EC2Connection)
.should_receive('authorize_security_group')
.and_return())
reservation = Reservation()
# the old implementation had a regression where public and private IPs
# were getting sorted, and thus public ip1 would point to private ip 2.
# to prevent this regression from resurfacing, set up the dns names so
# that a sort would mess them up again.
instance1 = Instance()
instance1.public_dns_name = 'ABC-public-ip1'
instance1.private_dns_name = 'DEF-private-ip1'
instance1.id = 'i-id1'
instance1._state.name = 'running'
instance1.key_name = 'bookeyname'
instance2 = Instance()
instance2.public_dns_name = 'DEF-public-ip2'
instance2.private_dns_name = 'ABC-private-ip2'
instance2.id = 'i-id2'
instance2._state.name = 'running'
instance2.key_name = 'bookeyname'
reservation.instances = [instance1, instance2]
(flexmock(EC2Connection)
.should_receive('get_all_instances')
.and_return([])
.and_return([reservation]))
(flexmock(EC2Connection)
.should_receive('run_instances')
.and_return())
(flexmock(utils)
.should_receive('get_secret')
.and_return('secret'))
(flexmock(utils)
.should_receive('sleep')
.and_return())
(flexmock(utils)
.should_receive('get_random_alphanumeric')
.and_return('0000000000'))
(flexmock(utils)
.should_receive('write_key_file')
.and_return())
def setUp(self):
(flexmock(EC2Connection)
.should_receive('get_key_pair')
.and_return(None))
(flexmock(EC2Connection)
.should_receive('create_key_pair')
.with_args('bookeyname')
.and_return(KeyPair()))
(flexmock(EC2Connection)
.should_receive('get_all_security_groups')
.and_return([]))
(flexmock(EC2Connection)
.should_receive('create_security_group')
.with_args('boogroup', 'AppScale security group')
.and_return(SecurityGroup()))
(flexmock(EC2Connection)
.should_receive('authorize_security_group')
.and_return())
reservation = Reservation()
# the old implementation had a regression where public and private IPs
# were getting sorted, and thus public ip1 would point to private ip 2.
# to prevent this regression from resurfacing, set up the dns names so
# that a sort would mess them up again.
instance1 = Instance()
instance1.public_dns_name = 'ABC-public-ip1'
instance1.private_dns_name = 'DEF-private-ip1'
instance1.id = 'i-id1'
instance1._state.name = 'running'
instance1.key_name = 'bookeyname'
instance2 = Instance()
instance2.public_dns_name = 'DEF-public-ip2'
instance2.private_dns_name = 'ABC-private-ip2'
instance2.id = 'i-id2'
instance2._state.name = 'running'
instance2.key_name = 'bookeyname'
reservation.instances = [instance1, instance2]
(flexmock(EC2Connection)
.should_receive('get_all_instances')
.and_return([])
.and_return([reservation]))
(flexmock(EC2Connection)
.should_receive('run_instances')
.and_return())
(flexmock(utils)
.should_receive('get_secret')
.and_return('secret'))
(flexmock(utils)
.should_receive('sleep')
.and_return())
(flexmock(utils)
.should_receive('get_random_alphanumeric')
.and_return('0000000000'))
(flexmock(utils)
.should_receive('write_key_file')
.and_return())
def setUp(self):
ec2.credentials.ACCESS_KEY_ID = 'abc'
ec2.credentials.SECRET_ACCESS_KEY = 'xyz'
# Build up two reservations, with two instances each, totalling 4 instances
# Two running, two stopped
reservations = []
instance_count = 0
for i in xrange(2):
i1 = Instance()
i1.id = 'i-abc%d' % instance_count
i1._state = RUNNING_STATE
i1.tags = {'Name': 'instance-%d' % instance_count}
instance_count += 1
i2 = Instance()
i2.id = 'i-abc%d' % instance_count
i2._state = STOPPED_STATE
i2.tags = {'Name': 'instance-%d' % instance_count}
instance_count += 1
reservation = MagicMock()
reservation.instances.__iter__ = MagicMock(return_value=iter([i1, i2]))
reservations.append(reservation)
security_groups = []
for i in xrange(2):
sg = SecurityGroup()
sg.id = 'sg-abc%d' % i
sg.name = 'group-%d' % i
sg.description = 'Group %d' % i
security_groups.append(sg)
vpcs = []
for i in xrange(2):
vpc = VPC()
vpc.id = 'vpc-abc%d' % i
if i % 2:
vpc.state = 'pending'
vpc.is_default = False
vpc.instance_tenancy = 'default'
else:
vpc.state = 'available'
vpc.is_default = True
vpc.instance_tenancy = 'dedicated'
vpc.cidr_block = '10.%d.0.0/16' % i
vpc.dhcp_options_id = 'dopt-abc%d' % i
vpcs.append(vpc)
self.connection = MagicMock()
self.connection.get_all_instances = MagicMock(return_value=reservations)
self.connection.get_all_security_groups = MagicMock(return_value=security_groups)
self.vpc_connection = MagicMock()
self.vpc_connection.get_all_vpcs = MagicMock(return_value=vpcs)
def setUp(self):
(flexmock(EC2Connection).should_receive('get_key_pair').and_return(
None))
(flexmock(EC2Connection).should_receive('create_key_pair').with_args(
'bookeyname').and_return(KeyPair()))
(flexmock(EC2Connection).should_receive(
'get_all_security_groups').and_return([]))
(flexmock(
EC2Connection).should_receive('create_security_group').with_args(
'boogroup',
'AppScale security group').and_return(SecurityGroup()))
(flexmock(EC2Connection).should_receive(
'authorize_security_group').and_return())
reservation = Reservation()
instance = Instance()
instance.private_dns_name = 'private-ip'
instance.public_dns_name = 'public-ip'
instance.id = 'i-id'
instance._state.name = 'running'
instance.key_name = 'bookeyname'
reservation.instances = [instance]
(flexmock(EC2Connection).should_receive(
'get_all_instances').and_return([]).and_return([reservation]))
(flexmock(EC2Connection).should_receive(
'terminate_instances').and_return([instance]))
(flexmock(EC2Connection).should_receive('run_instances').and_return())
(flexmock(utils).should_receive('get_secret').and_return('secret'))
(flexmock(utils).should_receive('sleep').and_return())
(flexmock(utils).should_receive('get_random_alphanumeric').and_return(
'0000000000'))
(flexmock(utils).should_receive('write_key_file').and_return())
def generate_instance(self, id, ip):
i = Instance()
i.id = id
i.private_ip_address = ip
i.private_dns_name = 'ip-{}.eu-west-1.compute.internal'.format(ip.replace('.', '-'))
i.tags = {'aws:cloudformation:stack-name': 'etc-cluster', 'aws:autoscaling:groupName': 'etc-cluster-postgres'}
return i
def run_instance(self,
image_id,
security_group_ids=None,
instance_type='m3.medium',
block_device_map=None):
instance = Instance()
instance.id = _new_id()
instance.root_device_name = '/dev/sda1'
instance._state.code = 0
instance._state.name = 'pending'
# Create volumes based on block device data from the image.
image = self.get_image(image_id)
instance_bdm = BlockDeviceMapping()
for device_name, bdm in image.block_device_mapping.iteritems():
# Create a new volume and attach it to the instance.
volume = Volume()
volume.size = 8
volume.id = _new_id()
self.volumes[volume.id] = volume
bdt = BlockDeviceType(volume_id=volume.id, size=8)
instance_bdm[device_name] = bdt
instance.block_device_mapping = instance_bdm
self.instances[instance.id] = instance
return instance
def generate_instance(self, id, ip):
i = Instance()
i.id = id
i.private_ip_address = ip
i.private_dns_name = 'ip-{}.eu-west-1.compute.internal'.format(ip.replace('.', '-'))
i.tags = {'aws:cloudformation:stack-name': 'etc-cluster', 'aws:autoscaling:groupName': 'etc-cluster-postgres'}
return i
def terminate_instances(self, instance_ids):
self.terminated.extend(instance_ids)
instances = []
for instance_id in instance_ids:
instance = Instance()
instance.id = instance_id
instances.append(instance)
return instances
def build_pending_reservations(instance_id):
instance = Instance()
instance.id = instance_id
instance.state = 'running'
instance.ip_address = '172.16.52.10'
instance.private_ip_address = '172.16.52.10'
r = Reservation()
r.instances = [instance]
return [r]
def run_instances(self, ami, *args, **kwargs):
self.instances.append("instance with ami %s and key %s and groups %s" % (
ami,
kwargs["key_name"],
", ".join(kwargs["security_groups"])
))
instance = Instance()
instance.id = 'i-00000302'
reservation = Reservation()
reservation.instances = [instance]
return reservation
def setUp(self):
(flexmock(EC2Connection)
.should_receive('get_key_pair')
.and_return(None))
(flexmock(EC2Connection)
.should_receive('create_key_pair')
.with_args('bookeyname')
.and_return(KeyPair()))
(flexmock(EC2Connection)
.should_receive('get_all_security_groups')
.and_return([]))
(flexmock(EC2Connection)
.should_receive('create_security_group')
.with_args('boogroup', 'AppScale security group')
.and_return(SecurityGroup()))
(flexmock(EC2Connection)
.should_receive('authorize_security_group')
.and_return())
reservation = Reservation()
instance = Instance()
instance.private_dns_name = 'private-ip'
instance.public_dns_name = 'public-ip'
instance.id = 'i-id'
instance._state.name = 'running'
instance.key_name = 'bookeyname'
reservation.instances = [instance]
(flexmock(EC2Connection)
.should_receive('get_all_instances')
.and_return([])
.and_return([reservation]))
(flexmock(EC2Connection)
.should_receive('terminate_instances')
.and_return([instance]))
(flexmock(EC2Connection)
.should_receive('run_instances')
.and_return())
(flexmock(utils)
.should_receive('get_secret')
.and_return('secret'))
(flexmock(utils)
.should_receive('sleep')
.and_return())
(flexmock(utils)
.should_receive('get_random_alphanumeric')
.and_return('0000000000'))
(flexmock(utils)
.should_receive('write_key_file')
.and_return())
def run_instance(self,
image_id,
security_group_ids=None,
instance_type='c3.xlarge',
placement=None,
block_device_map=None,
subnet_id=None,
user_data=None,
ebs_optimized=True,
instance_profile_name=None):
instance = Instance()
instance.id = new_id()
instance.image_id = image_id
instance.root_device_name = '/dev/sda1'
instance._state.code = 0
instance._state.name = 'pending'
# Create volumes based on block device data from the image.
image = self.get_image(image_id)
instance_bdm = BlockDeviceMapping()
for device_name, bdm in image.block_device_mapping.iteritems():
# Create a new volume and attach it to the instance.
volume = Volume()
volume.size = 8
volume.id = new_id()
self.volumes[volume.id] = volume
bdt = BlockDeviceType(volume_id=volume.id, size=8)
instance_bdm[device_name] = bdt
instance.block_device_mapping = instance_bdm
self.instances[instance.id] = instance
if self.run_instance_callback:
args = RunInstanceArgs()
args.image_id = image_id
args.instance_type = instance_type
args.ebs_optimized = ebs_optimized
args.security_group_ids = security_group_ids
args.subnet_id = subnet_id
args.user_data = user_data
args.instance = instance
self.run_instance_callback(args)
return instance
def setUp(self):
fake_ec2 = flexmock(name='fake_ec2')
fake_ec2.should_receive('get_key_pair')
fake_ec2.should_receive('create_key_pair').with_args('bookeyname') \
.and_return(KeyPair())
fake_ec2.should_receive('get_all_security_groups').and_return([])
fake_ec2.should_receive('create_security_group') \
.with_args('boogroup', 'AppScale security group') \
.and_return(SecurityGroup())
fake_ec2.should_receive('authorize_security_group')
reservation = Reservation()
instance = Instance()
instance.private_dns_name = 'private-ip'
instance.public_dns_name = 'public-ip'
instance.id = 'i-id'
instance._state.name = 'running'
instance.key_name = 'bookeyname'
reservation.instances = [instance]
fake_ec2.should_receive('get_all_instances').and_return([]) \
.and_return([reservation])
fake_ec2.should_receive('terminate_instances').and_return([instance])
fake_ec2.should_receive('request_spot_instances')
flexmock(boto.ec2)
boto.ec2.should_receive('connect_to_region').and_return(fake_ec2)
(flexmock(utils)
.should_receive('get_secret')
.and_return('secret'))
(flexmock(utils)
.should_receive('sleep')
.and_return())
(flexmock(utils)
.should_receive('get_random_alphanumeric')
.and_return('0000000000'))
(flexmock(utils)
.should_receive('write_key_file')
.and_return())
