def test_connection_singleton(self, client_mock):
client_obj_mock = mock.Mock()
client_obj_mock._service_model.service_name = 'EC2'
client_mock.return_value = client_obj_mock
conn1 = connection.Connection()
conn2 = connection.Connection()
connection.boto3.client.assert_called_once_with(
'ec2', region_name=connection.Connection.context.region_name)
self.assertEquals(conn1, conn2)
def __init__(self, name=None, id=None, metadata=None, role=None):
self.id = id
self.name = name
self.metadata = metadata
self.role = role
self.ec2_conn = connection.Connection()
self.route53_conn = connection.Connection(resource=constants.ROUTE_53)
if self.metadata:
if self.metadata.get('Tags', None):
self.name = [
t['Value'] for t in self.metadata['Tags']
if t['Key'] == 'Name'
][0]
def create(cls, name, key_name, count, image, instance_type, subnet_id,
secgroup_ids, user_data, role):
conn = connection.Connection()
_instances = conn.run_instances(
ImageId=Instances.get_ami_id(image),
MinCount=count,
MaxCount=count,
InstanceType=instance_type,
KeyName=key_name,
UserData=user_data,
NetworkInterfaces=[{
'DeviceIndex': 0,
'SubnetId': subnet_id,
'Groups': secgroup_ids,
'AssociatePublicIpAddress': True
}],
IamInstanceProfile={'Name': constants.IPA_EC2_IAM_ROLE}
if role == 'IPA' else {})
_ids = [i['InstanceId'] for i in _instances['Instances']]
_instances_json = Instances.load_json(ids=_ids)
_instances = []
for i in _instances_json:
_instance = Instance(id=i['InstanceId'],
name=name,
metadata=i,
role=role)
_instance.create_tags()
_instances.append(_instance)
return Instances(instances=_instances)
def __init__(self, name, vpc_id):
self.name = name
self.vpc = vpc.VPC(id=vpc_id)
self.ec2_conn = connection.Connection()
_role = constants.ROLES.get(self.__class__.__name__.upper(), 'DEFAULT')
self.role = _role
self.subnet = None
def get_iam_role(name, create=False):
iam_conn = connection.Connection('iam')
try:
return iam_conn.get_role(RoleName=name)
except iam_conn.exceptions.NoSuchEntityException:
if create:
return create_iam_role(name)
def _create(cls, cidr_block, vpc_id, name, gateway_id):
_ec2_conn = connection.Connection()
return _ec2_conn.create_subnet(
VpcId=vpc_id,
CidrBlock=cidr_block,
AvailabilityZone=Subnet._availability_zone()
)['Subnet']
def __init__(self, id=None, metadata=None):
self.ec2_conn = connection.Connection()
self.route53_conn = connection.Connection(resource=constants.ROUTE_53)
self.id = id
self.metadata = metadata
self.instances = []
self.secgroup_ids = []
self.subnet_ids = []
self.route_table_ids = []
self.route_related_ids = []
self.gateway_ids = []
self.subnets = []
self.association_ids = []
self.hosted_zone_id = None
self.reverse_hosted_zone_id = None
self.hosted_zone_ids = []
def create_iam_role(name, description=''):
iam_conn = connection.Connection('iam')
assume_role_policy_document = '''{ \
"Version": "2012-10-17", \
"Statement": { \
"Effect": "Allow", \
"Principal": {"Service": "ec2.amazonaws.com"}, \
"Action": "sts:AssumeRole" \
} \
} \
'''
role = iam_conn.create_role(
RoleName=name,
AssumeRolePolicyDocument=assume_role_policy_document,
Description=description
)
iam_conn.attach_role_policy(
RoleName=name,
PolicyArn='arn:aws:iam::aws:policy/AmazonEC2FullAccess'
)
iam_conn.create_instance_profile(
InstanceProfileName=name
)
iam_conn.add_role_to_instance_profile(
RoleName=name,
InstanceProfileName=name
)
return role
def disable(port, group_id, protocol='tcp', anywhere=True):
port = int(port)
conn = connection.Connection()
conn.revoke_security_group_ingress(CidrIp=_get_ip(anywhere),
FromPort=port,
ToPort=port,
GroupId=group_id,
IpProtocol=protocol)
def load_json(cls, ids=None, filters=None):
"""Fetch instance details"""
conn = connection.Connection()
if ids:
response = conn.describe_instances(InstanceIds=ids)['Reservations']
elif filters:
response = conn.describe_instances(Filters=filters)['Reservations']
else:
return []
return sum([r['Instances'] for r in response], [])
def create(
cls,
name,
key_name,
count,
image_id,
instance_type,
subnet_id,
secgroup_ids,
user_data,
hosted_zone_id,
reverse_hosted_zone_id,
role
):
conn = connection.Connection()
_instances = conn.run_instances(
ImageId=image_id,
MinCount=count,
MaxCount=count,
InstanceType=instance_type,
KeyName=key_name,
UserData=user_data,
NetworkInterfaces=[{
'DeviceIndex': 0,
'SubnetId': subnet_id,
'Groups': secgroup_ids,
'AssociatePublicIpAddress': True
}]
)
_ids = [i['InstanceId'] for i in _instances['Instances']]
_instances_json = Instances.load_json(ids=_ids)
_instances = []
for i in _instances_json:
_instance = Instance(
id=i['InstanceId'],
name=name,
metadata=i,
role=role
)
_instance.create_tags()
_instance.configure_dns_record(
hosted_zone_id
)
_instance.configure_dns_record(
reverse_hosted_zone_id,
reverse=True
)
_instances.append(_instance)
return Instances(instances=_instances)
def create(cls, cidr_block, vpc_id, name, gateway_id):
_ec2_conn = connection.Connection()
response = _ec2_conn.create_subnet(
VpcId=vpc_id,
CidrBlock=cidr_block,
AvailabilityZone=Subnet._availability_zone())
_subnet = Subnet(id=response['Subnet']['SubnetId'],
name=name,
metadata=response,
vpc_id=vpc_id)
_subnet.create_tags()
_subnet._create_route_table(gateway_id)
return _subnet
def __init__(
self,
name,
vpc_id
):
self.name = name
self.vpc = vpc.VPC(id=vpc_id)
self.route_53_conn = connection.Connection(constants.ROUTE_53)
self.instances = None
_role = constants.ROLES.get(
self.__class__.__name__.upper(),
'DEFAULT'
)
self.role = _role
class EC2Object:
ec2_conn = connection.Connection()
def __init__(self, name=None, id=None, metadata=None, role=None):
self._id = id
self.metadata = metadata
self._role = role
self._name = name
@property
def id(self):
return self._extract_id() or self._id
@property
def role(self):
return self._extract_attr_from_tags('Role') or self._role or ''
@property
def name(self):
return self._extract_attr_from_tags('Name') or self._name or ''
def create_tags(self):
if self.name:
tags = self._prepare_tag_attributes_for('name')
if self.role:
tags = tags + self._prepare_tag_attributes_for('role')
self.ec2_conn.create_tags(Resources=[self.id], Tags=tags)
def _prepare_tag_attributes_for(self, attr):
return [{'Key': attr.title(), 'Value': getattr(self, attr)}]
def _extract_id(self):
if self.metadata:
return self.metadata.get(self.__class__.__name__.title() + 'Id',
None)
def _extract_attr_from_tags(self, attr):
if self._tag_exists():
return [
t['Value'] for t in self.metadata['Tags'] if t['Key'] == attr
][0]
def _tag_exists(self):
return self.metadata and self.metadata.get('Tags', None)
def get_ami_id(cls, image):
conn = connection.Connection()
images = conn.describe_images(Filters=[{
'Name': 'name',
'Values': [image + '*']
}, {
'Name': 'owner-id',
'Values': ['309956199498']
}, {
'Name': 'image-type',
'Values': ['machine']
}], )['Images']
def get_time(str):
return datetime.strptime(str, '%Y-%m-%dT%H:%M:%S.%fZ')
return reduce((lambda x, y: x if get_time(x['CreationDate']) >
get_time(y['CreationDate']) else y), images)['ImageId']
def _load_json(cls, vpc_id, name, restrict_one=True):
_ec2_conn = connection.Connection()
_json = _ec2_conn.describe_subnets(
Filters=[
{
'Name': 'vpc-id',
'Values': [vpc_id]
},
{
'Name': 'tag:Name',
'Values': [name]
}
]
)['Subnets']
if restrict_one:
if len(_json) > 1:
raise ValueError("Multiple Subnets with name: " + name)
elif _json:
return _json[0]
else:
return _json
from urllib import request
from treadmill.infra import connection
import sys
my_ip = request.urlopen(
'http://ip.42.pl/raw'
).read().decode('utf-8') + '/32'
conn = connection.Connection()
conn.revoke_security_group_ingress(
CidrIp=my_ip,
FromPort=22,
ToPort=22,
GroupId=sys.argv[1],
IpProtocol='tcp'
)
from treadmill.infra import constants, connection
import sys
hosted_zones_to_keep = sys.argv[1:]
route53_conn = connection.Connection(resource=constants.ROUTE_53)
hosted_zones = route53_conn.list_hosted_zones()['HostedZones']
hosted_zone_ids = [hosted_zone['Id'] for hosted_zone in hosted_zones]
hosted_zone_ids = list(set(hosted_zone_ids) - set(hosted_zones_to_keep))
for id in hosted_zone_ids:
records = route53_conn.list_resource_record_sets(
HostedZoneId=id)['ResourceRecordSets']
for record in records:
if record['Type'] not in ["SOA", "NS"]:
route53_conn.change_resource_record_sets(
HostedZoneId=id.split('/')[-1],
ChangeBatch={
'Changes': [{
'Action': 'DELETE',
'ResourceRecordSet': {
'Name': record['Name'],
'Type': record['Type'],
'TTL': record['TTL'],
'ResourceRecords': record['ResourceRecords']
}
}]
})
route53_conn.delete_hosted_zone(Id=id)
print("Deleted" + str(id))
def test_establish_with_region(self):
connection.Connection.context.region_name = 'foobar'
conn = connection.Connection()
connection.boto3.client.assert_called_with('ec2', region_name='foobar')
self.assertEquals(conn, 'foo')
def __init__(self, instances):
self.instances = instances
self.volume_ids = []
self.ec2_conn = connection.Connection()
