monkee.ch/SickGear
1
0
Fork 0
mirror of https://github.com/SickGear/SickGear.git synced 2024-12-04 18:33:38 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
SickGear/lib/boto/ec2/connection.py

4528 lines
175 KiB
Python
Raw Normal View History

Change replace imdb lib with imdb-pie 5.6.3 (df7411d1).
2018-08-28 16:01:48 +00:00
# Copyright (c) 2006-2012 Mitch Garnaat http://garnaat.org/
# Copyright (c) 2010, Eucalyptus Systems, Inc.
# Copyright (c) 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish, dis-
# tribute, sublicense, and/or sell copies of the Software, and to permit
# persons to whom the Software is furnished to do so, subject to the fol-
# lowing conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
"""
Represents a connection to the EC2 service.
"""
import base64
import warnings
from datetime import datetime
from datetime import timedelta
import boto
from boto.auth import detect_potential_sigv4
from boto.connection import AWSQueryConnection
from boto.resultset import ResultSet
from boto.ec2.image import Image, ImageAttribute, CopyImage
from boto.ec2.instance import Reservation, Instance
from boto.ec2.instance import ConsoleOutput, InstanceAttribute
from boto.ec2.keypair import KeyPair
from boto.ec2.address import Address
from boto.ec2.volume import Volume, VolumeAttribute
from boto.ec2.snapshot import Snapshot
from boto.ec2.snapshot import SnapshotAttribute
from boto.ec2.zone import Zone
from boto.ec2.securitygroup import SecurityGroup
from boto.ec2.regioninfo import RegionInfo
from boto.ec2.instanceinfo import InstanceInfo
from boto.ec2.reservedinstance import ReservedInstancesOffering
from boto.ec2.reservedinstance import ReservedInstance
from boto.ec2.reservedinstance import ReservedInstanceListing
from boto.ec2.reservedinstance import ReservedInstancesConfiguration
from boto.ec2.reservedinstance import ModifyReservedInstancesResult
from boto.ec2.reservedinstance import ReservedInstancesModification
from boto.ec2.spotinstancerequest import SpotInstanceRequest
from boto.ec2.spotpricehistory import SpotPriceHistory
from boto.ec2.spotdatafeedsubscription import SpotDatafeedSubscription
from boto.ec2.bundleinstance import BundleInstanceTask
from boto.ec2.placementgroup import PlacementGroup
from boto.ec2.tag import Tag
from boto.ec2.instancetype import InstanceType
from boto.ec2.instancestatus import InstanceStatusSet
from boto.ec2.volumestatus import VolumeStatusSet
from boto.ec2.networkinterface import NetworkInterface
from boto.ec2.attributes import AccountAttribute, VPCAttribute
from boto.ec2.blockdevicemapping import BlockDeviceMapping, BlockDeviceType
from boto.exception import EC2ResponseError
from boto.compat import six
#boto.set_stream_logger('ec2')
class EC2Connection(AWSQueryConnection):
APIVersion = boto.config.get('Boto', 'ec2_version', '2014-10-01')
DefaultRegionName = boto.config.get('Boto', 'ec2_region_name', 'us-east-1')
DefaultRegionEndpoint = boto.config.get('Boto', 'ec2_region_endpoint',
'ec2.us-east-1.amazonaws.com')
ResponseError = EC2ResponseError
def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
is_secure=True, host=None, port=None,
proxy=None, proxy_port=None,
proxy_user=None, proxy_pass=None, debug=0,
https_connection_factory=None, region=None, path='/',
api_version=None, security_token=None,
validate_certs=True, profile_name=None):
"""
Init method to create a new connection to EC2.
"""
if not region:
region = RegionInfo(self, self.DefaultRegionName,
self.DefaultRegionEndpoint)
self.region = region
super(EC2Connection, self).__init__(aws_access_key_id,
aws_secret_access_key,
is_secure, port, proxy, proxy_port,
proxy_user, proxy_pass,
self.region.endpoint, debug,
https_connection_factory, path,
security_token,
validate_certs=validate_certs,
profile_name=profile_name)
if api_version:
self.APIVersion = api_version
def _required_auth_capability(self):
return ['hmac-v4']
def get_params(self):
"""
Returns a dictionary containing the value of all of the keyword
arguments passed when constructing this connection.
"""
param_names = ['aws_access_key_id', 'aws_secret_access_key',
'is_secure', 'port', 'proxy', 'proxy_port',
'proxy_user', 'proxy_pass',
'debug', 'https_connection_factory']
params = {}
for name in param_names:
params[name] = getattr(self, name)
return params
def build_filter_params(self, params, filters):
if not isinstance(filters, dict):
filters = dict(filters)
i = 1
for name in filters:
aws_name = name
if not aws_name.startswith('tag:'):
aws_name = name.replace('_', '-')
params['Filter.%d.Name' % i] = aws_name
value = filters[name]
if not isinstance(value, list):
value = [value]
j = 1
for v in value:
params['Filter.%d.Value.%d' % (i, j)] = v
j += 1
i += 1
# Image methods
def get_all_images(self, image_ids=None, owners=None,
executable_by=None, filters=None, dry_run=False):
"""
Retrieve all the EC2 images available on your account.
:type image_ids: list
:param image_ids: A list of strings with the image IDs wanted
:type owners: list
:param owners: A list of owner IDs, the special strings 'self',
'amazon', and 'aws-marketplace', may be used to describe
images owned by you, Amazon or AWS Marketplace
respectively
:type executable_by: list
:param executable_by: Returns AMIs for which the specified
user ID has explicit launch permissions
:type filters: dict
:param filters: Optional filters that can be used to limit the
results returned. Filters are provided in the form of a
dictionary consisting of filter names as the key and
filter values as the value. The set of allowable filter
names/values is dependent on the request being performed.
Check the EC2 API guide for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.image.Image`
"""
params = {}
if image_ids:
self.build_list_params(params, image_ids, 'ImageId')
if owners:
self.build_list_params(params, owners, 'Owner')
if executable_by:
self.build_list_params(params, executable_by, 'ExecutableBy')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeImages', params,
[('item', Image)], verb='POST')
def get_all_kernels(self, kernel_ids=None, owners=None, dry_run=False):
"""
Retrieve all the EC2 kernels available on your account.
Constructs a filter to allow the processing to happen server side.
:type kernel_ids: list
:param kernel_ids: A list of strings with the image IDs wanted
:type owners: list
:param owners: A list of owner IDs
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.image.Image`
"""
params = {}
if kernel_ids:
self.build_list_params(params, kernel_ids, 'ImageId')
if owners:
self.build_list_params(params, owners, 'Owner')
filter = {'image-type': 'kernel'}
self.build_filter_params(params, filter)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeImages', params,
[('item', Image)], verb='POST')
def get_all_ramdisks(self, ramdisk_ids=None, owners=None, dry_run=False):
"""
Retrieve all the EC2 ramdisks available on your account.
Constructs a filter to allow the processing to happen server side.
:type ramdisk_ids: list
:param ramdisk_ids: A list of strings with the image IDs wanted
:type owners: list
:param owners: A list of owner IDs
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.image.Image`
"""
params = {}
if ramdisk_ids:
self.build_list_params(params, ramdisk_ids, 'ImageId')
if owners:
self.build_list_params(params, owners, 'Owner')
filter = {'image-type': 'ramdisk'}
self.build_filter_params(params, filter)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeImages', params,
[('item', Image)], verb='POST')
def get_image(self, image_id, dry_run=False):
"""
Shortcut method to retrieve a specific image (AMI).
:type image_id: string
:param image_id: the ID of the Image to retrieve
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.image.Image`
:return: The EC2 Image specified or None if the image is not found
"""
try:
return self.get_all_images(image_ids=[image_id], dry_run=dry_run)[0]
except IndexError: # None of those images available
return None
def register_image(self, name=None, description=None, image_location=None,
architecture=None, kernel_id=None, ramdisk_id=None,
root_device_name=None, block_device_map=None,
dry_run=False, virtualization_type=None,
sriov_net_support=None,
snapshot_id=None,
delete_root_volume_on_termination=False):
"""
Register an image.
:type name: string
:param name: The name of the AMI. Valid only for EBS-based images.
:type description: string
:param description: The description of the AMI.
:type image_location: string
:param image_location: Full path to your AMI manifest in
Amazon S3 storage. Only used for S3-based AMI's.
:type architecture: string
:param architecture: The architecture of the AMI. Valid choices are:
* i386
* x86_64
:type kernel_id: string
:param kernel_id: The ID of the kernel with which to launch
the instances
:type root_device_name: string
:param root_device_name: The root device name (e.g. /dev/sdh)
:type block_device_map: :class:`boto.ec2.blockdevicemapping.BlockDeviceMapping`
:param block_device_map: A BlockDeviceMapping data structure
describing the EBS volumes associated with the Image.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:type virtualization_type: string
:param virtualization_type: The virutalization_type of the image.
Valid choices are:
* paravirtual
* hvm
:type sriov_net_support: string
:param sriov_net_support: Advanced networking support.
Valid choices are:
* simple
:type snapshot_id: string
:param snapshot_id: A snapshot ID for the snapshot to be used
as root device for the image. Mutually exclusive with
block_device_map, requires root_device_name
:type delete_root_volume_on_termination: bool
:param delete_root_volume_on_termination: Whether to delete the root
volume of the image after instance termination. Only applies when
creating image from snapshot_id. Defaults to False. Note that
leaving volumes behind after instance termination is not free.
:rtype: string
:return: The new image id
"""
params = {}
if name:
params['Name'] = name
if description:
params['Description'] = description
if architecture:
params['Architecture'] = architecture
if kernel_id:
params['KernelId'] = kernel_id
if ramdisk_id:
params['RamdiskId'] = ramdisk_id
if image_location:
params['ImageLocation'] = image_location
if root_device_name:
params['RootDeviceName'] = root_device_name
if snapshot_id:
root_vol = BlockDeviceType(snapshot_id=snapshot_id,
delete_on_termination=delete_root_volume_on_termination)
block_device_map = BlockDeviceMapping()
block_device_map[root_device_name] = root_vol
if block_device_map:
block_device_map.ec2_build_list_params(params)
if dry_run:
params['DryRun'] = 'true'
if virtualization_type:
params['VirtualizationType'] = virtualization_type
if sriov_net_support:
params['SriovNetSupport'] = sriov_net_support
rs = self.get_object('RegisterImage', params, ResultSet, verb='POST')
image_id = getattr(rs, 'imageId', None)
return image_id
def deregister_image(self, image_id, delete_snapshot=False, dry_run=False):
"""
Unregister an AMI.
:type image_id: string
:param image_id: the ID of the Image to unregister
:type delete_snapshot: bool
:param delete_snapshot: Set to True if we should delete the
snapshot associated with an EBS volume mounted at /dev/sda1
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
snapshot_id = None
if delete_snapshot:
image = self.get_image(image_id)
for key in image.block_device_mapping:
if key == "/dev/sda1":
snapshot_id = image.block_device_mapping[key].snapshot_id
break
params = {
'ImageId': image_id,
}
if dry_run:
params['DryRun'] = 'true'
result = self.get_status('DeregisterImage',
params, verb='POST')
if result and snapshot_id:
return result and self.delete_snapshot(snapshot_id)
return result
def create_image(self, instance_id, name,
description=None, no_reboot=False,
block_device_mapping=None, dry_run=False):
"""
Will create an AMI from the instance in the running or stopped
state.
:type instance_id: string
:param instance_id: the ID of the instance to image.
:type name: string
:param name: The name of the new image
:type description: string
:param description: An optional human-readable string describing
the contents and purpose of the AMI.
:type no_reboot: bool
:param no_reboot: An optional flag indicating that the
bundling process should not attempt to shutdown the
instance before bundling. If this flag is True, the
responsibility of maintaining file system integrity is
left to the owner of the instance.
:type block_device_mapping: :class:`boto.ec2.blockdevicemapping.BlockDeviceMapping`
:param block_device_mapping: A BlockDeviceMapping data structure
describing the EBS volumes associated with the Image.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: string
:return: The new image id
"""
params = {'InstanceId': instance_id,
'Name': name}
if description:
params['Description'] = description
if no_reboot:
params['NoReboot'] = 'true'
if block_device_mapping:
block_device_mapping.ec2_build_list_params(params)
if dry_run:
params['DryRun'] = 'true'
img = self.get_object('CreateImage', params, Image, verb='POST')
return img.id
# ImageAttribute methods
def get_image_attribute(self, image_id, attribute='launchPermission',
dry_run=False):
"""
Gets an attribute from an image.
:type image_id: string
:param image_id: The Amazon image id for which you want info about
:type attribute: string
:param attribute: The attribute you need information about.
Valid choices are:
* launchPermission
* productCodes
* blockDeviceMapping
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.image.ImageAttribute`
:return: An ImageAttribute object representing the value of the
attribute requested
"""
params = {'ImageId': image_id,
'Attribute': attribute}
if dry_run:
params['DryRun'] = 'true'
return self.get_object('DescribeImageAttribute', params,
ImageAttribute, verb='POST')
def modify_image_attribute(self, image_id, attribute='launchPermission',
operation='add', user_ids=None, groups=None,
product_codes=None, dry_run=False):
"""
Changes an attribute of an image.
:type image_id: string
:param image_id: The image id you wish to change
:type attribute: string
:param attribute: The attribute you wish to change
:type operation: string
:param operation: Either add or remove (this is required for changing
launchPermissions)
:type user_ids: list
:param user_ids: The Amazon IDs of users to add/remove attributes
:type groups: list
:param groups: The groups to add/remove attributes
:type product_codes: list
:param product_codes: Amazon DevPay product code. Currently only one
product code can be associated with an AMI. Once
set, the product code cannot be changed or reset.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'ImageId': image_id,
'Attribute': attribute,
'OperationType': operation}
if user_ids:
self.build_list_params(params, user_ids, 'UserId')
if groups:
self.build_list_params(params, groups, 'UserGroup')
if product_codes:
self.build_list_params(params, product_codes, 'ProductCode')
if dry_run:
params['DryRun'] = 'true'
return self.get_status('ModifyImageAttribute', params, verb='POST')
def reset_image_attribute(self, image_id, attribute='launchPermission',
dry_run=False):
"""
Resets an attribute of an AMI to its default value.
:type image_id: string
:param image_id: ID of the AMI for which an attribute will be described
:type attribute: string
:param attribute: The attribute to reset
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: Whether the operation succeeded or not
"""
params = {'ImageId': image_id,
'Attribute': attribute}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('ResetImageAttribute', params, verb='POST')
# Instance methods
def get_all_instances(self, instance_ids=None, filters=None, dry_run=False,
max_results=None):
"""
Retrieve all the instance reservations associated with your account.
.. note::
This method's current behavior is deprecated in favor of
:meth:`get_all_reservations`. A future major release will change
:meth:`get_all_instances` to return a list of
:class:`boto.ec2.instance.Instance` objects as its name suggests.
To obtain that behavior today, use :meth:`get_only_instances`.
:type instance_ids: list
:param instance_ids: A list of strings of instance IDs
:type filters: dict
:param filters: Optional filters that can be used to limit the
results returned. Filters are provided in the form of a
dictionary consisting of filter names as the key and
filter values as the value. The set of allowable filter
names/values is dependent on the request being performed.
Check the EC2 API guide for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:type max_results: int
:param max_results: The maximum number of paginated instance
items per response.
:rtype: list
:return: A list of :class:`boto.ec2.instance.Reservation`
"""
warnings.warn(('The current get_all_instances implementation will be '
'replaced with get_all_reservations.'),
PendingDeprecationWarning)
return self.get_all_reservations(instance_ids=instance_ids,
filters=filters, dry_run=dry_run,
max_results=max_results)
def get_only_instances(self, instance_ids=None, filters=None,
dry_run=False, max_results=None):
# A future release should rename this method to get_all_instances
# and make get_only_instances an alias for that.
"""
Retrieve all the instances associated with your account.
:type instance_ids: list
:param instance_ids: A list of strings of instance IDs
:type filters: dict
:param filters: Optional filters that can be used to limit the
results returned. Filters are provided in the form of a
dictionary consisting of filter names as the key and
filter values as the value. The set of allowable filter
names/values is dependent on the request being performed.
Check the EC2 API guide for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:type max_results: int
:param max_results: The maximum number of paginated instance
items per response.
:rtype: list
:return: A list of :class:`boto.ec2.instance.Instance`
"""
next_token = None
retval = []
while True:
reservations = self.get_all_reservations(instance_ids=instance_ids,
filters=filters,
dry_run=dry_run,
max_results=max_results,
next_token=next_token)
retval.extend([instance for reservation in reservations for
instance in reservation.instances])
next_token = reservations.next_token
if not next_token:
break
return retval
def get_all_reservations(self, instance_ids=None, filters=None,
dry_run=False, max_results=None, next_token=None):
"""
Retrieve all the instance reservations associated with your account.
:type instance_ids: list
:param instance_ids: A list of strings of instance IDs
:type filters: dict
:param filters: Optional filters that can be used to limit the
results returned. Filters are provided in the form of a
dictionary consisting of filter names as the key and
filter values as the value. The set of allowable filter
names/values is dependent on the request being performed.
Check the EC2 API guide for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:type max_results: int
:param max_results: The maximum number of paginated instance
items per response.
:type next_token: str
:param next_token: A string specifying the next paginated set
of results to return.
:rtype: list
:return: A list of :class:`boto.ec2.instance.Reservation`
"""
params = {}
if instance_ids:
self.build_list_params(params, instance_ids, 'InstanceId')
if filters:
if 'group-id' in filters:
gid = filters.get('group-id')
if not gid.startswith('sg-') or len(gid) != 11:
warnings.warn(
"The group-id filter now requires a security group "
"identifier (sg-*) instead of a group name. To filter "
"by group name use the 'group-name' filter instead.",
UserWarning)
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
if max_results is not None:
params['MaxResults'] = max_results
if next_token:
params['NextToken'] = next_token
return self.get_list('DescribeInstances', params,
[('item', Reservation)], verb='POST')
def get_all_instance_status(self, instance_ids=None,
max_results=None, next_token=None,
filters=None, dry_run=False,
include_all_instances=False):
"""
Retrieve all the instances in your account scheduled for maintenance.
:type instance_ids: list
:param instance_ids: A list of strings of instance IDs
:type max_results: int
:param max_results: The maximum number of paginated instance
items per response.
:type next_token: str
:param next_token: A string specifying the next paginated set
of results to return.
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:type include_all_instances: bool
:param include_all_instances: Set to True if all
instances should be returned. (Only running
instances are included by default.)
:rtype: list
:return: A list of instances that have maintenance scheduled.
"""
params = {}
if instance_ids:
self.build_list_params(params, instance_ids, 'InstanceId')
if max_results:
params['MaxResults'] = max_results
if next_token:
params['NextToken'] = next_token
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
if include_all_instances:
params['IncludeAllInstances'] = 'true'
return self.get_object('DescribeInstanceStatus', params,
InstanceStatusSet, verb='POST')
def run_instances(self, image_id, min_count=1, max_count=1,
key_name=None, security_groups=None,
user_data=None, addressing_type=None,
instance_type='m1.small', placement=None,
kernel_id=None, ramdisk_id=None,
monitoring_enabled=False, subnet_id=None,
block_device_map=None,
disable_api_termination=False,
instance_initiated_shutdown_behavior=None,
private_ip_address=None,
placement_group=None, client_token=None,
security_group_ids=None,
additional_info=None, instance_profile_name=None,
instance_profile_arn=None, tenancy=None,
ebs_optimized=False, network_interfaces=None,
dry_run=False):
"""
Runs an image on EC2.
:type image_id: string
:param image_id: The ID of the image to run.
:type min_count: int
:param min_count: The minimum number of instances to launch.
:type max_count: int
:param max_count: The maximum number of instances to launch.
:type key_name: string
:param key_name: The name of the key pair with which to
launch instances.
:type security_groups: list of strings
:param security_groups: The names of the EC2 classic security groups
with which to associate instances
:type user_data: string
:param user_data: The user data passed to the launched instances
:type instance_type: string
:param instance_type: The type of instance to run:
* t1.micro
* m1.small
* m1.medium
* m1.large
* m1.xlarge
* m3.medium
* m3.large
* m3.xlarge
* m3.2xlarge
* c1.medium
* c1.xlarge
* m2.xlarge
* m2.2xlarge
* m2.4xlarge
* cr1.8xlarge
* hi1.4xlarge
* hs1.8xlarge
* cc1.4xlarge
* cg1.4xlarge
* cc2.8xlarge
* g2.2xlarge
* c3.large
* c3.xlarge
* c3.2xlarge
* c3.4xlarge
* c3.8xlarge
* c4.large
* c4.xlarge
* c4.2xlarge
* c4.4xlarge
* c4.8xlarge
* i2.xlarge
* i2.2xlarge
* i2.4xlarge
* i2.8xlarge
* t2.micro
* t2.small
* t2.medium
:type placement: string
:param placement: The Availability Zone to launch the instance into.
:type kernel_id: string
:param kernel_id: The ID of the kernel with which to launch the
instances.
:type ramdisk_id: string
:param ramdisk_id: The ID of the RAM disk with which to launch the
instances.
:type monitoring_enabled: bool
:param monitoring_enabled: Enable detailed CloudWatch monitoring on
the instance.
:type subnet_id: string
:param subnet_id: The subnet ID within which to launch the instances
for VPC.
:type private_ip_address: string
:param private_ip_address: If you're using VPC, you can
optionally use this parameter to assign the instance a
specific available IP address from the subnet (e.g.,
10.0.0.25).
:type block_device_map: :class:`boto.ec2.blockdevicemapping.BlockDeviceMapping`
:param block_device_map: A BlockDeviceMapping data structure
describing the EBS volumes associated with the Image.
:type disable_api_termination: bool
:param disable_api_termination: If True, the instances will be locked
and will not be able to be terminated via the API.
:type instance_initiated_shutdown_behavior: string
:param instance_initiated_shutdown_behavior: Specifies whether the
instance stops or terminates on instance-initiated shutdown.
Valid values are:
* stop
* terminate
:type placement_group: string
:param placement_group: If specified, this is the name of the placement
group in which the instance(s) will be launched.
:type client_token: string
:param client_token: Unique, case-sensitive identifier you provide
to ensure idempotency of the request. Maximum 64 ASCII characters.
:type security_group_ids: list of strings
:param security_group_ids: The ID of the VPC security groups with
which to associate instances.
:type additional_info: string
:param additional_info: Specifies additional information to make
available to the instance(s).
:type tenancy: string
:param tenancy: The tenancy of the instance you want to
launch. An instance with a tenancy of 'dedicated' runs on
single-tenant hardware and can only be launched into a
VPC. Valid values are:"default" or "dedicated".
NOTE: To use dedicated tenancy you MUST specify a VPC
subnet-ID as well.
:type instance_profile_arn: string
:param instance_profile_arn: The Amazon resource name (ARN) of
the IAM Instance Profile (IIP) to associate with the instances.
:type instance_profile_name: string
:param instance_profile_name: The name of
the IAM Instance Profile (IIP) to associate with the instances.
:type ebs_optimized: bool
:param ebs_optimized: Whether the instance is optimized for
EBS I/O. This optimization provides dedicated throughput
to Amazon EBS and an optimized configuration stack to
provide optimal EBS I/O performance. This optimization
isn't available with all instance types.
:type network_interfaces: :class:`boto.ec2.networkinterface.NetworkInterfaceCollection`
:param network_interfaces: A NetworkInterfaceCollection data
structure containing the ENI specifications for the instance.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: Reservation
:return: The :class:`boto.ec2.instance.Reservation` associated with
the request for machines
"""
params = {'ImageId': image_id,
'MinCount': min_count,
'MaxCount': max_count}
if key_name:
params['KeyName'] = key_name
if security_group_ids:
l = []
for group in security_group_ids:
if isinstance(group, SecurityGroup):
l.append(group.id)
else:
l.append(group)
self.build_list_params(params, l, 'SecurityGroupId')
if security_groups:
l = []
for group in security_groups:
if isinstance(group, SecurityGroup):
l.append(group.name)
else:
l.append(group)
self.build_list_params(params, l, 'SecurityGroup')
if user_data:
if isinstance(user_data, six.text_type):
user_data = user_data.encode('utf-8')
params['UserData'] = base64.b64encode(user_data).decode('utf-8')
if addressing_type:
params['AddressingType'] = addressing_type
if instance_type:
params['InstanceType'] = instance_type
if placement:
params['Placement.AvailabilityZone'] = placement
if placement_group:
params['Placement.GroupName'] = placement_group
if tenancy:
params['Placement.Tenancy'] = tenancy
if kernel_id:
params['KernelId'] = kernel_id
if ramdisk_id:
params['RamdiskId'] = ramdisk_id
if monitoring_enabled:
params['Monitoring.Enabled'] = 'true'
if subnet_id:
params['SubnetId'] = subnet_id
if private_ip_address:
params['PrivateIpAddress'] = private_ip_address
if block_device_map:
block_device_map.ec2_build_list_params(params)
if disable_api_termination:
params['DisableApiTermination'] = 'true'
if instance_initiated_shutdown_behavior:
val = instance_initiated_shutdown_behavior
params['InstanceInitiatedShutdownBehavior'] = val
if client_token:
params['ClientToken'] = client_token
if additional_info:
params['AdditionalInfo'] = additional_info
if instance_profile_name:
params['IamInstanceProfile.Name'] = instance_profile_name
if instance_profile_arn:
params['IamInstanceProfile.Arn'] = instance_profile_arn
if ebs_optimized:
params['EbsOptimized'] = 'true'
if network_interfaces:
network_interfaces.build_list_params(params)
if dry_run:
params['DryRun'] = 'true'
return self.get_object('RunInstances', params, Reservation,
verb='POST')
def terminate_instances(self, instance_ids=None, dry_run=False):
"""
Terminate the instances specified
:type instance_ids: list
:param instance_ids: A list of strings of the Instance IDs to terminate
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of the instances terminated
"""
params = {}
if instance_ids:
self.build_list_params(params, instance_ids, 'InstanceId')
if dry_run:
params['DryRun'] = 'true'
return self.get_list('TerminateInstances', params,
[('item', Instance)], verb='POST')
def stop_instances(self, instance_ids=None, force=False, dry_run=False):
"""
Stop the instances specified
:type instance_ids: list
:param instance_ids: A list of strings of the Instance IDs to stop
:type force: bool
:param force: Forces the instance to stop
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of the instances stopped
"""
params = {}
if force:
params['Force'] = 'true'
if instance_ids:
self.build_list_params(params, instance_ids, 'InstanceId')
if dry_run:
params['DryRun'] = 'true'
return self.get_list('StopInstances', params,
[('item', Instance)], verb='POST')
def start_instances(self, instance_ids=None, dry_run=False):
"""
Start the instances specified
:type instance_ids: list
:param instance_ids: A list of strings of the Instance IDs to start
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of the instances started
"""
params = {}
if instance_ids:
self.build_list_params(params, instance_ids, 'InstanceId')
if dry_run:
params['DryRun'] = 'true'
return self.get_list('StartInstances', params,
[('item', Instance)], verb='POST')
def get_console_output(self, instance_id, dry_run=False):
"""
Retrieves the console output for the specified instance.
:type instance_id: string
:param instance_id: The instance ID of a running instance on the cloud.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.instance.ConsoleOutput`
:return: The console output as a ConsoleOutput object
"""
params = {}
self.build_list_params(params, [instance_id], 'InstanceId')
if dry_run:
params['DryRun'] = 'true'
return self.get_object('GetConsoleOutput', params,
ConsoleOutput, verb='POST')
def reboot_instances(self, instance_ids=None, dry_run=False):
"""
Reboot the specified instances.
:type instance_ids: list
:param instance_ids: The instances to terminate and reboot
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {}
if instance_ids:
self.build_list_params(params, instance_ids, 'InstanceId')
if dry_run:
params['DryRun'] = 'true'
return self.get_status('RebootInstances', params)
def confirm_product_instance(self, product_code, instance_id,
dry_run=False):
"""
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'ProductCode': product_code,
'InstanceId': instance_id}
if dry_run:
params['DryRun'] = 'true'
rs = self.get_object('ConfirmProductInstance', params,
ResultSet, verb='POST')
return (rs.status, rs.ownerId)
# InstanceAttribute methods
def get_instance_attribute(self, instance_id, attribute, dry_run=False):
"""
Gets an attribute from an instance.
:type instance_id: string
:param instance_id: The Amazon id of the instance
:type attribute: string
:param attribute: The attribute you need information about
Valid choices are:
* instanceType
* kernel
* ramdisk
* userData
* disableApiTermination
* instanceInitiatedShutdownBehavior
* rootDeviceName
* blockDeviceMapping
* productCodes
* sourceDestCheck
* groupSet
* ebsOptimized
* sriovNetSupport
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.image.InstanceAttribute`
:return: An InstanceAttribute object representing the value of the
attribute requested
"""
params = {'InstanceId': instance_id}
if attribute:
params['Attribute'] = attribute
if dry_run:
params['DryRun'] = 'true'
return self.get_object('DescribeInstanceAttribute', params,
InstanceAttribute, verb='POST')
def modify_network_interface_attribute(self, interface_id, attr, value,
attachment_id=None, dry_run=False):
"""
Changes an attribute of a network interface.
:type interface_id: string
:param interface_id: The interface id. Looks like 'eni-xxxxxxxx'
:type attr: string
:param attr: The attribute you wish to change.
Learn more at http://docs.aws.amazon.com/AWSEC2/latest/API\
Reference/ApiReference-query-ModifyNetworkInterfaceAttribute.html
* description - Textual description of interface
* groupSet - List of security group ids or group objects
* sourceDestCheck - Boolean
* deleteOnTermination - Boolean. Must also specify attachment_id
:type value: string
:param value: The new value for the attribute
:rtype: bool
:return: Whether the operation succeeded or not
:type attachment_id: string
:param attachment_id: If you're modifying DeleteOnTermination you must
specify the attachment_id.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
bool_reqs = (
'deleteontermination',
'sourcedestcheck',
)
if attr.lower() in bool_reqs:
if isinstance(value, bool):
if value:
value = 'true'
else:
value = 'false'
elif value not in ['true', 'false']:
raise ValueError('%s must be a boolean, "true", or "false"!'
% attr)
params = {'NetworkInterfaceId': interface_id}
# groupSet is handled differently from other arguments
if attr.lower() == 'groupset':
for idx, sg in enumerate(value):
if isinstance(sg, SecurityGroup):
sg = sg.id
params['SecurityGroupId.%s' % (idx + 1)] = sg
elif attr.lower() == 'description':
params['Description.Value'] = value
elif attr.lower() == 'sourcedestcheck':
params['SourceDestCheck.Value'] = value
elif attr.lower() == 'deleteontermination':
params['Attachment.DeleteOnTermination'] = value
if not attachment_id:
raise ValueError('You must also specify an attachment_id')
params['Attachment.AttachmentId'] = attachment_id
else:
raise ValueError('Unknown attribute "%s"' % (attr,))
if dry_run:
params['DryRun'] = 'true'
return self.get_status(
'ModifyNetworkInterfaceAttribute', params, verb='POST')
def modify_instance_attribute(self, instance_id, attribute, value,
dry_run=False):
"""
Changes an attribute of an instance
:type instance_id: string
:param instance_id: The instance id you wish to change
:type attribute: string
:param attribute: The attribute you wish to change.
* instanceType - A valid instance type (m1.small)
* kernel - Kernel ID (None)
* ramdisk - Ramdisk ID (None)
* userData - Base64 encoded String (None)
* disableApiTermination - Boolean (true)
* instanceInitiatedShutdownBehavior - stop|terminate
* blockDeviceMapping - List of strings - ie: ['/dev/sda=false']
* sourceDestCheck - Boolean (true)
* groupSet - Set of Security Groups or IDs
* ebsOptimized - Boolean (false)
* sriovNetSupport - String - ie: 'simple'
:type value: string
:param value: The new value for the attribute
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: Whether the operation succeeded or not
"""
# Allow a bool to be passed in for value of disableApiTermination
bool_reqs = ('disableapitermination',
'sourcedestcheck',
'ebsoptimized')
if attribute.lower() in bool_reqs:
if isinstance(value, bool):
if value:
value = 'true'
else:
value = 'false'
params = {'InstanceId': instance_id}
# groupSet is handled differently from other arguments
if attribute.lower() == 'groupset':
for idx, sg in enumerate(value):
if isinstance(sg, SecurityGroup):
sg = sg.id
params['GroupId.%s' % (idx + 1)] = sg
elif attribute.lower() == 'blockdevicemapping':
for idx, kv in enumerate(value):
dev_name, _, flag = kv.partition('=')
pre = 'BlockDeviceMapping.%d' % (idx + 1)
params['%s.DeviceName' % pre] = dev_name
params['%s.Ebs.DeleteOnTermination' % pre] = flag or 'true'
else:
# for backwards compatibility handle lowercase first letter
attribute = attribute[0].upper() + attribute[1:]
params['%s.Value' % attribute] = value
if dry_run:
params['DryRun'] = 'true'
return self.get_status('ModifyInstanceAttribute', params, verb='POST')
def reset_instance_attribute(self, instance_id, attribute, dry_run=False):
"""
Resets an attribute of an instance to its default value.
:type instance_id: string
:param instance_id: ID of the instance
:type attribute: string
:param attribute: The attribute to reset. Valid values are:
kernel|ramdisk
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: Whether the operation succeeded or not
"""
params = {'InstanceId': instance_id,
'Attribute': attribute}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('ResetInstanceAttribute', params, verb='POST')
# Spot Instances
def get_all_spot_instance_requests(self, request_ids=None,
filters=None, dry_run=False):
"""
Retrieve all the spot instances requests associated with your account.
:type request_ids: list
:param request_ids: A list of strings of spot instance request IDs
:type filters: dict
:param filters: Optional filters that can be used to limit the
results returned. Filters are provided in the form of a
dictionary consisting of filter names as the key and
filter values as the value. The set of allowable filter
names/values is dependent on the request being performed.
Check the EC2 API guide for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of
:class:`boto.ec2.spotinstancerequest.SpotInstanceRequest`
"""
params = {}
if request_ids:
self.build_list_params(params, request_ids, 'SpotInstanceRequestId')
if filters:
if 'launch.group-id' in filters:
lgid = filters.get('launch.group-id')
if not lgid.startswith('sg-') or len(lgid) != 11:
warnings.warn(
"The 'launch.group-id' filter now requires a security "
"group id (sg-*) and no longer supports filtering by "
"group name. Please update your filters accordingly.",
UserWarning)
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeSpotInstanceRequests', params,
[('item', SpotInstanceRequest)], verb='POST')
def get_spot_price_history(self, start_time=None, end_time=None,
instance_type=None, product_description=None,
availability_zone=None, dry_run=False,
max_results=None, next_token=None,
filters=None):
"""
Retrieve the recent history of spot instances pricing.
:type start_time: str
:param start_time: An indication of how far back to provide price
changes for. An ISO8601 DateTime string.
:type end_time: str
:param end_time: An indication of how far forward to provide price
changes for. An ISO8601 DateTime string.
:type instance_type: str
:param instance_type: Filter responses to a particular instance type.
:type product_description: str
:param product_description: Filter responses to a particular platform.
Valid values are currently:
* Linux/UNIX
* SUSE Linux
* Windows
* Linux/UNIX (Amazon VPC)
* SUSE Linux (Amazon VPC)
* Windows (Amazon VPC)
:type availability_zone: str
:param availability_zone: The availability zone for which prices
should be returned. If not specified, data for all
availability zones will be returned.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:type max_results: int
:param max_results: The maximum number of paginated items
per response.
:type next_token: str
:param next_token: The next set of rows to return. This should
be the value of the ``next_token`` attribute from a previous
call to ``get_spot_price_history``.
:type filters: dict
:param filters: Optional filters that can be used to limit the
results returned. Filters are provided in the form of a
dictionary consisting of filter names as the key and
filter values as the value. The set of allowable filter
names/values is dependent on the request being performed.
Check the EC2 API guide for details.
:rtype: list
:return: A list tuples containing price and timestamp.
"""
params = {}
if start_time:
params['StartTime'] = start_time
if end_time:
params['EndTime'] = end_time
if instance_type:
params['InstanceType'] = instance_type
if product_description:
params['ProductDescription'] = product_description
if availability_zone:
params['AvailabilityZone'] = availability_zone
if dry_run:
params['DryRun'] = 'true'
if max_results is not None:
params['MaxResults'] = max_results
if next_token:
params['NextToken'] = next_token
if filters:
self.build_filter_params(params, filters)
return self.get_list('DescribeSpotPriceHistory', params,
[('item', SpotPriceHistory)], verb='POST')
def request_spot_instances(self, price, image_id, count=1, type='one-time',
valid_from=None, valid_until=None,
launch_group=None, availability_zone_group=None,
key_name=None, security_groups=None,
user_data=None, addressing_type=None,
instance_type='m1.small', placement=None,
kernel_id=None, ramdisk_id=None,
monitoring_enabled=False, subnet_id=None,
placement_group=None,
block_device_map=None,
instance_profile_arn=None,
instance_profile_name=None,
security_group_ids=None,
ebs_optimized=False,
network_interfaces=None, dry_run=False):
"""
Request instances on the spot market at a particular price.
:type price: str
:param price: The maximum price of your bid
:type image_id: string
:param image_id: The ID of the image to run
:type count: int
:param count: The of instances to requested
:type type: str
:param type: Type of request. Can be 'one-time' or 'persistent'.
Default is one-time.
:type valid_from: str
:param valid_from: Start date of the request. An ISO8601 time string.
:type valid_until: str
:param valid_until: End date of the request. An ISO8601 time string.
:type launch_group: str
:param launch_group: If supplied, all requests will be fulfilled
as a group.
:type availability_zone_group: str
:param availability_zone_group: If supplied, all requests will be
fulfilled within a single availability zone.
:type key_name: string
:param key_name: The name of the key pair with which to
launch instances
:type security_groups: list of strings
:param security_groups: The names of the security groups with which to
associate instances
:type user_data: string
:param user_data: The user data passed to the launched instances
:type instance_type: string
:param instance_type: The type of instance to run:
* t1.micro
* m1.small
* m1.medium
* m1.large
* m1.xlarge
* m3.medium
* m3.large
* m3.xlarge
* m3.2xlarge
* c1.medium
* c1.xlarge
* m2.xlarge
* m2.2xlarge
* m2.4xlarge
* cr1.8xlarge
* hi1.4xlarge
* hs1.8xlarge
* cc1.4xlarge
* cg1.4xlarge
* cc2.8xlarge
* g2.2xlarge
* c3.large
* c3.xlarge
* c3.2xlarge
* c3.4xlarge
* c3.8xlarge
* c4.large
* c4.xlarge
* c4.2xlarge
* c4.4xlarge
* c4.8xlarge
* i2.xlarge
* i2.2xlarge
* i2.4xlarge
* i2.8xlarge
* t2.micro
* t2.small
* t2.medium
:type placement: string
:param placement: The availability zone in which to launch
the instances
:type kernel_id: string
:param kernel_id: The ID of the kernel with which to launch the
instances
:type ramdisk_id: string
:param ramdisk_id: The ID of the RAM disk with which to launch the
instances
:type monitoring_enabled: bool
:param monitoring_enabled: Enable detailed CloudWatch monitoring on
the instance.
:type subnet_id: string
:param subnet_id: The subnet ID within which to launch the instances
for VPC.
:type placement_group: string
:param placement_group: If specified, this is the name of the placement
group in which the instance(s) will be launched.
:type block_device_map: :class:`boto.ec2.blockdevicemapping.BlockDeviceMapping`
:param block_device_map: A BlockDeviceMapping data structure
describing the EBS volumes associated with the Image.
:type security_group_ids: list of strings
:param security_group_ids: The ID of the VPC security groups with
which to associate instances.
:type instance_profile_arn: string
:param instance_profile_arn: The Amazon resource name (ARN) of
the IAM Instance Profile (IIP) to associate with the instances.
:type instance_profile_name: string
:param instance_profile_name: The name of
the IAM Instance Profile (IIP) to associate with the instances.
:type ebs_optimized: bool
:param ebs_optimized: Whether the instance is optimized for
EBS I/O. This optimization provides dedicated throughput
to Amazon EBS and an optimized configuration stack to
provide optimal EBS I/O performance. This optimization
isn't available with all instance types.
:type network_interfaces: list
:param network_interfaces: A list of
:class:`boto.ec2.networkinterface.NetworkInterfaceSpecification`
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: Reservation
:return: The :class:`boto.ec2.spotinstancerequest.SpotInstanceRequest`
associated with the request for machines
"""
ls = 'LaunchSpecification'
params = {'%s.ImageId' % ls: image_id,
'Type': type,
'SpotPrice': price}
if count:
params['InstanceCount'] = count
if valid_from:
params['ValidFrom'] = valid_from
if valid_until:
params['ValidUntil'] = valid_until
if launch_group:
params['LaunchGroup'] = launch_group
if availability_zone_group:
params['AvailabilityZoneGroup'] = availability_zone_group
if key_name:
params['%s.KeyName' % ls] = key_name
if security_group_ids:
l = []
for group in security_group_ids:
if isinstance(group, SecurityGroup):
l.append(group.id)
else:
l.append(group)
self.build_list_params(params, l,
'%s.SecurityGroupId' % ls)
if security_groups:
l = []
for group in security_groups:
if isinstance(group, SecurityGroup):
l.append(group.name)
else:
l.append(group)
self.build_list_params(params, l, '%s.SecurityGroup' % ls)
if user_data:
params['%s.UserData' % ls] = base64.b64encode(user_data)
if addressing_type:
params['%s.AddressingType' % ls] = addressing_type
if instance_type:
params['%s.InstanceType' % ls] = instance_type
if placement:
params['%s.Placement.AvailabilityZone' % ls] = placement
if kernel_id:
params['%s.KernelId' % ls] = kernel_id
if ramdisk_id:
params['%s.RamdiskId' % ls] = ramdisk_id
if monitoring_enabled:
params['%s.Monitoring.Enabled' % ls] = 'true'
if subnet_id:
params['%s.SubnetId' % ls] = subnet_id
if placement_group:
params['%s.Placement.GroupName' % ls] = placement_group
if block_device_map:
block_device_map.ec2_build_list_params(params, '%s.' % ls)
if instance_profile_name:
params['%s.IamInstanceProfile.Name' % ls] = instance_profile_name
if instance_profile_arn:
params['%s.IamInstanceProfile.Arn' % ls] = instance_profile_arn
if ebs_optimized:
params['%s.EbsOptimized' % ls] = 'true'
if network_interfaces:
network_interfaces.build_list_params(params, prefix=ls + '.')
if dry_run:
params['DryRun'] = 'true'
return self.get_list('RequestSpotInstances', params,
[('item', SpotInstanceRequest)],
verb='POST')
def cancel_spot_instance_requests(self, request_ids, dry_run=False):
"""
Cancel the specified Spot Instance Requests.
:type request_ids: list
:param request_ids: A list of strings of the Request IDs to terminate
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of the instances terminated
"""
params = {}
if request_ids:
self.build_list_params(params, request_ids, 'SpotInstanceRequestId')
if dry_run:
params['DryRun'] = 'true'
return self.get_list('CancelSpotInstanceRequests', params,
[('item', SpotInstanceRequest)], verb='POST')
def get_spot_datafeed_subscription(self, dry_run=False):
"""
Return the current spot instance data feed subscription
associated with this account, if any.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.spotdatafeedsubscription.SpotDatafeedSubscription`
:return: The datafeed subscription object or None
"""
params = {}
if dry_run:
params['DryRun'] = 'true'
return self.get_object('DescribeSpotDatafeedSubscription',
params, SpotDatafeedSubscription, verb='POST')
def create_spot_datafeed_subscription(self, bucket, prefix, dry_run=False):
"""
Create a spot instance datafeed subscription for this account.
:type bucket: str or unicode
:param bucket: The name of the bucket where spot instance data
will be written. The account issuing this request
must have FULL_CONTROL access to the bucket
specified in the request.
:type prefix: str or unicode
:param prefix: An optional prefix that will be pre-pended to all
data files written to the bucket.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.spotdatafeedsubscription.SpotDatafeedSubscription`
:return: The datafeed subscription object or None
"""
params = {'Bucket': bucket}
if prefix:
params['Prefix'] = prefix
if dry_run:
params['DryRun'] = 'true'
return self.get_object('CreateSpotDatafeedSubscription',
params, SpotDatafeedSubscription, verb='POST')
def delete_spot_datafeed_subscription(self, dry_run=False):
"""
Delete the current spot instance data feed subscription
associated with this account
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
params = {}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('DeleteSpotDatafeedSubscription',
params, verb='POST')
# Zone methods
def get_all_zones(self, zones=None, filters=None, dry_run=False):
"""
Get all Availability Zones associated with the current region.
:type zones: list
:param zones: Optional list of zones. If this list is present,
only the Zones associated with these zone names
will be returned.
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list of :class:`boto.ec2.zone.Zone`
:return: The requested Zone objects
"""
params = {}
if zones:
self.build_list_params(params, zones, 'ZoneName')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeAvailabilityZones', params,
[('item', Zone)], verb='POST')
# Address methods
def get_all_addresses(self, addresses=None, filters=None,
allocation_ids=None, dry_run=False):
"""
Get all EIP's associated with the current credentials.
:type addresses: list
:param addresses: Optional list of addresses. If this list is present,
only the Addresses associated with these addresses
will be returned.
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type allocation_ids: list
:param allocation_ids: Optional list of allocation IDs. If this list is
present, only the Addresses associated with the given
allocation IDs will be returned.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list of :class:`boto.ec2.address.Address`
:return: The requested Address objects
"""
params = {}
if addresses:
self.build_list_params(params, addresses, 'PublicIp')
if allocation_ids:
self.build_list_params(params, allocation_ids, 'AllocationId')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeAddresses', params, [('item', Address)], verb='POST')
def allocate_address(self, domain=None, dry_run=False):
"""
Allocate a new Elastic IP address and associate it with your account.
:type domain: string
:param domain: Optional string. If domain is set to "vpc" the address
will be allocated to VPC . Will return address object with
allocation_id.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.address.Address`
:return: The newly allocated Address
"""
params = {}
if domain is not None:
params['Domain'] = domain
if dry_run:
params['DryRun'] = 'true'
return self.get_object('AllocateAddress', params, Address, verb='POST')
def assign_private_ip_addresses(self, network_interface_id=None,
private_ip_addresses=None,
secondary_private_ip_address_count=None,
allow_reassignment=False, dry_run=False):
"""
Assigns one or more secondary private IP addresses to a network
interface in Amazon VPC.
:type network_interface_id: string
:param network_interface_id: The network interface to which the IP
address will be assigned.
:type private_ip_addresses: list
:param private_ip_addresses: Assigns the specified IP addresses as
secondary IP addresses to the network interface.
:type secondary_private_ip_address_count: int
:param secondary_private_ip_address_count: The number of secondary IP
addresses to assign to the network interface. You cannot specify
this parameter when also specifying private_ip_addresses.
:type allow_reassignment: bool
:param allow_reassignment: Specifies whether to allow an IP address
that is already assigned to another network interface or instance
to be reassigned to the specified network interface.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
params = {}
if network_interface_id is not None:
params['NetworkInterfaceId'] = network_interface_id
if private_ip_addresses is not None:
self.build_list_params(params, private_ip_addresses,
'PrivateIpAddress')
elif secondary_private_ip_address_count is not None:
params['SecondaryPrivateIpAddressCount'] = \
secondary_private_ip_address_count
if allow_reassignment:
params['AllowReassignment'] = 'true'
if dry_run:
params['DryRun'] = 'true'
return self.get_status('AssignPrivateIpAddresses', params, verb='POST')
def _associate_address(self, status, instance_id=None, public_ip=None,
allocation_id=None, network_interface_id=None,
private_ip_address=None, allow_reassociation=False,
dry_run=False):
params = {}
if instance_id is not None:
params['InstanceId'] = instance_id
elif network_interface_id is not None:
params['NetworkInterfaceId'] = network_interface_id
# Allocation id trumps public ip in order to associate with VPCs
if allocation_id is not None:
params['AllocationId'] = allocation_id
elif public_ip is not None:
params['PublicIp'] = public_ip
if private_ip_address is not None:
params['PrivateIpAddress'] = private_ip_address
if allow_reassociation:
params['AllowReassociation'] = 'true'
if dry_run:
params['DryRun'] = 'true'
if status:
return self.get_status('AssociateAddress', params, verb='POST')
else:
return self.get_object('AssociateAddress', params, Address,
verb='POST')
def associate_address(self, instance_id=None, public_ip=None,
allocation_id=None, network_interface_id=None,
private_ip_address=None, allow_reassociation=False,
dry_run=False):
"""
Associate an Elastic IP address with a currently running instance.
This requires one of ``public_ip`` or ``allocation_id`` depending
on if you're associating a VPC address or a plain EC2 address.
When using an Allocation ID, make sure to pass ``None`` for ``public_ip``
as EC2 expects a single parameter and if ``public_ip`` is passed boto
will preference that instead of ``allocation_id``.
:type instance_id: string
:param instance_id: The ID of the instance
:type public_ip: string
:param public_ip: The public IP address for EC2 based allocations.
:type allocation_id: string
:param allocation_id: The allocation ID for a VPC-based elastic IP.
:type network_interface_id: string
:param network_interface_id: The network interface ID to which
elastic IP is to be assigned to
:type private_ip_address: string
:param private_ip_address: The primary or secondary private IP address
to associate with the Elastic IP address.
:type allow_reassociation: bool
:param allow_reassociation: Specify this option to allow an Elastic IP
address that is already associated with another network interface
or instance to be re-associated with the specified instance or
interface.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
return self._associate_address(True, instance_id=instance_id,
public_ip=public_ip, allocation_id=allocation_id,
network_interface_id=network_interface_id,
private_ip_address=private_ip_address,
allow_reassociation=allow_reassociation, dry_run=dry_run)
def associate_address_object(self, instance_id=None, public_ip=None,
allocation_id=None, network_interface_id=None,
private_ip_address=None, allow_reassociation=False,
dry_run=False):
"""
Associate an Elastic IP address with a currently running instance.
This requires one of ``public_ip`` or ``allocation_id`` depending
on if you're associating a VPC address or a plain EC2 address.
When using an Allocation ID, make sure to pass ``None`` for ``public_ip``
as EC2 expects a single parameter and if ``public_ip`` is passed boto
will preference that instead of ``allocation_id``.
:type instance_id: string
:param instance_id: The ID of the instance
:type public_ip: string
:param public_ip: The public IP address for EC2 based allocations.
:type allocation_id: string
:param allocation_id: The allocation ID for a VPC-based elastic IP.
:type network_interface_id: string
:param network_interface_id: The network interface ID to which
elastic IP is to be assigned to
:type private_ip_address: string
:param private_ip_address: The primary or secondary private IP address
to associate with the Elastic IP address.
:type allow_reassociation: bool
:param allow_reassociation: Specify this option to allow an Elastic IP
address that is already associated with another network interface
or instance to be re-associated with the specified instance or
interface.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: class:`boto.ec2.address.Address`
:return: The associated address instance
"""
return self._associate_address(False, instance_id=instance_id,
public_ip=public_ip, allocation_id=allocation_id,
network_interface_id=network_interface_id,
private_ip_address=private_ip_address,
allow_reassociation=allow_reassociation, dry_run=dry_run)
def disassociate_address(self, public_ip=None, association_id=None,
dry_run=False):
"""
Disassociate an Elastic IP address from a currently running instance.
:type public_ip: string
:param public_ip: The public IP address for EC2 elastic IPs.
:type association_id: string
:param association_id: The association ID for a VPC based elastic ip.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
params = {}
# If there is an association id it trumps public ip
# in order to successfully dissassociate with a VPC elastic ip
if association_id is not None:
params['AssociationId'] = association_id
elif public_ip is not None:
params['PublicIp'] = public_ip
if dry_run:
params['DryRun'] = 'true'
return self.get_status('DisassociateAddress', params, verb='POST')
def release_address(self, public_ip=None, allocation_id=None,
dry_run=False):
"""
Free up an Elastic IP address. Pass a public IP address to
release an EC2 Elastic IP address and an AllocationId to
release a VPC Elastic IP address. You should only pass
one value.
This requires one of ``public_ip`` or ``allocation_id`` depending
on if you're associating a VPC address or a plain EC2 address.
When using an Allocation ID, make sure to pass ``None`` for ``public_ip``
as EC2 expects a single parameter and if ``public_ip`` is passed boto
will preference that instead of ``allocation_id``.
:type public_ip: string
:param public_ip: The public IP address for EC2 elastic IPs.
:type allocation_id: string
:param allocation_id: The Allocation ID for VPC elastic IPs.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
params = {}
if public_ip is not None:
params['PublicIp'] = public_ip
elif allocation_id is not None:
params['AllocationId'] = allocation_id
if dry_run:
params['DryRun'] = 'true'
return self.get_status('ReleaseAddress', params, verb='POST')
def unassign_private_ip_addresses(self, network_interface_id=None,
private_ip_addresses=None, dry_run=False):
"""
Unassigns one or more secondary private IP addresses from a network
interface in Amazon VPC.
:type network_interface_id: string
:param network_interface_id: The network interface from which the
secondary private IP address will be unassigned.
:type private_ip_addresses: list
:param private_ip_addresses: Specifies the secondary private IP
addresses that you want to unassign from the network interface.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
params = {}
if network_interface_id is not None:
params['NetworkInterfaceId'] = network_interface_id
if private_ip_addresses is not None:
self.build_list_params(params, private_ip_addresses,
'PrivateIpAddress')
if dry_run:
params['DryRun'] = 'true'
return self.get_status('UnassignPrivateIpAddresses', params,
verb='POST')
# Volume methods
def get_all_volumes(self, volume_ids=None, filters=None, dry_run=False):
"""
Get all Volumes associated with the current credentials.
:type volume_ids: list
:param volume_ids: Optional list of volume ids. If this list
is present, only the volumes associated with
these volume ids will be returned.
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list of :class:`boto.ec2.volume.Volume`
:return: The requested Volume objects
"""
params = {}
if volume_ids:
self.build_list_params(params, volume_ids, 'VolumeId')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeVolumes', params,
[('item', Volume)], verb='POST')
def get_all_volume_status(self, volume_ids=None,
max_results=None, next_token=None,
filters=None, dry_run=False):
"""
Retrieve the status of one or more volumes.
:type volume_ids: list
:param volume_ids: A list of strings of volume IDs
:type max_results: int
:param max_results: The maximum number of paginated instance
items per response.
:type next_token: str
:param next_token: A string specifying the next paginated set
of results to return.
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of volume status.
"""
params = {}
if volume_ids:
self.build_list_params(params, volume_ids, 'VolumeId')
if max_results:
params['MaxResults'] = max_results
if next_token:
params['NextToken'] = next_token
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_object('DescribeVolumeStatus', params,
VolumeStatusSet, verb='POST')
def enable_volume_io(self, volume_id, dry_run=False):
"""
Enables I/O operations for a volume that had I/O operations
disabled because the data on the volume was potentially inconsistent.
:type volume_id: str
:param volume_id: The ID of the volume.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
params = {'VolumeId': volume_id}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('EnableVolumeIO', params, verb='POST')
def get_volume_attribute(self, volume_id,
attribute='autoEnableIO', dry_run=False):
"""
Describes attribute of the volume.
:type volume_id: str
:param volume_id: The ID of the volume.
:type attribute: str
:param attribute: The requested attribute. Valid values are:
* autoEnableIO
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list of :class:`boto.ec2.volume.VolumeAttribute`
:return: The requested Volume attribute
"""
params = {'VolumeId': volume_id, 'Attribute': attribute}
if dry_run:
params['DryRun'] = 'true'
return self.get_object('DescribeVolumeAttribute', params,
VolumeAttribute, verb='POST')
def modify_volume_attribute(self, volume_id, attribute, new_value,
dry_run=False):
"""
Changes an attribute of an Volume.
:type volume_id: string
:param volume_id: The volume id you wish to change
:type attribute: string
:param attribute: The attribute you wish to change. Valid values are:
AutoEnableIO.
:type new_value: string
:param new_value: The new value of the attribute.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'VolumeId': volume_id}
if attribute == 'AutoEnableIO':
params['AutoEnableIO.Value'] = new_value
if dry_run:
params['DryRun'] = 'true'
return self.get_status('ModifyVolumeAttribute', params, verb='POST')
def create_volume(self, size, zone, snapshot=None, volume_type=None,
iops=None, encrypted=False, kms_key_id=None, dry_run=False):
"""
Create a new EBS Volume.
:type size: int
:param size: The size of the new volume, in GiB
:type zone: string or :class:`boto.ec2.zone.Zone`
:param zone: The availability zone in which the Volume will be created.
:type snapshot: string or :class:`boto.ec2.snapshot.Snapshot`
:param snapshot: The snapshot from which the new Volume will be
created.
:type volume_type: string
:param volume_type: The type of the volume. (optional). Valid
values are: standard | io1 | gp2.
:type iops: int
:param iops: The provisioned IOPS you want to associate with
this volume. (optional)
:type encrypted: bool
:param encrypted: Specifies whether the volume should be encrypted.
(optional)
:type kms_key_id: string
:params kms_key_id: If encrypted is True, this KMS Key ID may be specified to
encrypt volume with this key (optional)
e.g.: arn:aws:kms:us-east-1:012345678910:key/abcd1234-a123-456a-a12b-a123b4cd56ef
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
if isinstance(zone, Zone):
zone = zone.name
params = {'AvailabilityZone': zone}
if size:
params['Size'] = size
if snapshot:
if isinstance(snapshot, Snapshot):
snapshot = snapshot.id
params['SnapshotId'] = snapshot
if volume_type:
params['VolumeType'] = volume_type
if iops:
params['Iops'] = str(iops)
if encrypted:
params['Encrypted'] = 'true'
if kms_key_id:
params['KmsKeyId'] = kms_key_id
if dry_run:
params['DryRun'] = 'true'
return self.get_object('CreateVolume', params, Volume, verb='POST')
def delete_volume(self, volume_id, dry_run=False):
"""
Delete an EBS volume.
:type volume_id: str
:param volume_id: The ID of the volume to be delete.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
params = {'VolumeId': volume_id}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('DeleteVolume', params, verb='POST')
def attach_volume(self, volume_id, instance_id, device, dry_run=False):
"""
Attach an EBS volume to an EC2 instance.
:type volume_id: str
:param volume_id: The ID of the EBS volume to be attached.
:type instance_id: str
:param instance_id: The ID of the EC2 instance to which it will
be attached.
:type device: str
:param device: The device on the instance through which the
volume will be exposted (e.g. /dev/sdh)
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
params = {'InstanceId': instance_id,
'VolumeId': volume_id,
'Device': device}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('AttachVolume', params, verb='POST')
def detach_volume(self, volume_id, instance_id=None,
device=None, force=False, dry_run=False):
"""
Detach an EBS volume from an EC2 instance.
:type volume_id: str
:param volume_id: The ID of the EBS volume to be attached.
:type instance_id: str
:param instance_id: The ID of the EC2 instance from which it will
be detached.
:type device: str
:param device: The device on the instance through which the
volume is exposted (e.g. /dev/sdh)
:type force: bool
:param force: Forces detachment if the previous detachment
attempt did not occur cleanly. This option can lead to
data loss or a corrupted file system. Use this option only
as a last resort to detach a volume from a failed
instance. The instance will not have an opportunity to
flush file system caches nor file system meta data. If you
use this option, you must perform file system check and
repair procedures.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
params = {'VolumeId': volume_id}
if instance_id:
params['InstanceId'] = instance_id
if device:
params['Device'] = device
if force:
params['Force'] = 'true'
if dry_run:
params['DryRun'] = 'true'
return self.get_status('DetachVolume', params, verb='POST')
# Snapshot methods
def get_all_snapshots(self, snapshot_ids=None,
owner=None, restorable_by=None,
filters=None, dry_run=False):
"""
Get all EBS Snapshots associated with the current credentials.
:type snapshot_ids: list
:param snapshot_ids: Optional list of snapshot ids. If this list is
present, only the Snapshots associated with
these snapshot ids will be returned.
:type owner: str or list
:param owner: If present, only the snapshots owned by the specified user(s)
will be returned. Valid values are:
* self
* amazon
* AWS Account ID
:type restorable_by: str or list
:param restorable_by: If present, only the snapshots that are restorable
by the specified account id(s) will be returned.
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list of :class:`boto.ec2.snapshot.Snapshot`
:return: The requested Snapshot objects
"""
params = {}
if snapshot_ids:
self.build_list_params(params, snapshot_ids, 'SnapshotId')
if owner:
self.build_list_params(params, owner, 'Owner')
if restorable_by:
self.build_list_params(params, restorable_by, 'RestorableBy')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeSnapshots', params,
[('item', Snapshot)], verb='POST')
def create_snapshot(self, volume_id, description=None, dry_run=False):
"""
Create a snapshot of an existing EBS Volume.
:type volume_id: str
:param volume_id: The ID of the volume to be snapshot'ed
:type description: str
:param description: A description of the snapshot.
Limited to 255 characters.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.snapshot.Snapshot`
:return: The created Snapshot object
"""
params = {'VolumeId': volume_id}
if description:
params['Description'] = description[0:255]
if dry_run:
params['DryRun'] = 'true'
snapshot = self.get_object('CreateSnapshot', params,
Snapshot, verb='POST')
volume = self.get_all_volumes([volume_id], dry_run=dry_run)[0]
volume_name = volume.tags.get('Name')
if volume_name:
snapshot.add_tag('Name', volume_name)
return snapshot
def delete_snapshot(self, snapshot_id, dry_run=False):
"""
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'SnapshotId': snapshot_id}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('DeleteSnapshot', params, verb='POST')
def copy_snapshot(self, source_region, source_snapshot_id,
description=None, dry_run=False):
"""
Copies a point-in-time snapshot of an Amazon Elastic Block Store
(Amazon EBS) volume and stores it in Amazon Simple Storage Service
(Amazon S3). You can copy the snapshot within the same region or from
one region to another. You can use the snapshot to create new Amazon
EBS volumes or Amazon Machine Images (AMIs).
:type source_region: str
:param source_region: The ID of the AWS region that contains the
snapshot to be copied (e.g 'us-east-1', 'us-west-2', etc.).
:type source_snapshot_id: str
:param source_snapshot_id: The ID of the Amazon EBS snapshot to copy
:type description: str
:param description: A description of the new Amazon EBS snapshot.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: str
:return: The snapshot ID
"""
params = {
'SourceRegion': source_region,
'SourceSnapshotId': source_snapshot_id,
}
if description is not None:
params['Description'] = description
if dry_run:
params['DryRun'] = 'true'
snapshot = self.get_object('CopySnapshot', params, Snapshot,
verb='POST')
return snapshot.id
def trim_snapshots(self, hourly_backups=8, daily_backups=7,
weekly_backups=4, monthly_backups=True):
"""
Trim excess snapshots, based on when they were taken. More current
snapshots are retained, with the number retained decreasing as you
move back in time.
If ebs volumes have a 'Name' tag with a value, their snapshots
will be assigned the same tag when they are created. The values
of the 'Name' tags for snapshots are used by this function to
group snapshots taken from the same volume (or from a series
of like-named volumes over time) for trimming.
For every group of like-named snapshots, this function retains
the newest and oldest snapshots, as well as, by default, the
first snapshots taken in each of the last eight hours, the first
snapshots taken in each of the last seven days, the first snapshots
taken in the last 4 weeks (counting Midnight Sunday morning as
the start of the week), and the first snapshot from the first
day of each month forever.
:type hourly_backups: int
:param hourly_backups: How many recent hourly backups should be saved.
:type daily_backups: int
:param daily_backups: How many recent daily backups should be saved.
:type weekly_backups: int
:param weekly_backups: How many recent weekly backups should be saved.
:type monthly_backups: int
:param monthly_backups: How many monthly backups should be saved. Use True for no limit.
"""
# This function first builds up an ordered list of target times
# that snapshots should be saved for (last 8 hours, last 7 days, etc.).
# Then a map of snapshots is constructed, with the keys being
# the snapshot / volume names and the values being arrays of
# chronologically sorted snapshots.
# Finally, for each array in the map, we go through the snapshot
# array and the target time array in an interleaved fashion,
# deleting snapshots whose start_times don't immediately follow a
# target time (we delete a snapshot if there's another snapshot
# that was made closer to the preceding target time).
now = datetime.utcnow()
last_hour = datetime(now.year, now.month, now.day, now.hour)
last_midnight = datetime(now.year, now.month, now.day)
last_sunday = datetime(now.year, now.month, now.day) - timedelta(days=(now.weekday() + 1) % 7)
start_of_month = datetime(now.year, now.month, 1)
target_backup_times = []
# there are no snapshots older than 1/1/2007
oldest_snapshot_date = datetime(2007, 1, 1)
for hour in range(0, hourly_backups):
target_backup_times.append(last_hour - timedelta(hours=hour))
for day in range(0, daily_backups):
target_backup_times.append(last_midnight - timedelta(days=day))
for week in range(0, weekly_backups):
target_backup_times.append(last_sunday - timedelta(weeks=week))
one_day = timedelta(days=1)
monthly_snapshots_added = 0
while (start_of_month > oldest_snapshot_date and
(monthly_backups is True or
monthly_snapshots_added < monthly_backups)):
# append the start of the month to the list of
# snapshot dates to save:
target_backup_times.append(start_of_month)
monthly_snapshots_added += 1
# there's no timedelta setting for one month, so instead:
# decrement the day by one, so we go to the final day of
# the previous month...
start_of_month -= one_day
# ... and then go to the first day of that previous month:
start_of_month = datetime(start_of_month.year,
start_of_month.month, 1)
temp = []
for t in target_backup_times:
if temp.__contains__(t) == False:
temp.append(t)
# sort to make the oldest dates first, and make sure the month start
# and last four week's start are in the proper order
target_backup_times = sorted(temp)
# get all the snapshots, sort them by date and time, and
# organize them into one array for each volume:
all_snapshots = self.get_all_snapshots(owner = 'self')
all_snapshots.sort(key=lambda x: x.start_time)
snaps_for_each_volume = {}
for snap in all_snapshots:
# the snapshot name and the volume name are the same.
# The snapshot name is set from the volume
# name at the time the snapshot is taken
volume_name = snap.tags.get('Name')
if volume_name:
# only examine snapshots that have a volume name
snaps_for_volume = snaps_for_each_volume.get(volume_name)
if not snaps_for_volume:
snaps_for_volume = []
snaps_for_each_volume[volume_name] = snaps_for_volume
snaps_for_volume.append(snap)
# Do a running comparison of snapshot dates to desired time
#periods, keeping the oldest snapshot in each
# time period and deleting the rest:
for volume_name in snaps_for_each_volume:
snaps = snaps_for_each_volume[volume_name]
snaps = snaps[:-1] # never delete the newest snapshot
time_period_number = 0
snap_found_for_this_time_period = False
for snap in snaps:
check_this_snap = True
while check_this_snap and time_period_number < target_backup_times.__len__():
snap_date = datetime.strptime(snap.start_time,
'%Y-%m-%dT%H:%M:%S.000Z')
if snap_date < target_backup_times[time_period_number]:
# the snap date is before the cutoff date.
# Figure out if it's the first snap in this
# date range and act accordingly (since both
#date the date ranges and the snapshots
# are sorted chronologically, we know this
#snapshot isn't in an earlier date range):
if snap_found_for_this_time_period == True:
if not snap.tags.get('preserve_snapshot'):
# as long as the snapshot wasn't marked
# with the 'preserve_snapshot' tag, delete it:
try:
self.delete_snapshot(snap.id)
boto.log.info('Trimmed snapshot %s (%s)' % (snap.tags['Name'], snap.start_time))
except EC2ResponseError:
boto.log.error('Attempt to trim snapshot %s (%s) failed. Possible result of a race condition with trimming on another server?' % (snap.tags['Name'], snap.start_time))
# go on and look at the next snapshot,
#leaving the time period alone
else:
# this was the first snapshot found for this
#time period. Leave it alone and look at the
# next snapshot:
snap_found_for_this_time_period = True
check_this_snap = False
else:
# the snap is after the cutoff date. Check it
# against the next cutoff date
time_period_number += 1
snap_found_for_this_time_period = False
def get_snapshot_attribute(self, snapshot_id,
attribute='createVolumePermission',
dry_run=False):
"""
Get information about an attribute of a snapshot. Only one attribute
can be specified per call.
:type snapshot_id: str
:param snapshot_id: The ID of the snapshot.
:type attribute: str
:param attribute: The requested attribute. Valid values are:
* createVolumePermission
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list of :class:`boto.ec2.snapshotattribute.SnapshotAttribute`
:return: The requested Snapshot attribute
"""
params = {'Attribute': attribute}
if snapshot_id:
params['SnapshotId'] = snapshot_id
if dry_run:
params['DryRun'] = 'true'
return self.get_object('DescribeSnapshotAttribute', params,
SnapshotAttribute, verb='POST')
def modify_snapshot_attribute(self, snapshot_id,
attribute='createVolumePermission',
operation='add', user_ids=None, groups=None,
dry_run=False):
"""
Changes an attribute of an image.
:type snapshot_id: string
:param snapshot_id: The snapshot id you wish to change
:type attribute: string
:param attribute: The attribute you wish to change. Valid values are:
createVolumePermission
:type operation: string
:param operation: Either add or remove (this is required for changing
snapshot ermissions)
:type user_ids: list
:param user_ids: The Amazon IDs of users to add/remove attributes
:type groups: list
:param groups: The groups to add/remove attributes. The only valid
value at this time is 'all'.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'SnapshotId': snapshot_id,
'Attribute': attribute,
'OperationType': operation}
if user_ids:
self.build_list_params(params, user_ids, 'UserId')
if groups:
self.build_list_params(params, groups, 'UserGroup')
if dry_run:
params['DryRun'] = 'true'
return self.get_status('ModifySnapshotAttribute', params, verb='POST')
def reset_snapshot_attribute(self, snapshot_id,
attribute='createVolumePermission',
dry_run=False):
"""
Resets an attribute of a snapshot to its default value.
:type snapshot_id: string
:param snapshot_id: ID of the snapshot
:type attribute: string
:param attribute: The attribute to reset
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: Whether the operation succeeded or not
"""
params = {'SnapshotId': snapshot_id,
'Attribute': attribute}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('ResetSnapshotAttribute', params, verb='POST')
# Keypair methods
def get_all_key_pairs(self, keynames=None, filters=None, dry_run=False):
"""
Get all key pairs associated with your account.
:type keynames: list
:param keynames: A list of the names of keypairs to retrieve.
If not provided, all key pairs will be returned.
:type filters: dict
:param filters: Optional filters that can be used to limit the
results returned. Filters are provided in the form of a
dictionary consisting of filter names as the key and
filter values as the value. The set of allowable filter
names/values is dependent on the request being performed.
Check the EC2 API guide for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.keypair.KeyPair`
"""
params = {}
if keynames:
self.build_list_params(params, keynames, 'KeyName')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeKeyPairs', params,
[('item', KeyPair)], verb='POST')
def get_key_pair(self, keyname, dry_run=False):
"""
Convenience method to retrieve a specific keypair (KeyPair).
:type keyname: string
:param keyname: The name of the keypair to retrieve
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.keypair.KeyPair`
:return: The KeyPair specified or None if it is not found
"""
try:
return self.get_all_key_pairs(
keynames=[keyname],
dry_run=dry_run
)[0]
except self.ResponseError as e:
if e.code == 'InvalidKeyPair.NotFound':
return None
else:
raise
def create_key_pair(self, key_name, dry_run=False):
"""
Create a new key pair for your account.
This will create the key pair within the region you
are currently connected to.
:type key_name: string
:param key_name: The name of the new keypair
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.keypair.KeyPair`
:return: The newly created :class:`boto.ec2.keypair.KeyPair`.
The material attribute of the new KeyPair object
will contain the the unencrypted PEM encoded RSA private key.
"""
params = {'KeyName': key_name}
if dry_run:
params['DryRun'] = 'true'
return self.get_object('CreateKeyPair', params, KeyPair, verb='POST')
def delete_key_pair(self, key_name, dry_run=False):
"""
Delete a key pair from your account.
:type key_name: string
:param key_name: The name of the keypair to delete
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'KeyName': key_name}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('DeleteKeyPair', params, verb='POST')
def import_key_pair(self, key_name, public_key_material, dry_run=False):
"""
imports the public key from an RSA key pair that you created
with a third-party tool.
Supported formats:
* OpenSSH public key format (e.g., the format
in ~/.ssh/authorized_keys)
* Base64 encoded DER format
* SSH public key file format as specified in RFC4716
DSA keys are not supported. Make sure your key generator is
set up to create RSA keys.
Supported lengths: 1024, 2048, and 4096.
:type key_name: string
:param key_name: The name of the new keypair
:type public_key_material: string
:param public_key_material: The public key. You must base64 encode
the public key material before sending
it to AWS.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.keypair.KeyPair`
:return: A :class:`boto.ec2.keypair.KeyPair` object representing
the newly imported key pair. This object will contain only
the key name and the fingerprint.
"""
public_key_material = base64.b64encode(public_key_material)
params = {'KeyName': key_name,
'PublicKeyMaterial': public_key_material}
if dry_run:
params['DryRun'] = 'true'
return self.get_object('ImportKeyPair', params, KeyPair, verb='POST')
# SecurityGroup methods
def get_all_security_groups(self, groupnames=None, group_ids=None,
filters=None, dry_run=False):
"""
Get all security groups associated with your account in a region.
:type groupnames: list
:param groupnames: A list of the names of security groups to retrieve.
If not provided, all security groups will be
returned.
:type group_ids: list
:param group_ids: A list of IDs of security groups to retrieve for
security groups within a VPC.
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.securitygroup.SecurityGroup`
"""
params = {}
if groupnames is not None:
self.build_list_params(params, groupnames, 'GroupName')
if group_ids is not None:
self.build_list_params(params, group_ids, 'GroupId')
if filters is not None:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeSecurityGroups', params,
[('item', SecurityGroup)], verb='POST')
def create_security_group(self, name, description, vpc_id=None,
dry_run=False):
"""
Create a new security group for your account.
This will create the security group within the region you
are currently connected to.
:type name: string
:param name: The name of the new security group
:type description: string
:param description: The description of the new security group
:type vpc_id: string
:param vpc_id: The ID of the VPC to create the security group in,
if any.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.securitygroup.SecurityGroup`
:return: The newly created :class:`boto.ec2.securitygroup.SecurityGroup`.
"""
params = {'GroupName': name,
'GroupDescription': description}
if vpc_id is not None:
params['VpcId'] = vpc_id
if dry_run:
params['DryRun'] = 'true'
group = self.get_object('CreateSecurityGroup', params,
SecurityGroup, verb='POST')
group.name = name
group.description = description
if vpc_id is not None:
group.vpc_id = vpc_id
return group
def delete_security_group(self, name=None, group_id=None, dry_run=False):
"""
Delete a security group from your account.
:type name: string
:param name: The name of the security group to delete.
:type group_id: string
:param group_id: The ID of the security group to delete within
a VPC.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful.
"""
params = {}
if name is not None:
params['GroupName'] = name
elif group_id is not None:
params['GroupId'] = group_id
if dry_run:
params['DryRun'] = 'true'
return self.get_status('DeleteSecurityGroup', params, verb='POST')
def authorize_security_group_deprecated(self, group_name,
src_security_group_name=None,
src_security_group_owner_id=None,
ip_protocol=None,
from_port=None, to_port=None,
cidr_ip=None, dry_run=False):
"""
NOTE: This method uses the old-style request parameters
that did not allow a port to be specified when
authorizing a group.
:type group_name: string
:param group_name: The name of the security group you are adding
the rule to.
:type src_security_group_name: string
:param src_security_group_name: The name of the security group you are
granting access to.
:type src_security_group_owner_id: string
:param src_security_group_owner_id: The ID of the owner of the security
group you are granting access to.
:type ip_protocol: string
:param ip_protocol: Either tcp | udp | icmp
:type from_port: int
:param from_port: The beginning port number you are enabling
:type to_port: int
:param to_port: The ending port number you are enabling
:type to_port: string
:param to_port: The CIDR block you are providing access to.
See http://goo.gl/Yj5QC
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful.
"""
params = {'GroupName': group_name}
if src_security_group_name:
params['SourceSecurityGroupName'] = src_security_group_name
if src_security_group_owner_id:
params['SourceSecurityGroupOwnerId'] = src_security_group_owner_id
if ip_protocol:
params['IpProtocol'] = ip_protocol
if from_port:
params['FromPort'] = from_port
if to_port:
params['ToPort'] = to_port
if cidr_ip:
params['CidrIp'] = cidr_ip
if dry_run:
params['DryRun'] = 'true'
return self.get_status('AuthorizeSecurityGroupIngress', params)
def authorize_security_group(self, group_name=None,
src_security_group_name=None,
src_security_group_owner_id=None,
ip_protocol=None,
from_port=None, to_port=None,
cidr_ip=None, group_id=None,
src_security_group_group_id=None,
dry_run=False):
"""
Add a new rule to an existing security group.
You need to pass in either src_security_group_name and
src_security_group_owner_id OR ip_protocol, from_port, to_port,
and cidr_ip. In other words, either you are authorizing another
group or you are authorizing some ip-based rule.
:type group_name: string
:param group_name: The name of the security group you are adding
the rule to.
:type src_security_group_name: string
:param src_security_group_name: The name of the security group you are
granting access to.
:type src_security_group_owner_id: string
:param src_security_group_owner_id: The ID of the owner of the security
group you are granting access to.
:type ip_protocol: string
:param ip_protocol: Either tcp | udp | icmp
:type from_port: int
:param from_port: The beginning port number you are enabling
:type to_port: int
:param to_port: The ending port number you are enabling
:type cidr_ip: string or list of strings
:param cidr_ip: The CIDR block you are providing access to.
See http://goo.gl/Yj5QC
:type group_id: string
:param group_id: ID of the EC2 or VPC security group to
modify. This is required for VPC security groups and can
be used instead of group_name for EC2 security groups.
:type src_security_group_group_id: string
:param src_security_group_group_id: The ID of the security
group you are granting access to. Can be used instead of
src_security_group_name
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful.
"""
if src_security_group_name:
if from_port is None and to_port is None and ip_protocol is None:
return self.authorize_security_group_deprecated(
group_name, src_security_group_name,
src_security_group_owner_id)
params = {}
if group_name:
params['GroupName'] = group_name
if group_id:
params['GroupId'] = group_id
if src_security_group_name:
param_name = 'IpPermissions.1.Groups.1.GroupName'
params[param_name] = src_security_group_name
if src_security_group_owner_id:
param_name = 'IpPermissions.1.Groups.1.UserId'
params[param_name] = src_security_group_owner_id
if src_security_group_group_id:
param_name = 'IpPermissions.1.Groups.1.GroupId'
params[param_name] = src_security_group_group_id
if ip_protocol:
params['IpPermissions.1.IpProtocol'] = ip_protocol
if from_port is not None:
params['IpPermissions.1.FromPort'] = from_port
if to_port is not None:
params['IpPermissions.1.ToPort'] = to_port
if cidr_ip:
if not isinstance(cidr_ip, list):
cidr_ip = [cidr_ip]
for i, single_cidr_ip in enumerate(cidr_ip):
params['IpPermissions.1.IpRanges.%d.CidrIp' % (i + 1)] = \
single_cidr_ip
if dry_run:
params['DryRun'] = 'true'
return self.get_status('AuthorizeSecurityGroupIngress',
params, verb='POST')
def authorize_security_group_egress(self,
group_id,
ip_protocol,
from_port=None,
to_port=None,
src_group_id=None,
cidr_ip=None,
dry_run=False):
"""
The action adds one or more egress rules to a VPC security
group. Specifically, this action permits instances in a
security group to send traffic to one or more destination
CIDR IP address ranges, or to one or more destination
security groups in the same VPC.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {
'GroupId': group_id,
'IpPermissions.1.IpProtocol': ip_protocol
}
if from_port is not None:
params['IpPermissions.1.FromPort'] = from_port
if to_port is not None:
params['IpPermissions.1.ToPort'] = to_port
if src_group_id is not None:
params['IpPermissions.1.Groups.1.GroupId'] = src_group_id
if cidr_ip is not None:
params['IpPermissions.1.IpRanges.1.CidrIp'] = cidr_ip
if dry_run:
params['DryRun'] = 'true'
return self.get_status('AuthorizeSecurityGroupEgress',
params, verb='POST')
def revoke_security_group_deprecated(self, group_name,
src_security_group_name=None,
src_security_group_owner_id=None,
ip_protocol=None,
from_port=None, to_port=None,
cidr_ip=None, dry_run=False):
"""
NOTE: This method uses the old-style request parameters
that did not allow a port to be specified when
authorizing a group.
Remove an existing rule from an existing security group.
You need to pass in either src_security_group_name and
src_security_group_owner_id OR ip_protocol, from_port, to_port,
and cidr_ip. In other words, either you are revoking another
group or you are revoking some ip-based rule.
:type group_name: string
:param group_name: The name of the security group you are removing
the rule from.
:type src_security_group_name: string
:param src_security_group_name: The name of the security group you are
revoking access to.
:type src_security_group_owner_id: string
:param src_security_group_owner_id: The ID of the owner of the security
group you are revoking access to.
:type ip_protocol: string
:param ip_protocol: Either tcp | udp | icmp
:type from_port: int
:param from_port: The beginning port number you are disabling
:type to_port: int
:param to_port: The ending port number you are disabling
:type to_port: string
:param to_port: The CIDR block you are revoking access to.
http://goo.gl/Yj5QC
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful.
"""
params = {'GroupName': group_name}
if src_security_group_name:
params['SourceSecurityGroupName'] = src_security_group_name
if src_security_group_owner_id:
params['SourceSecurityGroupOwnerId'] = src_security_group_owner_id
if ip_protocol:
params['IpProtocol'] = ip_protocol
if from_port:
params['FromPort'] = from_port
if to_port:
params['ToPort'] = to_port
if cidr_ip:
params['CidrIp'] = cidr_ip
if dry_run:
params['DryRun'] = 'true'
return self.get_status('RevokeSecurityGroupIngress', params)
def revoke_security_group(self, group_name=None,
src_security_group_name=None,
src_security_group_owner_id=None,
ip_protocol=None, from_port=None, to_port=None,
cidr_ip=None, group_id=None,
src_security_group_group_id=None, dry_run=False):
"""
Remove an existing rule from an existing security group.
You need to pass in either src_security_group_name and
src_security_group_owner_id OR ip_protocol, from_port, to_port,
and cidr_ip. In other words, either you are revoking another
group or you are revoking some ip-based rule.
:type group_name: string
:param group_name: The name of the security group you are removing
the rule from.
:type src_security_group_name: string
:param src_security_group_name: The name of the security group you are
revoking access to.
:type src_security_group_owner_id: string
:param src_security_group_owner_id: The ID of the owner of the security
group you are revoking access to.
:type ip_protocol: string
:param ip_protocol: Either tcp | udp | icmp
:type from_port: int
:param from_port: The beginning port number you are disabling
:type to_port: int
:param to_port: The ending port number you are disabling
:type cidr_ip: string
:param cidr_ip: The CIDR block you are revoking access to.
See http://goo.gl/Yj5QC
:type group_id: string
:param group_id: ID of the EC2 or VPC security group to
modify. This is required for VPC security groups and can
be used instead of group_name for EC2 security groups.
:type src_security_group_group_id: string
:param src_security_group_group_id: The ID of the security group
for which you are revoking access. Can be used instead
of src_security_group_name
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful.
"""
if src_security_group_name:
if from_port is None and to_port is None and ip_protocol is None:
return self.revoke_security_group_deprecated(
group_name, src_security_group_name,
src_security_group_owner_id)
params = {}
if group_name is not None:
params['GroupName'] = group_name
if group_id is not None:
params['GroupId'] = group_id
if src_security_group_name:
param_name = 'IpPermissions.1.Groups.1.GroupName'
params[param_name] = src_security_group_name
if src_security_group_group_id:
param_name = 'IpPermissions.1.Groups.1.GroupId'
params[param_name] = src_security_group_group_id
if src_security_group_owner_id:
param_name = 'IpPermissions.1.Groups.1.UserId'
params[param_name] = src_security_group_owner_id
if ip_protocol:
params['IpPermissions.1.IpProtocol'] = ip_protocol
if from_port is not None:
params['IpPermissions.1.FromPort'] = from_port
if to_port is not None:
params['IpPermissions.1.ToPort'] = to_port
if cidr_ip:
params['IpPermissions.1.IpRanges.1.CidrIp'] = cidr_ip
if dry_run:
params['DryRun'] = 'true'
return self.get_status('RevokeSecurityGroupIngress',
params, verb='POST')
def revoke_security_group_egress(self,
group_id,
ip_protocol,
from_port=None,
to_port=None,
src_group_id=None,
cidr_ip=None, dry_run=False):
"""
Remove an existing egress rule from an existing VPC security
group. You need to pass in an ip_protocol, from_port and
to_port range only if the protocol you are using is
port-based. You also need to pass in either a src_group_id or
cidr_ip.
:type group_name: string
:param group_id: The name of the security group you are removing
the rule from.
:type ip_protocol: string
:param ip_protocol: Either tcp | udp | icmp | -1
:type from_port: int
:param from_port: The beginning port number you are disabling
:type to_port: int
:param to_port: The ending port number you are disabling
:type src_group_id: src_group_id
:param src_group_id: The source security group you are
revoking access to.
:type cidr_ip: string
:param cidr_ip: The CIDR block you are revoking access to.
See http://goo.gl/Yj5QC
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful.
"""
params = {}
if group_id:
params['GroupId'] = group_id
if ip_protocol:
params['IpPermissions.1.IpProtocol'] = ip_protocol
if from_port is not None:
params['IpPermissions.1.FromPort'] = from_port
if to_port is not None:
params['IpPermissions.1.ToPort'] = to_port
if src_group_id is not None:
params['IpPermissions.1.Groups.1.GroupId'] = src_group_id
if cidr_ip:
params['IpPermissions.1.IpRanges.1.CidrIp'] = cidr_ip
if dry_run:
params['DryRun'] = 'true'
return self.get_status('RevokeSecurityGroupEgress',
params, verb='POST')
#
# Regions
#
def get_all_regions(self, region_names=None, filters=None, dry_run=False):
"""
Get all available regions for the EC2 service.
:type region_names: list of str
:param region_names: Names of regions to limit output
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.regioninfo.RegionInfo`
"""
params = {}
if region_names:
self.build_list_params(params, region_names, 'RegionName')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
regions = self.get_list('DescribeRegions', params,
[('item', RegionInfo)], verb='POST')
for region in regions:
region.connection_cls = EC2Connection
return regions
#
# Reservation methods
#
def get_all_reserved_instances_offerings(self,
reserved_instances_offering_ids=None,
instance_type=None,
availability_zone=None,
product_description=None,
filters=None,
instance_tenancy=None,
offering_type=None,
include_marketplace=None,
min_duration=None,
max_duration=None,
max_instance_count=None,
next_token=None,
max_results=None,
dry_run=False):
"""
Describes Reserved Instance offerings that are available for purchase.
:type reserved_instances_offering_ids: list
:param reserved_instances_id: One or more Reserved Instances
offering IDs.
:type instance_type: str
:param instance_type: Displays Reserved Instances of the specified
instance type.
:type availability_zone: str
:param availability_zone: Displays Reserved Instances within the
specified Availability Zone.
:type product_description: str
:param product_description: Displays Reserved Instances with the
specified product description.
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type instance_tenancy: string
:param instance_tenancy: The tenancy of the Reserved Instance offering.
A Reserved Instance with tenancy of dedicated will run on
single-tenant hardware and can only be launched within a VPC.
:type offering_type: string
:param offering_type: The Reserved Instance offering type. Valid
Values: `"Heavy Utilization" | "Medium Utilization" | "Light
Utilization"`
:type include_marketplace: bool
:param include_marketplace: Include Marketplace offerings in the
response.
:type min_duration: int :param min_duration: Minimum duration (in
seconds) to filter when searching for offerings.
:type max_duration: int
:param max_duration: Maximum duration (in seconds) to filter when
searching for offerings.
:type max_instance_count: int
:param max_instance_count: Maximum number of instances to filter when
searching for offerings.
:type next_token: string
:param next_token: Token to use when requesting the next paginated set
of offerings.
:type max_results: int
:param max_results: Maximum number of offerings to return per call.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of
:class:`boto.ec2.reservedinstance.ReservedInstancesOffering`.
"""
params = {}
if reserved_instances_offering_ids is not None:
self.build_list_params(params, reserved_instances_offering_ids,
'ReservedInstancesOfferingId')
if instance_type:
params['InstanceType'] = instance_type
if availability_zone:
params['AvailabilityZone'] = availability_zone
if product_description:
params['ProductDescription'] = product_description
if filters:
self.build_filter_params(params, filters)
if instance_tenancy is not None:
params['InstanceTenancy'] = instance_tenancy
if offering_type is not None:
params['OfferingType'] = offering_type
if include_marketplace is not None:
if include_marketplace:
params['IncludeMarketplace'] = 'true'
else:
params['IncludeMarketplace'] = 'false'
if min_duration is not None:
params['MinDuration'] = str(min_duration)
if max_duration is not None:
params['MaxDuration'] = str(max_duration)
if max_instance_count is not None:
params['MaxInstanceCount'] = str(max_instance_count)
if next_token is not None:
params['NextToken'] = next_token
if max_results is not None:
params['MaxResults'] = str(max_results)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeReservedInstancesOfferings',
params, [('item', ReservedInstancesOffering)],
verb='POST')
def get_all_reserved_instances(self, reserved_instances_id=None,
filters=None, dry_run=False):
"""
Describes one or more of the Reserved Instances that you purchased.
:type reserved_instance_ids: list
:param reserved_instance_ids: A list of the reserved instance ids that
will be returned. If not provided, all reserved instances
will be returned.
:type filters: dict
:param filters: Optional filters that can be used to limit the
results returned. Filters are provided in the form of a
dictionary consisting of filter names as the key and
filter values as the value. The set of allowable filter
names/values is dependent on the request being performed.
Check the EC2 API guide for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.reservedinstance.ReservedInstance`
"""
params = {}
if reserved_instances_id:
self.build_list_params(params, reserved_instances_id,
'ReservedInstancesId')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeReservedInstances',
params, [('item', ReservedInstance)], verb='POST')
def purchase_reserved_instance_offering(self,
reserved_instances_offering_id,
instance_count=1, limit_price=None,
dry_run=False):
"""
Purchase a Reserved Instance for use with your account.
** CAUTION **
This request can result in large amounts of money being charged to your
AWS account. Use with caution!
:type reserved_instances_offering_id: string
:param reserved_instances_offering_id: The offering ID of the Reserved
Instance to purchase
:type instance_count: int
:param instance_count: The number of Reserved Instances to purchase.
Default value is 1.
:type limit_price: tuple
:param instance_count: Limit the price on the total order.
Must be a tuple of (amount, currency_code), for example:
(100.0, 'USD').
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.reservedinstance.ReservedInstance`
:return: The newly created Reserved Instance
"""
params = {
'ReservedInstancesOfferingId': reserved_instances_offering_id,
'InstanceCount': instance_count}
if limit_price is not None:
params['LimitPrice.Amount'] = str(limit_price[0])
params['LimitPrice.CurrencyCode'] = str(limit_price[1])
if dry_run:
params['DryRun'] = 'true'
return self.get_object('PurchaseReservedInstancesOffering', params,
ReservedInstance, verb='POST')
def create_reserved_instances_listing(self, reserved_instances_id,
instance_count, price_schedules,
client_token, dry_run=False):
"""Creates a new listing for Reserved Instances.
Creates a new listing for Amazon EC2 Reserved Instances that will be
sold in the Reserved Instance Marketplace. You can submit one Reserved
Instance listing at a time.
The Reserved Instance Marketplace matches sellers who want to resell
Reserved Instance capacity that they no longer need with buyers who
want to purchase additional capacity. Reserved Instances bought and
sold through the Reserved Instance Marketplace work like any other
Reserved Instances.
If you want to sell your Reserved Instances, you must first register as
a Seller in the Reserved Instance Marketplace. After completing the
registration process, you can create a Reserved Instance Marketplace
listing of some or all of your Reserved Instances, and specify the
upfront price you want to receive for them. Your Reserved Instance
listings then become available for purchase.
:type reserved_instances_id: string
:param reserved_instances_id: The ID of the Reserved Instance that
will be listed.
:type instance_count: int
:param instance_count: The number of instances that are a part of a
Reserved Instance account that will be listed in the Reserved
Instance Marketplace. This number should be less than or equal to
the instance count associated with the Reserved Instance ID
specified in this call.
:type price_schedules: List of tuples
:param price_schedules: A list specifying the price of the Reserved
Instance for each month remaining in the Reserved Instance term.
Each tuple contains two elements, the price and the term. For
example, for an instance that 11 months remaining in its term,
we can have a price schedule with an upfront price of $2.50.
At 8 months remaining we can drop the price down to $2.00.
This would be expressed as::
price_schedules=[('2.50', 11), ('2.00', 8)]
:type client_token: string
:param client_token: Unique, case-sensitive identifier you provide
to ensure idempotency of the request. Maximum 64 ASCII characters.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of
:class:`boto.ec2.reservedinstance.ReservedInstanceListing`
"""
params = {
'ReservedInstancesId': reserved_instances_id,
'InstanceCount': str(instance_count),
'ClientToken': client_token,
}
for i, schedule in enumerate(price_schedules):
price, term = schedule
params['PriceSchedules.%s.Price' % i] = str(price)
params['PriceSchedules.%s.Term' % i] = str(term)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('CreateReservedInstancesListing',
params, [('item', ReservedInstanceListing)], verb='POST')
def cancel_reserved_instances_listing(self,
reserved_instances_listing_ids=None,
dry_run=False):
"""Cancels the specified Reserved Instance listing.
:type reserved_instances_listing_ids: List of strings
:param reserved_instances_listing_ids: The ID of the
Reserved Instance listing to be cancelled.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of
:class:`boto.ec2.reservedinstance.ReservedInstanceListing`
"""
params = {}
if reserved_instances_listing_ids is not None:
self.build_list_params(params, reserved_instances_listing_ids,
'ReservedInstancesListingId')
if dry_run:
params['DryRun'] = 'true'
return self.get_list('CancelReservedInstancesListing',
params, [('item', ReservedInstanceListing)], verb='POST')
def build_configurations_param_list(self, params, target_configurations):
for offset, tc in enumerate(target_configurations):
prefix = 'ReservedInstancesConfigurationSetItemType.%d.' % offset
if tc.availability_zone is not None:
params[prefix + 'AvailabilityZone'] = tc.availability_zone
if tc.platform is not None:
params[prefix + 'Platform'] = tc.platform
if tc.instance_count is not None:
params[prefix + 'InstanceCount'] = tc.instance_count
if tc.instance_type is not None:
params[prefix + 'InstanceType'] = tc.instance_type
def modify_reserved_instances(self, client_token, reserved_instance_ids,
target_configurations):
"""
Modifies the specified Reserved Instances.
:type client_token: string
:param client_token: A unique, case-sensitive, token you provide to
ensure idempotency of your modification request.
:type reserved_instance_ids: List of strings
:param reserved_instance_ids: The IDs of the Reserved Instances to
modify.
:type target_configurations: List of :class:`boto.ec2.reservedinstance.ReservedInstancesConfiguration`
:param target_configurations: The configuration settings for the
modified Reserved Instances.
:rtype: string
:return: The unique ID for the submitted modification request.
"""
params = {}
if client_token is not None:
params['ClientToken'] = client_token
if reserved_instance_ids is not None:
self.build_list_params(params, reserved_instance_ids,
'ReservedInstancesId')
if target_configurations is not None:
self.build_configurations_param_list(params, target_configurations)
mrir = self.get_object(
'ModifyReservedInstances',
params,
ModifyReservedInstancesResult,
verb='POST'
)
return mrir.modification_id
def describe_reserved_instances_modifications(self,
reserved_instances_modification_ids=None, next_token=None,
filters=None):
"""
A request to describe the modifications made to Reserved Instances in
your account.
:type reserved_instances_modification_ids: list
:param reserved_instances_modification_ids: An optional list of
Reserved Instances modification IDs to describe.
:type next_token: str
:param next_token: A string specifying the next paginated set
of results to return.
:type filters: dict
:param filters: Optional filters that can be used to limit the
results returned. Filters are provided in the form of a
dictionary consisting of filter names as the key and
filter values as the value. The set of allowable filter
names/values is dependent on the request being performed.
Check the EC2 API guide for details.
:rtype: list
:return: A list of :class:`boto.ec2.reservedinstance.ReservedInstance`
"""
params = {}
if reserved_instances_modification_ids:
self.build_list_params(params, reserved_instances_modification_ids,
'ReservedInstancesModificationId')
if next_token:
params['NextToken'] = next_token
if filters:
self.build_filter_params(params, filters)
return self.get_list('DescribeReservedInstancesModifications',
params, [('item', ReservedInstancesModification)],
verb='POST')
#
# Monitoring
#
def monitor_instances(self, instance_ids, dry_run=False):
"""
Enable detailed CloudWatch monitoring for the supplied instances.
:type instance_id: list of strings
:param instance_id: The instance ids
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.instanceinfo.InstanceInfo`
"""
params = {}
self.build_list_params(params, instance_ids, 'InstanceId')
if dry_run:
params['DryRun'] = 'true'
return self.get_list('MonitorInstances', params,
[('item', InstanceInfo)], verb='POST')
def monitor_instance(self, instance_id, dry_run=False):
"""
Deprecated Version, maintained for backward compatibility.
Enable detailed CloudWatch monitoring for the supplied instance.
:type instance_id: string
:param instance_id: The instance id
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.instanceinfo.InstanceInfo`
"""
return self.monitor_instances([instance_id], dry_run=dry_run)
def unmonitor_instances(self, instance_ids, dry_run=False):
"""
Disable CloudWatch monitoring for the supplied instance.
:type instance_id: list of string
:param instance_id: The instance id
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.instanceinfo.InstanceInfo`
"""
params = {}
self.build_list_params(params, instance_ids, 'InstanceId')
if dry_run:
params['DryRun'] = 'true'
return self.get_list('UnmonitorInstances', params,
[('item', InstanceInfo)], verb='POST')
def unmonitor_instance(self, instance_id, dry_run=False):
"""
Deprecated Version, maintained for backward compatibility.
Disable detailed CloudWatch monitoring for the supplied instance.
:type instance_id: string
:param instance_id: The instance id
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.instanceinfo.InstanceInfo`
"""
return self.unmonitor_instances([instance_id], dry_run=dry_run)
#
# Bundle Windows Instances
#
def bundle_instance(self, instance_id,
s3_bucket,
s3_prefix,
s3_upload_policy, dry_run=False):
"""
Bundle Windows instance.
:type instance_id: string
:param instance_id: The instance id
:type s3_bucket: string
:param s3_bucket: The bucket in which the AMI should be stored.
:type s3_prefix: string
:param s3_prefix: The beginning of the file name for the AMI.
:type s3_upload_policy: string
:param s3_upload_policy: Base64 encoded policy that specifies condition
and permissions for Amazon EC2 to upload the
user's image into Amazon S3.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'InstanceId': instance_id,
'Storage.S3.Bucket': s3_bucket,
'Storage.S3.Prefix': s3_prefix,
'Storage.S3.UploadPolicy': s3_upload_policy}
s3auth = boto.auth.get_auth_handler(None, boto.config,
self.provider, ['s3'])
params['Storage.S3.AWSAccessKeyId'] = self.aws_access_key_id
signature = s3auth.sign_string(s3_upload_policy)
params['Storage.S3.UploadPolicySignature'] = signature
if dry_run:
params['DryRun'] = 'true'
return self.get_object('BundleInstance', params,
BundleInstanceTask, verb='POST')
def get_all_bundle_tasks(self, bundle_ids=None, filters=None,
dry_run=False):
"""
Retrieve current bundling tasks. If no bundle id is specified, all
tasks are retrieved.
:type bundle_ids: list
:param bundle_ids: A list of strings containing identifiers for
previously created bundling tasks.
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {}
if bundle_ids:
self.build_list_params(params, bundle_ids, 'BundleId')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeBundleTasks', params,
[('item', BundleInstanceTask)], verb='POST')
def cancel_bundle_task(self, bundle_id, dry_run=False):
"""
Cancel a previously submitted bundle task
:type bundle_id: string
:param bundle_id: The identifier of the bundle task to cancel.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'BundleId': bundle_id}
if dry_run:
params['DryRun'] = 'true'
return self.get_object('CancelBundleTask', params,
BundleInstanceTask, verb='POST')
def get_password_data(self, instance_id, dry_run=False):
"""
Get encrypted administrator password for a Windows instance.
:type instance_id: string
:param instance_id: The identifier of the instance to retrieve the
password for.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'InstanceId': instance_id}
if dry_run:
params['DryRun'] = 'true'
rs = self.get_object('GetPasswordData', params, ResultSet, verb='POST')
return rs.passwordData
#
# Cluster Placement Groups
#
def get_all_placement_groups(self, groupnames=None, filters=None,
dry_run=False):
"""
Get all placement groups associated with your account in a region.
:type groupnames: list
:param groupnames: A list of the names of placement groups to retrieve.
If not provided, all placement groups will be
returned.
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.placementgroup.PlacementGroup`
"""
params = {}
if groupnames:
self.build_list_params(params, groupnames, 'GroupName')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribePlacementGroups', params,
[('item', PlacementGroup)], verb='POST')
def create_placement_group(self, name, strategy='cluster', dry_run=False):
"""
Create a new placement group for your account.
This will create the placement group within the region you
are currently connected to.
:type name: string
:param name: The name of the new placement group
:type strategy: string
:param strategy: The placement strategy of the new placement group.
Currently, the only acceptable value is "cluster".
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: bool
:return: True if successful
"""
params = {'GroupName': name, 'Strategy': strategy}
if dry_run:
params['DryRun'] = 'true'
group = self.get_status('CreatePlacementGroup', params, verb='POST')
return group
def delete_placement_group(self, name, dry_run=False):
"""
Delete a placement group from your account.
:type key_name: string
:param key_name: The name of the keypair to delete
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'GroupName': name}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('DeletePlacementGroup', params, verb='POST')
# Tag methods
def build_tag_param_list(self, params, tags):
keys = sorted(tags.keys())
i = 1
for key in keys:
value = tags[key]
params['Tag.%d.Key' % i] = key
if value is not None:
params['Tag.%d.Value' % i] = value
i += 1
def get_all_tags(self, filters=None, dry_run=False, max_results=None):
"""
Retrieve all the metadata tags associated with your account.
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:type max_results: int
:param max_results: The maximum number of paginated instance
items per response.
:rtype: list
:return: A list of :class:`boto.ec2.tag.Tag` objects
"""
params = {}
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
if max_results is not None:
params['MaxResults'] = max_results
return self.get_list('DescribeTags', params,
[('item', Tag)], verb='POST')
def create_tags(self, resource_ids, tags, dry_run=False):
"""
Create new metadata tags for the specified resource ids.
:type resource_ids: list
:param resource_ids: List of strings
:type tags: dict
:param tags: A dictionary containing the name/value pairs.
If you want to create only a tag name, the
value for that tag should be the empty string
(e.g. '').
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {}
self.build_list_params(params, resource_ids, 'ResourceId')
self.build_tag_param_list(params, tags)
if dry_run:
params['DryRun'] = 'true'
return self.get_status('CreateTags', params, verb='POST')
def delete_tags(self, resource_ids, tags, dry_run=False):
"""
Delete metadata tags for the specified resource ids.
:type resource_ids: list
:param resource_ids: List of strings
:type tags: dict or list
:param tags: Either a dictionary containing name/value pairs
or a list containing just tag names.
If you pass in a dictionary, the values must
match the actual tag values or the tag will
not be deleted. If you pass in a value of None
for the tag value, all tags with that name will
be deleted.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
if isinstance(tags, list):
tags = {}.fromkeys(tags, None)
params = {}
self.build_list_params(params, resource_ids, 'ResourceId')
self.build_tag_param_list(params, tags)
if dry_run:
params['DryRun'] = 'true'
return self.get_status('DeleteTags', params, verb='POST')
# Network Interface methods
def get_all_network_interfaces(self, network_interface_ids=None, filters=None, dry_run=False):
"""
Retrieve all of the Elastic Network Interfaces (ENI's)
associated with your account.
:type network_interface_ids: list
:param network_interface_ids: a list of strings representing ENI IDs
:type filters: dict
:param filters: Optional filters that can be used to limit
the results returned. Filters are provided
in the form of a dictionary consisting of
filter names as the key and filter values
as the value. The set of allowable filter
names/values is dependent on the request
being performed. Check the EC2 API guide
for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: list
:return: A list of :class:`boto.ec2.networkinterface.NetworkInterface`
"""
params = {}
if network_interface_ids:
self.build_list_params(params, network_interface_ids, 'NetworkInterfaceId')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeNetworkInterfaces', params,
[('item', NetworkInterface)], verb='POST')
def create_network_interface(self, subnet_id, private_ip_address=None,
description=None, groups=None, dry_run=False):
"""
Creates a network interface in the specified subnet.
:type subnet_id: str
:param subnet_id: The ID of the subnet to associate with the
network interface.
:type private_ip_address: str
:param private_ip_address: The private IP address of the
network interface. If not supplied, one will be chosen
for you.
:type description: str
:param description: The description of the network interface.
:type groups: list
:param groups: Lists the groups for use by the network interface.
This can be either a list of group ID's or a list of
:class:`boto.ec2.securitygroup.SecurityGroup` objects.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.networkinterface.NetworkInterface`
:return: The newly created network interface.
"""
params = {'SubnetId': subnet_id}
if private_ip_address:
params['PrivateIpAddress'] = private_ip_address
if description:
params['Description'] = description
if groups:
ids = []
for group in groups:
if isinstance(group, SecurityGroup):
ids.append(group.id)
else:
ids.append(group)
self.build_list_params(params, ids, 'SecurityGroupId')
if dry_run:
params['DryRun'] = 'true'
return self.get_object('CreateNetworkInterface', params,
NetworkInterface, verb='POST')
def attach_network_interface(self, network_interface_id,
instance_id, device_index, dry_run=False):
"""
Attaches a network interface to an instance.
:type network_interface_id: str
:param network_interface_id: The ID of the network interface to attach.
:type instance_id: str
:param instance_id: The ID of the instance that will be attached
to the network interface.
:type device_index: int
:param device_index: The index of the device for the network
interface attachment on the instance.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'NetworkInterfaceId': network_interface_id,
'InstanceId': instance_id,
'DeviceIndex': device_index}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('AttachNetworkInterface', params, verb='POST')
def detach_network_interface(self, attachment_id, force=False,
dry_run=False):
"""
Detaches a network interface from an instance.
:type attachment_id: str
:param attachment_id: The ID of the attachment.
:type force: bool
:param force: Set to true to force a detachment.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'AttachmentId': attachment_id}
if force:
params['Force'] = 'true'
if dry_run:
params['DryRun'] = 'true'
return self.get_status('DetachNetworkInterface', params, verb='POST')
def delete_network_interface(self, network_interface_id, dry_run=False):
"""
Delete the specified network interface.
:type network_interface_id: str
:param network_interface_id: The ID of the network interface to delete.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {'NetworkInterfaceId': network_interface_id}
if dry_run:
params['DryRun'] = 'true'
return self.get_status('DeleteNetworkInterface', params, verb='POST')
def get_all_instance_types(self):
"""
Get all instance_types available on this cloud (eucalyptus specific)
:rtype: list of :class:`boto.ec2.instancetype.InstanceType`
:return: The requested InstanceType objects
"""
params = {}
return self.get_list('DescribeInstanceTypes', params, [('item', InstanceType)], verb='POST')
def copy_image(self, source_region, source_image_id, name=None,
description=None, client_token=None, dry_run=False,
encrypted=None, kms_key_id=None):
"""
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:rtype: :class:`boto.ec2.image.CopyImage`
:return: Object containing the image_id of the copied image.
"""
params = {
'SourceRegion': source_region,
'SourceImageId': source_image_id,
}
if name is not None:
params['Name'] = name
if description is not None:
params['Description'] = description
if client_token is not None:
params['ClientToken'] = client_token
if encrypted is not None:
params['Encrypted'] = 'true' if encrypted else 'false'
if kms_key_id is not None:
params['KmsKeyId'] = kms_key_id
if dry_run:
params['DryRun'] = 'true'
return self.get_object('CopyImage', params, CopyImage,
verb='POST')
def describe_account_attributes(self, attribute_names=None, dry_run=False):
"""
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {}
if attribute_names is not None:
self.build_list_params(params, attribute_names, 'AttributeName')
if dry_run:
params['DryRun'] = 'true'
return self.get_list('DescribeAccountAttributes', params,
[('item', AccountAttribute)], verb='POST')
def describe_vpc_attribute(self, vpc_id, attribute=None, dry_run=False):
"""
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {
'VpcId': vpc_id
}
if attribute is not None:
params['Attribute'] = attribute
if dry_run:
params['DryRun'] = 'true'
return self.get_object('DescribeVpcAttribute', params,
VPCAttribute, verb='POST')
def modify_vpc_attribute(self, vpc_id, enable_dns_support=None,
enable_dns_hostnames=None, dry_run=False):
"""
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
"""
params = {
'VpcId': vpc_id
}
if enable_dns_support is not None:
params['EnableDnsSupport.Value'] = (
'true' if enable_dns_support else 'false')
if enable_dns_hostnames is not None:
params['EnableDnsHostnames.Value'] = (
'true' if enable_dns_hostnames else 'false')
if dry_run:
params['DryRun'] = 'true'
return self.get_status('ModifyVpcAttribute', params, verb='POST')
def get_all_classic_link_instances(self, instance_ids=None, filters=None,
dry_run=False, max_results=None,
next_token=None):
"""
Get all of your linked EC2-Classic instances. This request only
returns information about EC2-Classic instances linked to
a VPC through ClassicLink
:type instance_ids: list
:param instance_ids: A list of strings of instance IDs. Must be
instances linked to a VPC through ClassicLink.
:type filters: dict
:param filters: Optional filters that can be used to limit the
results returned. Filters are provided in the form of a
dictionary consisting of filter names as the key and
filter values as the value. The set of allowable filter
names/values is dependent on the request being performed.
Check the EC2 API guide for details.
:type dry_run: bool
:param dry_run: Set to True if the operation should not actually run.
:type max_results: int
:param max_results: The maximum number of paginated instance
items per response.
:rtype: list
:return: A list of :class:`boto.ec2.instance.Instance`
"""
params = {}
if instance_ids:
self.build_list_params(params, instance_ids, 'InstanceId')
if filters:
self.build_filter_params(params, filters)
if dry_run:
params['DryRun'] = 'true'
if max_results is not None:
params['MaxResults'] = max_results
if next_token:
params['NextToken'] = next_token
return self.get_list('DescribeClassicLinkInstances', params,
[('item', Instance)], verb='POST')
Reference in a new issue Copy permalink