def _to_balancer(self, el):
name = findtext(element=el, xpath='LoadBalancerName', namespace=NS)
id = findtext(element=el, xpath='LoadBalancerArn', namespace=NS)
dns_name = findtext(el, xpath='DNSName', namespace=NS)
balancer = LoadBalancer(id=id,
name=name,
state=State.UNKNOWN,
ip=dns_name,
port=None,
driver=self.connection.driver)
extra = {
'listeners': self._ex_get_balancer_listeners(balancer),
'target_groups': self._ex_get_balancer_target_groups(balancer),
'tags': self._ex_get_balancer_tags(balancer)
}
balancer.extra = extra
if len(extra['listeners']) > 0:
balancer.port = extra['listeners'][0]['port']
else:
balancer.port = None
balancer._members = self._ex_get_balancer_memebers(balancer)
return balancer
def test_balancer_detach_member(self):
balancer = LoadBalancer(23530, None, None, None, None, None)
member = self.driver.balancer_list_members(balancer)[0]
ret = self.driver.balancer_detach_member(balancer, member)
self.assertTrue(ret)
def test_balancer_attach_member(self):
balancer = LoadBalancer(23530, None, None, None, None, None)
member = self.driver.balancer_attach_member(balancer,
Member(None, ip='10.0.0.75', port='80'))
self.assertEquals(member.ip, '10.0.0.75')
self.assertEquals(member.port, 80)
def create_balancer(self,
name,
port,
protocol,
algorithm,
members,
ex_members_availability_zones=None):
if ex_members_availability_zones is None:
ex_members_availability_zones = ['a']
params = {
'Action': 'CreateLoadBalancer',
'LoadBalancerName': name,
'Listeners.member.1.InstancePort': str(port),
'Listeners.member.1.InstanceProtocol': protocol.upper(),
'Listeners.member.1.LoadBalancerPort': str(port),
'Listeners.member.1.Protocol': protocol.upper(),
}
for i, z in enumerate(ex_members_availability_zones):
zone = ''.join((self.region, z))
params['AvailabilityZones.member.%d' % (i + 1)] = zone
data = self.connection.request(ROOT, params=params).object
balancer = LoadBalancer(id=name,
name=name,
state=State.PENDING,
ip=findtext(element=data,
xpath='DNSName',
namespace=NS),
port=port,
driver=self.connection.driver)
balancer._members = []
return balancer
def _to_balancer(self, el):
_id = findtext(element=el,
xpath='LoadBalancerId',
namespace=self.namespace)
name = findtext(element=el,
xpath='LoadBalancerName',
namespace=self.namespace)
status = findtext(element=el,
xpath='LoadBalancerStatus',
namespace=self.namespace)
state = STATE_MAPPINGS.get(status, State.UNKNOWN)
address = findtext(element=el,
xpath='Address',
namespace=self.namespace)
extra = self._get_extra_dict(el,
RESOURCE_EXTRA_ATTRIBUTES_MAP['balancer'])
balancer = LoadBalancer(id=_id,
name=name,
state=state,
ip=address,
port=None,
driver=self,
extra=extra)
return balancer
def _to_balancer(self, element):
ipaddress = findtext(element, 'listenerIpAddress', TYPES_URN)
name = findtext(element, 'name', TYPES_URN)
port = findtext(element, 'port', TYPES_URN)
extra = {}
pool_element = element.find(fixxpath('pool', TYPES_URN))
if pool_element is None:
extra['pool_id'] = None
else:
extra['pool_id'] = pool_element.get('id')
extra['network_domain_id'] = findtext(element, 'networkDomainId',
TYPES_URN)
balancer = LoadBalancer(id=element.get('id'),
name=name,
state=self._VALUE_TO_STATE_MAP.get(
findtext(element, 'state', TYPES_URN),
State.UNKNOWN),
ip=ipaddress,
port=port,
driver=self.connection.driver,
extra=extra)
return balancer
def _to_balancer(self, element):
ipaddress = findtext(element, "listenerIpAddress", TYPES_URN)
name = findtext(element, "name", TYPES_URN)
port = findtext(element, "port", TYPES_URN)
extra = {}
pool_element = element.find(fixxpath("pool", TYPES_URN))
if pool_element is None:
extra["pool_id"] = None
else:
extra["pool_id"] = pool_element.get("id")
extra["network_domain_id"] = findtext(element, "networkDomainId",
TYPES_URN)
balancer = LoadBalancer(
id=element.get("id"),
name=name,
state=self._VALUE_TO_STATE_MAP.get(
findtext(element, "state", TYPES_URN), State.UNKNOWN),
ip=ipaddress,
port=port,
driver=self.connection.driver,
extra=extra,
)
return balancer
def _to_balancer(self, data):
return LoadBalancer(id=data['id'],
name=data['name'],
state=self.LB_STATE_MAP.get(
data['status'], State.UNKNOWN),
ip=self._public_ip(data),
port=data['listeners'][0]['in'],
driver=self.connection.driver)
def _to_balancer(self, data):
return LoadBalancer(
id=data["id"],
name=data["name"],
state=self.LB_STATE_MAP.get(data["status"], State.UNKNOWN),
ip=self._public_ip(data),
port=data["listeners"][0]["in"],
driver=self.connection.driver,
)
def _to_balancer(self, el):
lb = LoadBalancer(id=el.get("id"),
name=el["name"],
state=self.LB_STATE_MAP.get(el["state"]["name"],
State.UNKNOWN),
ip=el["virtualip"]["ip"]["ip"],
port=el["virtualip"]["port"],
driver=self.connection.driver)
return lb
def test_update_balancer_port(self):
balancer = LoadBalancer(id='3131',
name='LB_update',
state='PENDING_UPDATE',
ip='10.34.4.3',
port=80,
driver=self.driver)
updated_balancer = self.driver.update_balancer(balancer, port=1337)
self.assertEqual(1337, updated_balancer.port)
def test_ex_update_balancer_no_poll_port(self):
balancer = LoadBalancer(id='3131',
name='LB_update',
state='PENDING_UPDATE',
ip='10.34.4.3',
port=80,
driver=self.driver)
action_succeeded = self.driver.ex_update_balancer_no_poll(balancer,
port=1337)
self.assertTrue(action_succeeded)
def test_ex_update_balancer_no_poll_algorithm(self):
balancer = LoadBalancer(id='3133',
name='LB_update',
state='PENDING_UPDATE',
ip='10.34.4.3',
port=80,
driver=self.driver)
action_succeeded = self.driver.ex_update_balancer_no_poll(
balancer, algorithm=Algorithm.ROUND_ROBIN)
self.assertTrue(action_succeeded)
def test_balancer_attach_member(self):
balancer = LoadBalancer(23530, None, None, None, None, self.driver)
member = Member(None, ip='10.0.0.75', port='80')
member1 = self.driver.balancer_attach_member(balancer, member=member)
member2 = balancer.attach_member(member=member)
self.assertEqual(member1.ip, '10.0.0.75')
self.assertEqual(member1.port, 80)
self.assertEqual(member2.ip, '10.0.0.75')
self.assertEqual(member2.port, 80)
def _to_balancer(self, obj):
balancer = LoadBalancer(id=obj['id'],
name=obj['name'],
state=obj['state'],
ip=obj['publicip'],
port=obj['publicport'],
driver=self.connection.driver)
balancer.ex_private_port = obj['privateport']
balancer.ex_public_ip_id = obj['publicipid']
return balancer
def test_update_balancer_name(self):
balancer = LoadBalancer(id='3132',
name='LB_update',
state='PENDING_UPDATE',
ip='10.34.4.3',
port=80,
driver=self.driver)
updated_balancer = self.driver.update_balancer(balancer,
name='new_lb_name')
self.assertEqual('new_lb_name', updated_balancer.name)
def test_update_balancer_protocol(self):
balancer = LoadBalancer(id='3130',
name='LB_update',
state='PENDING_UPDATE',
ip='10.34.4.3',
port=80,
driver=self.driver)
updated_balancer = self.driver.update_balancer(balancer,
protocol='HTTPS')
self.assertEqual('HTTPS', updated_balancer.extra['protocol'])
def test_balancer_attach_compute_node(self):
balancer = LoadBalancer(23530, None, None, None, None, self.driver)
node = Node(id='1', name='test', state=None, public_ips=['10.0.0.75'],
private_ips=[], driver=DummyNodeDriver)
member1 = self.driver.balancer_attach_compute_node(balancer, node)
member2 = balancer.attach_compute_node(node)
self.assertEqual(member1.ip, '10.0.0.75')
self.assertEqual(member1.port, 80)
self.assertEqual(member2.ip, '10.0.0.75')
self.assertEqual(member2.port, 80)
def test_update_balancer_algorithm(self):
balancer = LoadBalancer(id='3133',
name='LB_update',
state='PENDING_UPDATE',
ip='10.34.4.3',
port=80,
driver=self.driver)
updated_balancer = self.driver.update_balancer(
balancer, algorithm=Algorithm.ROUND_ROBIN)
self.assertEqual(Algorithm.ROUND_ROBIN,
updated_balancer.extra['algorithm'])
def _to_balancer(self, obj):
balancer = LoadBalancer(
id=obj["id"],
name=obj["name"],
state=self.LB_STATE_MAP.get(obj["state"], State.UNKNOWN),
ip=obj["publicip"],
port=obj["publicport"],
driver=self.connection.driver,
)
balancer.ex_private_port = obj["privateport"]
balancer.ex_public_ip_id = obj["publicipid"]
return balancer
def test_destroy_balancer(self):
extra = {
'pool_id': '4d360b1f-bc2c-4ab7-9884-1f03ba2768f7',
'network_domain_id': '1234'
}
balancer = LoadBalancer(id='234',
name='test',
state=State.RUNNING,
ip='1.2.3.4',
port=1234,
driver=self.driver,
extra=extra)
response = self.driver.destroy_balancer(balancer)
self.assertEqual(response, True)
def test_ex_update_balancer_no_poll_bad_algorithm_exception(self):
balancer = LoadBalancer(id='3134',
name='LB_update',
state='PENDING_UPDATE',
ip='10.34.4.3',
port=80,
driver=self.driver)
try:
self.driver.update_balancer(balancer,
algorithm='HAVE_MERCY_ON_OUR_SERVERS')
except LibcloudError:
pass
else:
self.fail('Should have thrown exception with bad algorithm value')
def __init__(self):
self._TEST_BALANCER = LoadBalancer(
id='test_id',
name='test_balancer',
state=0, # RUNNING
ip='1.2.3.4',
port=80,
driver=self,
extra={})
self._TEST_MEMBER = Member(id='member_id',
ip='12.3.4.5',
port=443,
balancer=self._TEST_BALANCER,
extra=None)
def test_destroy_balancer(driver):
extra = {
"pool_id": "4d360b1f-bc2c-4ab7-9884-1f03ba2768f7",
"network_domain_id": "1234",
}
balancer = LoadBalancer(
id="234",
name="test",
state=State.RUNNING,
ip="1.2.3.4",
port=1234,
driver=driver,
extra=extra,
)
response = driver.destroy_balancer(balancer)
assert response is True
def test_balancer_list_members(self):
extra = {
'pool_id': '4d360b1f-bc2c-4ab7-9884-1f03ba2768f7',
'network_domain_id': '1234'
}
balancer = LoadBalancer(id='234',
name='test',
state=State.RUNNING,
ip='1.2.3.4',
port=1234,
driver=self.driver,
extra=extra)
members = self.driver.balancer_list_members(balancer)
self.assertEqual(2, len(members))
self.assertEqual(members[0].ip, '10.0.3.13')
self.assertEqual(members[0].id, '3dd806a2-c2c8-4c0c-9a4f-5219ea9266c0')
self.assertEqual(members[0].port, 9889)
def test_balancer_list_members(driver):
extra = {
'pool_id': '4d360b1f-bc2c-4ab7-9884-1f03ba2768f7',
'network_domain_id': '1234'
}
balancer = LoadBalancer(id='234',
name='test',
state=State.RUNNING,
ip='1.2.3.4',
port=1234,
driver=driver,
extra=extra)
members = driver.balancer_list_members(balancer)
assert 2 == len(members)
assert members[0].ip == '10.0.3.13'
assert members[0].id == '3dd806a2-c2c8-4c0c-9a4f-5219ea9266c0'
assert members[0].port == 9889
def __init__(self): # pylint: disable=W0231
self._TEST_BALANCER = LoadBalancer(
id="test_id",
name="test_balancer",
state=0, # RUNNING
ip="1.2.3.4",
port=80,
driver=self,
extra={},
)
self._TEST_MEMBER = Member(
id="member_id",
ip="12.3.4.5",
port=443,
balancer=self._TEST_BALANCER,
extra=None,
)
def _to_balancer(self, el):
ip = None
port = None
if 'virtualIps' in el:
ip = el["virtualIps"][0]["address"]
if 'port' in el:
port = el["port"]
lb = LoadBalancer(id=el["id"],
name=el["name"],
state=self.LB_STATE_MAP.get(el["status"],
State.UNKNOWN),
ip=ip,
port=port,
driver=self.connection.driver)
return lb
def test_balancer_list_members(driver):
extra = {
"pool_id": "4d360b1f-bc2c-4ab7-9884-1f03ba2768f7",
"network_domain_id": "1234",
}
balancer = LoadBalancer(
id="234",
name="test",
state=State.RUNNING,
ip="1.2.3.4",
port=1234,
driver=driver,
extra=extra,
)
members = driver.balancer_list_members(balancer)
assert 2 == len(members)
assert members[0].ip == "10.0.3.13"
assert members[0].id == "3dd806a2-c2c8-4c0c-9a4f-5219ea9266c0"
assert members[0].port == 9889
def test_balancer_detach_member(self):
extra = {
'pool_id': '4d360b1f-bc2c-4ab7-9884-1f03ba2768f7',
'network_domain_id': '1234'
}
balancer = LoadBalancer(id='234',
name='test',
state=State.RUNNING,
ip='1.2.3.4',
port=1234,
driver=self.driver,
extra=extra)
member = Member(id='3dd806a2-c2c8-4c0c-9a4f-5219ea9266c0',
ip='112.12.2.2',
port=80,
balancer=balancer,
extra=None)
result = self.driver.balancer_detach_member(balancer, member)
self.assertEqual(result, True)
