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):
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 set_up(self):
self.old_requests_post = requests.post
self.old_requests_get = requests.get
self.old_requests_delete = requests.delete
requests.post = requests_post
requests.get = requests_get
requests.delete = requests_delete
self.ec2 = Instance()
self.ec2.id = 'i-foobar'
self.ec2.private_ip_address = '127.0.0.1'
self.ec2.private_dns_name = 'ip-127-0-0-1.eu-west-1.compute.internal'
self.ec2.tags = {
'aws:cloudformation:stack-name': 'etc-cluster',
'aws:autoscaling:groupName': 'etc-cluster-postgres'
}
self.ec2_member = EtcdMember(self.ec2)
self.etcd = {
'id':
'deadbeef',
'name':
'i-foobar2',
'clientURLs': [],
'peerURLs':
['http://127.0.0.2:{}'.format(EtcdMember.DEFAULT_PEER_PORT)],
}
self.etcd_member = EtcdMember(self.etcd)
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 __enter__(self):
self.connect()
self._resolve_baseami()
self._instance = Instance(connection=self._connection)
self._instance.id = get_instance_metadata()['instance-id']
self._instance.update()
context = self._config.context
if context.ami.get("base_ami_name", None):
environ["AMINATOR_BASE_AMI_NAME"] = context.ami.base_ami_name
if context.ami.get("base_ami_id", None):
environ["AMINATOR_BASE_AMI_ID"] = context.ami.base_ami_id
if context.cloud.get("region", None):
environ["AMINATOR_REGION"] = context.cloud.region
return self
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):
self.instance = Instance()
self.instance.state = 'running'
self.instance.id = 'i-abc'
self.instance.tags = {'Name': 'awesome'}
def setUp(self):
self.instance = Instance()
self.instance._state = RUNNING_STATE
self.instance.id = 'i-abc'
self.instance.tags = {'Name': 'awesome'}
