def ls(cls, filters=None, session=None):
"""List user AMIs.
:param filters: same as Filters parameters of describe_instances
(see botocore)
:type filters: dict
:return a list of instances
:rtype: list[Instance]
"""
if filters is None:
filters = []
result = []
for r in session.regions:
c = session.client('ec2', r)
region_result = c.describe_instances(Filters=filters)
for reservation in region_result['Reservations']:
if 'Instances' not in reservation:
continue
for instance in reservation['Instances']:
result.append(
Instance(instance['InstanceId'],
r,
data=instance,
session=session))
return result
def ls(cls, filters=None, session=None):
"""List user instances.
Note that instances in "terminated" mode are ignored.
:param filters: same as Filters parameters of describe_instances
(see botocore)
:type filters: dict
:return a list of instances
:rtype: list[Instance]
"""
if filters is None:
filters = []
result = []
for r in session.regions:
c = session.client("ec2", r)
region_result = c.describe_instances(Filters=filters)
for reservation in region_result["Reservations"]:
if "Instances" not in reservation:
continue
for instance_data in reservation["Instances"]:
if instance_data["State"]["Name"] == "terminated":
# Ignore instance that are going to disappear soon
continue
result.append(
Instance(
instance_data["InstanceId"],
r,
data=instance_data,
session=session,
))
return result
def __init__(self, group_id=None, region=None, data=None, session=None):
"""Initialize a security group.
:param group_id: group id. Used to retrieve group data
if data parameter is None
:type group_id: str | None
:param region: region of the security group
:type region: str | None
:param data: botocore data describing the group. If None
then data is fetched automatically using group id and
region
"""
if data is None:
assert region is not None and group_id is not None
data = session.client('ec2', region).describe_security_groups(
GroupIds=[group_id])['SecurityGroups'][0]
super(SecurityGroup, self).__init__(data, region)
def __init__(self, ami_id, region=None, data=None, session=None):
"""Inialize an AMI description object.
:param ami_id: the id of the AMI
:type ami_id: str
:param region: region in which the AMI is present. If None then
use default region
:type region: None | str
:param data: a dict representing the metadata of the AMI. If None then
download AMI description using EC2 api
:type data: dict | None
"""
if data is None:
assert ami_id is not None
data = session.client(
"ec2", region).describe_images(ImageIds=[ami_id])["Images"][0]
super().__init__(data, region)
def __init__(self, instance_id=None, region=None, data=None, session=None):
"""Initialize an EC2 instance description.
:param instance_id: instance id. Used to retrieve instance data
if data parameter is None
:type group_id: str | None
:param region: region of the security group
:type region: str | None
:param data: botocore data describing the instance. If None
then data is fetched automatically using instance id and
region
"""
if data is None:
assert instance_id is not None and region is not None
data = session.client('ec2', region).describe_instances(
InstanceIds=[instance_id])['Reservations']['Instances'][0]
super(Instance, self).__init__(data, region)
def __init__(self, snapshot_id=None, region=None, data=None, session=None):
"""Initialize an EC2 snapshot description.
:param snapshot_id: snapshot id. Used to retrieve snapshot data
if data parameter is None
:type snapshot_id: str | None
:param region: region of the snapshot
:type region: str | None
:param data: botocore data describing the snapshot. If None
then data is fetched automatically using snapshot id and
region
"""
if data is None:
assert snapshot_id is not None and region is not None
data = session.client('ec2', region).describe_snapshots(
SnapshotIds=[snapshot_id])['Snapshots'][0]
super(Snapshot, self).__init__(data, region)
def ls(cls, filters=None):
"""List user AMIs.
:param filters: same as Filters parameters of describe_volumes
(see botocore)
:type filters: dict
:return a list of volumes
:rtype: list[Volume]
"""
if filters is None:
filters = []
result = []
for r in session.regions:
c = session.client('ec2', r)
region_result = c.describe_volumes(Filters=filters)
for volume in region_result.get('Volumes', []):
result.append(Volume(volume['VolumeId'], r, data=volume))
return result
def ls(cls, filters=None, session=None):
"""List user AMIs.
:param filters: same as Filters parameters of describe_images
(see botocore)
:type filters: dict
:return a list of images
:rtype: list[AMI]
"""
if filters is None:
filters = []
result = []
for r in session.regions:
c = session.client("ec2", r)
region_result = c.describe_images(Owners=["self"], Filters=filters)
for ami in region_result["Images"]:
result.append(AMI(ami["ImageId"], r, data=ami, session=session))
return result
def ls(cls, filters=None, session=None):
"""List snapshots.
:param filters: same as Filters parameters of describe_snapshots
(see botocore)
:type filters: dict
:return a list of snaptshots
:rtype: list[Snapshot]
"""
if filters is None:
filters = []
result = []
for r in session.regions:
c = session.client("ec2", r)
region_result = c.describe_snapshots(OwnerIds=["self"], Filters=filters)
for snapshot in region_result.get("Snapshots", []):
result.append(Snapshot(snapshot["SnapshotId"], r, data=snapshot))
return result
def __init__(self, volume_id=None, region=None, data=None, session=None):
"""Initialize an EC2 volume description.
:param volume_id: volume id. Used to retrieve volume data
if data parameter is None
:type group_id: str | None
:param region: region of the volume
:type region: str | None
:param data: botocore data describing the volume. If None
then data is fetched automatically using volume id and
region
"""
if data is None:
assert volume_id is not None and region is not None
data = session.client(
'ec2',
region).describe_volumes(InstanceIds=[volume_id])['Volumes'][0]
super(Volume, self).__init__(data, region)
def ls(cls, filters=None, session=None):
"""List user security groups.
Note that this API is cross region. All regions used when creating
the session are used.
:param filters: same as Filters parameters of describe_security_groups
(see botocore)
:type filters: dict
:return a list of images
:rtype: list[SecurityGroup]
"""
if filters is None:
filters = []
result = []
for r in session.regions:
c = session.client('ec2', r)
region_result = c.describe_security_groups(Filters=filters)
for sg in region_result['SecurityGroups']:
result.append(SecurityGroup(sg['GroupId'], r, data=sg))
return result
def delete(self, session=None):
"""Delete a snapshot."""
session.client(
'ec2', self.region).delete_snapshot(SnapshotId=self.snapshot_id)
def delete(self):
"""Delete a volume."""
session.client('ec2',
self.region).delete_volume(VolumeId=self.volume_id)
