Horizon UI support for Octavia
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

682 lines
26 KiB

# Copyright 2015, eBay Inc.
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from __future__ import absolute_import
import collections
from django.utils.translation import ugettext_lazy as _
from horizon import messages
from openstack_dashboard.api import neutron
neutronclient = neutron.neutronclient
class LBDetails(neutron.NeutronAPIDictWrapper):
"""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,
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:
listener = self.AttributeDict(self.listener)
pFormatted['protocol'] = listener.protocol
pFormatted['port'] = listener.protocol_port
except Exception:
if self.pool is not None:
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:
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
pFormatted['pool']['members'] = pool_members
pFormatted['members'] = ips
except Exception:
pass # ignore
if pool.monitors is not None:
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 ''
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'] = ''
return self.AttributeDict(pFormatted)
class Vip(neutron.NeutronAPIDictWrapper):
"""Wrapper for neutron load balancer vip."""
def __init__(self, apiresource):
super(Vip, self).__init__(apiresource)
class Pool(neutron.NeutronAPIDictWrapper):
"""Wrapper for neutron load balancer pool."""
def __init__(self, apiresource):
if 'provider' not in apiresource:
apiresource['provider'] = None
super(Pool, self).__init__(apiresource)
class Member(neutron.NeutronAPIDictWrapper):
"""Wrapper for neutron load balancer member."""
def __init__(self, apiresource):
super(Member, self).__init__(apiresource)
class PoolStats(neutron.NeutronAPIDictWrapper):
"""Wrapper for neutron load balancer pool stats."""
def __init__(self, apiresource):
super(PoolStats, self).__init__(apiresource)
class PoolMonitor(neutron.NeutronAPIDictWrapper):
"""Wrapper for neutron load balancer pool health monitor."""
def __init__(self, apiresource):
super(PoolMonitor, self).__init__(apiresource)
def vip_create(request, **kwargs):
"""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')
return Vip(vip)
def vip_list(request, **kwargs):
vips = neutronclient(request).list_vips(**kwargs).get('vips')
return [Vip(v) for v in vips]
def create_loadbalancer_full(request, **kwargs):
loadbalancer_body = {'loadbalancer': {'name': kwargs['name'],
'description': kwargs['description'],
'vip_subnet_id': kwargs['subnet_id'],
'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'],
'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']
client = neutronclient(request)
loadbalancer = client.\
listener_body['listener']['loadbalancer_id'] = loadbalancer['id']
listener = client.\
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)\
member = client.create_lbaas_member(member_body).get('member')
except Exception:
raise Exception(_("Could not create full loadbalancer."))
return [LBDetails(loadbalancer, listener, pool, member, health_monitor)]
def list_loadbalancers(request, **kwargs):
vips = neutronclient(request).list_loadbalancers(**kwargs)
vips = [] if not vips else vips
vips = vips.get('loadbalancers')
lbaas_list = []
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'),
if not listener:
listener = listener.get('listener')
pool = neutronclient(request).\
show_lbaas_pool(listener.get('default_pool_id'), **kwargs)
if not pool:
pool = pool.get('pool')
if pool.get('healthmonitor_id'):
health_monitor = neutronclient(request).\
health_monitor = health_monitor.get('healthmonitor')
health_monitor = None
members = neutronclient(request).\
lbaas_list.append(LBDetails(vip, listener, pool,
members, health_monitor))
except Exception:
raise Exception(_("Could not get load balancer list."))
return lbaas_list
def show_loadbalancer(request, lbaas_loadbalancer, **kwargs):
vip = neutronclient(request).show_loadbalancer(lbaas_loadbalancer,
if not vip:
loadbalancer = vip.get('loadbalancer')
viplisteners = loadbalancer.get('listeners')
if not viplisteners:
for viplistener in viplisteners:
listener = neutronclient(request).\
show_listener(viplistener.get('id'), **kwargs)
if not listener:
listener = listener.get('listener')
pool = neutronclient(request).\
show_lbaas_pool(listener.get('default_pool_id'), **kwargs)
if not pool:
pool = pool.get('pool')
health_monitor = None
if pool.get('healthmonitor_id'):
health_monitor = neutronclient(request).\
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,
def vip_get(request, vip_id):
return _vip_get(request, vip_id, expand_resource=True)
def _vip_get(request, vip_id, expand_resource=False):
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'])
return Vip(vip)
def vip_update(request, vip_id, **kwargs):
vip = neutronclient(request).update_vip(vip_id, kwargs).get('vip')
return Vip(vip)
def vip_delete(request, vip_id):
def pool_create(request, **kwargs):
"""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')
return Pool(pool)
def _get_vip(request, pool, vip_dict, expand_name_only=False):
if pool['vip_id'] is not None:
if vip_dict:
vip = vip_dict.get(pool['vip_id'])
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
return None
def pool_list(request, **kwargs):
return _pool_list(request, expand_subnet=True, expand_vip=True, **kwargs)
def _pool_list(request, expand_subnet=False, expand_vip=False, **kwargs):
pools = neutronclient(request).list_pools(**kwargs).get('pools')
if expand_subnet:
subnets = neutron.subnet_list(request)
subnet_dict = collections.OrderedDict((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 = collections.OrderedDict((v.id, v) for v in vips)
for p in pools:
p['vip_name'] = _get_vip(request, p, vip_dict,
return [Pool(p) for p in pools]
def pool_get(request, pool_id):
return _pool_get(request, pool_id, expand_resource=True)
def _pool_get(request, pool_id, expand_resource=False):
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
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,
pool['members'] = _member_list(request, expand_pool=False,
except Exception:
messages.warning(request, _("Unable to get members for pool "
"%(pool)s.") % {"pool": pool_id})
pool['health_monitors'] = pool_health_monitor_list(
request, id=pool['health_monitors'])
except Exception:
_("Unable to get health monitors "
"for pool %(pool)s.") % {"pool": pool_id})
return Pool(pool)
def pool_update(request, pool_id, **kwargs):
pool = neutronclient(request).update_pool(pool_id, kwargs).get('pool')
return Pool(pool)
def pool_delete(request, pool):
# not linked to UI yet
def pool_stats(request, pool_id, **kwargs):
stats = neutronclient(request).retrieve_pool_stats(pool_id, **kwargs)
return PoolStats(stats)
def pool_health_monitor_create(request, **kwargs):
"""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(
return PoolMonitor(mon)
def pool_health_monitor_list(request, **kwargs):
monitors = neutronclient(request).list_health_monitors(
return [PoolMonitor(m) for m in monitors]
def pool_health_monitor_get(request, monitor_id):
return _pool_health_monitor_get(request, monitor_id, expand_resource=True)
def _pool_health_monitor_get(request, monitor_id, expand_resource=False):
monitor = neutronclient(request
if expand_resource:
pool_ids = [p['pool_id'] for p in monitor['pools']]
monitor['pools'] = _pool_list(request, id=pool_ids)
return PoolMonitor(monitor)
def pool_health_monitor_update(request, monitor_id, **kwargs):
monitor = neutronclient(request).update_health_monitor(monitor_id, kwargs)
return PoolMonitor(monitor)
def pool_health_monitor_delete(request, mon_id):
def member_create(request, **kwargs):
"""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')
return Member(member)
def member_list(request, **kwargs):
return _member_list(request, expand_pool=True, **kwargs)
def _member_list(request, expand_pool, **kwargs):
members = neutronclient(request).list_members(**kwargs).get('members')
if expand_pool:
pools = _pool_list(request)
pool_dict = collections.OrderedDict((p.id, p) for p in pools)
for m in members:
m['pool_name'] = pool_dict.get(m['pool_id']).name_or_id
return [Member(m) for m in members]
def member_get(request, member_id):
return _member_get(request, member_id, expand_pool=True)
def _member_get(request, member_id, expand_pool):
member = neutronclient(request).show_member(member_id).get('member')
if expand_pool:
member['pool'] = _pool_get(request, member['pool_id'])
return Member(member)
def member_update(request, member_id, **kwargs):
member = neutronclient(request).update_member(member_id, kwargs)
return Member(member)
def member_delete(request, mem_id):
def pool_monitor_association_create(request, **kwargs):
"""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'], }}
kwargs['pool_id'], body)
def pool_monitor_association_delete(request, **kwargs):
"""Disassociate a health monitor from pool
:param request: request context
:param monitor_id: id of monitor
:param pool_id: id of pool
kwargs['pool_id'], kwargs['monitor_id'])