Merge "[OVN] Implement OVN agent metadata extension"

Author: Zuul

neutron/agent/ovn/agent/ovn_neutron_agent.py

@@ -54,9 +54,9 @@ class OVNNeutronAgent(service.Service):
     def __init__(self, conf):
         super().__init__()
         self._conf = conf
-        self.chassis = None
-        self.chassis_id = None
-        self.ovn_bridge = None
+        self._chassis = None
+        self._chassis_id = None
+        self._ovn_bridge = None
         self.ext_manager_api = ext_mgr.OVNAgentExtensionAPI()
         self.ext_manager = ext_mgr.OVNAgentExtensionManager(self._conf)
         self.ext_manager.initialize(None, 'ovn', self)
@@ -65,6 +65,10 @@ def __getitem__(self, name):
         """Return the named extension objet from ``self.ext_manager``"""
         return self.ext_manager[name].obj
 
+    @property
+    def conf(self):
+        return self._conf
+
     @property
     def ovs_idl(self):
         if not self.ext_manager_api.ovs_idl:
@@ -87,15 +91,27 @@ def sb_idl(self):
     def sb_post_fork_event(self):
         return self.ext_manager_api.sb_post_fork_event
 
+    @property
+    def chassis(self):
+        return self._chassis
+
+    @property
+    def chassis_id(self):
+        return self._chassis_id
+
+    @property
+    def ovn_bridge(self):
+        return self._ovn_bridge
+
     def load_config(self):
-        self.chassis = ovsdb.get_own_chassis_name(self.ovs_idl)
+        self._chassis = ovsdb.get_own_chassis_name(self.ovs_idl)
         try:
-            self.chassis_id = uuid.UUID(self.chassis)
+            self._chassis_id = uuid.UUID(self.chassis)
         except ValueError:
             # OVS system-id could be a non UUID formatted string.
-            self.chassis_id = uuid.uuid5(OVN_MONITOR_UUID_NAMESPACE,
-                                         self.chassis)
-        self.ovn_bridge = ovsdb.get_ovn_bridge(self.ovs_idl)
+            self._chassis_id = uuid.uuid5(OVN_MONITOR_UUID_NAMESPACE,
+                                          self._chassis)
+        self._ovn_bridge = ovsdb.get_ovn_bridge(self.ovs_idl)
         LOG.info("Loaded chassis name %s (UUID: %s) and ovn bridge %s.",
                  self.chassis, self.chassis_id, self.ovn_bridge)
 

neutron/agent/ovn/extensions/extension_manager.py

@@ -18,11 +18,13 @@
 
 from neutron_lib.agent import extension
 from neutron_lib import exceptions
+from oslo_log import log as logging
 
 from neutron._i18n import _
 from neutron.agent import agent_extensions_manager as agent_ext_mgr
 
 
+LOG = logging.getLogger(__name__)
 OVN_AGENT_EXT_MANAGER_NAMESPACE = 'neutron.agent.ovn.extensions'
 
 
@@ -45,13 +47,15 @@ def start(self):
         """Start the extensions, once the OVN agent has been initialized."""
         for ext in self:
             ext.obj.start()
+            LOG.info('Extension manager: %s started', ext.obj.name)
 
 
 class OVNAgentExtension(extension.AgentExtension, metaclass=abc.ABCMeta):
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self.agent_api = None
+        self._is_started = False
 
     @property
     @abc.abstractmethod
