def __init__(self, **kwargs):
region = kwargs.pop('region', None)
if not region:
region = RegionInfo(self, self.DefaultRegionName,
self.DefaultRegionEndpoint)
if 'host' not in kwargs or kwargs['host'] is None:
kwargs['host'] = region.endpoint
super(CloudHSMConnection, self).__init__(**kwargs)
self.region = region
def connect(self,accesskey, secretkey):
'''
Method to establish connection to EC2.
'''
try:
region = RegionInfo(name="eucalyptus", endpoint="128.111.179.130")
self.conn = boto.connect_ec2(aws_access_key_id="UQ8GATqwbQT6v1yAvg9R3EJzZdvfPeFyDiRg",aws_secret_access_key="hGe4WCORyqEEFPRZfM7dLPqvH607IsH1a1nZw",is_secure=False,region=region,port=8773,path="/services/Eucalyptus")
#self.conn = EC2Connection(accesskey, secretkey)
except Exception,e:
logging.error(str(e))
def regions():
"""
Get all available regions for the AWS Redshift service.
:rtype: list
:return: A list of :class:`boto.regioninfo.RegionInfo`
"""
from boto.redshift.layer1 import RedshiftConnection
cls = RedshiftConnection
return [
RegionInfo(name='us-east-1',
endpoint='redshift.us-east-1.amazonaws.com',
connection_cls=cls),
RegionInfo(name='us-west-2',
endpoint='redshift.us-west-2.amazonaws.com',
connection_cls=cls),
RegionInfo(name='eu-west-1',
endpoint='redshift.eu-west-1.amazonaws.com',
connection_cls=cls),
]
def regions(**kw_params):
"""
Get all available regions for the EC2 service.
You may pass any of the arguments accepted by the VPCConnection
object's constructor as keyword arguments and they will be
passed along to the VPCConnection object.
:rtype: list
:return: A list of :class:`boto.ec2.regioninfo.RegionInfo`
"""
regions = []
for region_name in RegionData:
region = RegionInfo(name=region_name,
endpoint=RegionData[region_name],
connection_cls=VPCConnection)
regions.append(region)
regions.append(
RegionInfo(name='us-gov-west-1',
endpoint=RegionData[region_name],
connection_cls=VPCConnection))
return regions
def get_con(port=9999):
u = os.environ['RABBITMQ_USERNAME']
p = os.environ['RABBITMQ_PASSWORD']
region = RegionInfo('localhost')
con = boto.ec2.autoscale.AutoScaleConnection(aws_access_key_id=u,
aws_secret_access_key=p,
is_secure=True,
port=port,
debug=3,
region=region)
con.host = 'localhost'
return con
def setup(self):
self.mock_conn = Mock(spec_set=SupportConnection)
type(self.mock_conn).region = RegionInfo(name='us-east-1')
self.cls = TrustedAdvisor()
self.cls.conn = self.mock_conn
self.mock_svc1 = Mock(spec_set=_AwsService)
self.mock_svc2 = Mock(spec_set=_AwsService)
self.services = {
'SvcFoo': self.mock_svc1,
'SvcBar': self.mock_svc2,
}
def test_init_region(self):
dynamodb = DynamoDBConnection(
aws_access_key_id='aws_access_key_id',
aws_secret_access_key='aws_secret_access_key')
self.assertEqual(dynamodb.region.name, 'us-east-1')
dynamodb = DynamoDBConnection(
region=RegionInfo(name='us-west-2',
endpoint='dynamodb.us-west-2.amazonaws.com'),
aws_access_key_id='aws_access_key_id',
aws_secret_access_key='aws_secret_access_key',
)
self.assertEqual(dynamodb.region.name, 'us-west-2')
def __init__(self, queue_name, aws_access_key_id=None, aws_secret_access_key=None, region='us-east-1',
endpoint=None, is_secure=True, port=None, incoming_message_class='boto.sqs.jsonmessage.JSONMessage'):
self._region = RegionInfo(name=region, endpoint=endpoint) if region and endpoint else None
self._queue_name = queue_name
self._is_secure = is_secure
self._port = port
self._incoming_message_class = incoming_message_class
self._aws_access_key_id = aws_access_key_id
self._aws_secret_access_key = aws_secret_access_key
self._message_class = locate(self._incoming_message_class)
self._queue = None
self._message_service = None
def regions():
"""
Get all available regions for the SES service.
:rtype: list
:return: A list of :class:`boto.regioninfo.RegionInfo` instances
"""
return [
RegionInfo(name='us-east-1',
endpoint='email.us-east-1.amazonaws.com',
connection_cls=SESConnection)
]
def __init__(self, fail_silently=False, *args, **kwargs):
super(SESBackend, self).__init__(fail_silently=fail_silently, *args,
**kwargs)
self._access_key_id = settings.ACCESS_KEY
self._access_key = settings.SECRET_KEY
self._region = RegionInfo(
name=settings.AWS_SES_REGION_NAME,
endpoint=settings.AWS_SES_REGION_ENDPOINT)
self._throttle = settings.AWS_SES_AUTO_THROTTLE
self.connection = None
def regions():
"""
Get all available regions for the AWS Elastic Transcoder service.
:rtype: list
:return: A list of :class:`boto.regioninfo.RegionInfo`
"""
from boto.elastictranscoder.layer1 import ElasticTranscoderConnection
cls = ElasticTranscoderConnection
return [
RegionInfo(name='us-east-1',
endpoint='elastictranscoder.us-east-1.amazonaws.com',
connection_cls=cls),
RegionInfo(name='us-west-1',
endpoint='elastictranscoder.us-west-1.amazonaws.com',
connection_cls=cls),
RegionInfo(name='us-west-2',
endpoint='elastictranscoder.us-west-2.amazonaws.com',
connection_cls=cls),
RegionInfo(name='ap-northeast-1',
endpoint='elastictranscoder.ap-northeast-1.amazonaws.com',
connection_cls=cls),
RegionInfo(name='ap-southeast-1',
endpoint='elastictranscoder.ap-southeast-1.amazonaws.com',
connection_cls=cls),
RegionInfo(name='eu-west-1',
endpoint='elastictranscoder.eu-west-1.amazonaws.com',
connection_cls=cls),
]
def regions():
"""
Get all available regions for the Amazon DynamoDB service.
:rtype: list
:return: A list of :class:`boto.regioninfo.RegionInfo`
"""
from boto.dynamodb2.layer1 import DynamoDBConnection
return [
RegionInfo(name='us-east-1',
endpoint='dynamodb.us-east-1.amazonaws.com',
connection_cls=DynamoDBConnection),
RegionInfo(name='us-gov-west-1',
endpoint='dynamodb.us-gov-west-1.amazonaws.com',
connection_cls=DynamoDBConnection),
RegionInfo(name='us-west-1',
endpoint='dynamodb.us-west-1.amazonaws.com',
connection_cls=DynamoDBConnection),
RegionInfo(name='us-west-2',
endpoint='dynamodb.us-west-2.amazonaws.com',
connection_cls=DynamoDBConnection),
RegionInfo(name='eu-west-1',
endpoint='dynamodb.eu-west-1.amazonaws.com',
connection_cls=DynamoDBConnection),
RegionInfo(name='ap-northeast-1',
endpoint='dynamodb.ap-northeast-1.amazonaws.com',
connection_cls=DynamoDBConnection),
RegionInfo(name='ap-southeast-1',
endpoint='dynamodb.ap-southeast-1.amazonaws.com',
connection_cls=DynamoDBConnection),
RegionInfo(name='ap-southeast-2',
endpoint='dynamodb.ap-southeast-2.amazonaws.com',
connection_cls=DynamoDBConnection),
RegionInfo(name='sa-east-1',
endpoint='dynamodb.sa-east-1.amazonaws.com',
connection_cls=DynamoDBConnection),
RegionInfo(name='cn-north-1',
endpoint='dynamodb.cn-north-1.amazonaws.com.cn',
connection_cls=DynamoDBConnection),
]
def regions():
"""
Get all available regions for the Amazon DynamoDB service.
:rtype: list
:return: A list of :class:`boto.regioninfo.RegionInfo`
"""
import boto.dynamodb.layer2
return [
RegionInfo(name='us-east-1',
endpoint='dynamodb.us-east-1.amazonaws.com',
connection_cls=boto.dynamodb.layer2.Layer2),
RegionInfo(name='us-west-1',
endpoint='dynamodb.us-west-1.amazonaws.com',
connection_cls=boto.dynamodb.layer2.Layer2),
RegionInfo(name='us-west-2',
endpoint='dynamodb.us-west-2.amazonaws.com',
connection_cls=boto.dynamodb.layer2.Layer2),
RegionInfo(name='ap-northeast-1',
endpoint='dynamodb.ap-northeast-1.amazonaws.com',
connection_cls=boto.dynamodb.layer2.Layer2),
RegionInfo(name='ap-southeast-1',
endpoint='dynamodb.ap-southeast-1.amazonaws.com',
connection_cls=boto.dynamodb.layer2.Layer2),
RegionInfo(name='eu-west-1',
endpoint='dynamodb.eu-west-1.amazonaws.com',
connection_cls=boto.dynamodb.layer2.Layer2),
]
def regions():
"""
Get all available regions for the SNS service.
:rtype: list
:return: A list of :class:`boto.regioninfo.RegionInfo` instances
"""
return [
RegionInfo(name='us-east-1',
endpoint='sns.us-east-1.amazonaws.com',
connection_cls=SNSConnection),
RegionInfo(name='eu-west-1',
endpoint='sns.eu-west-1.amazonaws.com',
connection_cls=SNSConnection),
RegionInfo(name='us-west-1',
endpoint='sns.us-west-1.amazonaws.com',
connection_cls=SNSConnection),
RegionInfo(name='us-west-2',
endpoint='sns.us-west-2.amazonaws.com',
connection_cls=SNSConnection),
RegionInfo(name='ap-northeast-1',
endpoint='sns.ap-northeast-1.amazonaws.com',
connection_cls=SNSConnection),
RegionInfo(name='ap-southeast-1',
endpoint='sns.ap-southeast-1.amazonaws.com',
connection_cls=SNSConnection),
]
def _euca_connection(_clchost, _port, _access_id, _secret_key, _token,
_conn_type):
region = RegionInfo(name='eucalyptus', endpoint=_clchost)
path = '/services/Eucalyptus'
conn_class = EC2Connection
api_version = '2012-12-01'
# Configure based on connection type
if conn_type == 'autoscale':
api_version = '2011-01-01'
conn_class = boto.ec2.autoscale.AutoScaleConnection
path = '/services/AutoScaling'
elif conn_type == 'cloudwatch':
path = '/services/CloudWatch'
conn_class = boto.ec2.cloudwatch.CloudWatchConnection
elif conn_type == 'elb':
path = '/services/LoadBalancing'
conn_class = boto.ec2.elb.ELBConnection
elif conn_type == 'iam':
path = '/services/Euare'
conn_class = boto.iam.IAMConnection
if conn_type == 'sts':
conn = EucaAuthenticator(_clchost, _port)
elif conn_type != 'iam':
conn = conn_class(_access_id,
_secret_key,
region=region,
port=_port,
path=path,
is_secure=True,
security_token=_token)
else:
conn = conn_class(_access_id,
_secret_key,
host=_clchost,
port=_port,
path=path,
is_secure=True,
security_token=_token)
# AutoScaling service needs additional auth info
if conn_type == 'autoscale':
conn.auth_region_name = 'Eucalyptus'
if conn_type != 'sts': # this is the only non-boto connection
setattr(conn, 'APIVersion', api_version)
conn.https_validate_certificates = False
conn.http_connection_kwargs['timeout'] = 30
# uncomment to enable boto request logger. Use only for development
#conn.set_request_hook(RequestLogger())
return conn
def regions():
"""
Get all available regions for the Amazon Support service.
:rtype: list
:return: A list of :class:`boto.regioninfo.RegionInfo`
"""
from boto.support.layer1 import SupportConnection
return [
RegionInfo(name='us-east-1',
endpoint='support.us-east-1.amazonaws.com',
connection_cls=SupportConnection),
]
def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
is_secure=True, port=None, proxy=None, proxy_port=None,
proxy_user=None, proxy_pass=None, debug=0,
https_connection_factory=None, region=None, path='/'):
if not region:
region = RegionInfo(self, self.DefaultRegionName,
self.DefaultRegionEndpoint)
self.region = region
AWSAuthConnection.__init__(self, self.region.endpoint,
aws_access_key_id, aws_secret_access_key,
is_secure, port, proxy, proxy_port,
proxy_user, proxy_pass, debug,
https_connection_factory, path)
def __init__(self,
aws_access_key_id=None,
aws_secret_access_key=None,
is_secure=True,
port=None,
proxy=None,
proxy_port=None,
proxy_user=None,
proxy_pass=None,
debug=0,
https_connection_factory=None,
region=None,
path='/',
security_token=None,
validate_certs=True,
profile_name=None,
aws_sudo_id=None):
"""
Init method to create a new connection to EC2 Monitoring Service.
B{Note:} The host argument is overridden by the host specified in the
boto configuration file.
"""
if not region:
region = RegionInfo(self, self.DefaultRegionName,
self.DefaultRegionEndpoint)
self.region = region
# Ugly hack to get around both a bug in Python and a
# misconfigured SSL cert for the eu-west-1 endpoint
if self.region.name == 'eu-west-1':
validate_certs = False
super(CloudWatchConnection,
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)
self.aws_sudo_id = aws_sudo_id
def __init__(self, virtapi, read_only=False):
super(EC2Driver, self).__init__(virtapi)
self.host_status_base = {
'vcpus': VCPUS,
'memory_mb': MEMORY_IN_MBS,
'local_gb': DISK_IN_GB,
'vcpus_used': 0,
'memory_mb_used': 0,
'local_gb_used': 100000000000,
'hypervisor_type': 'EC2',
'hypervisor_version': '1.0',
'hypervisor_hostname': CONF.host,
'cpu_info': {},
'disk_available_least': 500000000000,
}
self._mounts = {}
self._interfaces = {}
self.creds = get_nova_creds()
self.nova = client.Client(**self.creds)
region = RegionInfo(name=aws_region, endpoint=aws_endpoint)
self.ec2_conn = ec2.EC2Connection(aws_access_key_id=CONF.ec2driver.ec2_access_key_id,
aws_secret_access_key=CONF.ec2driver.ec2_secret_access_key,
host=host,
port=port,
region=region,
is_secure=secure)
self.cloudwatch_conn = ec2.cloudwatch.connect_to_region(
aws_region, aws_access_key_id=CONF.ec2driver.ec2_access_key_id, aws_secret_access_key=CONF.ec2driver.ec2_secret_access_key)
self.security_group_lock = Lock()
self.instance_rule_refresher = InstanceRuleRefresher(
GroupRuleRefresher(
ec2_connection=self.ec2_conn,
openstack_rule_service=OpenstackRuleService(
group_service=OpenstackGroupService(self.nova.security_groups),
openstack_rule_transformer=OpenstackRuleTransformer()
),
ec2_rule_service=EC2RuleService(
ec2_connection=self.ec2_conn,
ec2_rule_transformer=EC2RuleTransformer(self.ec2_conn)
)
)
)
if not '_EC2_NODES' in globals():
set_nodes([CONF.host])
def __init__(self, fail_silently=False, aws_access_key=None,
aws_secret_key=None, aws_region_name=None,
aws_region_endpoint=None, aws_auto_throttle=None,
**kwargs):
super(SESBackend, self).__init__(fail_silently=fail_silently, **kwargs)
self._access_key_id = aws_access_key or settings.AWS_SES_ACCESS_KEY_ID
self._access_key = aws_secret_key or settings.AWS_SES_SECRET_ACCESS_KEY
self._region = RegionInfo(
name=aws_region_name or settings.AWS_SES_REGION_NAME,
endpoint=aws_region_endpoint or settings.AWS_SES_REGION_ENDPOINT)
self._throttle = aws_auto_throttle or settings.AWS_SES_AUTO_THROTTLE
self.connection = None
def get_phantom_con():
u = os.environ['EC2_ACCESS_KEY']
p = os.environ['EC2_SECRET_KEY']
url = os.environ['PHANTOM_URL']
uparts = urlparse.urlparse(url)
is_secure = uparts.scheme == 'https'
region = RegionInfo(uparts.hostname)
con = boto.ec2.autoscale.AutoScaleConnection(aws_access_key_id=u,
aws_secret_access_key=p,
is_secure=is_secure,
port=uparts.port,
region=region)
con.host = uparts.hostname
return con
def send_email_ses(config, sender, subject, message, recipients, image_png):
import boto.ses
from boto.regioninfo import RegionInfo
region = config.get('email', 'region', 'us-east-1')
region_url = config.get('email', 'region', 'email.us-east-1.amazonaws.com')
con = boto.ses.connect_to_region(
region=RegionInfo(None, region, region_url),
aws_access_key_id=config.get('email', 'AWS_ACCESS_KEY', None),
aws_secret_access_key=config.get('email', 'AWS_SECRET_KEY', None))
msg_root = generate_email(sender, subject, message, recipients, image_png)
con.send_raw_email(msg_root.as_string(),
source=msg_root['From'],
destinations=msg_root['To'])
def test_bad_pw(self):
region = RegionInfo(endpoint=self.hostname)
con = boto.ec2.autoscale.AutoScaleConnection(
aws_access_key_id=self.username,
aws_secret_access_key="XXX",
is_secure=False,
port=self.port,
debug=3,
region=region)
try:
x = con.get_all_launch_configurations()
self.assertTrue(False, "login should have failed")
except BotoServerError, ex:
pass
def __init__(self, **kwargs):
region = kwargs.pop('region', None)
if not region:
region = RegionInfo(self, self.DefaultRegionName,
self.DefaultRegionEndpoint)
if 'host' not in kwargs or kwargs['host'] is None:
kwargs['host'] = region.endpoint
sign_request = kwargs.pop('sign_request', False)
self.sign_request = sign_request
super(CloudSearchConnection, self).__init__(**kwargs)
self.region = region
def __init__(self, fail_silently=False, *args, **kwargs):
super(SESBackend, self).__init__(fail_silently=fail_silently, *args,
**kwargs)
self._access_key_id = getattr(settings, 'AWS_ACCESS_KEY_ID', None)
self._access_key = getattr(settings, 'AWS_SECRET_ACCESS_KEY', None)
self._region = RegionInfo(
name=getattr(settings, 'AWS_SES_REGION_NAME',
SESConnection.DefaultRegionName),
endpoint=getattr(settings, 'AWS_SES_REGION_ENDPOINT',
SESConnection.DefaultRegionEndpoint))
self._throttle = getattr(settings, 'AWS_SES_AUTO_THROTTLE', 0.5)
self.connection = None
def regions():
"""
Get all available regions for the CloudWatch service.
:rtype: list
:return: A list of :class:`boto.RegionInfo` instances
"""
regions = []
for region_name in RegionData:
region = RegionInfo(name=region_name,
endpoint=RegionData[region_name],
connection_cls=CloudWatchConnection)
regions.append(region)
return regions
def __init__(self, **kwargs):
region = kwargs.get('region')
if not region:
region = RegionInfo(self, self.DefaultRegionName,
self.DefaultRegionEndpoint)
else:
del kwargs['region']
if kwargs.get('host', None) is None:
raise ValueError(
'The argument, host, must be provided when creating a '
'CloudSearchDomainConnection because its methods require the '
'specific domain\'s endpoint in order to successfully make '
'requests to that CloudSearch Domain.')
super(CloudSearchDomainConnection, self).__init__(**kwargs)
self.region = region
def sendEmailViaSES(subject, body, recipients, awsRegion, sesEndpoint,
senderAddress, awsAccessKeyId, awsSecretAccessKey):
"""
Send an email via AWS SES.
:param subject: Email subject header
:type subject: string
:param body: Email body
:type body: string
:param recipients: Email recipient(s)
:type recipients: sequence of strings
:param awsRegion: AWS region for error report email
:type awsRegion: string
:param sesEndpoint: AWS/SES endpoint for error report email
:type sesEndpoint: string
:param senderAddress: Sender address for error report email
:type senderAddress: string
:param awsAccessKeyId: AWS access key ID for error report email
:type awsAccessKeyId: string
:param awsSecretAccessKey: AWS secret access key for error report email
:type awsSecretAccessKey: string
"""
try:
regionInfo = RegionInfo(connection=None,
name=awsRegion,
endpoint=sesEndpoint,
connection_cls=None)
conn = boto.ses.SESConnection(region=regionInfo,
aws_access_key_id=awsAccessKeyId,
aws_secret_access_key=awsSecretAccessKey)
conn.send_email(source=senderAddress,
subject=subject,
body=body,
to_addresses=recipients)
g_log.info("Called boto.ses.SESConnection.send_email. This does not "
"necessarily mean that the email was successfully sent.")
except BotoServerError:
g_log.exception("Failed to send email via AWS/SES. subject='%s'" %
(subject, ))
raise
except socket.gaierror:
g_log.exception(
"Failed to connect to AWS/SES. Region=%s. SesEndpoint=%s" %
(awsRegion, sesEndpoint))
raise
def dashboard(request):
"""
Graph SES send statistics over time.
"""
cache_key = 'vhash:django_ses_stats'
cached_view = cache.get(cache_key)
if cached_view:
return cached_view
region = RegionInfo(
name=settings.AWS_SES_REGION_NAME,
endpoint=settings.AWS_SES_REGION_ENDPOINT)
ses_conn = SESConnection(
aws_access_key_id=settings.ACCESS_KEY,
aws_secret_access_key=settings.SECRET_KEY,
region=region)
quota_dict = ses_conn.get_send_quota()
verified_emails_dict = ses_conn.list_verified_email_addresses()
stats = ses_conn.get_send_statistics()
quota = quota_parse(quota_dict)
verified_emails = emails_parse(verified_emails_dict)
ordered_data = stats_to_list(stats)
summary = sum_stats(ordered_data)
extra_context = {
'title': 'SES Statistics',
'datapoints': ordered_data,
'24hour_quota': quota['Max24HourSend'],
'24hour_sent': quota['SentLast24Hours'],
'24hour_remaining': float(quota['Max24HourSend']) -
float(quota['SentLast24Hours']),
'persecond_rate': quota['MaxSendRate'],
'verified_emails': verified_emails,
'summary': summary,
'access_key': ses_conn.gs_access_key_id,
'local_time': True if pytz else False,
}
response = render_to_response(
'django_ses/send_stats.html',
extra_context,
context_instance=RequestContext(request))
cache.set(cache_key, response, 60 * 15) # Cache for 15 minutes
return response
def __init__(self,
aws_access_key_id=None,
aws_secret_access_key=None,
is_secure=True,
port=None,
proxy=None,
proxy_port=None,
proxy_user=None,
proxy_pass=None,
debug=0,
https_connection_factory=None,
region=None,
path='/',
security_token=None,
validate_certs=True,
profile_name=None,
use_block_device_types=False):
"""
Init method to create a new connection to the AutoScaling service.
B{Note:} The host argument is overridden by the host specified in the
boto configuration file.
"""
if not region:
region = RegionInfo(self, self.DefaultRegionName,
self.DefaultRegionEndpoint,
AutoScaleConnection)
self.region = region
self.use_block_device_types = use_block_device_types
super(AutoScaleConnection,
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=path,
security_token=security_token,
validate_certs=validate_certs,
profile_name=profile_name)
