Clustering service for managing homogeneous objects in OpenStack
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.
 
 
 
 
 
 

365 lines
14 KiB

# 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.
import eventlet
from oslo_context import context as oslo_context
from oslo_log import log as logging
from senlin.common import exception
from senlin.common.i18n import _
from senlin.drivers import base
from senlin.drivers.os import neutron_v2 as neutronclient
from senlin.drivers.os import octavia_v2 as octaviaclient
from senlin.profiles import base as pb
LOG = logging.getLogger(__name__)
class LoadBalancerDriver(base.DriverBase):
"""Load-balancing driver based on Neutron LBaaS V2 service."""
def __init__(self, params):
super(LoadBalancerDriver, self).__init__(params)
self.lb_status_timeout = 600
self._oc = None
self._nc = None
def oc(self):
"""Octavia client
:return: octavia client
"""
if self._oc:
return self._oc
self._oc = octaviaclient.OctaviaClient(self.conn_params)
return self._oc
def nc(self):
"""Neutron client
:return: neutron client
"""
if self._nc:
return self._nc
self._nc = neutronclient.NeutronClient(self.conn_params)
return self._nc
def _wait_for_lb_ready(self, lb_id, ignore_not_found=False):
"""Keep waiting until loadbalancer is ready
This method will keep waiting until loadbalancer resource specified
by lb_id becomes ready, i.e. its provisioning_status is ACTIVE.
:param lb_id: ID of the load-balancer to check.
:param ignore_not_found: if set to True, nonexistent loadbalancer
resource is also an acceptable result.
"""
waited = 0
while waited < self.lb_status_timeout:
try:
lb = self.oc().loadbalancer_get(lb_id, ignore_missing=True)
except exception.InternalError as ex:
LOG.exception('Failed in getting loadbalancer: %s.', ex)
return False
if lb is None:
lb_ready = ignore_not_found
else:
lb_ready = lb.provisioning_status == 'ACTIVE'
if lb_ready is True:
return True
LOG.debug('Waiting for loadbalancer %(lb)s to become ready',
{'lb': lb_id})
eventlet.sleep(10)
waited += 10
return False
def lb_create(self, vip, pool, hm=None, az=None, flavor_id=None):
"""Create a LBaaS instance
:param vip: A dict containing the properties for the VIP;
:param pool: A dict describing the pool of load-balancer members.
:param hm: A dict describing the health monitor.
"""
def _cleanup(msg, **kwargs):
LOG.error(msg)
self.lb_delete(**kwargs)
return
result = {}
# Create loadblancer
subnet_id = None
network_id = None
try:
if vip.get('subnet'):
subnet = self.nc().subnet_get(vip['subnet'])
subnet_id = subnet.id
if vip.get('network'):
network = self.nc().network_get(vip['network'])
network_id = network.id
except exception.InternalError as ex:
msg = 'Failed in getting subnet: %s.' % ex
LOG.exception(msg)
return False, msg
try:
lb = self.oc().loadbalancer_create(
subnet_id, network_id, vip.get('address', None),
vip['admin_state_up'], availability_zone=az,
flavor_id=flavor_id)
except exception.InternalError as ex:
msg = ('Failed in creating loadbalancer: %s.'
% str(ex))
LOG.exception(msg)
return False, msg
result['loadbalancer'] = lb.id
result['vip_address'] = lb.vip_address
res = self._wait_for_lb_ready(lb.id)
if res is False:
msg = 'Failed in creating loadbalancer (%s).' % lb.id
del result['vip_address']
_cleanup(msg, **result)
return False, msg
# Create listener
try:
listener = self.oc().listener_create(lb.id, vip['protocol'],
vip['protocol_port'],
vip.get('connection_limit',
None),
vip['admin_state_up'])
except exception.InternalError as ex:
msg = 'Failed in creating lb listener: %s.' % str(ex)
LOG.exception(msg)
return False, msg
result['listener'] = listener.id
res = self._wait_for_lb_ready(lb.id)
if res is False:
msg = 'Failed in creating listener (%s).' % listener.id
del result['vip_address']
_cleanup(msg, **result)
return res, msg
# Create pool
try:
pool = self.oc().pool_create(pool['lb_method'], listener.id,
pool['protocol'],
pool['admin_state_up'])
except exception.InternalError as ex:
msg = 'Failed in creating lb pool: %s.' % str(ex)
LOG.exception(msg)
return False, msg
result['pool'] = pool.id
res = self._wait_for_lb_ready(lb.id)
if res is False:
msg = 'Failed in creating pool (%s).' % pool.id
del result['vip_address']
_cleanup(msg, **result)
return res, msg
if not hm:
return True, result
# Create health monitor
try:
health_monitor = self.oc().healthmonitor_create(
hm['type'], hm['delay'], hm['timeout'], hm['max_retries'],
pool.id, hm['admin_state_up'], hm['http_method'],
hm['url_path'], hm['expected_codes'])
except exception.InternalError as ex:
msg = ('Failed in creating lb health monitor: %s.'
% str(ex))
LOG.exception(msg)
return False, msg
result['healthmonitor'] = health_monitor.id
res = self._wait_for_lb_ready(lb.id)
if res is False:
msg = 'Failed in creating health monitor (%s).' % health_monitor.id
del result['vip_address']
_cleanup(msg, **result)
return res, msg
return True, result
def lb_find(self, name_or_id, ignore_missing=False,
show_deleted=False):
return self.oc().loadbalancer_get(name_or_id, ignore_missing,
show_deleted)
def lb_delete(self, **kwargs):
"""Delete a Neutron lbaas instance
The following Neutron lbaas resources will be deleted in order:
1)healthmonitor; 2)pool; 3)listener; 4)loadbalancer.
"""
lb_id = kwargs.pop('loadbalancer')
lb = self.lb_find(lb_id, ignore_missing=True)
if lb is None:
LOG.debug('Loadbalancer (%s) is not existing.', lb_id)
return True, _('LB deletion succeeded')
healthmonitor_id = kwargs.pop('healthmonitor', None)
if healthmonitor_id:
try:
self.oc().healthmonitor_delete(healthmonitor_id)
except exception.InternalError as ex:
msg = ('Failed in deleting healthmonitor: %s.'
% str(ex))
LOG.exception(msg)
return False, msg
res = self._wait_for_lb_ready(lb_id)
if res is False:
msg = ('Failed in deleting healthmonitor '
'(%s).') % healthmonitor_id
return False, msg
pool_id = kwargs.pop('pool', None)
if pool_id:
try:
self.oc().pool_delete(pool_id)
except exception.InternalError as ex:
msg = ('Failed in deleting lb pool: %s.'
% str(ex))
LOG.exception(msg)
return False, msg
res = self._wait_for_lb_ready(lb_id)
if res is False:
msg = 'Failed in deleting pool (%s).' % pool_id
return False, msg
listener_id = kwargs.pop('listener', None)
if listener_id:
try:
self.oc().listener_delete(listener_id)
except exception.InternalError as ex:
msg = ('Failed in deleting listener: %s.'
% str(ex))
LOG.exception(msg)
return False, msg
res = self._wait_for_lb_ready(lb_id)
if res is False:
msg = 'Failed in deleting listener (%s).' % listener_id
return False, msg
self.oc().loadbalancer_delete(lb_id)
res = self._wait_for_lb_ready(lb_id, ignore_not_found=True)
if res is False:
msg = 'Failed in deleting loadbalancer (%s).' % lb_id
return False, msg
return True, _('LB deletion succeeded')
def member_add(self, node, lb_id, pool_id, port, subnet):
"""Add a member to Neutron lbaas pool.
:param node: A node object to be added to the specified pool.
:param lb_id: The ID of the loadbalancer.
:param pool_id: The ID of the pool for receiving the node.
:param port: The port for the new LB member to be created.
:param subnet: The subnet to be used by the new LB member.
:returns: The ID of the new LB member or None if errors occurred.
"""
try:
subnet_obj = self.nc().subnet_get(subnet)
net_id = subnet_obj.network_id
net = self.nc().network_get(net_id)
except exception.InternalError as ex:
resource = 'subnet' if subnet in ex.message else 'network'
LOG.exception('Failed in getting %(resource)s: %(msg)s.',
{'resource': resource, 'msg': ex})
return None
net_name = net.name
ctx = oslo_context.get_current()
prof = pb.Profile.load(ctx,
profile_id=node.profile_id,
project_safe=False)
node_detail = prof.do_get_details(node)
addresses = node_detail.get('addresses')
if net_name not in addresses:
LOG.error('Node is not in subnet %(subnet)s', {'subnet': subnet})
return None
# Use the first IP address that match with the subnet ip_version
# if more than one are found in target network
address = None
for ip in addresses[net_name]:
if ip['version'] == subnet_obj.ip_version:
address = ip['addr']
break
if not address:
LOG.error("Node does not match with subnet's (%s) ip version (%s)"
% (subnet, subnet_obj.ip_version))
return None
try:
# FIXME(Yanyan Hu): Currently, Neutron lbaasv2 service can not
# handle concurrent lb member operations well: new member creation
# deletion request will directly fail rather than being lined up
# when another operation is still in progress. In this workaround,
# loadbalancer status will be checked before creating lb member
# request is sent out. If loadbalancer keeps unready till waiting
# timeout, exception will be raised to fail member_add.
res = self._wait_for_lb_ready(lb_id)
if not res:
msg = 'Loadbalancer %s is not ready.' % lb_id
raise exception.Error(msg)
member = self.oc().pool_member_create(pool_id, address, port,
subnet_obj.id)
except (exception.InternalError, exception.Error) as ex:
LOG.exception('Failed in creating lb pool member: %s.', ex)
return None
res = self._wait_for_lb_ready(lb_id)
if res is False:
LOG.error('Failed in creating pool member (%s).', member.id)
return None
return member.id
def member_remove(self, lb_id, pool_id, member_id):
"""Delete a member from Neutron lbaas pool.
:param lb_id: The ID of the loadbalancer the operation is targeted at;
:param pool_id: The ID of the pool from which the member is deleted;
:param member_id: The ID of the LB member.
:returns: True if the operation succeeded or False if errors occurred.
"""
try:
# FIXME(Yanyan Hu): Currently, Neutron lbaasv2 service can not
# handle concurrent lb member operations well: new member creation
# deletion request will directly fail rather than being lined up
# when another operation is still in progress. In this workaround,
# loadbalancer status will be checked before deleting lb member
# request is sent out. If loadbalancer keeps unready till waiting
# timeout, exception will be raised to fail member_remove.
res = self._wait_for_lb_ready(lb_id, ignore_not_found=True)
# res = self._wait_for_lb_ready(lb_id)
# if not res:
# msg = 'Loadbalancer %s is not ready.' % lb_id
# raise exception.Error(msg)
self.oc().pool_member_delete(pool_id, member_id)
except (exception.InternalError, exception.Error) as ex:
LOG.exception('Failed in removing member %(m)s from pool %(p)s: '
'%(ex)s', {'m': member_id, 'p': pool_id, 'ex': ex})
return None
res = self._wait_for_lb_ready(lb_id, ignore_not_found=True)
if res is False:
LOG.error('Failed in deleting pool member (%s).', member_id)
return None
return True