@@ -77,6 +81,11 @@ def start(self):
         OVN agent and the extension manager API. It is executed at the end of
         the OVN agent ``start`` method.
         """
+        self._is_started = True
+
+    @property
+    def is_started(self):
+        return self._is_started
 
     @property
     @abc.abstractmethod

neutron/agent/ovn/extensions/metadata.py

@@ -0,0 +1,174 @@
+# Copyright 2024 Red Hat, 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 collections
+import functools
+import re
+
+from oslo_concurrency import lockutils
+from oslo_config import cfg
+from oslo_log import log
+from ovsdbapp.backend.ovs_idl import vlog
+
+from neutron.agent.linux import external_process
+from neutron.agent.ovn.extensions import extension_manager
+from neutron.agent.ovn.metadata import agent as metadata_agent
+from neutron.agent.ovn.metadata import server as metadata_server
+from neutron.common.ovn import constants as ovn_const
+from neutron.conf.agent.database import agents_db
+from neutron.conf.agent.metadata import config as meta_conf
+from neutron.conf.agent.ovn.metadata import config as ovn_meta
+from neutron.conf.plugins.ml2.drivers.ovn import ovn_conf as config
+
+
+LOG = log.getLogger(__name__)
+EXT_NAME = 'metadata'
+agents_db.register_db_agents_opts()
+_SYNC_STATE_LOCK = lockutils.ReaderWriterLock()
+CHASSIS_METADATA_LOCK = 'chassis_metadata_lock'
+
+SB_IDL_TABLES = ['Encap',
+                 'Port_Binding',
+                 'Datapath_Binding',
+                 'SB_Global',
+                 'Chassis',
+                 'Chassis_Private',
+                 ]
+
+NS_PREFIX = ovn_const.OVN_METADATA_PREFIX
+MAC_PATTERN = re.compile(r'([0-9A-F]{2}[:-]){5}([0-9A-F]{2})', re.I)
+OVN_VIF_PORT_TYPES = (
+    "", ovn_const.LSP_TYPE_EXTERNAL, ovn_const.LSP_TYPE_LOCALPORT)
+
+MetadataPortInfo = collections.namedtuple('MetadataPortInfo', ['mac',
+                                                               'ip_addresses',
+                                                               'logical_port'])
+
+
+def _sync_lock(f):
+    """Decorator to block all operations for a global sync call."""
+    @functools.wraps(f)
+    def wrapped(*args, **kwargs):
+        with _SYNC_STATE_LOCK.write_lock():
+            return f(*args, **kwargs)
+    return wrapped
+
+
+class MetadataExtension(extension_manager.OVNAgentExtension,
+                        metadata_agent.MetadataAgent):
+
+    def __init__(self):
+        super().__init__(conf=cfg.CONF)
+        vlog.use_python_logger(max_level=config.get_ovn_ovsdb_log_level())
+        self._process_monitor = None
+        self._proxy = None
+        # We'll restart all haproxy instances upon start so that they honor
+        # any potential changes in their configuration.
+        self.restarted_metadata_proxy_set = set()
+
+    @staticmethod
+    def _register_config_options():
+        ovn_meta.register_meta_conf_opts(meta_conf.SHARED_OPTS)
+        ovn_meta.register_meta_conf_opts(
+            meta_conf.UNIX_DOMAIN_METADATA_PROXY_OPTS)
+        ovn_meta.register_meta_conf_opts(meta_conf.METADATA_PROXY_HANDLER_OPTS)
+        ovn_meta.register_meta_conf_opts(meta_conf.METADATA_RATE_LIMITING_OPTS,
+                                         group=meta_conf.RATE_LIMITING_GROUP)
+
+    def initialize(self, *args):
+        self._register_config_options()
+        self._process_monitor = external_process.ProcessMonitor(
+            config=self.agent_api.conf, resource_type='metadata')
+
+    @property
+    def name(self):
+        return 'Metadata OVN agent extension'
+
+    @property
+    def ovs_idl_events(self):
+        return []
+
+    @property
+    def nb_idl_tables(self):
+        return []
+
+    @property
+    def nb_idl_events(self):
+        return []
+
+    @property
+    def sb_idl_tables(self):
+        return SB_IDL_TABLES
+
+    @property
+    def sb_idl_events(self):
+        return [metadata_agent.PortBindingUpdatedEvent,
+                metadata_agent.PortBindingDeletedEvent,
+                metadata_agent.SbGlobalUpdateEvent,
+                metadata_agent.ChassisPrivateCreateEvent,
+                ]
+
+    # NOTE(ralonsoh): the following properties are needed during the migration
+    # to the Metadata agent to the OVN agent, while sharing the code with
+    # ``metadata_agent.MetadataAgent``
+    @property
+    def nb_idl(self):
+        return self.agent_api.nb_idl
+
+    @property
+    def sb_idl(self):
+        return self.agent_api.sb_idl
+
+    @property
+    def ovs_idl(self):
+        return self.agent_api.ovs_idl
+
+    @property
+    def conf(self):
+        return self.agent_api.conf
+
+    @property
+    def chassis(self):
+        return self.agent_api.chassis
+
+    @property
+    def ovn_bridge(self):
+        return self.agent_api.ovn_bridge
+
+    @_sync_lock
+    def resync(self):
+        """Resync the Metadata OVN agent extension.
+
+        Reload the configuration and sync the agent again.
+        """
+        self.agent_api.load_config()
+        self.sync()
+
+    def start(self):
+        self._load_config()
+
+        # Launch the server that will act as a proxy between the VM's and Nova.
+        self._proxy = metadata_server.UnixDomainMetadataProxy(
+            self.agent_api.conf, self.agent_api.chassis,
+            sb_idl=self.agent_api.sb_idl)
+        self._proxy.run()
+
+        # Do the initial sync.
+        self.sync()
+
+        # Register the agent with its corresponding Chassis
+        self.register_metadata_agent()
+
+        # Raise the "is_started" flag.
+        self._is_started = True