def __init__(self,
name,
process,
platform,
env,
region,
domain=None,
public=False):
self.name = name
self.process = process
self.platform = platform
self.env = env
self.loadbalancer_name = "%s-%s-%s-%s" % (self.process, self.name,
self.platform, self.env)
self.region = region
self.connection = elb.connect_to_region(self.region)
self.interval = 10
self.healthy_threshold = 3
self.unhealthy_threshold = 5
self.target = 'HTTP:80/'
self.listeners = {
'80': [(80, 80, 'http')],
'443': [(80, 80, 'http'), (443, 80, 'https')]
}
self.domain = domain
self.listener = self.listeners['80']
self.public = public
def metrics_catalog(region):
'''Build a catalog of available metrics'''
conn_ec2 = ec2.connect_to_region(region)
conn_elb = elb.connect_to_region(region)
conn_rds = rds.connect_to_region(region)
conn_cloudwatch = cloudwatch.connect_to_region(region)
catalog = {'ec2':{}, 'ebs':{}, 'elb':{}, 'rds':{}}
# EC2 instances
for reservation in conn_ec2.get_all_instances():
for instance in reservation.instances:
catalog['ec2'][instance] = conn_cloudwatch.list_metrics(
dimensions={'InstanceId': [instance.id]})
# EBS Volumes
for volume in conn_ec2.get_all_volumes():
catalog['ebs'][volume] = conn_cloudwatch.list_metrics(
dimensions={'VolumeId': [volume.id]})
# ELB instances
for balancer in conn_elb.get_all_load_balancers():
catalog['elb'][balancer] = conn_cloudwatch.list_metrics(
dimensions={'LoadBalancerName': [balancer.name]})
# RDS instances
for instance in conn_rds.get_all_dbinstances():
catalog['rds'][instance] = conn_cloudwatch.list_metrics(
dimensions={'DBInstanceIdentifier': [instance.id]})
return catalog
def __init__(self, key, secret, region, elb_name):
self.elb = elb.connect_to_region(
region,
aws_access_key_id=key,
aws_secret_access_key=secret)
self.elb_name = elb_name
self._boto_lb = None
def _get_conn(region, key, keyid, profile):
'''
Get a boto connection to ELB.
'''
if profile:
if isinstance(profile, string_types):
_profile = __salt__['config.option'](profile)
elif isinstance(profile, dict):
_profile = profile
key = _profile.get('key', None)
keyid = _profile.get('keyid', None)
region = _profile.get('region', None)
if not region and __salt__['config.option']('elb.region'):
region = __salt__['config.option']('elb.region')
if not region:
region = 'us-east-1'
if not key and __salt__['config.option']('elb.key'):
key = __salt__['config.option']('elb.key')
if not keyid and __salt__['config.option']('elb.keyid'):
keyid = __salt__['config.option']('elb.keyid')
try:
conn = elb.connect_to_region(region, aws_access_key_id=keyid,
aws_secret_access_key=key)
except boto.exception.NoAuthHandlerFound:
log.error('No authentication credentials found when attempting to'
' make boto elb connection.')
return None
return conn
def metrics_catalog(region):
'''Build a catalog of available metrics'''
conn_ec2 = ec2.connect_to_region(region)
conn_elb = elb.connect_to_region(region)
conn_rds = rds.connect_to_region(region)
conn_cloudwatch = cloudwatch.connect_to_region(region)
catalog = {'ec2': {}, 'ebs': {}, 'elb': {}, 'rds': {}}
# EC2 instances
for reservation in conn_ec2.get_all_instances():
for instance in reservation.instances:
catalog['ec2'][instance] = conn_cloudwatch.list_metrics(
dimensions={'InstanceId': [instance.id]})
# EBS Volumes
for volume in conn_ec2.get_all_volumes():
catalog['ebs'][volume] = conn_cloudwatch.list_metrics(
dimensions={'VolumeId': [volume.id]})
# ELB instances
for balancer in conn_elb.get_all_load_balancers():
catalog['elb'][balancer] = conn_cloudwatch.list_metrics(
dimensions={'LoadBalancerName': [balancer.name]})
# RDS instances
for instance in conn_rds.get_all_dbinstances():
catalog['rds'][instance] = conn_cloudwatch.list_metrics(
dimensions={'DBInstanceIdentifier': [instance.id]})
return catalog
def _get_conn(region, key, keyid, profile):
'''
Get a boto connection to ELB.
'''
if profile:
if isinstance(profile, string_types):
_profile = __salt__['config.option'](profile)
elif isinstance(profile, dict):
_profile = profile
key = _profile.get('key', None)
keyid = _profile.get('keyid', None)
region = _profile.get('region', None)
if not region and __salt__['config.option']('elb.region'):
region = __salt__['config.option']('elb.region')
if not region:
region = 'us-east-1'
if not key and __salt__['config.option']('elb.key'):
key = __salt__['config.option']('elb.key')
if not keyid and __salt__['config.option']('elb.keyid'):
keyid = __salt__['config.option']('elb.keyid')
try:
conn = elb.connect_to_region(region,
aws_access_key_id=keyid,
aws_secret_access_key=key)
except boto.exception.NoAuthHandlerFound:
log.error('No authentication credentials found when attempting to'
' make boto elb connection.')
return None
return conn
def connect_elb_region(region_name=_DEFAULT_REGION):
"""Connects to the ELB service for region_name and returns the ELB
connection."""
print ("Connecting to ELB service for region {}".format(region_name))
return elb.connect_to_region(region_name,
aws_access_key_id=AWS_ACCESS_KEY_ID,
aws_secret_access_key=AWS_SECRET_ACCESS_KEY)
def get_loadbalancer(project):
tenant = landlord.Tenant()
tenant.load_properties()
conn = elb.connect_to_region(tenant.get_property('deploy.region'),
aws_access_key_id=tenant.get_property('aws.id'),
aws_secret_access_key=tenant.get_property('aws.secret'))
try:
load_balancers = conn.get_all_load_balancers(load_balancer_names=[tenant.get_property('environment')+'-lb-' + project['name']])
if load_balancers:
print "[LB] Found load balancer ..."
return load_balancers[0]
else:
raise BotoServerError('LoadBalancerNotFound', 'Load Balancer does not exists')
except BotoServerError:
print "[LB] No load balancer, creating one ..."
#TODO: https://github.com/boto/boto/issues/509
hc = HealthCheck(
interval=20,
healthy_threshold=3,
unhealthy_threshold=5,
target='HTTP:9000/public/version.txt')
ports = [(80, 9000, 'http')]
lb = conn.create_load_balancer(tenant.get_property('environment')+'-lb-' + project['name'], None, ports, [tenant.get_property('deploy.subnet')])
dns.update_dns(lb.dns_name, project)
print "[LB] Configuring health checks ... "
lb.configure_health_check(hc)
# TODO: Apply tags
if lb.instances is None:
lb.instances = []
return lb
def aws_conn_elb(region, profile='default'):
try:
conn = elb.connect_to_region(region, profile_name=profile)
return conn
except Exception as e:
logging.error(
"Unable to connect to region, please investigate: {0}".format(
e))
def dettach(load_balancer, instances):
if instances is not None and len(instances) > 0:
tenant = landlord.Tenant()
tenant.load_properties()
conn = elb.connect_to_region(tenant.get_property('deploy.region'),
aws_access_key_id=tenant.get_property('aws.id'),
aws_secret_access_key=tenant.get_property('aws.secret'))
conn.deregister_instances(load_balancer.name, instances)
def updateELB(conf, iam_certificate):
LOG.info("Updating ELB with new certificate")
elb_connection = elb.connect_to_region(conf['elb_region'])
response = elb_connection.set_lb_listener_SSL_certificate(
conf['elb'], 443, iam_certificate['upload_server_certificate_response']
['upload_server_certificate_result']['server_certificate_metadata']
['arn'])
return response
def connect_elb(self):
'''
Connect to ELB
'''
try:
for reg in elb.regions():
if(reg.name == os.environ['AWS_DEFAULT_REGION']):
return elb.connect_to_region(reg.name)
return None
except Exception as e:
print "%s" % e
exit(-1)
def create_elb(self, scheme='internet-facing', include_https=True):
name = self.random_name()
conn = elb.connect_to_region('us-east-1')
zones = ['us-east-1a', 'us-east-1b']
ports = [(80, 80, 'http')]
if include_https:
ports.append((443, 80, 'https', 'arn:aws:iam::1234567890123:server-certificate/my.nifty.cert.net'))
lb = conn.create_load_balancer(name, zones, ports, scheme=scheme)
def connect_elb(self):
'''
Connect to ELB
'''
try:
for reg in elb.regions():
if (reg.name == os.environ['AWS_DEFAULT_REGION']):
return elb.connect_to_region(reg.name)
return None
except Exception as e:
print "%s" % e
exit(-1)
def elb_connect(self, region, assumedRoleObject):
''' create connection to api server'''
if self.eucalyptus:
self.fail_with_error("Untested elb connection to eucalyptus. Please turn 'elbs' flag to False.")
else:
conn = elb.connect_to_region(region,
aws_access_key_id=assumedRoleObject.credentials.access_key,
aws_secret_access_key=assumedRoleObject.credentials.secret_key,
security_token=assumedRoleObject.credentials.session_token)
# connect_to_region will fail "silently" by returning None if the region name is wrong or not supported
if conn is None:
self.fail_with_error("region name: %s likely not supported, or AWS is down. connection to region failed." % region)
return conn
def get_ec2_connection(server_type, **kwargs):
"""
Create and return a valid connection to AWS.
To establish a valid connection, aws_access_key and aws_secret_key have to
be defined in a file specified by env.AWS_CREDENTIAL, with a format similar
to server.ini file. You should define env.AWS_CREDENTIAL in your fabfile.
By default, this function looks into $PROJECT_DIR/deploy/amazon.ini for the
credential information, and this file should has a section named 'amazon-aws'
and containing lines defining aws_access_key and aws_secret_key, like below
[amazon-aws]
aws_access_key =
aws_secret_key =
"""
amzn = env.get('AWS_CREDENTIAL', os.path.join(env.deploy_path,
'amazon.ini'))
if not os.path.exists(amzn):
print(
"Cannot find environment variable AMAZON_CREDENTIALS which should"
" point to a file with your aws_access_key and aws_secret_key info"
" inside. You may specify it through your fab env.")
sys.exit(1)
parser = ConfigParser()
parser.read(amzn)
aws_access_key = parser.get('amazon-aws', 'aws_access_key')
aws_secret_key = parser.get('amazon-aws', 'aws_secret_key')
if not aws_access_key or not aws_secret_key:
print "You must specify your amazon aws credentials to your env."
sys.exit(1)
region = kwargs.get('region', env.get('region'))
if not region:
region = DEFAULT_REGION
if server_type == 'ec2':
conn = ec2.connect_to_region(region,
aws_access_key_id=aws_access_key,
aws_secret_access_key=aws_secret_key)
return conn
elif server_type == 'elb':
conn = elb.connect_to_region(region,
aws_access_key_id=aws_access_key,
aws_secret_access_key=aws_secret_key)
return conn
def _get_load_balancer_handle(self):
try:
conn = _elb.connect_to_region(self.region, **self.aws_credentials)
for i in conn.get_all_load_balancers():
if i.dns_name == self.load_balancer_dns_name:
return i
except Exception as e:
_logger.error(
"Unable to connect to ELB with name '%s' in region '%s', error: %s"
% (self.load_balancer_dns_name, self.region, e))
raise Exception(
"Cannot find load balancer with name '%s' in region '%s'." %
(self.load_balancer_dns_name, self.region))
def get_ec2_connection(server_type, **kwargs):
"""
Create and return a valid connection to AWS.
To establish a valid connection, aws_access_key and aws_secret_key have to
be defined in a file specified by env.AWS_CREDENTIAL, with a format similar
to server.ini file. You should define env.AWS_CREDENTIAL in your fabfile.
By default, this function looks into $PROJECT_DIR/deploy/amazon.ini for the
credential information, and this file should has a section named 'amazon-aws'
and containing lines defining aws_access_key and aws_secret_key, like below
[amazon-aws]
aws_access_key =
aws_secret_key =
"""
amzn = env.get('AWS_CREDENTIAL',
os.path.join(env.deploy_path, 'amazon.ini'))
if not os.path.exists(amzn):
print ("Cannot find environment variable AMAZON_CREDENTIALS which should"
" point to a file with your aws_access_key and aws_secret_key info"
" inside. You may specify it through your fab env.")
sys.exit(1)
parser = ConfigParser()
parser.read(amzn)
aws_access_key = parser.get('amazon-aws', 'aws_access_key')
aws_secret_key = parser.get('amazon-aws', 'aws_secret_key')
if not aws_access_key or not aws_secret_key:
print "You must specify your amazon aws credentials to your env."
sys.exit(1)
region = kwargs.get('region', env.get('region'))
if not region:
region = DEFAULT_REGION
if server_type == 'ec2':
conn = ec2.connect_to_region(region,
aws_access_key_id=aws_access_key,
aws_secret_access_key=aws_secret_key)
return conn
elif server_type == 'elb':
conn = elb.connect_to_region(region,
aws_access_key_id=aws_access_key,
aws_secret_access_key=aws_secret_key)
return conn
def get_elb_instances_by_region(self, region):
''' Makes an AWS API call to the list of ELB instances in a particular
region '''
try:
conn = elb.connect_to_region(region)
if conn:
instances = conn.get_all_load_balancers()
for instance in instances:
self.add_elb_instance(instance, region)
except boto.exception.BotoServerError, e:
if not e.reason == "Forbidden":
print "Looks like AWS ELB is down: "
print e
sys.exit(1)
def get_elb_instances_by_region(self, region):
''' Makes an AWS API call to the list of ELB instances in a particular
region '''
try:
conn = elb.connect_to_region(region)
if conn:
instances = conn.get_all_load_balancers()
for instance in instances:
self.add_elb_instance(instance, region)
except boto.exception.BotoServerError, e:
if not e.reason == "Forbidden":
print "Looks like AWS ELB is down: "
print e
sys.exit(1)
def _get_elb(name):
'''
Retrieves a boto ELB instance for the given name.
'''
try:
elb_conn = _boto_elb.connect_to_region(__grains__['region'])
elb = elb_conn.get_all_load_balancers(load_balancer_names=[name])
except Exception:
# TODO: Add support for using AWS keys. Right now you need IAM roles
import traceback
log.debug("Error getting ELB instance %s", name)
log.debug(traceback.format_exc())
return False
return elb[0]
def _get_elb(name):
'''
Retrieves a boto ELB instance for the given name.
'''
try:
elb_conn = _boto_elb.connect_to_region(__grains__['region'])
elb = elb_conn.get_all_load_balancers(load_balancer_names=[name])
except Exception:
# TODO: Add support for using AWS keys. Right now you need IAM roles
import traceback
log.debug("Error getting ELB instance %s", name)
log.debug(traceback.format_exc())
return False
return elb[0]
def set_elb_dns(self, domain_name):
elbo = elb.connect_to_region(self.region)
lb = elbo.get_all_load_balancers(
load_balancer_names=self.lb_name).pop()
r53 = route53.connect_to_region(self.region)
dns_zone = None
for zone in r53.get_zones():
if domain_name == zone.name:
dns_zone = zone
if not dns_zone:
raise Exception(
'DNS Hosting for {0} not setup in Route53'.format(domain_name))
status = dns_zone.add_record(
'CNAME', '{0}.{1}'.format(self.lb_name.strip(), domain_name),
lb.dns_name)
return status
def __init__(self, name, process, platform, env, region, domain=None, public=False):
self.name = name
self.process = process
self.platform = platform
self.env = env
self.loadbalancer_name = "%s-%s-%s-%s" % (self.process, self.name, self.platform, self.env)
self.region = region
self.connection = elb.connect_to_region(self.region)
self.interval = 10
self.healthy_threshold = 3
self.unhealthy_threshold = 5
self.target = 'HTTP:80/'
self.listeners = {
'80': [(80, 80, 'http')],
'443': [(80, 80, 'http'), (443, 80, 'https')]
}
self.domain = domain
self.listener = self.listeners['80']
self.public = public
def get_aws_connection(service, region_name='eu-west-1'):
credentials = {
'aws_access_key_id': config.AWS_ACCESS_KEY_ID,
'aws_secret_access_key': config.AWS_SECERET_ACCESS_KEY
}
if service == 'ec2':
return ec2.connect_to_region(region_name, **credentials)
elif service == 'cloudformation':
return cloudformation.connect_to_region(region_name, **credentials)
elif service == 'autoscale':
return autoscale.connect_to_region(region_name, **credentials)
elif service == 'elb':
return elb.connect_to_region(region_name, **credentials)
elif service == 'cloudwatch':
return cloudwatch.connect_to_region(region_name, **credentials)
else:
raise Exception("Unkown service '%s'" % service)
def _initialise_aws_connections():
_log.info('Initialising AWS Connections')
_validate_environment()
# Even though the Boto lib can use the environment variables we'll import one
# for easier re-use in this script
_log.info('Loading credentials from Environment')
aws_region = os.getenv('AWS_DEFAULT_REGION')
_log.info('Initializing Boto resources')
resources = {
'vpc': vpc.connect_to_region(aws_region),
'ec2': ec2.connect_to_region(aws_region),
'elb': elb.connect_to_region(aws_region),
'iam': iam.connect_to_region(aws_region),
'route53': Route53Connection(),
'cloudwatch': cloudwatch.connect_to_region(aws_region),
'region': aws_region
}
return resources
def __init__(self, settings):
super(ELBService, self).__init__(settings)
region_name = settings.get('ELB', 'REGION_NAME', 'us-west-1')
self.conn = elb.connect_to_region(region_name=region_name)
assert self.conn is not None
def setUp(self):
self.env_id = uuid.uuid4().hex
from boto.ec2 import elb
self.elb = elb.connect_to_region(self.region)
clean_env()
self.conf = '%s/%s/%s.ini' % (os.getenv('AWS_CRED_DIR'),
acct_name, acct_name)
try:
boto.config.load_credential_file(self.conf)
except IOError, msg:
print >> sys.stderr, 'ERROR: %s' % msg
return False
if service == 's3':
self.conn = s3.connect_to_region(region)
if service == 'ec2':
self.conn = ec2.connect_to_region(region)
if service == 'rds':
self.conn = rds.connect_to_region(region)
if service == 'rds2':
self.conn = rds2.connect_to_region(region)
if service == 'elb':
self.conn = elb.connect_to_region(region)
if service == 'sqs':
self.conn = sqs.connect_to_region(region)
if service == 'emr':
self.conn = emr.connect_to_region(region)
if service == 'route53':
self.conn = route53.connect_to_region(region)
if service == 'iam':
self.conn = iam.connect_to_region('universal')
if not self.conn:
print >> sys.stderr, 'ERROR: Unknown service'
return False
return self.conn
def connect_elb(region = None):
"""Return a boto ELBConnection using credentials specified in env. Connects to env.aws_ec2_region unless otherwise specified.
Use directly for AWS-specific tweaking not supported by other fabulous functionality."""
region = region or env.aws_ec2_region
return elb.connect_to_region(region, aws_access_key_id=env.aws_access_key_id, aws_secret_access_key=env.aws_secret_access_key)
def __init__(self, region):
configure_logging()
self.logger = logging.getLogger(__name__)
self.elb_client = elb.connect_to_region(region)
def get_elb_connection():
connection = elb.connect_to_region(config.get_value('Boto', 'elb_region_name'))
if connection is None:
raise ELBError.CannotGetConnection("cannot get elb connection. invalid 'elb_region_name'?")
else:
return connection
def __init__(self, region):
configure_logging()
self.logger = logging.getLogger(__name__)
self.elb_client = elb.connect_to_region(region)
def update_listeners(region_name, elb_name, proxy_rules):
c = connect_to_region(region_name)
c.create_load_balancer_listeners(elb_name, [(p.haproxy_port, p.haproxy_port, p.protocol) for p in proxy_rules])
import urllib2
import redis
import boto.ec2 as ec2
import boto.ec2.elb as elb
instance_id = urllib2.urlopen(
"http://169.254.169.254/latest/meta-data/instance-id").read()
print "I am %s" % instance_id
region = os.environ['AWS_REGION']
if region == 'compute-1':
region = 'us-east-1'
print "We are in %s" % region
ec2_con = ec2.connect_to_region(region)
elb_con = elb.connect_to_region(region)
reservations = ec2_con.get_all_instances()
instances = [i for r in reservations for i in r.instances]
elb_name = None
for instance in instances:
if instance.__dict__['id'] == instance_id:
elb_name = instance.__dict__['tags']['bidderElb']
break
if elb_name is None:
print "ERROR: cannot figure out my ELB name!"
sys.exit(1)
print "My ELB is %s" % elb_name
elbs = elb_con.get_all_load_balancers(load_balancer_names=[elb_name])
count = 0
for state in elbs[0].get_instance_health():
def __init__(self, region, **kwargs):
self.conn = connect_to_region(region, **kwargs)
import sys
AWS_REGION = ''
AWS_KEY = ''
AWS_SECRET = ''
ELB_NAME = ''
CRITICAL_LIMIT = 1
state = {}
state['InService'] = 0
state['OutOfService'] = 0
state['unknown'] = 0
conn = elb.connect_to_region(AWS_REGION,
aws_access_key_id=AWS_KEY,
aws_secret_access_key=AWS_SECRET)
instances = conn.describe_instance_health("tester")
for instance in instances:
if instance.state == 'InService':
state['InService'] += 1
elif instance.state == 'OutOfService':
state['OutOfService'] = +1
else:
state['unknown'] += 1
if state['unknown'] > 0:
message = "WARN - instances in an unknown state | "
EXIT = 1
def __init__(self, settings):
super(ELBService, self).__init__(settings)
region_name = settings.get('ELB', 'REGION_NAME', 'us-west-1')
self.conn = elb.connect_to_region(region_name=region_name)
assert self.conn is not None
from time import mktime
from fabric import api as fab
from boto import ec2
from boto.ec2 import elb, ec2object
from fabric.operations import run, put
logger = logging.getLogger('AMIBackup')
hdlr = logging.FileHandler('fab.log')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
logger.setLevel(logging.INFO)
SERVER_USER = '******'
SSH_KEY_FILE = 'id_rsa.pem'
lb_conn = elb.connect_to_region("ap-southeast-1")
ec_conn = ec2.connect_to_region("ap-southeast-1")
env = fab.env
local = fab.local
cd = fab.cd
run = fab.run
env.user = '******'
env.disable_known_hosts = "True" # for EC2
env.key = 'id_rsa.pem'
env.key_filename = '/home/ubuntu/id_rsa.pem'
env.dir = '/home/ubuntu/src/apps/'
# Sets the number of concurrent processes to use
# when executing tasks in parallel
env.pool_size = 5
def get_elb_connection():
c = elb.connect_to_region(config.region,
aws_access_key_id=config.aws_access_key_id,
aws_secret_access_key=config.aws_secret_access_key)
return c
listc.append(i.placement)
if placement =='d':
listd.append(i.placement)
if placement =='e':
liste.append(i.placement)
connection=ec2.connect_to_region('us-east-1')
regions = connection.get_all_regions()
for region in regions:
lbconnection = boto.ec2.elb.connect_to_region(region.name)
ec2conn = ec2.connect_to_region(region.name)
elbconn = elb.connect_to_region(region.name)
elbs = lbconnection.get_all_load_balancers()
if not elbs:
with open('ELB.csv', 'a') as csvfile:
writer = csv.writer(csvfile, delimiter='\t')
writer.writerow(['ELB does not exists',region.name])
else:
for lb in elbs:
number= len(lb.instances)
if lb.instances:
lista = []
listb = []
listc = []
listd = []
liste = []
def aws_conn_elb(region, profile='default'):
try:
conn = elb.connect_to_region(region, profile_name=profile)
return conn
except Exception as e:
logging.error("Unable to connect to region, please investigate: {0}".format(e))
def register_node(self, instance_id):
elb = elb.connect_to_region(self.region)
lb = elb.get_all_load_balancers(load_balancer_names=self.app_name)
lb.register_instances([instance_id])
from time import mktime
from fabric import api as fab
from boto import ec2
from boto.ec2 import elb, ec2object
from fabric.operations import run, put
logger = logging.getLogger('AMIBackup')
hdlr = logging.FileHandler('fab.log')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
logger.setLevel(logging.INFO)
SERVER_USER = '******'
SSH_KEY_FILE = 'id_rsa.pem'
lb_conn = elb.connect_to_region("ap-southeast-1")
ec_conn = ec2.connect_to_region("ap-southeast-1")
env = fab.env
local = fab.local
cd = fab.cd
run = fab.run
env.user = '******'
env.disable_known_hosts = "True" # for EC2
env.key = 'id_rsa.pem'
env.key_filename = '/home/ubuntu/id_rsa.pem'
env.dir = '/home/ubuntu/src/apps/'
# Sets the number of concurrent processes to use
# when executing tasks in parallel
env.pool_size = 5
def _ConnectELB(region_name): """Connect to a given region for load balancer queries.""" return elb.connect_to_region(region_name)
def configure(self, region='ap-southeast-2'):
self.conn = connect_to_region(region_name=region, **self.aws_keys)
return self.conn # Hmm, if only I could inherit a class from this connection
def load_balancer_deregister_instance(
region_name, aws_creds, lb_name, instance_name):
instance = get_instance(region_name, aws_creds, instance_name)
elb_cxn = elb.connect_to_region(region_name, **aws_creds)
elb_cxn.deregister_instances(lb_name, [instance.id])
def get_elb_connection(region_name):
return elb.connect_to_region(region_name)
def load_balancer_deregister_instance(region_name, aws_creds, lb_name,
instance_name):
instance = get_instance(region_name, aws_creds, instance_name)
elb_cxn = elb.connect_to_region(region_name, **aws_creds)
elb_cxn.deregister_instances(lb_name, [instance.id])
import sys
AWS_REGION = ''
AWS_KEY = ''
AWS_SECRET = ''
ELB_NAME = ''
CRITICAL_LIMIT = 1
state = {}
state['InService'] = 0
state['OutOfService'] = 0
state['unknown'] = 0
conn = elb.connect_to_region(AWS_REGION, aws_access_key_id=AWS_KEY,
aws_secret_access_key=AWS_SECRET)
instances = conn.describe_instance_health("tester")
for instance in instances:
if instance.state == 'InService':
state['InService'] += 1
elif instance.state == 'OutOfService':
state['OutOfService'] =+ 1
else:
state['unknown'] +=1
if state['unknown'] > 0:
message = "WARN - instances in an unknown state | "
EXIT = 1
