class BotoBalanceInterface(BalanceInterface):
conn = None
saveclcdata = False
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)
self.conn = ELBConnection(access_id, secret_key, region=reg,
port=port, path=path,
is_secure=True, security_token=token, debug=0)
self.conn.https_validate_certificates = False
self.conn.http_connection_kwargs['timeout'] = 30
def __save_json__(self, obj, name):
f = open(name, 'w')
json.dump(obj, f, cls=BotoJsonBalanceEncoder, indent=2)
f.close()
def create_load_balancer(self, name, zones, listeners, subnets=None,
security_groups=None, scheme='internet-facing'):
return self.conn.create_load_balancer(name, zones, listeners, subnets, security_groups, scheme)
def delete_load_balancer(self, name):
return self.conn.delete_load_balancer(name)
def get_all_load_balancers(self, load_balancer_names=None):
return []
obj = self.conn.get_all_load_balancers(load_balancer_names)
if self.saveclcdata:
self.__save_json__(obj, "mockdata/ELB_Balancers.json")
return obj
def deregister_instances(self, load_balancer_name, instances):
return self.conn.deregister_instances(load_balancer_name, instances)
def register_instances(self, load_balancer_name, instances):
return self.conn.register_instances(load_balancer_name, instances)
def create_load_balancer_listeners(self, name, listeners):
return self.conn.create_load_balancer_listeners(name, listeners)
def delete_load_balancer_listeners(self, name, ports):
return self.conn.delete_load_balancer_listeners(name, ports)
def configure_health_check(self, name, health_check):
return self.conn.configure_health_check(name, health_check)
def describe_instance_health(self, load_balancer_name, instances=None):
obj = self.conn.describe_instance_health(load_balancer_name, instances)
if self.saveclcdata:
self.__save_json__(obj, "mockdata/ELB_Instances.json")
return obj
def test_create_load_balancer(self):
c = ELBConnection()
name = 'elb-boto-unit-test'
availability_zones = ['us-east-1a']
listeners = [(80, 8000, 'HTTP')]
balancer = c.create_load_balancer(name, availability_zones, listeners)
self.assertEqual(balancer.name, name)
self.assertEqual(balancer.availability_zones, availability_zones)
self.assertEqual(balancer.listeners, listeners)
balancers = c.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [name])
def test_create_load_balancer(self):
c = ELBConnection()
name = 'elb-boto-unit-test'
availability_zones = ['us-east-1a']
listeners = [(80, 8000, 'HTTP')]
balancer = c.create_load_balancer(name, availability_zones, listeners)
self.assertEqual(balancer.name, name)
self.assertEqual(balancer.availability_zones, availability_zones)
self.assertEqual(balancer.listeners, listeners)
balancers = c.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [name])
def test_create_load_balancer_listeners(self):
c = ELBConnection()
name = 'elb-boto-unit-test'
availability_zones = ['us-east-1a']
listeners = [(80, 8000, 'HTTP')]
balancer = c.create_load_balancer(name, availability_zones, listeners)
more_listeners = [(443, 8001, 'HTTP')]
c.create_load_balancer_listeners(name, more_listeners)
balancers = c.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [name])
self.assertEqual(sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(listeners + more_listeners))
def test_create_load_balancer_listeners(self):
c = ELBConnection()
name = 'elb-boto-unit-test'
availability_zones = ['us-east-1a']
listeners = [(80, 8000, 'HTTP')]
balancer = c.create_load_balancer(name, availability_zones, listeners)
more_listeners = [(443, 8001, 'HTTP')]
c.create_load_balancer_listeners(name, more_listeners)
balancers = c.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [name])
self.assertEqual(
sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(listeners + more_listeners)
)
def create_LoadBalancer():
print "Creating ELB..."
elb_conn = ELBConnection(AWSAccessKeyId, AWSSecretKey)
zones = ['us-east-1a']
ports = [(80, 80, 'http')]
hc = HealthCheck(interval=30,
healthy_threshold=2,
unhealthy_threshold=10,
target='HTTP:80/heartbeat?username=chihangw')
global elb
elb = elb_conn.create_load_balancer(name='myELB',
zones=zones,
listeners=ports)
elb.configure_health_check(hc)
ELB_DNS = elb.dns_name
print "ELB created successfully"
print "ELB DNS: %s" % ELB_DNS
return ELB_DNS
def test_delete_load_balancer_listeners(self):
c = ELBConnection()
name = 'elb-boto-unit-test'
availability_zones = ['us-east-1a']
listeners = [(80, 8000, 'HTTP', 'HTTP', None), (443, 8001, 'HTTP', 'HTTP', None)]
balancer = c.create_load_balancer(name, availability_zones, listeners)
balancers = c.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [name])
self.assertEqual(
[l.get_tuple() for l in balancers[0].listeners], listeners)
c.delete_load_balancer_listeners(name, [443])
balancers = c.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [name])
self.assertEqual(
[l.get_tuple() for l in balancers[0].listeners],
listeners[:1]
)
def test_create_load_balancer_listeners_with_policies(self):
c = ELBConnection()
name = 'elb-boto-unit-test-policy'
availability_zones = ['us-east-1a']
listeners = [(80, 8000, 'HTTP')]
balancer = c.create_load_balancer(name, availability_zones, listeners)
more_listeners = [(443, 8001, 'HTTP')]
c.create_load_balancer_listeners(name, more_listeners)
lb_policy_name = 'lb-policy'
c.create_lb_cookie_stickiness_policy(1000, name, lb_policy_name)
c.set_lb_policies_of_listener(name, listeners[0][0], lb_policy_name)
app_policy_name = 'app-policy'
c.create_app_cookie_stickiness_policy('appcookie', name,
app_policy_name)
c.set_lb_policies_of_listener(name, more_listeners[0][0],
app_policy_name)
balancers = c.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [name])
self.assertEqual(sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(listeners + more_listeners))
def test_create_load_balancer_listeners_with_policies(self):
c = ELBConnection()
name = 'elb-boto-unit-test-policy'
availability_zones = ['us-east-1a']
listeners = [(80, 8000, 'HTTP')]
balancer = c.create_load_balancer(name, availability_zones, listeners)
more_listeners = [(443, 8001, 'HTTP')]
c.create_load_balancer_listeners(name, more_listeners)
lb_policy_name = 'lb-policy'
c.create_lb_cookie_stickiness_policy(1000, name, lb_policy_name)
c.set_lb_policies_of_listener(name, listeners[0][0], lb_policy_name)
app_policy_name = 'app-policy'
c.create_app_cookie_stickiness_policy('appcookie', name, app_policy_name)
c.set_lb_policies_of_listener(name, more_listeners[0][0], app_policy_name)
balancers = c.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [name])
self.assertEqual(
sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(listeners + more_listeners)
)
class BotoBalanceInterface(BalanceInterface):
conn = None
saveclcdata = False
def __init__(self, clc_host, access_id, secret_key, token):
#boto.set_stream_logger('foo')
path = '/services/LoadBalancing'
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)
self.conn = ELBConnection(access_id,
secret_key,
region=reg,
port=port,
path=path,
is_secure=True,
security_token=token,
debug=0)
self.conn.https_validate_certificates = False
self.conn.http_connection_kwargs['timeout'] = 30
def __save_json__(self, obj, name):
f = open(name, 'w')
json.dump(obj, f, cls=BotoJsonBalanceEncoder, indent=2)
f.close()
def create_load_balancer(self,
name,
zones,
listeners,
subnets=None,
security_groups=None,
scheme='internet-facing'):
return self.conn.create_load_balancer(name, zones, listeners, subnets,
security_groups, scheme)
def delete_load_balancer(self, name):
return self.conn.delete_load_balancer(name)
def get_all_load_balancers(self, load_balancer_names=None):
obj = self.conn.get_all_load_balancers(load_balancer_names)
if self.saveclcdata:
self.__save_json__(obj, "mockdata/ELB_Balancers.json")
return obj
def deregister_instances(self, load_balancer_name, instances):
return self.conn.deregister_instances(load_balancer_name, instances)
def register_instances(self, load_balancer_name, instances):
return self.conn.register_instances(load_balancer_name, instances)
def create_load_balancer_listeners(self, name, listeners):
return self.conn.create_load_balancer_listeners(name, listeners)
def delete_load_balancer_listeners(self, name, ports):
return self.conn.delete_load_balancer_listeners(name, ports)
def configure_health_check(self, name, health_check):
return self.conn.configure_health_check(name, health_check)
def describe_instance_health(self, load_balancer_name, instances=None):
obj = self.conn.describe_instance_health(load_balancer_name, instances)
if self.saveclcdata:
self.__save_json__(obj, "mockdata/ELB_Instances.json")
return obj
for zone in zones:
zoneStrings.append(zone.name)
conn_elb = ELBConnection(AWS_ACCESS_KEY, AWS_SECRET_KEY)
conn_as = AutoScaleConnection(AWS_ACCESS_KEY, AWS_SECRET_KEY)
#=================Create a Load Balancer=============================================
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#module-boto.ec2.elb.healthcheck
hc = HealthCheck('healthCheck',
interval=elastic_load_balancer['interval'],
target=elastic_load_balancer['health_check_target'],
timeout=elastic_load_balancer['timeout'])
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.elb.ELBConnection.create_load_balancer
lb = conn_elb.create_load_balancer(
elastic_load_balancer['name'], zoneStrings,
elastic_load_balancer['connection_forwarding'])
lb.configure_health_check(hc)
#DNS name for your new load balancer
print "Map the CNAME of your website to: %s" % (lb.dns_name)
#=================Create a Auto Scaling Group and a Launch Configuration=============================================
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.autoscale.launchconfig.LaunchConfiguration
lc = LaunchConfiguration(name=lc_name,
image_id=as_ami['id'],
key_name=as_ami['access_key'],
security_groups=as_ami['security_groups'],
instance_type=as_ami['instance_type'],
instance_monitoring=as_ami['instance_monitoring'])
class BotoBalanceInterface(BalanceInterface):
conn = None
saveclcdata = False
def __init__(self, clc_host, access_id, secret_key, token):
#boto.set_stream_logger('foo')
path = '/services/LoadBalancing'
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)
self.conn = ELBConnection(access_id,
secret_key,
region=reg,
port=port,
path=path,
is_secure=True,
security_token=token,
debug=0)
self.conn.https_validate_certificates = False
self.conn.http_connection_kwargs['timeout'] = 30
def __save_json__(self, obj, name):
f = open(name, 'w')
json.dump(obj, f, cls=BotoJsonBalanceEncoder, indent=2)
f.close()
def create_load_balancer(self,
name,
zones,
listeners,
subnets=None,
security_groups=None,
scheme='internet-facing'):
return self.conn.create_load_balancer(name, zones, listeners, subnets,
security_groups, scheme)
def delete_load_balancer(self, name):
return self.conn.delete_load_balancer(name)
def get_all_load_balancers(self, load_balancer_names=None):
params = {}
if load_balancer_names:
self.build_list_params(params, load_balancer_names,
'LoadBalancerNames.member.%d')
http_request = self.conn.build_base_http_request(
'GET', '/', None, params, {}, '', self.conn.server_name())
http_request.params['Action'] = 'DescribeLoadBalancers'
http_request.params['Version'] = self.conn.APIVersion
response = self.conn._mexe(http_request, override_num_retries=2)
body = response.read()
boto.log.debug(body)
if not body:
boto.log.error('Null body %s' % body)
raise self.conn.ResponseError(response.status, response.reason,
body)
elif response.status == 200:
obj = boto.resultset.ResultSet([
('member', boto.ec2.elb.loadbalancer.LoadBalancer)
])
h = boto.handler.XmlHandler(obj, self.conn)
import xml.sax
xml.sax.parseString(body, h)
if self.saveclcdata:
self.__save_json__(obj, "mockdata/ELB_Balancers.json")
return obj
else:
boto.log.error('%s %s' % (response.status, response.reason))
boto.log.error('%s' % body)
raise self.conn.ResponseError(response.status, response.reason,
body)
def deregister_instances(self, load_balancer_name, instances):
return self.conn.deregister_instances(load_balancer_name, instances)
def register_instances(self, load_balancer_name, instances):
return self.conn.register_instances(load_balancer_name, instances)
def create_load_balancer_listeners(self, name, listeners):
return self.conn.create_load_balancer_listeners(name, listeners)
def delete_load_balancer_listeners(self, name, ports):
return self.conn.delete_load_balancer_listeners(name, ports)
def configure_health_check(self, name, health_check):
return self.conn.configure_health_check(name, health_check)
def describe_instance_health(self, load_balancer_name, instances=None):
obj = self.conn.describe_instance_health(load_balancer_name, instances)
if self.saveclcdata:
self.__save_json__(obj, "mockdata/ELB_Instances.json")
return obj
class ELBConnectionTest(unittest.TestCase):
ec2 = True
def setUp(self):
"""Creates a named load balancer that can be safely
deleted at the end of each test"""
self.conn = ELBConnection()
self.name = 'elb-boto-unit-test'
self.availability_zones = ['us-east-1a']
self.listeners = [(80, 8000, 'HTTP')]
self.balancer = self.conn.create_load_balancer(self.name, self.availability_zones, self.listeners)
# S3 bucket for log tests
self.s3 = boto.connect_s3()
self.timestamp = str(int(time.time()))
self.bucket_name = 'boto-elb-%s' % self.timestamp
self.bucket = self.s3.create_bucket(self.bucket_name)
self.bucket.set_canned_acl('public-read-write')
self.addCleanup(self.cleanup_bucket, self.bucket)
def cleanup_bucket(self, bucket):
for key in bucket.get_all_keys():
key.delete()
bucket.delete()
def tearDown(self):
""" Deletes the test load balancer after every test.
It does not delete EVERY load balancer in your account"""
self.balancer.delete()
def test_build_list_params(self):
params = {}
self.conn.build_list_params(
params, ['thing1', 'thing2', 'thing3'], 'ThingName%d')
expected_params = {
'ThingName1': 'thing1',
'ThingName2': 'thing2',
'ThingName3': 'thing3'
}
self.assertEqual(params, expected_params)
# TODO: for these next tests, consider sleeping until our load
# balancer comes up, then testing for connectivity to
# balancer.dns_name, along the lines of the existing EC2 unit tests.
def test_create_load_balancer(self):
self.assertEqual(self.balancer.name, self.name)
self.assertEqual(self.balancer.availability_zones,\
self.availability_zones)
self.assertEqual(self.balancer.listeners, self.listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
def test_create_load_balancer_listeners(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(
sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners)
)
def test_delete_load_balancer_listeners(self):
mod_listeners = [(80, 8000, 'HTTP'), (443, 8001, 'HTTP')]
mod_name = self.name + "-mod"
self.mod_balancer = self.conn.create_load_balancer(mod_name,\
self.availability_zones, mod_listeners)
mod_balancers = self.conn.get_all_load_balancers(load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual(
sorted([l.get_tuple() for l in mod_balancers[0].listeners]),
sorted(mod_listeners))
self.conn.delete_load_balancer_listeners(self.mod_balancer.name, [443])
mod_balancers = self.conn.get_all_load_balancers(load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual([l.get_tuple() for l in mod_balancers[0].listeners],
mod_listeners[:1])
self.mod_balancer.delete()
def test_create_load_balancer_listeners_with_policies(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
lb_policy_name = 'lb-policy'
self.conn.create_lb_cookie_stickiness_policy(1000, self.name, lb_policy_name)
self.conn.set_lb_policies_of_listener(self.name, self.listeners[0][0], lb_policy_name)
app_policy_name = 'app-policy'
self.conn.create_app_cookie_stickiness_policy('appcookie', self.name, app_policy_name)
self.conn.set_lb_policies_of_listener(self.name, more_listeners[0][0], app_policy_name)
balancers = self.conn.get_all_load_balancers(load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(
sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners)
)
# Policy names should be checked here once they are supported
# in the Listener object.
def test_create_load_balancer_backend_with_policies(self):
other_policy_name = 'enable-proxy-protocol'
backend_port = 8081
self.conn.create_lb_policy(self.name, other_policy_name,
'ProxyProtocolPolicyType', {'ProxyProtocol': True})
self.conn.set_lb_policies_of_backend_server(self.name, backend_port, [other_policy_name])
balancers = self.conn.get_all_load_balancers(load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(len(balancers[0].policies.other_policies), 1)
self.assertEqual(balancers[0].policies.other_policies[0].policy_name, other_policy_name)
self.assertEqual(len(balancers[0].backends), 1)
self.assertEqual(balancers[0].backends[0].instance_port, backend_port)
self.assertEqual(balancers[0].backends[0].policies[0].policy_name, other_policy_name)
self.conn.set_lb_policies_of_backend_server(self.name, backend_port, [])
balancers = self.conn.get_all_load_balancers(load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(len(balancers[0].policies.other_policies), 1)
self.assertEqual(len(balancers[0].backends), 0)
def test_create_load_balancer_complex_listeners(self):
complex_listeners = [
(8080, 80, 'HTTP', 'HTTP'),
(2525, 25, 'TCP', 'TCP'),
]
self.conn.create_load_balancer_listeners(
self.name,
complex_listeners=complex_listeners
)
balancers = self.conn.get_all_load_balancers(
load_balancer_names=[self.name]
)
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(
sorted(l.get_complex_tuple() for l in balancers[0].listeners),
# We need an extra 'HTTP' here over what ``self.listeners`` uses.
sorted([(80, 8000, 'HTTP', 'HTTP')] + complex_listeners)
)
def test_load_balancer_access_log(self):
attributes = self.balancer.get_attributes()
self.assertEqual(False, attributes.access_log.enabled)
attributes.access_log.enabled = True
attributes.access_log.s3_bucket_name = self.bucket_name
attributes.access_log.s3_bucket_prefix = 'access-logs'
attributes.access_log.emit_interval = 5
self.conn.modify_lb_attribute(self.balancer.name, 'accessLog',
attributes.access_log)
new_attributes = self.balancer.get_attributes()
self.assertEqual(True, new_attributes.access_log.enabled)
self.assertEqual(self.bucket_name,
new_attributes.access_log.s3_bucket_name)
self.assertEqual('access-logs',
new_attributes.access_log.s3_bucket_prefix)
self.assertEqual(5, new_attributes.access_log.emit_interval)
def test_load_balancer_get_attributes(self):
attributes = self.balancer.get_attributes()
connection_draining = self.conn.get_lb_attribute(self.balancer.name,
'ConnectionDraining')
self.assertEqual(connection_draining.enabled,
attributes.connection_draining.enabled)
self.assertEqual(connection_draining.timeout,
attributes.connection_draining.timeout)
access_log = self.conn.get_lb_attribute(self.balancer.name,
'AccessLog')
self.assertEqual(access_log.enabled, attributes.access_log.enabled)
self.assertEqual(access_log.s3_bucket_name, attributes.access_log.s3_bucket_name)
self.assertEqual(access_log.s3_bucket_prefix, attributes.access_log.s3_bucket_prefix)
self.assertEqual(access_log.emit_interval, attributes.access_log.emit_interval)
cross_zone_load_balancing = self.conn.get_lb_attribute(self.balancer.name,
'CrossZoneLoadBalancing')
self.assertEqual(cross_zone_load_balancing,
attributes.cross_zone_load_balancing.enabled)
def change_and_verify_load_balancer_connection_draining(self, enabled, timeout = None):
attributes = self.balancer.get_attributes()
attributes.connection_draining.enabled = enabled
if timeout != None:
attributes.connection_draining.timeout = timeout
self.conn.modify_lb_attribute(self.balancer.name,
'ConnectionDraining', attributes.connection_draining)
attributes = self.balancer.get_attributes()
self.assertEqual(enabled, attributes.connection_draining.enabled)
if timeout != None:
self.assertEqual(timeout, attributes.connection_draining.timeout)
def test_load_balancer_connection_draining_config(self):
self.change_and_verify_load_balancer_connection_draining(True, 128)
self.change_and_verify_load_balancer_connection_draining(True, 256)
self.change_and_verify_load_balancer_connection_draining(False)
self.change_and_verify_load_balancer_connection_draining(True, 64)
def test_set_load_balancer_policies_of_listeners(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
lb_policy_name = 'lb-policy'
self.conn.create_lb_cookie_stickiness_policy(
1000,
self.name,
lb_policy_name
)
self.conn.set_lb_policies_of_listener(
self.name,
self.listeners[0][0],
lb_policy_name
)
# Try to remove the policy by passing empty list.
# http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_SetLoadBalancerPoliciesOfListener.html
# documents this as the way to remove policies.
self.conn.set_lb_policies_of_listener(
self.name,
self.listeners[0][0],
[]
)
class ELBConnectionTest(unittest.TestCase):
ec2 = True
def setup(self):
"""Creates a named load balancer that can be safely
deleted at the end of each test"""
self.conn = ELBConnection()
self.name = 'elb-boto-unit-test'
self.availability_zones = ['us-east-1a']
self.listeners = [(80, 8000, 'HTTP')]
self.balancer = self.conn.create_load_balancer(name, availability_zones, listeners)
def tearDown(self):
""" Deletes the test load balancer after every test.
It does not delete EVERY load balancer in your account"""
self.balancer.delete()
def test_build_list_params(self):
params = {}
self.conn.build_list_params(
params, ['thing1', 'thing2', 'thing3'], 'ThingName%d')
expected_params = {
'ThingName1': 'thing1',
'ThingName2': 'thing2',
'ThingName3': 'thing3'
}
self.assertEqual(params, expected_params)
# TODO: for these next tests, consider sleeping until our load
# balancer comes up, then testing for connectivity to
# balancer.dns_name, along the lines of the existing EC2 unit tests.
def test_create_load_balancer(self):
self.assertEqual(self.balancer.name, self.name)
self.assertEqual(self.balancer.availability_zones,\
self.availability_zones)
self.assertEqual(self.balancer.listeners, self.listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
def test_create_load_balancer_listeners(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(
sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners)
)
def test_delete_load_balancer_listeners(self):
mod_listeners = [(80, 8000, 'HTTP'), (443, 8001, 'HTTP')]
mod_name = self.name + "_mod"
self.mod_balancer = self.conn.create_load_balancer(mod_name,\
self.availability_zones, mod_listeners)
mod_balancers = self.conn.get_all_load_balancers(load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual(
sorted([l.get_tuple() for l in mod_balancers[0].listeners]),
sorted(mod_listeners))
self.conn.delete_load_balancer_listeners(self.mod_balancer.name, [443])
mod_balancers = self.conn.get_all_load_balancers(load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual([l.get_tuple() for l in mod_balancers[0].listeners],
mod_listeners[:1])
self.mod_balancer.delete()
def test_create_load_balancer_listeners_with_policies(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
lb_policy_name = 'lb-policy'
self.conn.create_lb_cookie_stickiness_policy(1000, self.name, lb_policy_name)
self.conn.set_lb_policies_of_listener(self.name, self.listeners[0][0], lb_policy_name)
app_policy_name = 'app-policy'
self.conn.create_app_cookie_stickiness_policy('appcookie', self.name, app_policy_name)
self.conn.set_lb_policies_of_listener(self.name, more_listeners[0][0], app_policy_name)
balancers = self.conn.get_all_load_balancers(load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(
sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners)
)
reservation = conn.run_instances(LG_IMAGE, instance_type = LG_TYPE, key_name = KEY_NAME, placement = ZONE, security_groups = SECURITY_GROUPS_LG)
instance = reservation.instances[0]
time.sleep(10)
while not instance.update() == 'running':
time.sleep(3)
instance.add_tag("Project", "2.2")
LG_DNS = str(instance.dns_name)
print LG_DNS
time.sleep(10)
#Create ELB
print 'Creating ELB'
elb = elb_conn.create_load_balancer('Project22hongf', ZONE, PORT)
healthcheck = HealthCheck(access_point = 'Project22hongf', interval=30, healthy_threshold=2, unhealthy_threshold=10, target='HTTP:80/heartbeat?lg='+LG_DNS)
elb.configure_health_check(healthcheck)
ELB_DNS = str(elb.dns_name)
print ELB_DNS
time.sleep(10)
#tag ELB
client = boto3.client('elb')
response = client.add_tags(
LoadBalancerNames=[
'Project22hongf',
],
Tags=[
class AutoScale:
def __init__(self, args):
"""
Initializing basic variables needed for auto scaling
"""
self.configs = ConfigParser.RawConfigParser()
self.args = args
self.test_props = {}
self.props = {}
self.ec2_connection = EC2Connection(self.args.access_key, self.args.secret_key)
self.autoscale_connection = AutoScaleConnection(self.args.access_key, self.args.secret_key)
self.elb_connection = ELBConnection(self.args.access_key, self.args.secret_key)
self.cw_connection = CloudWatchConnection(self.args.access_key, self.args.secret_key)
self.firstInstance = None
self.launchConfiguration = None
self.healthCheck = None
def loadConfigs(self):
"""
FIX ME: Currently doesnt do anything
This method will load the configurations from boto config file if present else will
accept parameters passed by user.
"""
if os.path.isfile("/etc/boto.cfg"):
self.configs.read("/etc/boto.cfg")
conf = self.configs.sections()
self.populateConfigs(conf)
if os.path.isfile("~/.boto"):
self.configs.read("~/.boto")
conf = self.configs.sections()
self.populateConfigs(conf)
print ">>> Loaded configs"
def populateConfigs(self, sections):
for section in sections:
self.boto_props[section] = self.configs.items(section)
for item in self.boto_props[section]:
key, value = item
if not self.props.has_key(key):
self.props[key] = value
def createLaunchConfiguration(self, lc_name, ami_id, key_name):
"""
Creates launch configuration for the auto scaling cluster
"""
self.launchConfiguration = LaunchConfiguration(name = lc_name,
image_id = ami_id,
key_name = key_name)
self.autoscale_connection.create_launch_configuration(self.launchConfiguration)
print ">>> Created launch configuration: " + lc_name
def createAutoScaleGroup(self, asg_name):
"""
Create a Auto scaling group for the auto scaling cluster
"""
autoScalingGroup = AutoScalingGroup(group_name = asg_name,
load_balancers = [self.args.lb_name],
launch_config = self.launchConfiguration,
min_size = self.args.min_size,
max_size = self.args.max_size,
availability_zones = ['us-east-1a'])
self.autoscale_connection.create_auto_scaling_group(autoScalingGroup)
print ">>> Created auto scaling group: " + asg_name
def createTrigger(self, trigger_name, measure, asg_name):
"""
Trigger to spawn new instances as per specific metrics
"""
alarm_actions = []
dimensions = {"AutoScalingGroupName" : asg_name}
policies = self.autoscale_connection.get_all_policies(as_group=self.args.asg_name, policy_names=[self.args.asp_name])
for policy in policies:
alarm_actions.append(policy.policy_arn)
alarm = MetricAlarm(name = trigger_name,
namespace = "AWS/EC2",
metric = measure,
statistic = "Average",
comparison = ">=",
threshold = 50,
period = 60,
unit = "Percent",
evaluation_periods = 2,
alarm_actions = alarm_actions,
dimensions = dimensions)
self.cw_connection.create_alarm(alarm)
print ">>> Created trigger: "+self.args.trigger
def createAutoScalePolicy(self, asp_name):
"""
Creates a Auto scaling policy to Add/Remove a instance from auto scaling cluster
"""
self.autoScalingUpPolicy = ScalingPolicy(name = asp_name+'-up',
adjustment_type = "ChangeInCapacity",
as_name = self.args.asg_name,
scaling_adjustment = 1,
cooldown = 180)
self.autoScalingDownPolicy = ScalingPolicy(name = asp_name+'-down',
adjustment_type = "ChangeInCapacity",
as_name = self.args.asg_name,
scaling_adjustment = -1,
cooldown = 180)
self.autoscale_connection.create_scaling_policy(self.autoScalingUpPolicy)
self.autoscale_connection.create_scaling_policy(self.autoScalingDownPolicy)
print ">>> Created auto scaling policy: " + asp_name
def configureHealthCheck(self, target):
"""
Configures health check for the cluster
"""
self.healthCheck = HealthCheck(target = target,
timeout = 5)
print ">>> Configured health check for: " + target
def createLoadBalancer(self, lb_name, region, lb_port, instance_port, protocol):
"""
Creates a load balancer for cluster
"""
listener = (int(lb_port), int(instance_port), protocol)
tuple_list =[]
tuple_list.append(listener)
lbs = self.elb_connection.get_all_load_balancers()
for lb in lbs:
if lb.name != lb_name:
self.elb_connection.create_load_balancer(lb_name, [region], tuple_list)
self.elb_connection.configure_health_check(name = lb_name,
health_check = self.healthCheck)
print ">>> Created load balancer: " + lb_name
else:
print "Load balancer with name '"+lb_name+"' already exists"
def startInstance(self, image_id, key_name, region, instance_type):
"""
Starts the first instance which will be serving requests irrespective of auto scaling
instances.
"""
reservation = self.ec2_connection.run_instances(image_id=image_id, min_count=1, max_count=1, placement=region, key_name=key_name, instance_type=instance_type)
# for instance in reservation.instances:
# instance.add_tag('node', '0')
# break
self.firstInstance = reservation.instances[0].id.split('\'')[0]
print ">>> Started instance: ", self.firstInstance
def registerInstanceToELB(self, lb_name):
"""
Register the first instance started to the Elastic Load Balancer.
"""
self.elb_connection.register_instances(load_balancer_name = lb_name,
instances = [self.firstInstance])
print ">>> Registered instance '",self.firstInstance,"' to load balancer '"+lb_name+"'"
def setUp(self):
"""
Set's up the auto scaling for the application
"""
# STEP 1: Load the configurations
self.loadConfigs()
# STEP 2: Configure the health check for the instances
self.configureHealthCheck(self.args.lb_target)
# STEP 3: Create a load balancer
self.createLoadBalancer(self.args.lb_name, self.args.region, self.args.lb_port, self.args.instance_port, self.args.protocol)
# STEP 4: Start the first instance
self.startInstance(self.args.ami_id, self.args.key_name, self.args.region, self.args.instance_type)
# STEP 5: Register the instance to the load balancer created in STEP 4
self.registerInstanceToELB(self.args.lb_name)
# STEP 6: Create launch configuration to launch instances by auto scale
self.createLaunchConfiguration(self.args.lc_name, self.args.ami_id, self.args.key_name)
# STEP 7: Create a auto scale group which will manage the instances started by auto scaling
self.createAutoScaleGroup(self.args.asg_name)
# STEP 8: Create a auto scaling policy to say add/remove a node
self.createAutoScalePolicy(self.args.asp_name)
# STEP 9: Create a trigger, so that auto scaling can trigger it to start
# or remove a instance from auto scaling group
self.createTrigger(self.args.trigger, self.args.measure, self.args.asg_name)
conn_cw = boto.ec2.cloudwatch.connect_to_region(regionName)
conn_cw = boto.ec2.cloudwatch.connect_to_region(
regionName,
aws_access_key_id=AWS_ACCESS_KEY,
aws_secret_access_key=AWS_SECRET_KEY)
# ============================================== #
# configure a health check
hc = HealthCheck(
interval=elastic_load_balancer['interval'],
healthy_threshold=elastic_load_balancer['healthyThreshold'],
unhealthy_threshold=elastic_load_balancer['unhealthyThreshold'],
target=elastic_load_balancer['healthCheckTarget'])
# create a load balancer
lb = conn_elb.create_load_balancer(elastic_load_balancer['name'],
elastic_load_balancer['zones'],
elastic_load_balancer['ports'])
lb.configure_health_check(hc)
print lb.dns_name + " created!"
sleep(10)
# ============================================== #
# ============================================== #
# clear the last execution results
# conn_as.delete_auto_scaling_group('my_group')
# conn_as.delete_launch_configuration('my-launch_config')
# ============================================== #
# ============================================== #
# create launch configuration
MaxCount=2,)
# create VPC
vpc = ec2.create_vpc(CidrBlock='10.0.0.0/16')
vpc.create_tags(Tags=[{"Key":"TestVPC","Value":"default_vpc"}])
vpc.wait_until_available()
print(vpc.id)
subnet = ec2.create_subnet(CidrBlock = '10.0.2.0/24', VpcId= vpc.id)
print(subnet.id)
# create ELB
conn_elb = ELBConnection(aws_access_key_id='', aws_secret_access_key='')
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#module-boto.ec2.elb.healthcheck
hc = HealthCheck('healthCheck',
interval=20,
target='HTTP:80/index.html',
timeout=3)
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.elb.ELBConnection.create_load_balancer
lb = conn_elb.create_load_balancer('my-lb',
['us-east-1a', 'us-east-1b', 'us-east-1c'],
[(80, 80, 'http'), (443, 443, 'tcp')])
lb.configure_health_check(hc)
#DNS name for your new load balancer
print "Map the CNAME of your website to: %s" % (lb.dns_name)
#conn_elb = ELBConnection(AWS_ACCESS_KEY, AWS_SECRET_KEY,region=conn_reg.region)
#conn_elb = ELBConnection(AWS_ACCESS_KEY, AWS_SECRET_KEY,region=conn_reg.region)
#conn_as = AutoScaleConnection(AWS_ACCESS_KEY, AWS_SECRET_KEY,region=conn_reg.region)
conn_elb = ELBConnection(AWS_ACCESS_KEY, AWS_SECRET_KEY)
conn_as = AutoScaleConnection(AWS_ACCESS_KEY, AWS_SECRET_KEY)
#=================Create a Load Balancer=============================================
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#module-boto.ec2.elb.healthcheck
hc = HealthCheck('healthCheck', interval=elastic_load_balancer['interval'], target=elastic_load_balancer['health_check_target'], timeout=elastic_load_balancer['timeout'])
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.elb.ELBConnection.create_load_balancer
lb = conn_elb.create_load_balancer(elastic_load_balancer['name'], zoneStrings, elastic_load_balancer['connection_forwarding'])
lb.configure_health_check(hc)
#DNS name for your new load balancer
print "Map the CNAME of your website to: %s" % (lb.dns_name)
#=================Create a Auto Scaling Group and a Launch Configuration=============================================
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.autoscale.launchconfig.LaunchConfiguration
lc = LaunchConfiguration(name=lc_name, image_id=as_ami['id'],
key_name=as_ami['access_key'],
security_groups=as_ami['security_groups'],
instance_type=as_ami['instance_type'],
instance_monitoring=as_ami['instance_monitoring'])
conn_as.create_launch_configuration(lc)
class aws:
def __init__(self,PREFIX='tfound-',ENV='dev',AMI='',TYPE='',SIZE='',
DOMAIN='tfound',SSHKEY='myprivatekey',AWSKEY='',AWSSECRET='',AVAIL_ZONES=["us-east-1a","us-east-1b","us-east-1c","us-east-1d"]):
'''
Shows examples
Create load balancer group 'tfound-dev-web-lb' for web servers, in dev group for tfound:
python control-lb-and-groups.py --createlb --env dev --aws SC --type web
Add an instance to the load balancer group:
python control-lb-and-groups.py --addtolb=true --env dev --aws SC --type web --instance=i-999999
Create launch config using ami ami-fa6b8393 (default), medium sized instance, and Autoscale Group 'tfound-dev-web-group' with a min of 2 instances, max 5, with health check on port 80:
python control-lb-and-groups.py --createlc --ami ami-fa6b8393 --size c1.medium --env dev --aws SC --type web --createag --min 2 --max 5
Triggers/Health checks are hard coded to spawn new instances when total cpu reaches 60 percent or health check fails.
'''
self.PREFIX=PREFIX+DOMAIN+'-'+ENV+'-'+TYPE
self.ENV=ENV
self.AMI=AMI
self.TYPE=TYPE
self.DOMAIN=DOMAIN
self.SIZE=SIZE
self.MIN=MIN
self.MAX=MAX
self.SSHKEY=SSHKEY
self.AWSKEY=AWSKEY
self.AWSSECRET=AWSSECRET
self.AVAIL_ZONES=AVAIL_ZONES
self.LBNAME=self.PREFIX+'-lb'
self.AGNAME=self.PREFIX+'-group'
self.TRNAME=self.PREFIX+'-trigger'
self.LCNAME=self.PREFIX+'-launch_config'
self.asconn=AutoScaleConnection(self.AWSKEY, self.AWSSECRET)
self.elbconn = ELBConnection(aws_access_key_id=AWSKEY,aws_secret_access_key=AWSSECRET)
self.lc = self._buildLaunchConfig()
self.ag = self._buildAutoscaleGroup()
def _buildLaunchConfig(self):
return LaunchConfiguration(name=self.LCNAME,
image_id=self.AMI,
key_name=self.SSHKEY,
security_groups=[self.ENV+'.'+self.TYPE],
user_data='LAUNCHTAGS="'+self.ENV+' '
+self.TYPE+' '+self.DOMAIN+'";',
instance_type=self.SIZE)
def _buildAutoscaleGroup(self):
return AutoScalingGroup(group_name=self.AGNAME,
load_balancers=[self.LBNAME],
availability_zones=self.AVAIL_ZONES,
launch_config=self.lc,
min_size=self.MIN,
max_size=self.MAX)
def getGroups(self):
'''get existing lb groups'''
# conn = AutoScaleConnection(AWSKEY, AWSSECRET)
#conn = AutoScaleConnection()
return self.asconn.get_all_groups()
def getActivities(self,AUTOSCALE_GROUP=None):
return self.asconn.get_all_activities(AUTOSCALE_GROUP)
def createLaunchConfig(self):
'''create Launch Configuration to define initial startup params
'''
#conn = AutoScaleConnection(AWSKEY, AWSSECRET)
#lc = self.buildLaunchConfig()
return self.asconn.create_launch_configuration(self.lc)
def createAutoscaleGroup(self):
'''We now have created a launch configuration called tfound...launch-config.
We are now ready to associate it with our new autoscale group.
returns autoscale object
'''
#conn = AutoScaleConnection(AWSKEY, AWSSECRET)
#lc = self.buildLaunchConfig()
return self.asconn.create_auto_scaling_group(self.ag)
#conn.get_all_activities(ag)
def createTrigger(self,AUTOSCALE_GROUP=None):
'''
you create a trigger on a group, pass in a group object
this creates a trigger that scales up to MAX instances if average cpu utilitzation goes over 60,
scales down to MIN instances if under 40 avg cpu
'''
#conn = AutoScaleConnection(AWSKEY, AWSSECRET)
tr = Trigger(name=self.TRNAME,
autoscale_group=AUTOSCALE_GROUP,
measure_name='CPUUtilization', statistic='Average',
unit='Percent',
dimensions=[('AutoScalingGroupName', AUTOSCALE_GROUP.name),
('Namespace','AWS/EC2')],
period=120, lower_threshold=10,
lower_breach_scale_increment='-1',
upper_threshold=30,
upper_breach_scale_increment='1',
breach_duration=360)
return self.asconn.create_trigger(tr)
def createHealthCheck(self):
return HealthCheck('instance_health',
interval=20,
target='TCP:8080',
timeout='5')
def createLoadbalancer(self):
#elbconn = ELBConnection(aws_access_key_id=AWSKEY,aws_secret_access_key=AWSSECRET)
#conn = ELBConnection(aws_access_key_id=AWSKEY,aws_secret_access_key=AWSSECRET,
# host='us-east-1a.elasticloadbalancing.amazonaws.com')
# hc = HealthCheck('instance_health', interval=20, target='HTTP:80/index.php', timeout='5')
# lb = conn.create_load_balancer('tfound-'+options.ENV+'-'+options.TYPE+'-lb', [options.ZONE],
# [(80, 80, 'http'),(8000,8000, 'tcp')])
## lb.delete()
hc = self.createHealthCheck()
lb = self.elbconn.create_load_balancer(self.LBNAME,
[self.ZONE],
[(8080,8080, 'tcp')])
lb.configure_health_check(hc)
return lb.dns_name
def addToLoadbalancer(self,INSTANCE=None):
#from boto.ec2.elb import ELBConnection
#from boto.ec2.elb import HealthCheck
#conn = ELBConnection(aws_access_key_id=AWSKEY,aws_secret_access_key=AWSSECRET)
# conn = ELBConnection(aws_access_key_id=AWSKEY,aws_secret_access_key=AWSSECRET,
# host='us-east-1a.elasticloadbalancing.amazonaws.com')
if INSTANCE == None:
sys.stderr.write("Please provide instance id to add. not acceptble: %s\n" % options.INSTANCE )
raise SystemExit(1)
lb = self.elbconn.register_instances(self.LBNAME,
INSTANCE)
#lbgroup = 'tfound-'+options.ENV+'-'+options.TYPE+'-lb'
print "Added instance %s to %s\n" % (INSTANCE, self.LBNAME)
def getLoadbalancers(self):
return self.elbconn.get_all_load_balancers()
def startInstances(self,TYPE='',NUM='',SIZE=''):
return
img_id = 'ami-69e3d500'
key_pair_name = 'jichuanl_project2.3'
test_bash = ['./apache_bench.sh', 'sample.jpg', '100000', '100', '', '']
sec_group = ['sg-98f73bfd']
zones = ['us-east-1d']
subnet = 'subnet-1fd7ee6b'
ports = [(80, 80, 'http'), (8080, 8080, 'http')]
hc = HealthCheck(
interval=30,
healthy_threshold=2,
unhealthy_threshold=10,
target='HTTP:8080/upload')
elb = ELBConnection()
lb = elb.create_load_balancer('my-lb', zones, ports)
lb.configure_health_check(hc)
lb_dns = lb.dns_name
ec2 = boto.connect_ec2()
#key_pair = ec2.create_key_pair(key_pair_name)
#key_pair.save('/home/ubuntu/.ssh')
rpc = 0
count = 0
while rpc < 2000: #test until get 2000req/sec
reservation = ec2.run_instances(image_id=img_id, key_name=key_pair_name, instance_type=types, security_group_ids=sec_group, subnet_id=subnet)
instance = []
for r in ec2.get_all_instances():
if r.id == reservation.id:
time.sleep(3)
time.sleep(5)
# add tag
lg_instance.add_tag(TAGK, TAGV)
time.sleep(5)
print lg_instance.id
print lg_instance.dns_name
print lg_instance.tags
print 'Creating ELB'
# initialize elastc load balancer
conn2 = ELBConnection(os.environ['AWS_ACCESS_KEY_ID'], os.environ['AWS_SECRET_KEY'])
# set heartbeat
page = 'HTTP:80' + '/heartbeat?lg=' + lg_instance.dns_name
hc = HealthCheck(interval=20, healthy_threshold=3, unhealthy_threshold=5, target=page)
# set port 80
elb = conn2.create_load_balancer('elb', [ZONE], [(80, 80, 'http')])
# allow all traffic
conn2.apply_security_groups_to_lb('elb', [sg.id])
conn2.configure_health_check('elb', hc)
print elb.dns_name
print 'Creating ASG'
# initialize launch config
conn3 = AutoScaleConnection(os.environ['AWS_ACCESS_KEY_ID'], os.environ['AWS_SECRET_KEY'])
config = LaunchConfiguration(name='config', image_id=DC_IMAGE, security_groups=sgs,
instance_type=TYPE, instance_monitoring=True)
conn3.create_launch_configuration(config)
# initialize auto scaling group
ag = AutoScalingGroup(connection=conn3, name='gp', load_balancers=['elb'], availability_zones=[ZONE],
health_check_type='ELB', health_check_period=60, launch_config=config,
min_size=2, max_size=5, desired_capacity=2,
tags=[Tag(key=TAGK, value=TAGV, propagate_at_launch=True,
class MSBManager:
def __init__(self, aws_access_key, aws_secret_key):
self.ec2_conn = EC2Connection(aws_access_key, aws_secret_key)
self.elb_conn = ELBConnection(aws_access_key, aws_secret_key)
self.auto_scale_conn = AutoScaleConnection(aws_access_key, aws_secret_key)
self.cloud_watch_conn = CloudWatchConnection(aws_access_key, aws_secret_key)
self.default_cooldown = 60
def get_security_group(self, name):
sgs = [g for g in self.ec2_conn.get_all_security_groups() if g.name == name]
return sgs[0] if sgs else None
def create_security_group(self, name, description):
sgs = [g for g in self.ec2_conn.get_all_security_groups() if g.name == name]
sg = sgs[0] if sgs else None
if not sgs:
sg = self.ec2_conn.create_security_group(name, description)
try:
sg.authorize(ip_protocol="-1", from_port=None, to_port=None, cidr_ip="0.0.0.0/0", dry_run=False)
except EC2ResponseError:
pass
return sg
def remove_security_group(self, name):
self.ec2_conn.delete_security_group(name=name)
def create_instance(self, image, instance_type, key_name, zone, security_groups, tags):
instance = None
reservations = self.ec2_conn.get_all_instances()
for reservation in reservations:
for i in reservation.instances:
if "Name" in i.tags and i.tags["Name"] == tags["Name"] and i.state == "running":
instance = i
break
if not instance:
reservation = self.ec2_conn.run_instances(
image,
instance_type=instance_type,
key_name=key_name,
placement=zone,
security_groups=security_groups,
monitoring_enabled=True,
)
instance = reservation.instances[0]
while not instance.update() == "running":
time.sleep(5)
time.sleep(10)
self.ec2_conn.create_tags([instance.id], tags)
return instance
def request_spot_instance(self, bid, image, instance_type, key_name, zone, security_groups, tags):
req = self.ec2_conn.request_spot_instances(
price=bid,
instance_type=instance_type,
image_id=image,
placement=zone,
key_name=key_name,
security_groups=security_groups,
)
instance_id = None
while not instance_id:
job_sir_id = req[0].id
requests = self.ec2_conn.get_all_spot_instance_requests()
for sir in requests:
if sir.id == job_sir_id:
instance_id = sir.instance_id
break
print "Job {} not ready".format(job_sir_id)
time.sleep(60)
self.ec2_conn.create_tags([instance_id], tags)
def remove_instance(self, instance_id):
self.remove_instances([instance_id])
def remove_instances(self, instance_ids):
self.ec2_conn.terminate_instances(instance_ids)
def remove_instance_by_tag_name(self, name):
reservations = self.ec2_conn.get_all_instances()
data_centers_intance_ids = []
for reservation in reservations:
for instance in reservation.instances:
if "Name" in instance.tags and instance.tags["Name"] == name and instance.state == "running":
data_centers_intance_ids.append(instance.id)
if data_centers_intance_ids:
self.remove_instances(data_centers_intance_ids)
def create_elb(self, name, zone, project_tag_value, security_group_id, instance_ids=None):
lbs = [l for l in self.elb_conn.get_all_load_balancers() if l.name == name]
lb = lbs[0] if lbs else None
if not lb:
hc = HealthCheck(
timeout=50, interval=60, healthy_threshold=2, unhealthy_threshold=8, target="HTTP:80/heartbeat"
)
ports = [(80, 80, "http")]
zones = [zone]
lb = self.elb_conn.create_load_balancer(name, zones, ports)
self.elb_conn.apply_security_groups_to_lb(name, [security_group_id])
lb.configure_health_check(hc)
if instance_ids:
lb.register_instances(instance_ids)
params = {
"LoadBalancerNames.member.1": lb.name,
"Tags.member.1.Key": "15619project",
"Tags.member.1.Value": project_tag_value,
}
lb.connection.get_status("AddTags", params, verb="POST")
return lb
def remove_elb(self, name):
self.elb_conn.delete_load_balancer(name)
def create_launch_configuration(self, name, image, key_name, security_groups, instance_type):
lcs = [l for l in self.auto_scale_conn.get_all_launch_configurations() if l.name == name]
lc = lcs[0] if lcs else None
if not lc:
lc = LaunchConfiguration(
name=name,
image_id=image,
key_name=key_name,
security_groups=[security_groups],
instance_type=instance_type,
)
self.auto_scale_conn.create_launch_configuration(lc)
return lc
def remove_launch_configuration(self, name):
self.auto_scale_conn.delete_launch_configuration(name)
def create_autoscaling_group(self, name, lb_name, zone, tags, instance_ids=None):
lc = self.create_launch_configuration()
as_groups = [a for a in self.auto_scale_conn.get_all_groups() if a.name == name]
as_group = as_groups[0] if as_groups else None
if not as_group:
as_group = AutoScalingGroup(
group_name=name,
load_balancers=[lb_name],
availability_zones=[zone],
launch_config=lc,
min_size=4,
max_size=4,
health_check_type="ELB",
health_check_period=120,
connection=self.auto_scale_conn,
default_cooldown=self.default_cooldown,
desired_capacity=4,
tags=tags,
)
self.auto_scale_conn.create_auto_scaling_group(as_group)
if instance_ids:
self.auto_scale_conn.attach_instances(name, instance_ids)
scale_up_policy = ScalingPolicy(
name="scale_up",
adjustment_type="ChangeInCapacity",
as_name=name,
scaling_adjustment=1,
cooldown=self.default_cooldown,
)
scale_down_policy = ScalingPolicy(
name="scale_down",
adjustment_type="ChangeInCapacity",
as_name=name,
scaling_adjustment=-1,
cooldown=self.default_cooldown,
)
self.auto_scale_conn.create_scaling_policy(scale_up_policy)
self.auto_scale_conn.create_scaling_policy(scale_down_policy)
scale_up_policy = self.auto_scale_conn.get_all_policies(as_group=name, policy_names=["scale_up"])[0]
scale_down_policy = self.auto_scale_conn.get_all_policies(as_group=name, policy_names=["scale_down"])[0]
alarm_dimensions = {"AutoScalingGroupName": name}
scale_up_alarm = MetricAlarm(
name="scale_up_on_cpu",
namespace="AWS/EC2",
metric="CPUUtilization",
statistic="Average",
comparison=">",
threshold=85,
period=60,
evaluation_periods=1,
alarm_actions=[scale_up_policy.policy_arn],
dimensions=alarm_dimensions,
)
self.cloud_watch_conn.create_alarm(scale_up_alarm)
scale_down_alarm = MetricAlarm(
name="scale_down_on_cpu",
namespace="AWS/EC2",
metric="CPUUtilization",
statistic="Average",
comparison="<",
threshold=60,
period=60,
evaluation_periods=1,
alarm_actions=[scale_down_policy.policy_arn],
dimensions=alarm_dimensions,
)
self.cloud_watch_conn.create_alarm(scale_down_alarm)
return as_group
def update_autoscaling_group_max_size(self, as_group, max_size):
setattr(as_group, "max_size", max_size)
as_group.update()
def update_autoscaling_group_min_size(self, as_group, min_size):
setattr(as_group, "min_size", min_size)
as_group.update()
def remove_autoscaling_group(self, name):
self.auto_scale_conn.delete_auto_scaling_group(name)
class AutoScale:
def __init__(self, args):
"""
Initializing basic variables needed for auto scaling
"""
self.configs = ConfigParser.RawConfigParser()
self.args = args
self.test_props = {}
self.props = {}
self.ec2_connection = EC2Connection(self.args.access_key,
self.args.secret_key)
self.autoscale_connection = AutoScaleConnection(
self.args.access_key, self.args.secret_key)
self.elb_connection = ELBConnection(self.args.access_key,
self.args.secret_key)
self.cw_connection = CloudWatchConnection(self.args.access_key,
self.args.secret_key)
self.firstInstance = None
self.launchConfiguration = None
self.healthCheck = None
def loadConfigs(self):
"""
FIX ME: Currently doesnt do anything
This method will load the configurations from boto config file if present else will
accept parameters passed by user.
"""
if os.path.isfile("/etc/boto.cfg"):
self.configs.read("/etc/boto.cfg")
conf = self.configs.sections()
self.populateConfigs(conf)
if os.path.isfile("~/.boto"):
self.configs.read("~/.boto")
conf = self.configs.sections()
self.populateConfigs(conf)
print ">>> Loaded configs"
def populateConfigs(self, sections):
for section in sections:
self.boto_props[section] = self.configs.items(section)
for item in self.boto_props[section]:
key, value = item
if not self.props.has_key(key):
self.props[key] = value
def createLaunchConfiguration(self, lc_name, ami_id, key_name):
"""
Creates launch configuration for the auto scaling cluster
"""
self.launchConfiguration = LaunchConfiguration(name=lc_name,
image_id=ami_id,
key_name=key_name)
self.autoscale_connection.create_launch_configuration(
self.launchConfiguration)
print ">>> Created launch configuration: " + lc_name
def createAutoScaleGroup(self, asg_name):
"""
Create a Auto scaling group for the auto scaling cluster
"""
autoScalingGroup = AutoScalingGroup(
group_name=asg_name,
load_balancers=[self.args.lb_name],
launch_config=self.launchConfiguration,
min_size=self.args.min_size,
max_size=self.args.max_size,
availability_zones=['us-east-1a'])
self.autoscale_connection.create_auto_scaling_group(autoScalingGroup)
print ">>> Created auto scaling group: " + asg_name
def createTrigger(self, trigger_name, measure, asg_name):
"""
Trigger to spawn new instances as per specific metrics
"""
alarm_actions = []
dimensions = {"AutoScalingGroupName": asg_name}
policies = self.autoscale_connection.get_all_policies(
as_group=self.args.asg_name, policy_names=[self.args.asp_name])
for policy in policies:
alarm_actions.append(policy.policy_arn)
alarm = MetricAlarm(name=trigger_name,
namespace="AWS/EC2",
metric=measure,
statistic="Average",
comparison=">=",
threshold=50,
period=60,
unit="Percent",
evaluation_periods=2,
alarm_actions=alarm_actions,
dimensions=dimensions)
self.cw_connection.create_alarm(alarm)
print ">>> Created trigger: " + self.args.trigger
def createAutoScalePolicy(self, asp_name):
"""
Creates a Auto scaling policy to Add/Remove a instance from auto scaling cluster
"""
self.autoScalingUpPolicy = ScalingPolicy(
name=asp_name + '-up',
adjustment_type="ChangeInCapacity",
as_name=self.args.asg_name,
scaling_adjustment=1,
cooldown=180)
self.autoScalingDownPolicy = ScalingPolicy(
name=asp_name + '-down',
adjustment_type="ChangeInCapacity",
as_name=self.args.asg_name,
scaling_adjustment=-1,
cooldown=180)
self.autoscale_connection.create_scaling_policy(
self.autoScalingUpPolicy)
self.autoscale_connection.create_scaling_policy(
self.autoScalingDownPolicy)
print ">>> Created auto scaling policy: " + asp_name
def configureHealthCheck(self, target):
"""
Configures health check for the cluster
"""
self.healthCheck = HealthCheck(target=target, timeout=5)
print ">>> Configured health check for: " + target
def createLoadBalancer(self, lb_name, region, lb_port, instance_port,
protocol):
"""
Creates a load balancer for cluster
"""
listener = (int(lb_port), int(instance_port), protocol)
tuple_list = []
tuple_list.append(listener)
lbs = self.elb_connection.get_all_load_balancers()
for lb in lbs:
if lb.name != lb_name:
self.elb_connection.create_load_balancer(
lb_name, [region], tuple_list)
self.elb_connection.configure_health_check(
name=lb_name, health_check=self.healthCheck)
print ">>> Created load balancer: " + lb_name
else:
print "Load balancer with name '" + lb_name + "' already exists"
def startInstance(self, image_id, key_name, region, instance_type):
"""
Starts the first instance which will be serving requests irrespective of auto scaling
instances.
"""
reservation = self.ec2_connection.run_instances(
image_id=image_id,
min_count=1,
max_count=1,
placement=region,
key_name=key_name,
instance_type=instance_type)
# for instance in reservation.instances:
# instance.add_tag('node', '0')
# break
self.firstInstance = reservation.instances[0].id.split('\'')[0]
print ">>> Started instance: ", self.firstInstance
def registerInstanceToELB(self, lb_name):
"""
Register the first instance started to the Elastic Load Balancer.
"""
self.elb_connection.register_instances(load_balancer_name=lb_name,
instances=[self.firstInstance])
print ">>> Registered instance '", self.firstInstance, "' to load balancer '" + lb_name + "'"
def setUp(self):
"""
Set's up the auto scaling for the application
"""
# STEP 1: Load the configurations
self.loadConfigs()
# STEP 2: Configure the health check for the instances
self.configureHealthCheck(self.args.lb_target)
# STEP 3: Create a load balancer
self.createLoadBalancer(self.args.lb_name, self.args.region,
self.args.lb_port, self.args.instance_port,
self.args.protocol)
# STEP 4: Start the first instance
self.startInstance(self.args.ami_id, self.args.key_name,
self.args.region, self.args.instance_type)
# STEP 5: Register the instance to the load balancer created in STEP 4
self.registerInstanceToELB(self.args.lb_name)
# STEP 6: Create launch configuration to launch instances by auto scale
self.createLaunchConfiguration(self.args.lc_name, self.args.ami_id,
self.args.key_name)
# STEP 7: Create a auto scale group which will manage the instances started by auto scaling
self.createAutoScaleGroup(self.args.asg_name)
# STEP 8: Create a auto scaling policy to say add/remove a node
self.createAutoScalePolicy(self.args.asp_name)
# STEP 9: Create a trigger, so that auto scaling can trigger it to start
# or remove a instance from auto scaling group
self.createTrigger(self.args.trigger, self.args.measure,
self.args.asg_name)
print 'Load Generator running'
lg.add_tag("Project","2.2")
# -------------------------Create Load Balancer---------------------------------
con_elb = ELBConnection()
elb = {
'name': 'ELB',
'zone': ZONE,
'ports': [(80, 80, 'http')],
'target': 'HTTP:80/heartbeat?lg=',
'time_out': 3,
'interval': 20
}
lb = con_elb.create_load_balancer(elb['name'],
elb['zone'],
listeners=elb['ports'],
security_groups=sec_group2.id)
time.sleep(5)
lb_dns = lb.dns_name;
elb['target'] += lg_dns
hc = HealthCheck(interval=elb['interval'],
healthy_threshold=10,
unhealthy_threshold=2,
target=elb['target'],
timeout=elb['time_out'])
lb.configure_health_check(hc)
params = {"LoadBalancerNames.member.1": lb.name,
conn_as = AutoScaleConnection()
all_elb = conn_elb.get_all_load_balancers()
##=================Create a Load Balancer=============================================
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#module-boto.ec2.elb.healthcheck
hc = HealthCheck('healthCheck',
interval=elastic_load_balancer['interval'],
target=elastic_load_balancer['health_check_target'],
timeout=elastic_load_balancer['timeout'])
#
##For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.elb.ELBConnection.create_load_balancer
lb = conn_elb.create_load_balancer(elastic_load_balancer['name'],
sorted(zoneStrings, reverse=True),
elastic_load_balancer['connection_forwarding'])
lb.configure_health_check(hc)
lb.enable_zones(zoneStrings)
#
##DNS name for your new load balancer
print "Map the CNAME of your website to: %s" % (lb.dns_name)
#=================Create a Auto Scaling Group and a Launch Configuration=============================================
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.autoscale.launchconfig.LaunchConfiguration
lc = LaunchConfiguration(name=lc_name, image_id=as_ami['id'],
key_name=as_ami['access_key'],
security_groups=as_ami['security_groups'],
instance_type=as_ami['instance_type'],
instance_monitoring=as_ami['instance_monitoring'])
class ELBConnectionTest(unittest.TestCase):
ec2 = True
def setUp(self):
"""Creates a named load balancer that can be safely
deleted at the end of each test"""
self.conn = ELBConnection()
self.name = 'elb-boto-unit-test'
self.availability_zones = ['us-east-1a']
self.listeners = [(80, 8000, 'HTTP')]
self.balancer = self.conn.create_load_balancer(self.name, self.availability_zones, self.listeners)
def tearDown(self):
""" Deletes the test load balancer after every test.
It does not delete EVERY load balancer in your account"""
self.balancer.delete()
def test_build_list_params(self):
params = {}
self.conn.build_list_params(
params, ['thing1', 'thing2', 'thing3'], 'ThingName%d')
expected_params = {
'ThingName1': 'thing1',
'ThingName2': 'thing2',
'ThingName3': 'thing3'
}
self.assertEqual(params, expected_params)
# TODO: for these next tests, consider sleeping until our load
# balancer comes up, then testing for connectivity to
# balancer.dns_name, along the lines of the existing EC2 unit tests.
def test_create_load_balancer(self):
self.assertEqual(self.balancer.name, self.name)
self.assertEqual(self.balancer.availability_zones,\
self.availability_zones)
self.assertEqual(self.balancer.listeners, self.listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
def test_create_load_balancer_listeners(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(
sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners)
)
def test_delete_load_balancer_listeners(self):
mod_listeners = [(80, 8000, 'HTTP'), (443, 8001, 'HTTP')]
mod_name = self.name + "-mod"
self.mod_balancer = self.conn.create_load_balancer(mod_name,\
self.availability_zones, mod_listeners)
mod_balancers = self.conn.get_all_load_balancers(load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual(
sorted([l.get_tuple() for l in mod_balancers[0].listeners]),
sorted(mod_listeners))
self.conn.delete_load_balancer_listeners(self.mod_balancer.name, [443])
mod_balancers = self.conn.get_all_load_balancers(load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual([l.get_tuple() for l in mod_balancers[0].listeners],
mod_listeners[:1])
self.mod_balancer.delete()
def test_create_load_balancer_listeners_with_policies(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
lb_policy_name = 'lb-policy'
self.conn.create_lb_cookie_stickiness_policy(1000, self.name, lb_policy_name)
self.conn.set_lb_policies_of_listener(self.name, self.listeners[0][0], lb_policy_name)
app_policy_name = 'app-policy'
self.conn.create_app_cookie_stickiness_policy('appcookie', self.name, app_policy_name)
self.conn.set_lb_policies_of_listener(self.name, more_listeners[0][0], app_policy_name)
balancers = self.conn.get_all_load_balancers(load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(
sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners)
)
# Policy names should be checked here once they are supported
# in the Listener object.
def test_create_load_balancer_backend_with_policies(self):
other_policy_name = 'enable-proxy-protocol'
backend_port = 8081
self.conn.create_lb_policy(self.name, other_policy_name,
'ProxyProtocolPolicyType', {'ProxyProtocol': True})
self.conn.set_lb_policies_of_backend_server(self.name, backend_port, [other_policy_name])
balancers = self.conn.get_all_load_balancers(load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(len(balancers[0].policies.other_policies), 1)
self.assertEqual(balancers[0].policies.other_policies[0].policy_name, other_policy_name)
self.assertEqual(len(balancers[0].backends), 1)
self.assertEqual(balancers[0].backends[0].instance_port, backend_port)
self.assertEqual(balancers[0].backends[0].policies[0].policy_name, other_policy_name)
self.conn.set_lb_policies_of_backend_server(self.name, backend_port, [])
balancers = self.conn.get_all_load_balancers(load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(len(balancers[0].policies.other_policies), 1)
self.assertEqual(len(balancers[0].backends), 0)
def test_create_load_balancer_complex_listeners(self):
complex_listeners = [
(8080, 80, 'HTTP', 'HTTP'),
(2525, 25, 'TCP', 'TCP'),
]
self.conn.create_load_balancer_listeners(
self.name,
complex_listeners=complex_listeners
)
balancers = self.conn.get_all_load_balancers(
load_balancer_names=[self.name]
)
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(
sorted(l.get_complex_tuple() for l in balancers[0].listeners),
# We need an extra 'HTTP' here over what ``self.listeners`` uses.
sorted([(80, 8000, 'HTTP', 'HTTP')] + complex_listeners)
)
as_ami = {
'id': 'ami-8e1fece7', #The AMI ID of the instance your Auto Scaling group will launch
'access_key': 'anant-key', #The key the EC2 instance will be configured with
'security_groups': ['web-sg'],
'instance_type': 't1.nano',
'instance_monitoring': True
}
lc_name = 'web-server-auto-scaling-configuration'
conn_reg = boto.ec2.connect_to_region(region_name=region)
zones = conn_reg.get_all_zones()
zoneStrings = []
for zone in zones:
zoneStrings.append(zone.name)
lb = conn_elb.create_load_balancer(LoadBalancerName=elastic_load_balancer['name'],
AvailabilityZones=zoneStrings,
Listeners=elastic_load_balancer['connection_forwarding'],
SecurityGroups=['load-balancer-sg']
Tags=[{'Project':'ccbda bootstrap','Cost-center':'laboratory'}])
conn_as.create_launch_configuration(lc)
ag = AutoScalingGroup(group_name=autoscaling_group['name'], load_balancers=[elastic_load_balancer['name']],
availability_zones=zoneStrings,
launch_config=lc, min_size=autoscaling_group['min_size'], max_size=autoscaling_group['max_size'])
conn_as.create_auto_scaling_group(ag)
class BotoBalanceInterface(BalanceInterface):
conn = None
saveclcdata = False
def __init__(self, clc_host, access_id, secret_key, token):
self.access_id = access_id
self.secret_key = secret_key
self.token = token
self.set_endpoint(clc_host)
def set_endpoint(self, endpoint):
#boto.set_stream_logger('foo')
reg = RegionInfo(name='eucalyptus', endpoint=endpoint)
path = '/services/LoadBalancing'
port = 8773
if endpoint[len(endpoint)-13:] == 'amazonaws.com':
endpoint = endpoint.replace('ec2', 'elasticloadbalancing', 1)
path = '/'
reg = RegionInfo(endpoint=endpoint)
port = 443
self.conn = ELBConnection(self.access_id, self.secret_key, region=reg,
port=port, path=path,
is_secure=True, security_token=self.token, debug=0)
self.conn.https_validate_certificates = False
self.conn.http_connection_kwargs['timeout'] = 30
def __save_json__(self, obj, name):
f = open(name, 'w')
json.dump(obj, f, cls=BotoJsonBalanceEncoder, indent=2)
f.close()
def create_load_balancer(self, name, zones, listeners, subnets=None,
security_groups=None, scheme='internet-facing'):
return self.conn.create_load_balancer(name, zones, listeners, subnets, security_groups, scheme)
def delete_load_balancer(self, name):
return self.conn.delete_load_balancer(name)
def get_all_load_balancers(self, load_balancer_names=None):
params = {}
if load_balancer_names:
self.build_list_params(params, load_balancer_names,
'LoadBalancerNames.member.%d')
http_request = self.conn.build_base_http_request('GET', '/', None,
params, {}, '',
self.conn.server_name())
http_request.params['Action'] = 'DescribeLoadBalancers'
http_request.params['Version'] = self.conn.APIVersion
response = self.conn._mexe(http_request, override_num_retries=2)
body = response.read()
boto.log.debug(body)
if not body:
boto.log.error('Null body %s' % body)
raise self.conn.ResponseError(response.status, response.reason, body)
elif response.status == 200:
obj = boto.resultset.ResultSet([('member', boto.ec2.elb.loadbalancer.LoadBalancer)])
h = boto.handler.XmlHandler(obj, self.conn)
import xml.sax;
xml.sax.parseString(body, h)
if self.saveclcdata:
self.__save_json__(obj, "mockdata/ELB_Balancers.json")
return obj
else:
boto.log.error('%s %s' % (response.status, response.reason))
boto.log.error('%s' % body)
raise self.conn.ResponseError(response.status, response.reason, body)
def deregister_instances(self, load_balancer_name, instances):
return self.conn.deregister_instances(load_balancer_name, instances)
def register_instances(self, load_balancer_name, instances):
return self.conn.register_instances(load_balancer_name, instances)
def create_load_balancer_listeners(self, name, listeners):
return self.conn.create_load_balancer_listeners(name, listeners)
def delete_load_balancer_listeners(self, name, ports):
return self.conn.delete_load_balancer_listeners(name, ports)
def configure_health_check(self, name, health_check):
return self.conn.configure_health_check(name, health_check)
def describe_instance_health(self, load_balancer_name, instances=None):
obj = self.conn.describe_instance_health(load_balancer_name, instances)
if self.saveclcdata:
self.__save_json__(obj, "mockdata/ELB_Instances.json")
return obj
class ELBConnectionTest(unittest.TestCase):
ec2 = True
def setup(self):
"""Creates a named load balancer that can be safely
deleted at the end of each test"""
self.conn = ELBConnection()
self.name = 'elb-boto-unit-test'
self.availability_zones = ['us-east-1a']
self.listeners = [(80, 8000, 'HTTP')]
self.balancer = self.conn.create_load_balancer(name,
availability_zones,
listeners)
def tearDown(self):
""" Deletes the test load balancer after every test.
It does not delete EVERY load balancer in your account"""
self.balancer.delete()
def test_build_list_params(self):
params = {}
self.conn.build_list_params(params, ['thing1', 'thing2', 'thing3'],
'ThingName%d')
expected_params = {
'ThingName1': 'thing1',
'ThingName2': 'thing2',
'ThingName3': 'thing3'
}
self.assertEqual(params, expected_params)
# TODO: for these next tests, consider sleeping until our load
# balancer comes up, then testing for connectivity to
# balancer.dns_name, along the lines of the existing EC2 unit tests.
def test_create_load_balancer(self):
self.assertEqual(self.balancer.name, self.name)
self.assertEqual(self.balancer.availability_zones,\
self.availability_zones)
self.assertEqual(self.balancer.listeners, self.listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
def test_create_load_balancer_listeners(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners))
def test_delete_load_balancer_listeners(self):
mod_listeners = [(80, 8000, 'HTTP'), (443, 8001, 'HTTP')]
mod_name = self.name + "_mod"
self.mod_balancer = self.conn.create_load_balancer(mod_name,\
self.availability_zones, mod_listeners)
mod_balancers = self.conn.get_all_load_balancers(
load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual(
sorted([l.get_tuple() for l in mod_balancers[0].listeners]),
sorted(mod_listeners))
self.conn.delete_load_balancer_listeners(self.mod_balancer.name, [443])
mod_balancers = self.conn.get_all_load_balancers(
load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual([l.get_tuple() for l in mod_balancers[0].listeners],
mod_listeners[:1])
self.mod_balancer.delete()
def test_create_load_balancer_listeners_with_policies(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
lb_policy_name = 'lb-policy'
self.conn.create_lb_cookie_stickiness_policy(1000, self.name,
lb_policy_name)
self.conn.set_lb_policies_of_listener(self.name, self.listeners[0][0],
lb_policy_name)
app_policy_name = 'app-policy'
self.conn.create_app_cookie_stickiness_policy('appcookie', self.name,
app_policy_name)
self.conn.set_lb_policies_of_listener(self.name, more_listeners[0][0],
app_policy_name)
balancers = self.conn.get_all_load_balancers(
load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners))
from boto.ec2.elb import ELBConnection
from boto.ec2.elb import HealthCheck
conn_elb = ELBConnection(AWS_ACCESS_KEY, AWS_SECRET_KEY)
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#module-boto.ec2.elb.healthcheck
hc = HealthCheck('healthCheck',
interval=10,
target='HTTP:80/index.html',
timeout=2)
#For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.elb.ELBConnection.create_load_balancer
lb = conn_elb.create_load_balancer('nginx-lb', ['eu-central-1', 'eu-west-1'],
[(80, 80, 'http'), (443, 443, 'tcp')])
lb.configure_health_check(hc)
#DNS name for your new load balancer
print "Map the FQDN of your website to: %s" % (lb.dns_name)
class ELBConnectionTest(unittest.TestCase):
ec2 = True
def setUp(self):
"""Creates a named load balancer that can be safely
deleted at the end of each test"""
self.conn = ELBConnection()
self.name = 'elb-boto-unit-test'
self.availability_zones = ['us-east-1a']
self.listeners = [(80, 8000, 'HTTP')]
self.balancer = self.conn.create_load_balancer(self.name,
self.availability_zones,
self.listeners)
# S3 bucket for log tests
self.s3 = boto.connect_s3()
self.timestamp = str(int(time.time()))
self.bucket_name = 'boto-elb-%s' % self.timestamp
self.bucket = self.s3.create_bucket(self.bucket_name)
self.bucket.set_canned_acl('public-read-write')
self.addCleanup(self.cleanup_bucket, self.bucket)
def cleanup_bucket(self, bucket):
for key in bucket.get_all_keys():
key.delete()
bucket.delete()
def tearDown(self):
""" Deletes the test load balancer after every test.
It does not delete EVERY load balancer in your account"""
self.balancer.delete()
def test_build_list_params(self):
params = {}
self.conn.build_list_params(params, ['thing1', 'thing2', 'thing3'],
'ThingName%d')
expected_params = {
'ThingName1': 'thing1',
'ThingName2': 'thing2',
'ThingName3': 'thing3'
}
self.assertEqual(params, expected_params)
# TODO: for these next tests, consider sleeping until our load
# balancer comes up, then testing for connectivity to
# balancer.dns_name, along the lines of the existing EC2 unit tests.
def test_create_load_balancer(self):
self.assertEqual(self.balancer.name, self.name)
self.assertEqual(self.balancer.availability_zones,\
self.availability_zones)
self.assertEqual(self.balancer.listeners, self.listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
def test_create_load_balancer_listeners(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners))
def test_delete_load_balancer_listeners(self):
mod_listeners = [(80, 8000, 'HTTP'), (443, 8001, 'HTTP')]
mod_name = self.name + "-mod"
self.mod_balancer = self.conn.create_load_balancer(mod_name,\
self.availability_zones, mod_listeners)
mod_balancers = self.conn.get_all_load_balancers(
load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual(
sorted([l.get_tuple() for l in mod_balancers[0].listeners]),
sorted(mod_listeners))
self.conn.delete_load_balancer_listeners(self.mod_balancer.name, [443])
mod_balancers = self.conn.get_all_load_balancers(
load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual([l.get_tuple() for l in mod_balancers[0].listeners],
mod_listeners[:1])
self.mod_balancer.delete()
def test_create_load_balancer_listeners_with_policies(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
lb_policy_name = 'lb-policy'
self.conn.create_lb_cookie_stickiness_policy(1000, self.name,
lb_policy_name)
self.conn.set_lb_policies_of_listener(self.name, self.listeners[0][0],
lb_policy_name)
app_policy_name = 'app-policy'
self.conn.create_app_cookie_stickiness_policy('appcookie', self.name,
app_policy_name)
self.conn.set_lb_policies_of_listener(self.name, more_listeners[0][0],
app_policy_name)
balancers = self.conn.get_all_load_balancers(
load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners))
# Policy names should be checked here once they are supported
# in the Listener object.
def test_create_load_balancer_backend_with_policies(self):
other_policy_name = 'enable-proxy-protocol'
backend_port = 8081
self.conn.create_lb_policy(self.name, other_policy_name,
'ProxyProtocolPolicyType',
{'ProxyProtocol': True})
self.conn.set_lb_policies_of_backend_server(self.name, backend_port,
[other_policy_name])
balancers = self.conn.get_all_load_balancers(
load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(len(balancers[0].policies.other_policies), 1)
self.assertEqual(balancers[0].policies.other_policies[0].policy_name,
other_policy_name)
self.assertEqual(len(balancers[0].backends), 1)
self.assertEqual(balancers[0].backends[0].instance_port, backend_port)
self.assertEqual(balancers[0].backends[0].policies[0].policy_name,
other_policy_name)
self.conn.set_lb_policies_of_backend_server(self.name, backend_port,
[])
balancers = self.conn.get_all_load_balancers(
load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(len(balancers[0].policies.other_policies), 1)
self.assertEqual(len(balancers[0].backends), 0)
def test_create_load_balancer_complex_listeners(self):
complex_listeners = [
(8080, 80, 'HTTP', 'HTTP'),
(2525, 25, 'TCP', 'TCP'),
]
self.conn.create_load_balancer_listeners(
self.name, complex_listeners=complex_listeners)
balancers = self.conn.get_all_load_balancers(
load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(
sorted(l.get_complex_tuple() for l in balancers[0].listeners),
# We need an extra 'HTTP' here over what ``self.listeners`` uses.
sorted([(80, 8000, 'HTTP', 'HTTP')] + complex_listeners))
def test_load_balancer_access_log(self):
attributes = self.balancer.get_attributes()
self.assertEqual(False, attributes.access_log.enabled)
attributes.access_log.enabled = True
attributes.access_log.s3_bucket_name = self.bucket_name
attributes.access_log.s3_bucket_prefix = 'access-logs'
attributes.access_log.emit_interval = 5
self.conn.modify_lb_attribute(self.balancer.name, 'accessLog',
attributes.access_log)
new_attributes = self.balancer.get_attributes()
self.assertEqual(True, new_attributes.access_log.enabled)
self.assertEqual(self.bucket_name,
new_attributes.access_log.s3_bucket_name)
self.assertEqual('access-logs',
new_attributes.access_log.s3_bucket_prefix)
self.assertEqual(5, new_attributes.access_log.emit_interval)
class ELBConnectionTest(unittest.TestCase):
ec2 = True
def setUp(self):
"""Creates a named load balancer that can be safely
deleted at the end of each test"""
self.conn = ELBConnection()
self.name = 'elb-boto-unit-test'
self.availability_zones = ['us-east-1a']
self.listeners = [(80, 8000, 'HTTP')]
self.balancer = self.conn.create_load_balancer(self.name,
self.availability_zones,
self.listeners)
# S3 bucket for log tests
self.s3 = boto.connect_s3()
self.timestamp = str(int(time.time()))
self.bucket_name = 'boto-elb-%s' % self.timestamp
self.bucket = self.s3.create_bucket(self.bucket_name)
self.bucket.set_canned_acl('public-read-write')
self.addCleanup(self.cleanup_bucket, self.bucket)
def cleanup_bucket(self, bucket):
for key in bucket.get_all_keys():
key.delete()
bucket.delete()
def tearDown(self):
""" Deletes the test load balancer after every test.
It does not delete EVERY load balancer in your account"""
self.balancer.delete()
def test_build_list_params(self):
params = {}
self.conn.build_list_params(params, ['thing1', 'thing2', 'thing3'],
'ThingName%d')
expected_params = {
'ThingName1': 'thing1',
'ThingName2': 'thing2',
'ThingName3': 'thing3'
}
self.assertEqual(params, expected_params)
# TODO: for these next tests, consider sleeping until our load
# balancer comes up, then testing for connectivity to
# balancer.dns_name, along the lines of the existing EC2 unit tests.
def test_create_load_balancer(self):
self.assertEqual(self.balancer.name, self.name)
self.assertEqual(self.balancer.availability_zones,
self.availability_zones)
self.assertEqual(self.balancer.listeners, self.listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
def test_create_load_balancer_listeners(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
balancers = self.conn.get_all_load_balancers()
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners))
def test_delete_load_balancer_listeners(self):
mod_listeners = [(80, 8000, 'HTTP'), (443, 8001, 'HTTP')]
mod_name = self.name + "-mod"
self.mod_balancer = self.conn.create_load_balancer(
mod_name, self.availability_zones, mod_listeners)
mod_balancers = self.conn.get_all_load_balancers(
load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual(
sorted([l.get_tuple() for l in mod_balancers[0].listeners]),
sorted(mod_listeners))
self.conn.delete_load_balancer_listeners(self.mod_balancer.name, [443])
mod_balancers = self.conn.get_all_load_balancers(
load_balancer_names=[mod_name])
self.assertEqual([lb.name for lb in mod_balancers], [mod_name])
self.assertEqual([l.get_tuple() for l in mod_balancers[0].listeners],
mod_listeners[:1])
self.mod_balancer.delete()
def test_create_load_balancer_listeners_with_policies(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
lb_policy_name = 'lb-policy'
self.conn.create_lb_cookie_stickiness_policy(1000, self.name,
lb_policy_name)
self.conn.set_lb_policies_of_listener(self.name, self.listeners[0][0],
lb_policy_name)
app_policy_name = 'app-policy'
self.conn.create_app_cookie_stickiness_policy('appcookie', self.name,
app_policy_name)
self.conn.set_lb_policies_of_listener(self.name, more_listeners[0][0],
app_policy_name)
balancers = self.conn.get_all_load_balancers(
load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(sorted(l.get_tuple() for l in balancers[0].listeners),
sorted(self.listeners + more_listeners))
# Policy names should be checked here once they are supported
# in the Listener object.
def test_create_load_balancer_backend_with_policies(self):
other_policy_name = 'enable-proxy-protocol'
backend_port = 8081
self.conn.create_lb_policy(self.name, other_policy_name,
'ProxyProtocolPolicyType',
{'ProxyProtocol': True})
self.conn.set_lb_policies_of_backend_server(self.name, backend_port,
[other_policy_name])
balancers = self.conn.get_all_load_balancers(
load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(len(balancers[0].policies.other_policies), 1)
self.assertEqual(balancers[0].policies.other_policies[0].policy_name,
other_policy_name)
self.assertEqual(len(balancers[0].backends), 1)
self.assertEqual(balancers[0].backends[0].instance_port, backend_port)
self.assertEqual(balancers[0].backends[0].policies[0].policy_name,
other_policy_name)
self.conn.set_lb_policies_of_backend_server(self.name, backend_port,
[])
balancers = self.conn.get_all_load_balancers(
load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(len(balancers[0].policies.other_policies), 1)
self.assertEqual(len(balancers[0].backends), 0)
def test_create_load_balancer_complex_listeners(self):
complex_listeners = [
(8080, 80, 'HTTP', 'HTTP'),
(2525, 25, 'TCP', 'TCP'),
]
self.conn.create_load_balancer_listeners(
self.name, complex_listeners=complex_listeners)
balancers = self.conn.get_all_load_balancers(
load_balancer_names=[self.name])
self.assertEqual([lb.name for lb in balancers], [self.name])
self.assertEqual(
sorted(l.get_complex_tuple() for l in balancers[0].listeners),
# We need an extra 'HTTP' here over what ``self.listeners`` uses.
sorted([(80, 8000, 'HTTP', 'HTTP')] + complex_listeners))
def test_load_balancer_access_log(self):
attributes = self.balancer.get_attributes()
self.assertEqual(False, attributes.access_log.enabled)
attributes.access_log.enabled = True
attributes.access_log.s3_bucket_name = self.bucket_name
attributes.access_log.s3_bucket_prefix = 'access-logs'
attributes.access_log.emit_interval = 5
self.conn.modify_lb_attribute(self.balancer.name, 'accessLog',
attributes.access_log)
new_attributes = self.balancer.get_attributes()
self.assertEqual(True, new_attributes.access_log.enabled)
self.assertEqual(self.bucket_name,
new_attributes.access_log.s3_bucket_name)
self.assertEqual('access-logs',
new_attributes.access_log.s3_bucket_prefix)
self.assertEqual(5, new_attributes.access_log.emit_interval)
def test_load_balancer_get_attributes(self):
attributes = self.balancer.get_attributes()
connection_draining = self.conn.get_lb_attribute(
self.balancer.name, 'ConnectionDraining')
self.assertEqual(connection_draining.enabled,
attributes.connection_draining.enabled)
self.assertEqual(connection_draining.timeout,
attributes.connection_draining.timeout)
access_log = self.conn.get_lb_attribute(self.balancer.name,
'AccessLog')
self.assertEqual(access_log.enabled, attributes.access_log.enabled)
self.assertEqual(access_log.s3_bucket_name,
attributes.access_log.s3_bucket_name)
self.assertEqual(access_log.s3_bucket_prefix,
attributes.access_log.s3_bucket_prefix)
self.assertEqual(access_log.emit_interval,
attributes.access_log.emit_interval)
cross_zone_load_balancing = self.conn.get_lb_attribute(
self.balancer.name, 'CrossZoneLoadBalancing')
self.assertEqual(cross_zone_load_balancing,
attributes.cross_zone_load_balancing.enabled)
def change_and_verify_load_balancer_connection_draining(
self, enabled, timeout=None):
attributes = self.balancer.get_attributes()
attributes.connection_draining.enabled = enabled
if timeout is not None:
attributes.connection_draining.timeout = timeout
self.conn.modify_lb_attribute(self.balancer.name, 'ConnectionDraining',
attributes.connection_draining)
attributes = self.balancer.get_attributes()
self.assertEqual(enabled, attributes.connection_draining.enabled)
if timeout is not None:
self.assertEqual(timeout, attributes.connection_draining.timeout)
def test_load_balancer_connection_draining_config(self):
self.change_and_verify_load_balancer_connection_draining(True, 128)
self.change_and_verify_load_balancer_connection_draining(True, 256)
self.change_and_verify_load_balancer_connection_draining(False)
self.change_and_verify_load_balancer_connection_draining(True, 64)
def test_set_load_balancer_policies_of_listeners(self):
more_listeners = [(443, 8001, 'HTTP')]
self.conn.create_load_balancer_listeners(self.name, more_listeners)
lb_policy_name = 'lb-policy'
self.conn.create_lb_cookie_stickiness_policy(1000, self.name,
lb_policy_name)
self.conn.set_lb_policies_of_listener(self.name, self.listeners[0][0],
lb_policy_name)
# Try to remove the policy by passing empty list.
# http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_SetLoadBalancerPoliciesOfListener.html
# documents this as the way to remove policies.
self.conn.set_lb_policies_of_listener(self.name, self.listeners[0][0],
[])
def test_can_make_sigv4_call(self):
connection = boto.ec2.elb.connect_to_region('eu-central-1')
lbs = connection.get_all_load_balancers()
self.assertTrue(isinstance(lbs, list))
aws_access_key_id = AWS_ACCESS_KEY,
aws_secret_access_key = AWS_SECRET_KEY
)
# ============================================== #
# configure a health check
hc = HealthCheck(
interval=elastic_load_balancer['interval'],
healthy_threshold=elastic_load_balancer['healthyThreshold'],
unhealthy_threshold=elastic_load_balancer['unhealthyThreshold'],
target=elastic_load_balancer['healthCheckTarget']
)
# create a load balancer
lb = conn_elb.create_load_balancer(elastic_load_balancer['name'],
elastic_load_balancer['zones'],
elastic_load_balancer['ports'])
lb.configure_health_check(hc)
print lb.dns_name + " created!"
sleep(10)
# ============================================== #
# ============================================== #
# clear the last execution results
# conn_as.delete_auto_scaling_group('my_group')
# conn_as.delete_launch_configuration('my-launch_config')
# ============================================== #
