def startElement(self, name, attrs, connection):
if name == 'HealthCheck':
self.health_check = HealthCheck(self)
return self.health_check
elif name == 'ListenerDescriptions':
self.listeners = ResultSet([('member', Listener)])
return self.listeners
elif name == 'AvailabilityZones':
return self.availability_zones
elif name == 'Instances':
self.instances = ResultSet([('member', InstanceInfo)])
return self.instances
elif name == 'Policies':
self.policies = Policies(self)
return self.policies
elif name == 'SourceSecurityGroup':
self.source_security_group = SecurityGroup()
return self.source_security_group
elif name == 'Subnets':
return self.subnets
elif name == 'SecurityGroups':
return self.security_groups
elif name == 'VPCId':
pass
else:
return None
def _set_health_check(self):
"""Set health check values on ELB as needed"""
if self.health_check:
# This just makes it easier to compare each of the attributes
# and look for changes. Keys are attributes of the current
# health_check; values are desired values of new health_check
health_check_config = {
"target": self._get_health_check_target(),
"timeout": self.health_check['response_timeout'],
"interval": self.health_check['interval'],
"unhealthy_threshold": self.health_check['unhealthy_threshold'],
"healthy_threshold": self.health_check['healthy_threshold'],
}
update_health_check = False
# The health_check attribute is *not* set on newly created
# ELBs! So we have to create our own.
if not self.elb.health_check:
self.elb.health_check = HealthCheck()
for attr, desired_value in health_check_config.iteritems():
if getattr(self.elb.health_check, attr) != desired_value:
setattr(self.elb.health_check, attr, desired_value)
update_health_check = True
if update_health_check:
self.elb.configure_health_check(self.elb.health_check)
self.changed = True
def startElement(self, name, attrs, connection):
if name == 'HealthCheck':
self.health_check = HealthCheck(self)
return self.health_check
elif name == 'ListenerDescriptions':
self.listeners = ResultSet([('member', Listener)])
return self.listeners
elif name == 'AvailabilityZones':
return self.availability_zones
elif name == 'BackendInstances':
self.instances = ResultSet([('member', BackendInstance)])
return self.instances
elif name == 'PolicyDescriptions':
self.policy_descriptions = ResultSet([('member', PolicyDescription)])
return self.policy_descriptions
elif name == 'SourceSecurityGroup':
self.source_security_group = SecurityGroup()
return self.source_security_group
elif name == 'Subnets':
return self.subnets
elif name == 'SecurityGroups':
return self.security_groups
elif name == 'VPCId':
pass
elif name == "BackendServerDescriptions":
self.backends = ResultSet([('member', Backend)])
return self.backends
elif name == "LoadBalancerAttributes":
self.attributes = LbAttributes(self)
return self.attributes
else:
return None
def create_healthcheck(self, target="HTTP:80/instance-name", interval=10, timeout=5, healthy_threshold=2,
unhealthy_threshold=10):
self.debug("Creating healthcheck: " + target + " interval=" + str(interval) + " timeout=" + str(timeout) +
" healthy threshold=" + str(healthy_threshold) + " unhealthy threshold=" + str(unhealthy_threshold))
healthcheck = HealthCheck(target=target,
timeout=timeout,
interval=interval,
healthy_threshold=healthy_threshold,
unhealthy_threshold=unhealthy_threshold)
return healthcheck
def startElement(self, name, attrs, connection):
if name == 'HealthCheck':
self.health_check = HealthCheck(self)
return self.health_check
elif name == 'Listeners':
self.listeners = ResultSet([('member', Listener)])
return self.listeners
elif name == 'AvailabilityZones':
return self.availability_zones
elif name == 'Instances':
self.instances = ResultSet([('member', InstanceInfo)])
return self.instances
else:
return None
def _update_server(self, **kwargs):
conn = get_ec2_connection(server_type='ec2', **kwargs)
elb_conn = get_ec2_connection(server_type='elb', **kwargs)
zones = [z.name for z in conn.get_all_zones()]
context = self.get_context()
lb_name = context.get('lb_name')
listeners = context.get('listeners')
connections = env.config_object.get_list('app-server',
env.config_object.CONNECTIONS)
instances = set(self.get_instance_id_by_connections(connections))
if len(instances) == 0:
print "Cannot find any ec2 instances match your connections"
sys.exit(1)
elb = self._get_elb(elb_conn, lb_name)
print "find load balancer %s" % lb_name
if not elb:
elb = elb_conn.create_load_balancer(lb_name, zones, listeners)
print "load balancer %s successfully created" % lb_name
elb_instances = set([x.id for x in elb.instances])
to_remove = elb_instances - instances
to_add = instances - elb_instances
if to_add:
elb.register_instances(to_add)
print "register instances into load balancer"
print to_add
if to_remove:
print "remove instances from load balancer"
print to_remove
elb.deregister_instances(list(to_remove))
hc_policy = context.get('hc_policy')
if not hc_policy:
hc_policy = self.hc_policy
print "Configure load balancer health check policy"
hc = HealthCheck(**hc_policy)
elb.configure_health_check(hc)
def _create_health_check(user_health_check):
health_check = {
'interval': constants.HEALTH_CHECK_INTERVAL,
'healthy_threshold': constants.HEALTH_CHECK_HEALTHY_THRESHOLD,
'timeout': constants.HEALTH_CHECK_TIMEOUT,
'unhealthy_threshold': constants.HEALTH_CHECK_UNHEALTHY_THRESHOLD
}
health_check.update(user_health_check)
try:
health_check = HealthCheck(**health_check)
except boto.exception.BotoClientError as e:
raise NonRecoverableError(
'Health Check not created due to bad definition: '
'{0}'.format(str(e)))
return health_check
if __name__ == "__main__":
instance_id = 'i-2023dc50'
# make some calls to proxy class to test things out
client = UIProxyClient()
client.login('localhost', '8888', 'ui-test-acct-03', 'admin',
'mypassword6')
print "=== Getting Load Balancers ==="
print client.get_all_load_balancers()
print "=== Create Load Balancer ==="
listener = '80', '8888', 'HTTP'
print client.create_load_balancer('testbalancer', ['cluster01'],
[listener])
print client.get_all_load_balancers()
print "=== Registering Instance ==="
print client.register_instances('testbalancer', [instance_id])
print "=== Configuring Health Check ==="
print client.configure_health_check('testbalancer',
HealthCheck(target='HTTP:80/hc/test'))
print "=== Create LB liistener ==="
listener = '2022', '8022', 'TCP'
print client.create_load_balancer_listeners('testbalancer', [listener])
print "=== Getting Instance Health ==="
print client.describe_instance_health('testbalancer')
print "=== Delete LB liistener ==="
print client.delete_load_balancer_listeners('testbalancer', ['443'])
print "=== Deregistering Instance ==="
print client.deregister_instances('testbalancer', [instance_id])
print "=== Delete Load Balancer ==="
print client.delete_load_balancer('testbalancer')
def post(self):
if not self.authorized():
raise tornado.web.HTTPError(401, "not authorized")
if not(self.user_session.elb):
if self.should_use_mock():
self.user_session.elb = MockBalanceInterface()
else:
host = eucaconsole.config.get('server', 'clchost')
if self.user_session.host_override:
host = self.user_session.host_override
self.user_session.elb = BotoBalanceInterface(host,
self.user_session.access_key,
self.user_session.secret_key,
self.user_session.session_token)
# could make this conditional, but add caching always for now
self.user_session.elb = CachingBalanceInterface(self.user_session.elb, eucaconsole.config)
self.user_session.session_lifetime_requests += 1
try:
action = self.get_argument("Action")
if action.find('Get') == -1:
self.user_session.session_last_used = time.time()
self.check_xsrf_cookie()
if action == 'CreateLoadBalancer':
azones = self.get_argument_list('AvailabilityZones.member')
listeners = self.get_listener_args()
name = self.get_argument('LoadBalancerName')
scheme = self.get_argument('Scheme', 'internet-facing')
groups = self.get_argument_list('SecurityGroups.member')
subnets = self.get_argument_list('Subnets.member')
self.user_session.elb.create_load_balancer(name, azones, listeners, subnets, groups, scheme, self.callback)
elif action == 'DeleteLoadBalancer':
name = self.get_argument('LoadBalancerName')
self.user_session.elb.delete_load_balancer(name, self.callback)
elif action == 'DescribeLoadBalancers':
names = self.get_argument_list('LoadBalancerNames.member')
self.user_session.elb.get_all_load_balancers(names, self.callback)
elif action == 'DeregisterInstancesFromLoadBalancer':
name = self.get_argument('LoadBalancerName')
instances = self.get_argument_list('Instances.member')
self.user_session.elb.deregister_instances(name, instances, self.callback)
elif action == 'RegisterInstancesWithLoadBalancer':
name = self.get_argument('LoadBalancerName')
instances = self.get_argument_list('Instances.member')
self.user_session.elb.register_instances(name, instances, self.callback)
elif action == 'CreateLoadBalancerListeners':
name = self.get_argument('LoadBalancerName')
listeners = self.get_listener_args()
self.user_session.elb.create_load_balancer_listeners(name, listeners, self.callback)
elif action == 'DeleteLoadBalancerListeners':
name = self.get_argument('LoadBalancerName')
ports = self.get_argument_list('LoadBalancerPorts.member')
self.user_session.elb.delete_load_balancer_listeners(name, ports, self.callback)
elif action == 'ConfigureHealthCheck':
name = self.get_argument('LoadBalancerName')
timeout = self.get_argument('HealthCheck.Timeout')
target = self.get_argument('HealthCheck.Target')
interval = self.get_argument('HealthCheck.Interval')
unhealthy = self.get_argument('HealthCheck.UnhealthyThreshold')
healthy = self.get_argument('HealthCheck.HealthyThreshold')
hc = HealthCheck(timeout=timeout, target=target, interval=interval,
unhealthy_threshold=unhealthy, healthy_threshold=healthy)
self.user_session.elb.configure_health_check(name, hc, self.callback)
elif action == 'DescribeInstanceHealth':
name = self.get_argument('LoadBalancerName')
instances = self.get_argument_list('Instances.member')
self.user_session.elb.describe_instance_health(name, instances, self.callback)
except Exception as ex:
logging.error("Could not fulfill request, exception to follow")
logging.error("Since we got here, client likely not notified either!")
logging.exception(ex)
