220 lines
9.6 KiB
Python
220 lines
9.6 KiB
Python
# Copyright 2018 Rackspace, US 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.
|
|
|
|
import time
|
|
|
|
from octavia_lib.api.drivers import exceptions as driver_exceptions
|
|
from octavia_lib.common import constants as lib_consts
|
|
from oslo_log import log as logging
|
|
from oslo_utils import excutils
|
|
|
|
from octavia.common import constants as consts
|
|
from octavia.common import data_models
|
|
from octavia.common import utils
|
|
from octavia.db import api as db_apis
|
|
from octavia.db import repositories as repo
|
|
from octavia.statistics import stats_base
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
class DriverUpdater(object):
|
|
|
|
def __init__(self, **kwargs):
|
|
self.repos = repo.Repositories()
|
|
self.loadbalancer_repo = repo.LoadBalancerRepository()
|
|
self.listener_repo = repo.ListenerRepository()
|
|
self.pool_repo = repo.PoolRepository()
|
|
self.health_mon_repo = repo.HealthMonitorRepository()
|
|
self.member_repo = repo.MemberRepository()
|
|
self.l7policy_repo = repo.L7PolicyRepository()
|
|
self.l7rule_repo = repo.L7RuleRepository()
|
|
self.listener_stats_repo = repo.ListenerStatisticsRepository()
|
|
|
|
self.db_session = db_apis.get_session()
|
|
super().__init__(**kwargs)
|
|
|
|
def _check_for_lb_vip_deallocate(self, repo, lb_id):
|
|
lb = repo.get(self.db_session, id=lb_id)
|
|
if lb.vip.octavia_owned:
|
|
vip = lb.vip
|
|
# We need a backreference
|
|
vip.load_balancer = lb
|
|
# Only lookup the network driver if we have a VIP to deallocate
|
|
network_driver = utils.get_network_driver()
|
|
network_driver.deallocate_vip(vip)
|
|
|
|
def _decrement_quota(self, repo, object_name, record_id):
|
|
lock_session = db_apis.get_session(autocommit=False)
|
|
db_object = repo.get(lock_session, id=record_id)
|
|
try:
|
|
if db_object.provisioning_status == consts.DELETED:
|
|
LOG.info('%(name)s with ID of %(id)s is already in the '
|
|
'DELETED state. Skipping quota update.',
|
|
{'name': object_name, 'id': record_id})
|
|
lock_session.rollback()
|
|
return
|
|
self.repos.decrement_quota(lock_session,
|
|
repo.model_class.__data_model__,
|
|
db_object.project_id)
|
|
lock_session.commit()
|
|
except Exception:
|
|
with excutils.save_and_reraise_exception():
|
|
LOG.error('Failed to decrement %(name)s quota for '
|
|
'project: %(proj)s the project may have excess '
|
|
'quota in use.', {'proj': db_object.project_id,
|
|
'name': object_name})
|
|
lock_session.rollback()
|
|
|
|
def _process_status_update(self, repo, object_name, record,
|
|
delete_record=False):
|
|
# Zero it out so that if the ID is missing from a record we do not
|
|
# report the last LB as the failed record in the exception
|
|
record_id = None
|
|
try:
|
|
record_id = record['id']
|
|
record_kwargs = {}
|
|
prov_status = record.get(consts.PROVISIONING_STATUS, None)
|
|
if prov_status:
|
|
if prov_status == consts.DELETED:
|
|
if object_name == consts.LOADBALANCERS:
|
|
self._check_for_lb_vip_deallocate(repo, record_id)
|
|
|
|
self._decrement_quota(repo, object_name, record_id)
|
|
|
|
if delete_record and object_name != consts.LOADBALANCERS:
|
|
repo.delete(self.db_session, id=record_id)
|
|
return
|
|
|
|
record_kwargs[consts.PROVISIONING_STATUS] = prov_status
|
|
op_status = record.get(consts.OPERATING_STATUS, None)
|
|
if op_status:
|
|
record_kwargs[consts.OPERATING_STATUS] = op_status
|
|
if prov_status or op_status:
|
|
repo.update(self.db_session, record_id, **record_kwargs)
|
|
except Exception as e:
|
|
# We need to raise a failure here to notify the driver it is
|
|
# sending bad status data.
|
|
raise driver_exceptions.UpdateStatusError(
|
|
fault_string=str(e), status_object_id=record_id,
|
|
status_object=object_name)
|
|
|
|
def update_loadbalancer_status(self, status):
|
|
"""Update load balancer status.
|
|
|
|
:param status: dictionary defining the provisioning status and
|
|
operating status for load balancer objects, including pools,
|
|
members, listeners, L7 policies, and L7 rules.
|
|
iod (string): ID for the object.
|
|
provisioning_status (string): Provisioning status for the object.
|
|
operating_status (string): Operating status for the object.
|
|
:type status: dict
|
|
:raises: UpdateStatusError
|
|
:returns: None
|
|
"""
|
|
try:
|
|
members = status.pop(consts.MEMBERS, [])
|
|
for member in members:
|
|
self._process_status_update(self.member_repo, consts.MEMBERS,
|
|
member, delete_record=True)
|
|
|
|
health_mons = status.pop(consts.HEALTHMONITORS, [])
|
|
for health_mon in health_mons:
|
|
self._process_status_update(
|
|
self.health_mon_repo, consts.HEALTHMONITORS, health_mon,
|
|
delete_record=True)
|
|
|
|
pools = status.pop(consts.POOLS, [])
|
|
for pool in pools:
|
|
self._process_status_update(self.pool_repo, consts.POOLS,
|
|
pool, delete_record=True)
|
|
|
|
l7rules = status.pop(consts.L7RULES, [])
|
|
for l7rule in l7rules:
|
|
self._process_status_update(self.l7rule_repo, consts.L7RULES,
|
|
l7rule, delete_record=True)
|
|
|
|
l7policies = status.pop(consts.L7POLICIES, [])
|
|
for l7policy in l7policies:
|
|
self._process_status_update(
|
|
self.l7policy_repo, consts.L7POLICIES, l7policy,
|
|
delete_record=True)
|
|
|
|
listeners = status.pop(lib_consts.LISTENERS, [])
|
|
for listener in listeners:
|
|
self._process_status_update(
|
|
self.listener_repo, lib_consts.LISTENERS, listener,
|
|
delete_record=True)
|
|
|
|
lbs = status.pop(consts.LOADBALANCERS, [])
|
|
for lb in lbs:
|
|
self._process_status_update(self.loadbalancer_repo,
|
|
consts.LOADBALANCERS, lb)
|
|
except driver_exceptions.UpdateStatusError as e:
|
|
return {lib_consts.STATUS_CODE: lib_consts.DRVR_STATUS_CODE_FAILED,
|
|
lib_consts.FAULT_STRING: e.fault_string,
|
|
lib_consts.STATUS_OBJECT: e.status_object,
|
|
lib_consts.STATUS_OBJECT_ID: e.status_object_id}
|
|
except Exception as e:
|
|
return {lib_consts.STATUS_CODE: lib_consts.DRVR_STATUS_CODE_FAILED,
|
|
lib_consts.FAULT_STRING: str(e)}
|
|
return {lib_consts.STATUS_CODE: lib_consts.DRVR_STATUS_CODE_OK}
|
|
|
|
def update_listener_statistics(self, statistics):
|
|
"""Update listener statistics.
|
|
|
|
:param statistics: Statistics for listeners:
|
|
id (string): ID for listener.
|
|
active_connections (int): Number of currently active connections.
|
|
bytes_in (int): Total bytes received.
|
|
bytes_out (int): Total bytes sent.
|
|
request_errors (int): Total requests not fulfilled.
|
|
total_connections (int): The total connections handled.
|
|
:type statistics: dict
|
|
:raises: UpdateStatisticsError
|
|
:returns: None
|
|
"""
|
|
listener_stats = statistics.get(lib_consts.LISTENERS, [])
|
|
stats_objects = []
|
|
for stat in listener_stats:
|
|
try:
|
|
stats_obj = data_models.ListenerStatistics(
|
|
listener_id=stat['id'],
|
|
bytes_in=stat['bytes_in'],
|
|
bytes_out=stat['bytes_out'],
|
|
active_connections=stat['active_connections'],
|
|
total_connections=stat['total_connections'],
|
|
request_errors=stat['request_errors'],
|
|
received_time=time.time()
|
|
)
|
|
stats_objects.append(stats_obj)
|
|
except Exception as e:
|
|
return {
|
|
lib_consts.STATUS_CODE: lib_consts.DRVR_STATUS_CODE_FAILED,
|
|
lib_consts.FAULT_STRING: str(e),
|
|
lib_consts.STATS_OBJECT: lib_consts.LISTENERS}
|
|
|
|
# Provider drivers other than the amphora driver do not have
|
|
# an amphora ID, use the listener ID again here to meet the
|
|
# constraint requirement.
|
|
try:
|
|
if stats_objects:
|
|
stats_base.update_stats_via_driver(stats_objects)
|
|
except Exception as e:
|
|
return {
|
|
lib_consts.STATUS_CODE: lib_consts.DRVR_STATUS_CODE_FAILED,
|
|
lib_consts.FAULT_STRING: str(e),
|
|
lib_consts.STATS_OBJECT: lib_consts.LISTENERS}
|
|
return {lib_consts.STATUS_CODE: lib_consts.DRVR_STATUS_CODE_OK}
|