"""Wrapper for neutron load balancer vip."""

def __init__(self, vip, listener=None, pool=None, members=None,

monitors=None, profile_name=None, cert=None, key=None,

chain=None):

vip['pool'] = pool

pool['members'] = members

pool['monitors'] = monitors

# vip['cert_name'] = cert_name

vip['listener'] = listener

vip['cert'] = cert

vip['key'] = key

vip['chain'] = chain

vip['profile_name'] = profile_name

super(LBDetails, self).__init__(vip)

class AttributeDict(dict):

def __getattr__(self, attr):

return self[attr]

def __setattr__(self, attr, value):

self[attr] = value

def convert_status(self, value):

return "Enabled" if value else "Disabled"

def readable(self, request=None):

pFormatted = {'id': self.id,

'name': self.name,

'dns_name': self.name,

# 'lb_method': self.lb_method,

'description': self.description,

# 'protocol': self.protocol,

'address': self.vip_address,

# 'port': self.port,

'enabled': self.convert_status(self.admin_state_up),

'use_common_cert': False,

'provisioning_status': self.provisioning_status,

'operating_status': self.operating_status,

# 'monitor' : self.monitor

}

# status_string = 'vip: %s' % self['status'].lower()

pFormatted['status'] = 'na'

# if self.profile_name:

# try:

# if self.profile_name.upper() ==

# _construct_common_cert_profile_name(request).upper():

# pFormatted['use_common_cert'] = True

# pFormatted['cert_name'] = self.profile_name

# else:

# pFormatted['use_common_cert'] = False

# pFormatted['cert_name'] = self.profile_name

# pFormatted['cert'] = self.cert

# pFormatted['private_key'] = self.key

# pFormatted['chain_cert'] = self.chain

# except Exception as e:

# LOG.error("unable to read cert")

if self.listener is not None:

try:

listener = self.AttributeDict(self.listener)

pFormatted['protocol'] = listener.protocol

pFormatted['port'] = listener.protocol_port

except Exception:

pass

if self.pool is not None:

try:

pool = self.AttributeDict(self.pool)

# status_string = '%s \n pool: %s' % (pFormatted['status'],

# pool['status'].lower())

# pFormatted['status'] = status_string

pFormatted['pool'] = pool

pFormatted['pool_id'] = pool.id

pFormatted['lb_method'] = pool.lb_algorithm

if pool.members is not None:

try:

ips = []

pool_members = []

for m in pool.members:

member = self.AttributeDict(m)

pFormatted['instance_port'] = member.protocol_port

pool_member = member

pool_member.port = member.protocol_port

pool_members.append(pool_member)

ips.append(member.address)

pFormatted['pool']['members'] = pool_members

pFormatted['members'] = ips

except Exception:

pass # ignore

if pool.monitors is not None:

try:

for m in pool.monitors:

monitor = self.AttributeDict(m)

# monitor_status =_get_monitor_status(pool['id'],m)

# status_string = '%s \n monitor: %s' %

# (pFormatted['status'], monitor_status.lower())

# pFormatted['status'] = status_string

interval = int(monitor.delay)

# timeout = int(monitor.timeout)

retry = int(monitor.max_retries)

monitor_type = 'http-ecv'

# if monitor.name.upper() in basic_monitors:

# monitor_type = monitor.name

monitor_type = monitor.name

pFormatted['pool']['monitor'] = monitor_type

pFormatted['monitor'] = monitor_type

pFormatted['interval'] = interval

pFormatted['timeout'] = retry

pFormatted['send'] = monitor.url_path \

if hasattr(monitor, 'url_path') else ''

pFormatted['receive'] = monitor.response_string \

if hasattr(monitor, 'response_string') else ''

break

except Exception:

pass # ignore

except Exception:

pass # ignore

if 'cert_name' not in pFormatted:

pFormatted['cert_name'] = ''

if 'cert' not in pFormatted:

pFormatted['cert'] = ''

if 'private_key' not in pFormatted:

pFormatted['private_key'] = ''

if 'chain_cert' not in pFormatted:

pFormatted['chain_cert'] = ''

if 'pool_id' not in pFormatted:

pFormatted['pool_id'] = 'UNKNOWN'

