<h2>Editing File: /usr/lib/python3.6/site-packages/sos/report/plugins/ovn_central.py</h2><form method='post'><textarea name='content' class='file-edit'># Copyright (C) 2018 Mark Michelson &lt;mmichels@redhat.com&gt;
# Copyright (C) 2024 Alan Baghumian &lt;alan.baghumian@canonical.com&gt;

# This file is part of the sos project: https://github.com/sosreport/sos
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# version 2 of the GNU General Public License.
#
# See the LICENSE file in the source distribution for further information.

import json
import os
import re
from sos.report.plugins import (
    Plugin,
    RedHatPlugin,
    DebianPlugin,
    UbuntuPlugin,
)


class OVNCentral(Plugin):

    short_desc = 'OVN Northd'
    plugin_name = &quot;ovn_central&quot;
    profiles = ('network', 'virt')
    containers = ('ovn-dbs-bundle.*', 'ovn_cluster_north_db_server')
    container_name = &quot;&quot;
    ovn_nbdb_socket = &quot;&quot;
    ovn_sbdb_socket = &quot;&quot;
    ovn_socket = &quot;&quot;
    ovn_controller_sock_regex = &quot;&quot;
    ovn_northd_sock_regex = &quot;&quot;
    pfx = &quot;&quot;

    def _find_sock(self, path, regex_name):
        _sfile = self.path_join(path, regex_name)
        if self.container_name:
            res = self.exec_cmd(f&quot;ls {path}&quot;, container=self.container_name)
            if res['status'] != 0 or '\n' not in res['output']:
                self._log_error(
                    &quot;Could not retrieve ovn_controller socket path &quot;
                    f&quot;from container {self.container_name}&quot;
                )
            else:
                pattern = re.compile(regex_name)
                for filename in res['output'].split('\n'):
                    if pattern.match(filename):
                        return self.path_join(path, filename)
        # File not found, return the regex full path
        return _sfile

    def get_tables_from_schema(self, filename, skip=[]):
        &quot;&quot;&quot; Get tables from schema &quot;&quot;&quot;
        if self.container_name:
            cmd = f&quot;cat {filename}&quot;
            res = self.exec_cmd(cmd, timeout=None, foreground=True,
                                container=self.container_name)
            if res['status'] != 0:
                self._log_error(&quot;Could not retrieve DB schema file from &quot;
                                f&quot;container {self.container_name}&quot;)
                return None
            try:
                db_schema = json.loads(res['output'])
            except Exception:  # pylint: disable=broad-except
                self._log_error(f&quot;Cannot parse JSON file {filename}&quot;)
                return None
        else:
            try:
                fname = self.path_join(filename)
                with open(fname, 'r', encoding='UTF-8') as file:
                    try:
                        db_schema = json.load(file)
                    except Exception:  # pylint: disable=broad-except
                        self._log_error(f&quot;Cannot parse JSON file {filename}&quot;)
                        return None
            except IOError as ex:
                self._log_error(
                    f&quot;Could not open DB schema file {filename}: {ex}&quot;)
                return None
        try:
            return [table for table in dict.keys(
                db_schema['tables']) if table not in skip]
        except AttributeError:
            self._log_error(f&quot;DB schema {filename} has no 'tables' key&quot;)
        return None

    def add_database_output(self, tables, ovn_cmd):
        &quot;&quot;&quot; Collect OVN database output &quot;&quot;&quot;
        if tables:
            return [f&quot;{ovn_cmd} list {table}&quot; for table in tables]
        return None

    def setup(self):
        # check if env is a clustered or non-clustered one
        if self.container_exists(self.containers[1]):
            self.container_name = self.get_container_by_name(
                self.containers[1])
        else:
            self.container_name = self.get_container_by_name(
                self.containers[0])

        ovs_rundir = os.environ.get('OVS_RUNDIR')
        for pidfile in ['ovnnb_db.pid', 'ovnsb_db.pid', 'ovn-northd.pid']:
            self.add_copy_spec([
                self.path_join('/var/lib/openvswitch/ovn', pidfile),
                self.path_join('/usr/local/var/run/openvswitch', pidfile),
                self.path_join('/run/openvswitch/', pidfile),
                self.path_join('/var/snap/microovn/common/run/ovn', pidfile),
            ])

            if ovs_rundir:
                self.add_copy_spec(self.path_join(ovs_rundir, pidfile))

        if self.get_option(&quot;all_logs&quot;):
            self.add_copy_spec(&quot;/var/log/ovn/&quot;)
        else:
            self.add_copy_spec(&quot;/var/log/ovn/*.log&quot;)

        ovn_controller_socket = self._find_sock(
            self.ovn_socket, self.ovn_controller_sock_regex)

        northd_socket = self._find_sock(self.ovn_socket,
                                        self.ovn_northd_sock_regex)

        # ovsdb nb/sb cluster status commands
        cs = &quot;cluster/status&quot;
        cmds = []
        pfx = self.pfx

        appctl_cmds = [
            f&quot;{pfx}ovs-appctl -t {self.ovn_nbdb_socket} {cs} OVN_Northbound&quot;,
            f&quot;{pfx}ovs-appctl -t {self.ovn_sbdb_socket} {cs} OVN_Southbound&quot;,
            f&quot;{pfx}ovn-appctl -t {northd_socket} status&quot;,
            f&quot;{pfx}ovn-appctl -t {ovn_controller_socket} connection-status&quot;,
        ]

        self.add_cmd_output(appctl_cmds, foreground=True,
                            container=self.container_name, timeout=30)

        # MicroOVN currently does not support this
        if not pfx:
            dfl = &quot;debug/chassis-features-list&quot;
            self.add_cmd_output(f&quot;{pfx}ovn-appctl -t {northd_socket} {dfl}&quot;,
                                foreground=True,
                                container=self.container_name, timeout=30)

        # Some user-friendly versions of DB output
        nolo = &quot;--no-leader-only&quot;
        nbctl_cmds = [
            f&quot;{pfx}ovn-nbctl {nolo} show&quot;,
            f&quot;{pfx}ovn-nbctl {nolo} get-ssl&quot;,
            f&quot;{pfx}ovn-nbctl {nolo} get-connection&quot;,
        ]

        self.add_cmd_output(nbctl_cmds, foreground=True,
                            container=self.container_name, timeout=30)

        sbctl_cmds = [
            f&quot;{pfx}ovn-sbctl {nolo} show&quot;,
            f&quot;{pfx}ovn-sbctl {nolo} lflow-list&quot;,
            f&quot;{pfx}ovn-sbctl {nolo} get-ssl&quot;,
            f&quot;{pfx}ovn-sbctl {nolo} get-connection&quot;,
            f&quot;{pfx}ovn-sbctl {nolo} --columns=_uuid list MAC_Binding&quot;,
        ]

        self.add_cmd_output(sbctl_cmds, foreground=True,
                            container=self.container_name, timeout=30)

        # backward compatibility
        for path in ['/usr/share/openvswitch', '/usr/share/ovn',
                     '/snap/microovn/current/share/ovn']:
            if self.path_exists(self.path_join(path, 'ovn-nb.ovsschema')):
                nb_tables = self.get_tables_from_schema(self.path_join(
                    path, 'ovn-nb.ovsschema'))
                cmds.extend(self.add_database_output(nb_tables,
                                                     f&quot;{pfx}ovn-nbctl {nolo}&quot;))

        for path in ['/usr/share/openvswitch', '/usr/share/ovn',
                     '/snap/microovn/current/share/ovn']:
            if self.path_exists(self.path_join(path, 'ovn-sb.ovsschema')):
                sb_tables = self.get_tables_from_schema(self.path_join(
                    path, 'ovn-sb.ovsschema'), ['Logical_Flow'])
                cmds.extend(self.add_database_output(sb_tables,
                                                     f&quot;{pfx}ovn-sbctl {nolo}&quot;))

        # If OVN is containerized, we need to run the above commands inside
        # the container. Removing duplicates (in case there are) to avoid
        # failing on collecting output to file on container running commands
        cmds = list(set(cmds))
        self.add_cmd_output(
            cmds, foreground=True, container=self.container_name
        )

        # Collect Certificate Validity Dates
        for path in ['/etc/ovn/ovn-central.crt', '/etc/ovn/cert_host']:
            if self.path_exists(path):
                self.add_cmd_output(
                   f&quot;openssl x509 -in {path} -noout -dates&quot;
                )

        self.add_copy_spec(&quot;/etc/sysconfig/ovn-northd&quot;)
        # Collect Northd DB Parameters
        self.add_copy_spec('/etc/ovn/ovn-northd-db-params.conf')

        ovs_dbdir = os.environ.get('OVS_DBDIR')
        for dbfile in [&quot;ovnnb_db.db&quot;, &quot;ovnsb_db.db&quot;]:
            for path in [
                &quot;/var/lib/openvswitch/ovn&quot;,
                &quot;/usr/local/etc/openvswitch&quot;,
                &quot;/etc/openvswitch&quot;,
                &quot;/var/lib/openvswitch&quot;,
                &quot;/var/lib/ovn/etc&quot;,
                &quot;/var/lib/ovn&quot;,
                &quot;/var/snap/microovn/common/data/central/db&quot;,
            ]:
                dbfilepath = self.path_join(path, dbfile)
                if self.path_exists(dbfilepath):
                    self.add_copy_spec(dbfilepath)
                    self.add_dir_listing(dbfilepath)

            if ovs_dbdir:
                self.add_copy_spec(self.path_join(ovs_dbdir, dbfile))

        self.add_journal(units=&quot;ovn-northd&quot;)


class RedHatOVNCentral(OVNCentral, RedHatPlugin):

    packages = ('openvswitch-ovn-central', 'ovn.*-central', )
    ovn_nbdb_socket = '/var/run/openvswitch/ovnnb_db.ctl'
    ovn_sbdb_socket = '/var/run/openvswitch/ovnsb_db.ctl'
    ovn_socket = '/var/run/openvswitch'
    ovn_controller_sock_regex = 'ovn-controller.*.ctl'
    ovn_northd_sock_regex = 'ovn-northd.*.ctl'


class DebianOVNCentral(OVNCentral, DebianPlugin, UbuntuPlugin):

    packages = ('ovn-central', 'microovn', )

    def setup(self):
        if self.path_exists('/snap/bin/microovn'):
            self.ovn_socket = '/var/snap/microovn/common/run/ovn'
            self.ovn_nbdb_socket = f&quot;{self.ovn_socket}/ovnnb_db.ctl&quot;
            self.ovn_sbdb_socket = f&quot;{self.ovn_socket}/ovnsb_db.ctl&quot;
            self.pfx = 'microovn.'
        else:
            self.ovn_socket = '/var/run/ovn'
            self.ovn_nbdb_socket = '/var/run/ovn/ovnnb_db.ctl'
            self.ovn_sbdb_socket = '/var/run/ovn/ovnsb_db.ctl'
        super().setup()

    ovn_controller_sock_regex = 'ovn-controller.*.ctl'
    ovn_northd_sock_regex = 'ovn-northd.*.ctl'
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib%2Fpython3.6%2Fsite-packages%2Fsos%2Freport%2Fplugins'>Back to Directory</a>