def regions():
"""
Get all available regions for the Amazon Glacier service.
:rtype: list
:return: A list of :class:`boto.regioninfo.RegionInfo`
"""
from boto.glacier.layer2 import Layer2
return [
RegionInfo(name='us-east-1',
endpoint='glacier.us-east-1.amazonaws.com',
connection_cls=Layer2),
RegionInfo(name='us-west-1',
endpoint='glacier.us-west-1.amazonaws.com',
connection_cls=Layer2),
RegionInfo(name='us-west-2',
endpoint='glacier.us-west-2.amazonaws.com',
connection_cls=Layer2),
RegionInfo(name='ap-northeast-1',
endpoint='glacier.ap-northeast-1.amazonaws.com',
connection_cls=Layer2),
RegionInfo(name='eu-west-1',
endpoint='glacier.eu-west-1.amazonaws.com',
connection_cls=Layer2),
]
def __init__(self, job_description, resource_url,
pilot_compute_description):
self.job_description = job_description
logger.debug("URL: " + str(resource_url) + " Type: " +
str(type(resource_url)))
self.resource_url = saga.Url(str(resource_url))
self.pilot_compute_description = pilot_compute_description
self.id = "bigjob-" + str(uuid.uuid1())
self.network_ip = None
self.ec2_conn = None
if self.resource_url.scheme == "euca+ssh" or self.resource_url.scheme == "nova+ssh":
host = self.resource_url.host
path = "/services/Eucalyptus"
if self.resource_url.path != None:
path = self.resource_url.path
port = 8773
if self.resource_url.port != None:
port = self.resource_url.port
region = None
logger.debug("Host: %s, Path: %s, Port: %d" % (host, path, port))
if self.resource_url.scheme == "euca+ssh":
region = RegionInfo(name="eucalyptus", endpoint=host)
elif self.resource_url.scheme == "nova+ssh":
region = RegionInfo(name="openstack", endpoint=host)
logger.debug("Access Key: %s Secret: %s" %
(self.pilot_compute_description["access_key_id"],
self.pilot_compute_description["secret_access_key"]))
self.ec2_conn = EC2Connection(
aws_access_key_id=self.
pilot_compute_description["access_key_id"],
aws_secret_access_key=self.
pilot_compute_description["secret_access_key"],
region=region,
is_secure=False,
port=port,
path=path)
else:
aws_region = None
if self.pilot_compute_description.has_key("region"):
region = self.pilot_compute_description["region"]
logger.debug("Connect to region: %s" % (str(region)))
aws_region = boto.ec2.get_region(
region,
aws_access_key_id=self.
pilot_compute_description["access_key_id"],
aws_secret_access_key=self.
pilot_compute_description["secret_access_key"])
self.ec2_conn = EC2Connection(
aws_access_key_id=self.
pilot_compute_description["access_key_id"],
aws_secret_access_key=self.
pilot_compute_description["secret_access_key"],
region=aws_region)
self.instance = None
def connection_for_env(self, **kwargs):
"""
Returns a boto ec2 connection for the current environment.
"""
access_key = os.getenv('EC2_ACCESS_KEY')
secret_key = os.getenv('EC2_SECRET_KEY')
clc_url = os.getenv('EC2_URL')
if not access_key or not secret_key or not clc_url:
raise Exception('Missing EC2 environment variables. Please source '
'the appropriate novarc file before running this '
'test.')
parts = self.split_clc_url(clc_url)
if FLAGS.use_ipv6:
return boto_v6.connect_ec2(aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
is_secure=parts['is_secure'],
region=RegionInfo(None,
'nova',
parts['ip']),
port=parts['port'],
path='/services/Cloud',
**kwargs)
return boto.connect_ec2(aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
is_secure=parts['is_secure'],
region=RegionInfo(None,
'nova',
parts['ip']),
port=parts['port'],
path='/services/Cloud',
**kwargs)
def regions():
"""
Get all available regions for the Amazon CloudSearch service.
:rtype: list
:return: A list of :class:`boto.regioninfo.RegionInfo`
"""
import boto.cloudsearch.layer1
return [
RegionInfo(name='us-east-1',
endpoint='cloudsearch.us-east-1.amazonaws.com',
connection_cls=boto.cloudsearch.layer1.Layer1),
RegionInfo(name='eu-west-1',
endpoint='cloudsearch.eu-west-1.amazonaws.com',
connection_cls=boto.cloudsearch.layer1.Layer1),
RegionInfo(name='us-west-1',
endpoint='cloudsearch.us-west-1.amazonaws.com',
connection_cls=boto.cloudsearch.layer1.Layer1),
RegionInfo(name='us-west-2',
endpoint='cloudsearch.us-west-2.amazonaws.com',
connection_cls=boto.cloudsearch.layer1.Layer1),
RegionInfo(name='ap-southeast-1',
endpoint='cloudsearch.ap-southeast-1.amazonaws.com',
connection_cls=boto.cloudsearch.layer1.Layer1),
]
def aws_connect(creds_fname=None):
credentials_ec2 = creds_fname
if not credentials_ec2:
config = get_cloudsim_config()
# log("config: %s" % config)
credentials_ec2 = config['boto_path']
ec2_region_name, aws_access_key_id, aws_secret_access_key, region_endpoint\
= read_boto_file(credentials_ec2)
if ec2_region_name == 'nova':
# TODO: remove hardcoded OpenStack endpoint
region = RegionInfo(None, 'cloudsim', region_endpoint) # 172.16.0.201
ec2conn = EC2Connection(aws_access_key_id,
aws_secret_access_key,
is_secure=False,
region=region,
port=8773,
path='/services/Cloud')
vpcconn = VPCConnection(aws_access_key_id,
aws_secret_access_key,
is_secure=False,
region=region,
port=8773,
path='/services/Cloud')
else:
region = RegionInfo(None, ec2_region_name, region_endpoint)
ec2conn = boto.connect_ec2(aws_access_key_id,
aws_secret_access_key,
region=region)
vpcconn = boto.connect_vpc(aws_access_key_id,
aws_secret_access_key,
region=region)
return ec2conn, vpcconn
def get_euca_connection(self, project_name=None):
if not has_boto:
logger.info('Unable to access EC2 API - boto library not found.')
return None
if not self.access_key or not self.secret_key:
self.init_context(project_name)
url = self.config.SFA_NOVA_API_URL
host = None
port = None
path = "/"
use_ssl = False
# Split the url into parts
if url.find('https://') >= 0:
use_ssl = True
url = url.replace('https://', '')
elif url.find('http://') >= 0:
use_ssl = False
url = url.replace('http://', '')
parts = url.split(':')
host = parts[0]
if len(parts) > 1:
parts = parts[1].split('/')
port = int(parts[0])
parts = parts[1:]
path = '/'+'/'.join(parts)
return boto.connect_ec2(aws_access_key_id=self.access_key,
aws_secret_access_key=self.secret_key,
is_secure=use_ssl,
region=RegionInfo(None, 'eucalyptus', host),
host=host,
port=port,
path=path)
def setup_sts_connection(self, endpoint=None, region=None, aws_access_key_id=None, aws_secret_access_key=None, path="/",port=443, is_secure=True, boto_debug=0):
sts_region = RegionInfo()
if region:
self.debug("Check region: " + str(region))
try:
if not endpoint:
sts_region.endpoint = EC2RegionData[region]
else:
sts_region.endpoint = endpoint
except KeyError:
raise Exception( 'Unknown region: %s' % region)
else:
sts_region.name = 'eucalyptus'
if endpoint:
sts_region.endpoint = endpoint
else:
sts_region.endpoint = self.get_ec2_ip()
try:
sts_connection_args = { 'aws_access_key_id' : aws_access_key_id,
'aws_secret_access_key': aws_secret_access_key,
'is_secure': is_secure,
'debug':boto_debug,
'port' : port,
'path' : path,
'region' : sts_region}
self.debug("Attempting to create STS connection to " + self.get_ec2_ip() + ':' + str(port) + path)
self.tokens = boto.connect_sts(**sts_connection_args)
except Exception, e:
self.critical("Was unable to create STS connection because of exception: " + str(e))
def make_snapshot(key,
access,
cluster,
name="main",
expiration='weekly',
device="/dev/sdf"):
# first get the mountpoint (requires some energy, but we can...)
df = subprocess.Popen(["/bin/df", device], stdout=subprocess.PIPE)
output = df.communicate()[0]
dummy, size, used, available, percent, mountpoint = \
output.split("\n")[1].split()
region_info = RegionInfo(name=region,
endpoint="ec2.{0}.amazonaws.com".format(region))
ec2 = EC2Connection(key, access, region=region_info)
# if we have the device (/dev/sdf) just don't do anything anymore
mapping = ec2.get_instance_attribute(instance_id, 'blockDeviceMapping')
try:
volume_id = mapping['blockDeviceMapping'][device].volume_id
os.system("/usr/sbin/xfs_freeze -f {0}".format(mountpoint))
snapshot = ec2.create_snapshot(
volume_id, "Backup of {0} - for {1}/{2} - expires {3}".format(
volume_id, cluster, name, expires[expiration]))
os.system("/usr/sbin/xfs_freeze -u {0}".format(mountpoint))
except Exception as e:
print e
return ["{0}".format(snapshot.id), expires[expiration]]
def __init__(self, clc_host, access_id, secret_key, token):
#boto.set_stream_logger('foo')
path = '/services/elb'
port = 8773
if clc_host[len(clc_host) - 13:] == 'amazonaws.com':
clc_host = clc_host.replace('ec2', 'elasticloadbalancing', 1)
path = '/'
reg = None
port = 443
reg = RegionInfo(name='eucalyptus', endpoint=clc_host)
if boto.__version__ < '2.6':
self.conn = ELBConnection(access_id,
secret_key,
region=reg,
port=port,
path=path,
is_secure=True,
security_token=token,
debug=0)
else:
self.conn = ELBConnection(access_id,
secret_key,
region=reg,
port=port,
path=path,
validate_certs=False,
is_secure=True,
security_token=token,
debug=0)
self.conn.http_connection_kwargs['timeout'] = 30
def __init__(self, config, *args, **kwargs):
super(APIClientEC2, self).__init__(config, *args, **kwargs)
aws_access = config.boto.aws_access
aws_secret = config.boto.aws_secret
purl = urlparse.urlparse(config.boto.ec2_url)
region = RegionInfo(name=config.boto.aws_region,
endpoint=purl.hostname)
port = purl.port
if port is None:
if purl.scheme is not "https":
port = 80
else:
port = 443
else:
port = int(port)
self.connection_data = {
"aws_access_key_id": aws_access,
"aws_secret_access_key": aws_secret,
"is_secure": purl.scheme == "https",
"region": region,
"host": purl.hostname,
"port": port,
"path": purl.path
}
def connect_ec2_endpoint(url, aws_access_key_id=None,
aws_secret_access_key=None,
**kwargs):
"""
Connect to an EC2 Api endpoint. Additional arguments are passed
through to connect_ec2.
:type url: string
:param url: A url for the ec2 api endpoint to connect to
:type aws_access_key_id: string
:param aws_access_key_id: Your AWS Access Key ID
:type aws_secret_access_key: string
:param aws_secret_access_key: Your AWS Secret Access Key
:rtype: :class:`boto.ec2.connection.EC2Connection`
:return: A connection to Eucalyptus server
"""
from boto.ec2.regioninfo import RegionInfo
purl = urlparse(url)
kwargs['port'] = purl.port
kwargs['host'] = purl.hostname
kwargs['path'] = purl.path
if not 'is_secure' in kwargs:
kwargs['is_secure'] = (purl.scheme == "https")
kwargs['region'] = RegionInfo(name=purl.hostname,
endpoint=purl.hostname)
kwargs['aws_access_key_id'] = aws_access_key_id
kwargs['aws_secret_access_key'] = aws_secret_access_key
return(connect_ec2(**kwargs))
def connect_ec2(a_key, s_key, cloud):
""" Create and return an EC2-compatible connection object.
"""
#ci = _get_cloud_info(cloud)
ci = {}
ci["region_name"] = 'us-east-1'
ci["region_endpoint"] = 'ec2.amazonaws.com'
ci["is_secure"] = True
ci["ec2_port"] = None
ci["ec2_conn_path"] = '/'
ci["cloud_type"] = "ec2"
# AWS connection values
# region_name = 'us-east-1'
# region_endpoint = 'ec2.amazonaws.com'
# is_secure = True
# ec2_port = None
# ec2_conn_path = '/'
r = RegionInfo(name=ci['region_name'], endpoint=ci['region_endpoint'])
ec2_conn = boto.connect_ec2(
aws_access_key_id=a_key,
aws_secret_access_key=s_key,
# api_version is needed for availability zone support for EC2
api_version='2011-11-01' if ci['cloud_type'] == 'ec2' else None,
is_secure=ci['is_secure'],
region=r,
port=ci['ec2_port'],
path=ci['ec2_conn_path'])
return ec2_conn
def __connect_icu(self, url, aws_access_key_id='', aws_secret_access_key='', login='', password='', **kwargs):
"""
Connect to an ICU Api endpoint.
Additional arguments are passed to ICUConnection.
:param str url: Url for the icu api endpoint to connect to
:param str aws_access_key_id: Your AWS Access Key ID
:param str aws_secret_access_key: Your AWS Secret Access Key
:param str login: Your login email ID
:param str password: Your raw password to login
:param dict kwargs:
:return class: `outscale.boto.icu.ICUConnection`
"""
if not url.startswith('https://'):
url = 'https://{0}'.format(url)
purl = urlparse.urlparse(url)
kwargs['port'] = purl.port
kwargs['path'] = purl.path
if not 'is_secure' in kwargs:
kwargs['is_secure'] = (purl.scheme == "https")
kwargs['host'] = RegionInfo(name=purl.hostname, endpoint=purl.hostname).endpoint
kwargs['aws_access_key_id'] = aws_access_key_id
kwargs['aws_secret_access_key'] = aws_secret_access_key
kwargs['login'] = login
kwargs['password'] = password
return ICUConnection(**kwargs)
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):
if not region:
region = RegionInfo(self, self.DefaultRegionName,
self.DefaultRegionEndpoint)
self.region = region
super(EmrConnection, 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)
# Many of the EMR hostnames are of the form:
# <region>.<service_name>.amazonaws.com
# rather than the more common:
# <service_name>.<region>.amazonaws.com
# so we need to explicitly set the region_name and service_name
# for the SigV4 signing.
self.auth_region_name = self.region.name
self.auth_service_name = 'elasticmapreduce'
def connect_euca(host,
aws_access_key_id=None,
aws_secret_access_key=None,
port=8773,
path='/services/Eucalyptus',
is_secure=False,
**kwargs):
"""
Connect to a Eucalyptus service.
:type host: string
:param host: the host name or ip address of the Eucalyptus server
:type aws_access_key_id: string
:param aws_access_key_id: Your AWS Access Key ID
:type aws_secret_access_key: string
:param aws_secret_access_key: Your AWS Secret Access Key
:rtype: :class:`boto.ec2.connection.EC2Connection`
:return: A connection to Eucalyptus server
"""
from boto.ec2 import EC2Connection
from boto.ec2.regioninfo import RegionInfo
reg = RegionInfo(name='eucalyptus', endpoint=host)
return EC2Connection(aws_access_key_id,
aws_secret_access_key,
region=reg,
port=port,
path=path,
is_secure=is_secure,
**kwargs)
def register_key_with_iaas(iaas_url, keytext, keyname, access_key,
access_secret):
up = urlparse.urlparse(iaas_url)
ssl = up.scheme == "https"
host = up.hostname
port = up.port
region = RegionInfo(name="nimbus", endpoint=host)
ec2conn = boto.connect_ec2(access_key,
access_secret,
region=region,
port=port,
validate_certs=False)
# Workaround for a bug in Nimbus <= 2.10.1:
# import_key_pair does not properly update an existing key
try:
if ec2conn.get_key_pair(keyname) is not None:
ec2conn.delete_key_pair(keyname)
except IndexError:
# This exception is raised when boto can't find a key on Nimbus
pass
ec2conn.import_key_pair(keyname, keytext)
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='/'):
"""
Init method to create a new connection to EC2.
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
AWSQueryConnection.__init__(self, 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)
def EucalyptusProvider_config_get_ubuntu_images_by_region(conf=None):
if conf is not None:
access_key = conf['aws_access_key']
secret_key = conf['aws_secret_key']
ec2_url = conf['ec2_url']
else:
access_key = os.environ.get('EC2_ACCESS_KEY')
secret_key = os.environ.get('EC2_SECRET_KEY')
ec2_url = os.environ.get('EC2_URL')
try:
o = urlparse(ec2_url)
ec2_host = o.hostname
ec2_port = o.port
ec2_path = o.path
# Setup connection to Eucalyptus
conn = boto.connect_ec2(aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
is_secure=False,
region=RegionInfo(name="eucalyptus",
endpoint=ec2_host),
port=ec2_port,
path=ec2_path)
# Run commands
images = conn.get_all_images()
for i in images:
if 'trusty' in i.name.lower():
return i.id
except Exception as e:
logging.debug(
'EucalyptusProvider_config_get_ubuntu_images_by_region() caught exception {0}'
.format(e))
return None
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):
if not region:
region = RegionInfo(self, self.DefaultRegionName,
self.DefaultRegionEndpoint)
self.region = region
AWSQueryConnection.__init__(self,
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)
def __init__(self,
team_id,
access_key,
secret_key,
bucket='cs144students'):
"""
(constructor)
Creates a new instance of the Rankmaniac class for a specific
team using the provided credentials.
Arguments:
team_id <str> the team identifier, which may be
differ slightly from the actual team
name.
access_key <str> the AWS access key identifier.
secret_key <str> the AWS secret acess key.
Keyword arguments:
bucket <str> the S3 bucket name.
"""
region = RegionInfo(None, self.DefaultRegionName,
self.DefaultRegionEndpoint)
self._s3_bucket = bucket
self._s3_conn = S3Connection(access_key, secret_key)
self._emr_conn = EmrConnection(access_key, secret_key, region=region)
self.team_id = team_id
self.job_id = None
self._reset()
self._num_instances = 1
def connect_fcu_endpoint(url, aws_access_key_id, aws_secret_access_key, **kwargs):
"""
Connect to an FCU Api endpoint. Additional arguments are passed
through to FCUConnection.
:type url: string
:param url: A url for the ec2 api endpoint to connect to
:type aws_access_key_id: string
:param aws_access_key_id: Your AWS Access Key ID
:type aws_secret_access_key: string
:param aws_secret_access_key: Your AWS Secret Access Key
:rtype: :class:`osc_cloud_builder.vendor.outscale.fcu.FCUConnection`
"""
from boto.ec2.regioninfo import RegionInfo
purl = urlparse.urlparse(url)
kwargs['port'] = purl.port
kwargs['host'] = purl.hostname
kwargs['path'] = purl.path
if not 'is_secure' in kwargs:
kwargs['is_secure'] = (purl.scheme == "https")
kwargs['region'] = RegionInfo(name=purl.hostname,
endpoint=purl.hostname)
kwargs['aws_access_key_id'] = aws_access_key_id
kwargs['aws_secret_access_key'] = aws_secret_access_key
return FCUConnection(**kwargs)
def main(argv):
def print_help(file=sys.stdout):
print('server_deployment.py -a <EC2 Access Key> -s <EC2 Secret Key>',
file=file)
ec2_access_key = config.ec2AccessKey
ec2_secret_key = config.ec2SecretKey
# try:
# opts, args = getopt.getopt(argv[1:], "ha:s:", ["ec2AccessKey=", "ec2SecretKey="])
# except getopt.GetoptError:
# print_help(file=sys.stderr)
# sys.exit(2)
# #print("opts:", opts, "args:", args)
# for opt, arg in opts:
# #print("option:", opt, "arg:", arg)
# if opt == '-h':
# print_help()
# sys.exit()
# elif opt in ("-a", "--ec2AccessKey"):
# ec2_access_key = arg
# elif opt in ("-s", "--ec2SecretKey"):
# ec2_secret_key = arg
region = RegionInfo(name='melbourne', endpoint='nova.rc.nectar.org.au')
ec2_conn = boto.connect_ec2(aws_access_key_id=ec2_access_key,
aws_secret_access_key=ec2_secret_key,
is_secure=True,
region=region,
port=8773,
path='/services/Cloud',
validate_certs=False)
reservations = ec2_conn.get_all_reservations()
terminateID_list = []
volumeID_list = []
for res in reservations:
terminateID_list.append(res.instances[0].id)
print('\nID: {}\tIP: {}\tPlacement: {}'.format(
res.instances[0].id, res.instances[0].private_ip_address,
res.instances[0].placement))
if terminateID_list:
ec2_conn.terminate_instances(instance_ids=terminateID_list)
while True:
time.sleep(2)
curr_r = ec2_conn.get_all_reservations()
if (len(curr_r) == 0):
print('ALL instances been terminated')
break
volumnes = ec2_conn.get_all_volumes()
print('Index\tID\t\tSize')
for idx, vol in enumerate(volumnes):
volumeID_list.append(vol.id)
print('{}\t{}\t{}'.format(idx, vol.id, vol.size))
if volumeID_list:
for v_id in volumeID_list:
ec2_conn.delete_volume(volume_id=v_id)
def start_ec2_boto_connection():
print "Starting Boto EC2 Connection."
region = RegionInfo(name=aws_region, endpoint=aws_endpoint)
ec2conn = boto.connect_ec2(
aws_access_key_id=key_id,
aws_secret_access_key=secret_key,
region=region)
return ec2conn
def get_connection():
return boto.connect_ec2(aws_access_key_id=ACCESS_KEY,
aws_secret_access_key=SECRET_KEY,
is_secure=False,
region=RegionInfo(None, REGION, CLC_IP),
port=CLC_PORT,
path='/services/Cloud',
debug=99)
def get_conn(i,regions,endpoints):
# first create a region object and connection
region = RegionInfo(name=regions[i], endpoint=endpoints[i])
# first create a connection to the appropriate host, using your credentials
ec2conn = boto.connect_ec2(region = region)
reservations = ec2conn.get_all_instances()
return reservations
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),
RegionInfo(name='sa-east-1',
endpoint='dynamodb.sa-east-1.amazonaws.com',
connection_cls=boto.dynamodb.layer2.Layer2),
]
def regions():
"""
Get all available regions for the Amazon Simple Workflow service.
:rtype: list
:return: A list of :class:`boto.regioninfo.RegionInfo`
"""
import boto.swf.layer1
return [
RegionInfo(name='us-east-1',
endpoint='swf.us-east-1.amazonaws.com',
connection_cls=boto.swf.layer1.Layer1),
RegionInfo(name='us-west-1',
endpoint='swf.us-west-1.amazonaws.com',
connection_cls=boto.swf.layer1.Layer1),
RegionInfo(name='us-west-2',
endpoint='swf.us-west-2.amazonaws.com',
connection_cls=boto.swf.layer1.Layer1),
RegionInfo(name='ap-northeast-1',
endpoint='swf.ap-northeast-1.amazonaws.com',
connection_cls=boto.swf.layer1.Layer1),
RegionInfo(name='ap-southeast-1',
endpoint='swf.ap-southeast-1.amazonaws.com',
connection_cls=boto.swf.layer1.Layer1),
RegionInfo(name='ap-southeast-2',
endpoint='swf.ap-southeast-2.amazonaws.com',
connection_cls=boto.swf.layer1.Layer1),
RegionInfo(name='eu-west-1',
endpoint='swf.eu-west-1.amazonaws.com',
connection_cls=boto.swf.layer1.Layer1),
]
def get_cw_connection_args(self,
endpoint=None,
aws_access_key_id=None,
aws_secret_access_key=None,
is_secure=True,
host=None,
region=None,
path='/',
port=443,
boto_debug=0):
'''
:param endpoint:
:param aws_access_key_id:
:param aws_secret_access_key:
:param is_secure:
:param host:
:param region:
:param path:
:param port:
:param boto_debug:
:raise:
'''
cw_region = RegionInfo()
if region:
self.log.debug('Check region: ' + str(region))
try:
if not endpoint:
cw_region.endpoint = CWRegionData[region]
else:
cw_region.endpoint = endpoint
except KeyError:
raise Exception('Unknown region: %s' % region)
else:
cw_region.name = 'eucalyptus'
if not host:
if endpoint:
cw_region.endpoint = endpoint
else:
cw_region.endpoint = self.get_cw_ip()
connection_args = {
'aws_access_key_id': aws_access_key_id,
'aws_secret_access_key': aws_secret_access_key,
'is_secure': is_secure,
'debug': boto_debug,
'port': port,
'path': path,
'region': cw_region
}
if re.search('2.6', boto_version):
connection_args['validate_certs'] = False
cw_connection_args = copy.copy(connection_args)
cw_connection_args['path'] = path
cw_connection_args['region'] = cw_region
return cw_connection_args
def connect(self):
""" Connects to the cloud using boto interface """
self.region = RegionInfo(name=self.cloud_type, endpoint=self.cloud_uri)
self.conn = EC2Connection(self.access_id,
self.secret_key,
port=self.cloud_port,
region=self.region)
self.conn.host = self.cloud_uri
LOG.debug("Connected to cloud: %s" % (self.name))
def start_ec2_boto_connection():
print "Starting Boto Connection."
region = RegionInfo(name=cloud_name, endpoint=ec2_host)
ec2conn = boto.connect_ec2(aws_access_key_id=key_id,
aws_secret_access_key=secret_key,
is_secure=False,
port=8773,
path=ec2_service_path,
region=region)
return ec2conn