if 'lb_method' not in pFormatted:

pFormatted['lb_method'] = 'UNKNOWN'

if 'monitor' not in pFormatted:

pFormatted['monitor'] = 'None'

# if 'monitor' not in pFormatted['pool']:

# pFormatted['pool']['monitor'] = 'None'

if 'interval' not in pFormatted:

pFormatted['interval'] = 1

if 'timeout' not in pFormatted:

pFormatted['timeout'] = 1

if 'send' not in pFormatted:

pFormatted['send'] = None

if 'receive' not in pFormatted:

pFormatted['receive'] = None

if 'members' not in pFormatted:

pFormatted['members'] = []

if 'instance_port' not in pFormatted:

pFormatted['instance_port'] = ''

"""Wrapper for neutron load balancer vip."""

def __init__(self, apiresource):

"""Wrapper for neutron load balancer pool."""

def __init__(self, apiresource):

if 'provider' not in apiresource:

apiresource['provider'] = None

"""Wrapper for neutron load balancer member."""

def __init__(self, apiresource):

"""Wrapper for neutron load balancer pool stats."""

def __init__(self, apiresource):

"""Wrapper for neutron load balancer pool health monitor."""

def __init__(self, apiresource):

"""Create a vip for a specified pool.

:param request: request context

:param address: virtual IP address

:param name: name for vip

:param description: description for vip

:param subnet_id: subnet_id for subnet of vip

:param protocol_port: transport layer port number for vip

:returns: Vip object

"""

body = {'vip': {'name': kwargs['name'],

'description': kwargs['description'],

'subnet_id': kwargs['subnet_id'],

'protocol_port': kwargs['protocol_port'],

'protocol': kwargs['protocol'],

'pool_id': kwargs['pool_id'],

'session_persistence': kwargs['session_persistence'],

'admin_state_up': kwargs['admin_state_up']

}}

if kwargs.get('connection_limit'):

body['vip']['connection_limit'] = kwargs['connection_limit']

if kwargs.get('address'):

body['vip']['address'] = kwargs['address']

vip = neutronclient(request).create_vip(body).get('vip')

loadbalancer_body = {'loadbalancer': {'name': kwargs['name'],

'description': kwargs['description'],

'vip_subnet_id': kwargs['subnet_id'],

'admin_state_up':

kwargs['admin_state_up'],

'vip_address': kwargs['address'],

# 'provider': 'HAProxy'

}}

listener_body = {'listener': {'name': kwargs['name'],

'description': kwargs['description'],

'protocol': kwargs['protocol'],

'protocol_port': kwargs['protocol_port'],

'default_tls_container_id': None,

'sni_container_ids': [],

'connection_limit': 100,

'admin_state_up': kwargs['admin_state_up'],

'loadbalancer_id': None}}

pool_body = {'pool': {'name': kwargs['name'],

'description': kwargs['description'],

'protocol': kwargs['protocol'],

'lb_method': kwargs['lb_method'],

'admin_state_up': kwargs['admin_state_up']

}}

member_body = {'member': {'pool_id': kwargs['pool_id'],

'address': kwargs['address'],

'protocol_port': kwargs['protocol_port'],

'admin_state_up': kwargs['admin_state_up'],

'pool_id': None

}}

if kwargs.get('weight'):

member_body['member']['weight'] = kwargs['weight']

monitor_type = kwargs['type'].upper()

health_monitor_body = {'health_monitor': {'tenant_id': kwargs['tenant_id'],

'type': monitor_type,

'delay': kwargs['delay'],

'timeout': kwargs['timeout'],

'max_retries':

kwargs['max_retries'],

'admin_state_up':

kwargs['admin_state_up'],

'pool_id': None

}

}

if monitor_type in ['HTTP', 'HTTPS']:

health_mon = health_monitor_body['health_monitor']

health_mon['http_method'] = kwargs['http_method']

health_mon['url_path'] = kwargs['url_path']

health_mon['expected_codes'] = kwargs['expected_codes']

try:

client = neutronclient(request)

loadbalancer = client.\

create_loadbalancer(loadbalancer_body).get('loadbalancer')

