<h2>Edit File: osmsplugin.py</h2><form method="post"><textarea name="content" rows="20" cols="80">#   Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
#   Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.org/licenses/UPL.

import copy
import errno
import json
import logging
import os
import sys

import dnf
from dnf.conf.config import PRIO_PLUGINCONFIG
import dnf.exceptions
from dnfpluginscore import _, logger
import librepo

sys.path.insert(0, &#039;/usr/share/oracle-cloud-agent/plugins/osms&#039;)

from osms import actions
from osms import config
from osms.i18n import ustr
from osms.server import get_cacert, get_proxy, OsmsServer


STORED_CHANNELS_NAME = &#039;_osms.json&#039;
RHN_DISABLED = _(&quot;OSMS based repositories will be disabled.&quot;)
COMMUNICATION_ERROR = _(&quot;There was an error communicating with OSMS server.&quot;)
NOT_REGISTERED_ERROR = _(&quot;This system is not registered with OSMS server.&quot;)
UPDATES_FROM_OSMS = _(&quot;This system is receiving updates from OSMS server.&quot;)
GPG_KEY_REJECTED = _(
    &quot;For security reasons packages from OSMS based repositories can be &quot;
    &quot;verified only with locally installed gpg keys. GPG key &#039;%s&#039; has been &quot;
    &quot;rejected.&quot;
)
PROFILE_NOT_SENT = _(&quot;Package profile information could not be sent.&quot;)
MISSING_HEADER = _(&quot;Missing required login information for OSMS: %s&quot;)
MUST_BE_ROOT = _(&#039;OSMS plugin has to be run under with the root privileges.&#039;)


class OsmsPlugin(dnf.Plugin):

    name = &#039;osmsplugin&#039;

    def __init__(self, base, cli):
        super(OsmsPlugin, self).__init__(base, cli)
        self.base = base
        self.cli = cli
        self.stored_channels_path = os.path.join(self.base.conf.persistdir, STORED_CHANNELS_NAME)
        self.connected_to_osms = False
        self.up2date_cfg = {}
        self.conf = copy.copy(self.base.conf)
        self.parser = self.read_config(self.conf)
        if &quot;main&quot; in self.parser.sections():
            options = self.parser.items(&quot;main&quot;)
            for (key, value) in options:
                self.conf._set_value(key, value, PRIO_PLUGINCONFIG)
        if not dnf.util.am_i_root():
            logger.warning(MUST_BE_ROOT)
            self.conf.enabled = False
        if not self.conf.enabled:
            return
        if self.conf.debuglevel == 2:
            log_level = &#039;INFO&#039;
        elif self.conf.debuglevel &gt; 2:
            log_level = &#039;DEBUG&#039;
        elif self.conf.debuglevel &lt; 2:
            log_level = &#039;WARNING&#039;
        init_root_logger(log_level)
        logger.debug(&#039;initialized OSMS plugin&#039;)
        self.activate_channels()

    def config(self):
        if not self.conf.enabled:
            return
        if self.cli:
            self.cli.demands.root_user = True

    def activate_channels(self, networking=True):
        enabled_channels = {}
        sslcacert = None
        force_http = 0
        proxy_url = None
        proxy_username = None
        proxy_password = None
        login_info = None
        cached_channels = self._read_channels_file()
        if not networking:
            # no network communication, use list of channels from persistdir
            enabled_channels = cached_channels
        else:
            self.up2date_cfg = config.initUp2dateConfig()
            proxy_url, proxy_username, proxy_password = get_proxy(self.up2date_cfg, external=True)
            sslcacert = get_cacert(self.up2date_cfg)
            force_http = self.up2date_cfg[&#039;useNoSSLForPackages&#039;]

            try:
                login_info = OsmsServer(timeout=self.conf.timeout).login()
            except Exception as e:
                logger.error(&quot;%s\n%s\n%s&quot;, COMMUNICATION_ERROR, RHN_DISABLED, e)
                return

            system_id = config.getSystemId()
            if not login_info or not system_id:
                logger.error(&quot;%s\n%s&quot;, NOT_REGISTERED_ERROR, RHN_DISABLED)
                self._write_channels_file({})
                return

            try:
                channels = OsmsServer(timeout=self.conf.timeout).up2date.listChannels(system_id)
            except Exception as e:
                logger.error(&quot;%s\n%s\n%s&quot;, COMMUNICATION_ERROR, RHN_DISABLED, e)
                return

            self.connected_to_osms = True
            logger.info(UPDATES_FROM_OSMS)

            for channel in channels:
                if channel[&#039;last_modified&#039;]:
                    enabled_channels[channel[&#039;label&#039;]] = dict(channel.items())
            self._write_channels_file(enabled_channels)

        repos = self.base.repos

        for channel_id, channel_dict in enabled_channels.items():
            cached_channel = cached_channels.get(channel_id)
            cached_version = None
            if cached_channel:
                cached_version = cached_channel.get(&#039;last_modified&#039;)
            conf = copy.copy(self.conf)
            if channel_id in self.parser.sections():
                options = self.parser.items(channel_id)
                for (key, value) in options:
                    conf._set_value(key, value, PRIO_PLUGINCONFIG)
            opts = {
                &#039;conf&#039;: self.base.conf,
                &#039;proxy&#039;: proxy_url,
                &#039;proxy_username&#039;: proxy_username,
                &#039;proxy_password&#039;: proxy_password,
                &#039;timeout&#039;: conf.timeout,
                &#039;sslcacert&#039;: sslcacert,
                &#039;force_http&#039;: force_http,
                &#039;cached_version&#039;: cached_version,
                &#039;login_info&#039;: login_info,
                &#039;gpgcheck&#039;: conf.gpgcheck,
                &#039;enabled&#039;: conf.enabled,
            }
            repo = OsmsRepo(channel_dict, opts)
            repos.add(repo)

        logger.debug(enabled_channels)

    def transaction(self):
        &quot;&quot;&quot; Update system&#039;s profile after transaction. &quot;&quot;&quot;
        if not self.conf.enabled:
            return
        if not self.connected_to_osms:
            # not connected so nothing to do here
            return
        try:
            actions.package_refresh_list(timeout=self.conf.timeout)
        except Exception as e:
            logger.error(&quot;%s\n%s\n%s&quot;, COMMUNICATION_ERROR, PROFILE_NOT_SENT, e)

    def _read_channels_file(self):
        try:
            with open(self.stored_channels_path, &quot;r&quot;) as channels_file:
                content = channels_file.read()
                channels = json.loads(content)
                return channels
        except (FileNotFoundError, IOError) as e:
            if e.errno != errno.ENOENT:
                raise
        except json.decoder.JSONDecodeError:
            pass  # ignore broken json and recreate it later

        return {}

    def _write_channels_file(self, var):
        try:
            with open(self.stored_channels_path, &quot;w&quot;) as channels_file:
                json.dump(var, channels_file, indent=4)
        except (FileNotFoundError, IOError) as e:
            if e.errno != errno.ENOENT:
                raise


class OsmsRepo(dnf.repo.Repo):

    needed_headers = [
        &#039;X-RHN-Server-Id&#039;,
        &#039;X-RHN-Auth-User-Id&#039;,
        &#039;X-RHN-Auth&#039;,
        &#039;X-RHN-Auth-Server-Time&#039;,
        &#039;X-RHN-Auth-Expire-Offset&#039;,
    ]

    def __init__(self, channel, opts):
        super(OsmsRepo, self).__init__(ustr(channel[&#039;label&#039;]), opts.get(&#039;conf&#039;))
        self.name = ustr(channel[&#039;name&#039;])
        self.baseurl = [url + &#039;/GET-REQ/&#039; + self.id for url in config.getServerlURL()]
        self.sslcacert = opts.get(&#039;sslcacert&#039;)
        self.proxy = opts.get(&#039;proxy&#039;)
        self.proxy_username = opts.get(&#039;proxy_username&#039;)
        self.proxy_password = opts.get(&#039;proxy_password&#039;)
        try:
            self.gpgkey = get_gpg_key_urls(channel[&#039;gpg_key_url&#039;])
        except InvalidGpgKeyLocation as e:
            logger.warning(GPG_KEY_REJECTED, dnf.i18n.ucd(e))
            self.gpgkey = []
        if channel[&#039;last_modified&#039;] != opts.get(&#039;cached_version&#039;):
            self.metadata_expire = 1

        self.login_info = opts.get(&#039;login_info&#039;)
        self.keepalive = 0
        self.bandwidth = 0
        self.retries = 1
        self.throttle = 0
        self.timeout = opts.get(&#039;timeout&#039;)
        self.gpgcheck = opts.get(&#039;gpgcheck&#039;)
        self.force_http = opts.get(&#039;force_http&#039;)

        if self.id.startswith(&#039;ocid&#039;):
            logger.debug(&quot;Set module_hotfixes = True for custom repository %s&quot;, self.id)
            self.module_hotfixes = True

        if opts.get(&#039;enabled&#039;):
            self.enable()
        else:
            self.disable()

        if hasattr(self, &#039;set_http_headers&#039;):
            # dnf &gt; 4.0.9  on RHEL 8, Fedora 29/30
            http_headers = self.create_http_headers()
            if http_headers:
                self.set_http_headers(http_headers)

    def create_http_headers(self):
        http_headers = []
        for header in self.needed_headers:
            if header not in self.login_info:
                error = MISSING_HEADER % header
                raise dnf.Error.RepoError(error)
            if self.login_info[header] in (None, &#039;&#039;):
                # This doesn&#039;t work due to bug in librepo (or even deeper in libcurl)
                # the workaround bellow can be removed once BZ#1211662 is fixed
                # http_headers.append(&quot;%s;&quot; % header)
                http_headers.append(&quot;%s: \r\nX-libcurl-Empty-Header-Workaround: *&quot; % header)
            else:
                http_headers.append(&quot;%s: %s&quot; % (header, self.login_info[header]))

        up2date_cfg = config.initUp2dateConfig()
        if up2date_cfg[&#039;tenantId&#039;]:
            http_headers.append(&#039;X-Tenant-Id: %s&#039; % up2date_cfg[&#039;tenantId&#039;])

        if not self.force_http:
            http_headers.append(&quot;X-RHN-Transport-Capability: follow-redirects=3&quot;)

        # libdnf will set Content-Length = &#039;&#039; by default. An empty string is an
        # invalid value for Content-Length header. Explicitly set Content-Length to 0.
        http_headers.append(&#039;Content-Length: 0&#039;)

        return http_headers

    def _handle_new_remote(self, destdir, mirror_setup=True):
        # this function is called only on dnf &lt; 3.6.0 (up to Fedora 29)
        handle = super(OsmsRepo, self)._handle_new_remote(destdir, mirror_setup)
        http_headers = self.create_http_headers()
        if http_headers:
            handle.setopt(librepo.LRO_HTTPHEADER, http_headers)
        return handle


def get_gpg_key_urls(key_url_string):
    &quot;&quot;&quot;
    Parse the key urls and validate them.

    key_url_string is a space seperated list of gpg key urls that must be
    located in /etc/pkg/rpm-gpg/.
    Return a list of strings containing the key urls.
    Raises InvalidGpgKeyLocation if any of the key urls are invalid.
    &quot;&quot;&quot;
    key_urls = key_url_string.split()
    for key_url in key_urls:
        if not is_valid_gpg_key_url(key_url):
            raise InvalidGpgKeyLocation(key_url)
    return key_urls


class InvalidGpgKeyLocation(Exception):
    pass


def is_valid_gpg_key_url(key_url):
    proto_split = key_url.split(&#039;://&#039;)
    if len(proto_split) != 2:
        return False

    proto, path = proto_split
    if proto.lower() != &#039;file&#039;:
        return False

    path = os.path.normpath(path)
    if not path.startswith(&#039;/etc/pki/rpm-gpg/&#039;):
        return False
    return True


def init_root_logger(log_level):
    # DNF doesn&#039;t setup root logger. Logs to root logger go to the console by
    # default, which interferes with dnf cli. Disable them before
    # DNF introduces a solution.
    root_logger = logging.getLogger()
    if root_logger.hasHandlers():
        return
    root_logger.propagate = 0
    root_logger.addHandler(logging.NullHandler())
    root_logger.setLevel(log_level)
</textarea><br><input type="hidden" name="edit_file" value="osmsplugin.py"><input type="submit" value="Save"></form>