139 lines
4.7 KiB
Python
139 lines
4.7 KiB
Python
# Copyright (c) 2017 Fujitsu Limited
|
|
# All Rights Reserved.
|
|
#
|
|
# 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 abc
|
|
import contextlib
|
|
|
|
from neutron_lib.agent import extension
|
|
from neutron_lib import constants
|
|
from oslo_concurrency import lockutils
|
|
import six
|
|
|
|
from neutron.api.rpc.callbacks.consumer import registry
|
|
from neutron.api.rpc.callbacks import events
|
|
from neutron.api.rpc.callbacks import resources
|
|
from neutron.api.rpc.handlers import resources_rpc
|
|
from neutron.conf.services import logging as log_cfg
|
|
from neutron import manager
|
|
from neutron.services.logapi.rpc import agent as agent_rpc
|
|
|
|
log_cfg.register_log_driver_opts()
|
|
|
|
LOGGING_DRIVERS_NAMESPACE = 'neutron.services.logapi.drivers'
|
|
|
|
|
|
@six.add_metaclass(abc.ABCMeta)
|
|
class LoggingDriver(object):
|
|
"""Defines abstract interface for logging driver"""
|
|
|
|
# specific logging types are supported
|
|
SUPPORTED_LOGGING_TYPES = None
|
|
|
|
@abc.abstractmethod
|
|
def initialize(self, resource_rpc, **kwargs):
|
|
"""Perform logging driver initialization.
|
|
"""
|
|
|
|
@abc.abstractmethod
|
|
def start_logging(self, context, **kwargs):
|
|
"""Enable logging
|
|
|
|
:param context: rpc context
|
|
:param kwargs: log_resources data or port_id
|
|
"""
|
|
|
|
@abc.abstractmethod
|
|
def stop_logging(self, context, **kwargs):
|
|
"""Disable logging
|
|
|
|
:param context: rpc context
|
|
:param kwargs: log_resources data or port_id
|
|
"""
|
|
|
|
def defer_apply_on(self):
|
|
"""Defer application of logging rule."""
|
|
pass
|
|
|
|
def defer_apply_off(self):
|
|
"""Turn off deferral of rules and apply the logging rules now."""
|
|
pass
|
|
|
|
@contextlib.contextmanager
|
|
def defer_apply(self):
|
|
"""Defer apply context."""
|
|
self.defer_apply_on()
|
|
try:
|
|
yield
|
|
finally:
|
|
self.defer_apply_off()
|
|
|
|
|
|
class LoggingExtension(extension.AgentExtension):
|
|
SUPPORTED_RESOURCE_TYPES = [resources.LOGGING_RESOURCE]
|
|
|
|
def initialize(self, connection, driver_type):
|
|
"""Initialize agent extension."""
|
|
|
|
self.log_driver = manager.NeutronManager.load_class_for_provider(
|
|
LOGGING_DRIVERS_NAMESPACE, driver_type)(self.agent_api)
|
|
self.resource_rpc = agent_rpc.LoggingApiStub()
|
|
self._register_rpc_consumers(connection)
|
|
self.log_driver.initialize(self.resource_rpc)
|
|
|
|
def consume_api(self, agent_api):
|
|
self.agent_api = agent_api
|
|
|
|
def _register_rpc_consumers(self, connection):
|
|
endpoints = [resources_rpc.ResourcesPushRpcCallback()]
|
|
for resource_type in self.SUPPORTED_RESOURCE_TYPES:
|
|
registry.register(self._handle_notification, resource_type)
|
|
topic = resources_rpc.resource_type_versioned_topic(resource_type)
|
|
connection.create_consumer(topic, endpoints, fanout=True)
|
|
|
|
@lockutils.synchronized('log-port')
|
|
def _handle_notification(self, context, resource_type,
|
|
log_resources, event_type):
|
|
with self.log_driver.defer_apply():
|
|
if event_type == events.UPDATED:
|
|
self._update_logging(context, log_resources)
|
|
elif event_type == events.CREATED:
|
|
self.log_driver.start_logging(
|
|
context, log_resources=log_resources)
|
|
elif event_type == events.DELETED:
|
|
self.log_driver.stop_logging(
|
|
context, log_resources=log_resources)
|
|
|
|
@lockutils.synchronized('log-port')
|
|
def handle_port(self, context, port):
|
|
if port['device_owner'].startswith(
|
|
constants.DEVICE_OWNER_COMPUTE_PREFIX):
|
|
self.log_driver.start_logging(context, port_id=port['port_id'])
|
|
|
|
def delete_port(self, context, port):
|
|
self.log_driver.stop_logging(context, port_id=port['port_id'])
|
|
|
|
def _update_logging(self, context, log_resources):
|
|
enables = []
|
|
disables = []
|
|
for log_resource in log_resources:
|
|
if log_resource.enabled:
|
|
enables.append(log_resource)
|
|
else:
|
|
disables.append(log_resource)
|
|
if enables:
|
|
self.log_driver.start_logging(context, log_resources=enables)
|
|
if disables:
|
|
self.log_driver.stop_logging(context, log_resources=disables)
|