listener_body['listener']['loadbalancer_id'] = loadbalancer['id']

listener = client.\

create_listener(listener_body).get('listener')

pool = client.create_lbaas_pool(pool_body).get('pool')

member_body['member']['pool_id'] = pool['id']

health_monitor_body['health_monitor']['pool_id'] = pool['id']

health_monitor = client.create_lbaas_healthmonitor(health_monitor_body)\

.get('health_monitor')

member = client.create_lbaas_member(member_body).get('member')

except Exception:

raise Exception(_("Could not create full loadbalancer."))

vips = neutronclient(request).list_loadbalancers(**kwargs)

vips = [] if not vips else vips

vips = vips.get('loadbalancers')

for vip in vips:

listeners = vip.get('listeners')

listeners = [] if not listeners else listeners

for listener in listeners:

listener = neutronclient(request).show_listener(listener.get('id'),

**kwargs)

if not listener:

continue

listener = listener.get('listener')

try:

pool = neutronclient(request).\

show_lbaas_pool(listener.get('default_pool_id'), **kwargs)

if not pool:

continue

pool = pool.get('pool')

if pool.get('healthmonitor_id'):

health_monitor = neutronclient(request).\

show_lbaas_healthmonitor(pool.get('healthmonitor_id'),

**kwargs)

health_monitor = health_monitor.get('healthmonitor')

members = neutronclient(request).\

list_lbaas_members(listener.get('default_pool_id'),

**kwargs)

except Exception:

raise Exception(_("Could not get load balancer list."))

return [LBDetails(v, listener, pool, members, health_monitor)

vip = neutronclient(request).show_loadbalancer(lbaas_loadbalancer,

**kwargs)

if not vip:

return

loadbalancer = vip.get('loadbalancer')

viplisteners = loadbalancer.get('listeners')

if not viplisteners:

return

for viplistener in viplisteners:

listener = neutronclient(request).\

show_listener(viplistener.get('id'), **kwargs)

if not listener:

continue

listener = listener.get('listener')

pool = neutronclient(request).\

show_lbaas_pool(listener.get('default_pool_id'), **kwargs)

if not pool:

continue

pool = pool.get('pool')

health_monitor = None

if pool.get('healthmonitor_id'):

health_monitor = neutronclient(request).\

show_lbaas_healthmonitor(pool.get('healthmonitor_id'),

**kwargs)

health_monitor = health_monitor.get('healthmonitor')

members = neutronclient(request).\

list_lbaas_members(listener.get('default_pool_id'), **kwargs)

return LBDetails(vip.get('loadbalancer'), listener, pool, members,

vip = neutronclient(request).show_vip(vip_id).get('vip')

if expand_resource:

vip['subnet'] = neutron.subnet_get(request, vip['subnet_id'])

vip['port'] = neutron.port_get(request, vip['port_id'])

vip['pool'] = _pool_get(request, vip['pool_id'])

"""Create a pool for specified protocol

:param request: request context

:param name: name for pool

:param description: description for pool

:param subnet_id: subnet_id for subnet of pool

:param protocol: load balanced protocol

:param lb_method: load balancer method

:param admin_state_up: admin state (default on)

"""

body = {'pool': {'name': kwargs['name'],

'description': kwargs['description'],

'subnet_id': kwargs['subnet_id'],

'protocol': kwargs['protocol'],

'lb_method': kwargs['lb_method'],

'admin_state_up': kwargs['admin_state_up'],

'provider': kwargs['provider'],

}}

pool = neutronclient(request).create_pool(body).get('pool')

if pool['vip_id'] is not None:

try:

if vip_dict:

vip = vip_dict.get(pool['vip_id'])

else:

vip = _vip_get(request, pool['vip_id'])

except Exception:

messages.warning(request, _("Unable to get VIP for pool "

"%(pool)s.") % {"pool": pool["id"]})

vip = Vip({'id': pool['vip_id'], 'name': ''})

if expand_name_only:

vip = vip.name_or_id

return vip

else:

pools = neutronclient(request).list_pools(**kwargs).get('pools')

if expand_subnet:

subnets = neutron.subnet_list(request)

subnet_dict = SortedDict((s.id, s) for s in subnets)

for p in pools:

subnet = subnet_dict.get(p['subnet_id'])

p['subnet_name'] = subnet.cidr if subnet else None

if expand_vip:

vips = vip_list(request)

vip_dict = SortedDict((v.id, v) for v in vips)

for p in pools:

p['vip_name'] = _get_vip(request, p, vip_dict,

expand_name_only=True)

try:

pool = neutronclient(request).show_pool(pool_id).get('pool')

except Exception:

messages.warning(request, _("Unable to get pool detail."))

return None

if expand_resource:

# TODO(lyj): The expand resource(subnet, member etc.) attached

# to a pool could be deleted without cleanup pool related database,

# this will cause exceptions if we trying to get the deleted resources.

# so we need to handle the situation by showing a warning message here.

# we can safely remove the try/except once the neutron bug is fixed

# https://bugs.launchpad.net/neutron/+bug/1406854

try:

pool['subnet'] = neutron.subnet_get(request, pool['subnet_id'])

except Exception:

messages.warning(request, _("Unable to get subnet for pool "

"%(pool)s.") % {"pool": pool_id})

pool['vip'] = _get_vip(request, pool, vip_dict=None,

expand_name_only=False)

try:

pool['members'] = _member_list(request, expand_pool=False,

pool_id=pool_id)

except Exception:

messages.warning(request, _("Unable to get members for pool "

"%(pool)s.") % {"pool": pool_id})

try:

pool['health_monitors'] = pool_health_monitor_list(

request, id=pool['health_monitors'])

except Exception:

messages.warning(request,

_("Unable to get health monitors "

"for pool %(pool)s.") % {"pool": pool_id})

"""Create a health monitor

:param request: request context

:param type: type of monitor

:param delay: delay of monitor

:param timeout: timeout of monitor

:param max_retries: max retries [1..10]

:param http_method: http method

:param url_path: url path

:param expected_codes: http return code

:param admin_state_up: admin state

"""

monitor_type = kwargs['type'].upper()

body = {'health_monitor': {'type': monitor_type,

'delay': kwargs['delay'],

'timeout': kwargs['timeout'],

'max_retries': kwargs['max_retries'],

'admin_state_up': kwargs['admin_state_up']

}}

if monitor_type in ['HTTP', 'HTTPS']:

body['health_monitor']['http_method'] = kwargs['http_method']

body['health_monitor']['url_path'] = kwargs['url_path']

body['health_monitor']['expected_codes'] = kwargs['expected_codes']

mon = neutronclient(request).create_health_monitor(body).get(

'health_monitor')

monitor = neutronclient(request

).show_health_monitor(monitor_id

).get('health_monitor')

if expand_resource:

pool_ids = [p['pool_id'] for p in monitor['pools']]

monitor['pools'] = _pool_list(request, id=pool_ids)

"""Create a load balance member

:param request: request context

:param pool_id: pool_id of pool for member

:param address: IP address

:param protocol_port: transport layer port number

:param weight: weight for member

:param admin_state_up: admin_state

"""

body = {'member': {'pool_id': kwargs['pool_id'],

'address': kwargs['address'],

'protocol_port': kwargs['protocol_port'],

'admin_state_up': kwargs['admin_state_up']

}}

if kwargs.get('weight'):

body['member']['weight'] = kwargs['weight']

member = neutronclient(request).create_member(body).get('member')

members = neutronclient(request).list_members(**kwargs).get('members')

if expand_pool:

pools = _pool_list(request)

pool_dict = SortedDict((p.id, p) for p in pools)

for m in members:

m['pool_name'] = pool_dict.get(m['pool_id']).name_or_id

member = neutronclient(request).show_member(member_id).get('member')

if expand_pool:

member['pool'] = _pool_get(request, member['pool_id'])

"""Associate a health monitor with pool

:param request: request context

:param monitor_id: id of monitor

:param pool_id: id of pool

"""

body = {'health_monitor': {'id': kwargs['monitor_id'], }}

neutronclient(request).associate_health_monitor(

"""Disassociate a health monitor from pool

:param request: request context

:param monitor_id: id of monitor

:param pool_id: id of pool

"""

neutronclient(request).disassociate_health_monitor(