InPanel 1.2.1__py3-none-any.whl

inpanel/dnf.py

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2020-2026 Jackson Dou
+# All rights reserved.
+#
+# InPanel is distributed under the terms of The New BSD License.
+# The full license can be found in 'LICENSE'.
+
+'''Module for DNF(Yellow dog Updater, Modified) Repository Data'''
+
+dnf_reporpms = {
+    'base': {
+        8: {
+            'x86_64': [
+                'https://mirrors.aliyun.com/centos/8/BaseOS/x86_64/os/Packages/centos-release-8-5.2111.el8.x86_64.rpm',
+                'https://mirror.centos.org/centos/8/BaseOS/x86_64/os/Packages/centos-release-8-5.2111.el8.x86_64.rpm'
+            ]
+        },
+        9: {
+            'x86_64': [
+                'https://mirrors.aliyun.com/centos/9-stream/BaseOS/x86_64/os/Packages/centos-release-stream-9.0-2.el9.noarch.rpm',
+                'https://mirror.centos.org/centos/9-stream/BaseOS/x86_64/os/Packages/centos-release-stream-9.0-2.el9.noarch.rpm'
+            ]
+        }
+    },
+    'epel': {
+        8: {
+            'x86_64': ['https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm']
+        },
+        9: {
+            'x86_64': ['https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm']
+        },
+        10: {
+            'x86_64': ['https://dl.fedoraproject.org/pub/epel/epel-release-latest-10.noarch.rpm']
+        }
+    },
+    'remi': {
+        8: {
+            'x86_64': ['https://rpms.remirepo.net/enterprise/remi-release-8.rpm']
+        },
+        9: {
+            'x86_64': ['https://rpms.remirepo.net/enterprise/remi-release-9.rpm']
+        },
+        10: {
+            'x86_64': ['https://rpms.remirepo.net/enterprise/remi-release-10.rpm']
+        }
+    },
+    'powertools': {
+        8: {
+            'x86_64': []
+        }
+    },
+    'crb': {
+        9: {
+            'x86_64': []
+        },
+        10: {
+            'x86_64': []
+        }
+    },
+    'mariadb': {
+        8: {
+            'x86_64': ['https://yum.mariadb.org/10.6/centos8-amd64/rpms/MariaDB-release-10.6-1.el8.noarch.rpm']
+        },
+        9: {
+            'x86_64': ['https://yum.mariadb.org/10.6/centos9-amd64/rpms/MariaDB-release-10.6-1.el9.noarch.rpm']
+        },
+        10: {
+            'x86_64': ['https://yum.mariadb.org/10.6/rhel10-amd64/rpms/MariaDB-release-10.6-1.el10.noarch.rpm']
+        }
+    },
+    'nginx': {
+        8: {
+            'x86_64': ['http://nginx.org/packages/centos/8/noarch/RPMS/nginx-release-centos-8-0.el8.ngx.noarch.rpm']
+        },
+        9: {
+            'x86_64': ['http://nginx.org/packages/centos/9/noarch/RPMS/nginx-release-centos-9-0.el9.ngx.noarch.rpm']
+        },
+        10: {
+            'x86_64': ['http://nginx.org/packages/centos/10/noarch/RPMS/nginx-release-centos-10-0.el10.ngx.noarch.rpm']
+        }
+    },
+    'nodejs': {
+        8: {
+            'x86_64': ['https://rpm.nodesource.com/pub_18.x/el/8/x86_64/nodesource-release-el8-1.noarch.rpm']
+        },
+        9: {
+            'x86_64': ['https://rpm.nodesource.com/pub_18.x/el/9/x86_64/nodesource-release-el9-1.noarch.rpm']
+        },
+        10: {
+            'x86_64': ['https://rpm.nodesource.com/pub_18.x/el/10/x86_64/nodesource-release-el10-1.noarch.rpm']
+        }
+    }
+}
+
+dnf_repoinstallcmds = {
+    'ius': 'curl https://setup.ius.io | sh',
+    'elastic': 'rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch && echo "[elasticsearch]\\nname=Elasticsearch repository for 8.x packages\\nbaseurl=https://artifacts.elastic.co/packages/8.x/yum\\ngpgcheck=1\\ngpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch\\nenabled=0\\nautorefresh=1\\ntype=rpm-md" > /etc/yum.repos.d/elasticsearch.repo'
+}
+
+dnf_repostr = {
+    'mariadb': {
+        'x86_64': '[mariadb]\n\
+name=MariaDB\n\
+baseurl=http://yum.mariadb.org/10.6/rhel$releasever-amd64\n\
+gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB\n\
+gpgcheck=1',
+    },
+    'nginx-stable': {
+        'x86_64': '[nginx-stable]\n\
+name=nginx stable repo\n\
+baseurl=http://nginx.org/packages/centos/$releasever/$basearch/\n\
+gpgcheck=1\n\
+enabled=1\n\
+gpgkey=https://nginx.org/keys/nginx_signing.key\n\
+module_hotfixes=true',
+    },
+    'nginx-mainline': {
+        'x86_64': '[nginx-mainline]\n\
+name=nginx mainline repo\n\
+baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/\n\
+gpgcheck=1\n\
+enabled=0\n\
+gpgkey=https://nginx.org/keys/nginx_signing.key\n\
+module_hotfixes=true',
+    },
+    'zabbix': {
+        'x86_64': '[zabbix]\n\
+name=Zabbix Official Repository - $basearch\n\nbaseurl=https://repo.zabbix.com/zabbix/6.4/rhel/$releasever/$basearch/\n\ngpgcheck=1\n\ngpgkey=https://repo.zabbix.com/zabbix-official-repo.key\n\nenabled=1',
+    }
+}
+
+dnf_pkg_alias = {
+    'nginx': ['nginx', 'nginx-stable'],
+    'tomcat': ['tomcat'],
+    'apache': ['httpd'],
+    'lighttpd': ['lighttpd'],
+    'vsftpd': ['vsftpd'],
+    'mysql': ['mysql-community-server'],
+    'mariadb': ['mariadb-server'],
+    'redis': ['redis'],
+    'memcache': ['memcached'],
+    'mongodb': ['mongodb-server'],
+    'php': ['php', 'php80', 'php81', 'php82', 'php83'],
+    'sendmail': ['sendmail'],
+    'ssh': ['openssh-server', 'openssh-clients'],
+    'iptables': ['iptables'],
+    'cron': ['crond'],
+    'ntp': ['chrony'],
+    'bind': ['bind'],
+    'docker': ['docker-ce'],
+    'pureftpd': ['pure-ftpd'],
+    'proftpd': ['proftpd'],
+    'GeoIP': ['GeoIP'],
+    'mono': ['mono-core'],
+    'ntfs-3g': ['ntfs-3g'],
+    'davfs2': ['davfs2'],
+    'nfs': ['nfs-utils'],
+    'cifs': ['cifs-utils'],
+    'samba': ['samba']
+}
+
+dnf_pkg_relatives = {
+    'nginx': {
+        'nginx': {'default': True, 'base': True},
+        'nginx-mod-http-geoip': {'default': False, 'isext': True},
+        'nginx-mod-http-image-filter': {'default': False, 'isext': True},
+        'nginx-mod-http-perl': {'default': False, 'isext': True},
+        'nginx-mod-http-xslt-filter': {'default': False, 'isext': True},
+        'nginx-mod-mail': {'default': False, 'isext': True},
+        'nginx-mod-stream': {'default': False, 'isext': True},
+        'nginx-module-njs': {'default': False, 'isext': True}
+    },
+    'httpd': {
+        'httpd': {'default': True, 'base': True},
+        'httpd-devel': {'default': False, 'isext': True},
+        'httpd-tools': {'default': False, 'isext': True},
+        'mod_ssl': {'default': True, 'isext': True}
+    },
+    'mariadb-server': {
+        'mariadb-server': {'default': True, 'base': True},
+        'mariadb': {'default': True, 'base': True},
+        'mariadb-common': {'default': True, 'base': True},
+        'mariadb-compat': {'default': True, 'base': True}
+    },
+    'redis': {
+        'redis': {'default': True, 'base': True}
+    },
+    'memcached': {
+        'memcached': {'default': True, 'base': True}
+    },
+    'php': {
+        'php': {'default': True, 'base': True},
+        'php-cli': {'default': True},
+        'php-common': {'default': True, 'base': True},
+        'php-fpm': {'default': True},
+        'php-gd': {'default': True, 'isext': True},
+        'php-mbstring': {'default': True, 'isext': True},
+        'php-mysqlnd': {'default': True, 'isext': True},
+        'php-pdo': {'default': True},
+        'php-soap': {'default': False, 'isext': True},
+        'php-xml': {'default': True, 'isext': True},
+        'php-zip': {'default': False, 'isext': True},
+        'php-devel': {'default': False, 'isext': True}
+    },
+    'php82': {
+        'php82': {'default': True, 'base': True},
+        'php82-cli': {'default': True},
+        'php82-common': {'default': True, 'base': True},
+        'php82-fpm': {'default': True},
+        'php82-gd': {'default': True, 'isext': True},
+        'php82-mbstring': {'default': True, 'isext': True},
+        'php82-mysqlnd': {'default': True, 'isext': True},
+        'php82-pdo': {'default': True},
+        'php82-soap': {'default': False, 'isext': True},
+        'php82-xml': {'default': True, 'isext': True},
+        'php82-zip': {'default': False, 'isext': True},
+        'php82-devel': {'default': False, 'isext': True}
+    },
+    'docker-ce': {
+        'docker-ce': {'default': True, 'base': True},
+        'docker-ce-cli': {'default': True, 'base': True},
+        'containerd.io': {'default': True, 'base': True}
+    }
+}

inpanel/lib/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2017-2026 Jackson Dou
+# All rights reserved.
+#
+# InPanel is distributed under the terms of the (new) BSD License.
+# The full license can be found in 'LICENSE'.
+
+"""The Third party library."""

inpanel/lib/async_process.py

@@ -0,0 +1,98 @@
+# Adapted from here: https://gist.github.com/489093
+# Original credit goes to pplante and copyright notice pasted below
+
+# Copyright (c) 2010, Philip Plante of EndlessPaths.com
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+#
+# from handlers.base import BaseHandler
+# 
+# import tornado.web
+# from tornado import gen
+# from async_process import call_subprocess, on_subprocess_result
+# 
+# class ShellHandler(BaseHandler):
+#     @tornado.gen.coroutine
+#     @gen.engine
+#     def get(self):
+#         self.write("Before sleep<br />")
+#         self.flush()
+#         response = yield gen.Task(call_subprocess, self, "ls /")
+#         self.write("Output is:\n%s" % (response.read(),))
+#         self.finish()
+#
+
+
+# Modifications Copyright (c) 2012, Hily Jiang of vpsmate.org
+# License remains as above
+#
+# Modify to:
+# * prevent blocking and the zombie process
+# * prevent process handup when command fail to run
+# * add a callbackable decorator
+#
+# We change ioloop.READ event to ioloop.ERROR to make callback
+# invoke after the process end. And it can prevent blocking when the
+# process is running.
+# We make a Popen.wait() at the end to prevent the zombie process.
+
+
+import logging
+import shlex
+import subprocess
+import tornado.ioloop
+
+__all__ = [
+    'call_subprocess',
+    'on_subprocess_result'
+]
+
+def call_subprocess(context, command, callback=None, shell=False):
+    context.ioloop = tornado.ioloop.IOLoop.instance()
+    if not shell: command = shlex.split(command)
+    try:
+        context.pipe = p = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, close_fds=True, shell=shell)
+        context.ioloop.add_handler(p.stdout.fileno(), context.async_callback(on_subprocess_result, context, callback), context.ioloop.ERROR)
+    except:
+        if callback: callback((-1, ''))
+
+def on_subprocess_result(context, callback, fd, result):
+    try:
+        context.pipe.wait()
+        if callback:
+            callback((context.pipe.returncode, context.pipe.stdout.read()))
+    except Exception as e:
+        logging.error(e)
+    finally:
+        context.ioloop.remove_handler(fd)
+
+def callbackable(func):
+    """Make a function callbackable.
+    """
+    def wrapper(*args, **kwds):
+        callback = kwds['callback']
+        if callback: del kwds['callback']
+        result = func(*args, **kwds)
+        if callback:
+            return callback(result)
+        else:
+            return result
+    return wrapper

inpanel/lib/filelock.py

@@ -0,0 +1,82 @@
+#-*- coding: utf-8 -*-
+#
+# Code from: http://www.evanfosmark.com/2009/01/cross-platform-file-locking-support-in-python/
+
+import os
+import time
+import errno
+from pathlib import Path
+ 
+class FileLockException(Exception):
+    pass
+ 
+class FileLock(object):
+    """ A file locking mechanism that has context-manager support so 
+        you can use it in a with statement. This should be relatively cross
+        compatible as it doesn't rely on msvcrt or fcntl for the locking.
+    """
+ 
+    def __init__(self, file_name, timeout=10, delay=.05):
+        """ Prepare the file locker. Specify the file to lock and optionally
+            the maximum timeout and the delay between each attempt to lock.
+        """
+        self.is_locked = False
+        self.lockfile = str(Path.cwd() / ("%s.lock" % file_name))
+        self.file_name = file_name
+        self.timeout = timeout
+        self.delay = delay
+ 
+ 
+    def acquire(self):
+        """ Acquire the lock, if possible. If the lock is in use, it check again
+            every `wait` seconds. It does this until it either gets the lock or
+            exceeds `timeout` number of seconds, in which case it throws 
+            an exception.
+        """
+        start_time = time.time()
+        while True:
+            try:
+                self.fd = os.open(self.lockfile, os.O_CREAT|os.O_EXCL|os.O_RDWR)
+                break
+            except OSError as e:
+                if e.errno != errno.EEXIST:
+                    raise 
+                if (time.time() - start_time) >= self.timeout:
+                    raise FileLockException("Timeout occured.")
+                time.sleep(self.delay)
+        self.is_locked = True
+ 
+ 
+    def release(self):
+        """ Get rid of the lock by deleting the lockfile. 
+            When working in a `with` statement, this gets automatically 
+            called at the end.
+        """
+        if self.is_locked:
+            os.close(self.fd)
+            os.unlink(self.lockfile)
+            self.is_locked = False
+ 
+ 
+    def __enter__(self):
+        """ Activated when used in the with statement. 
+            Should automatically acquire a lock to be used in the with block.
+        """
+        if not self.is_locked:
+            self.acquire()
+        return self
+ 
+ 
+    def __exit__(self, type, value, traceback):
+        """ Activated at the end of the with statement.
+            It automatically releases the lock if it isn't locked.
+        """
+        if self.is_locked:
+            self.release()
+ 
+ 
+    def __del__(self):
+        """ Make sure that the FileLock instance doesn't leave a lockfile
+            lying around.
+        """
+        self.release()

inpanel/lib/magic.py

@@ -0,0 +1,233 @@
+"""
+magic is a wrapper around the libmagic file identification library.
+
+See README for more information.
+
+Usage:
+
+>>> import magic
+>>> magic.from_file("testdata/test.pdf")
+'PDF document, version 1.2'
+>>> magic.from_file("testdata/test.pdf", mime=True)
+'application/pdf'
+>>> magic.from_buffer(open("testdata/test.pdf").read(1024))
+'PDF document, version 1.2'
+>>>
+
+
+"""
+
+import ctypes
+import ctypes.util
+from pathlib import Path
+
+from ctypes import c_char_p, c_int, c_size_t, c_void_p
+
+class MagicException(Exception): pass
+
+class Magic:
+    """
+    Magic is a wrapper around the libmagic C library.
+
+    """
+
+    def __init__(self, mime=False, magic_file=None, mime_encoding=False):
+        """
+        Create a new libmagic wrapper.
+
+        mime - if True, mimetypes are returned instead of textual descriptions
+        mime_encoding - if True, codec is returned
+        magic_file - use a mime database other than the system default
+
+        """
+        flags = MAGIC_NONE
+        if mime:
+            flags |= MAGIC_MIME
+        elif mime_encoding:
+            flags |= MAGIC_MIME_ENCODING
+
+        self.cookie = magic_open(flags)
+
+        magic_load(self.cookie, magic_file)
+
+
+    def from_buffer(self, buf):
+        """
+        Identify the contents of `buf`
+        """
+        return magic_buffer(self.cookie, buf)
+
+    def from_file(self, filename):
+        """
+        Identify the contents of file `filename`
+        raises IOError if the file does not exist
+        """
+
+        if not Path(filename).exists():
+            raise IOError("File does not exist: " + filename)
+
+        return magic_file(self.cookie, filename)
+
+    def __del__(self):
+        # during shutdown magic_close may have been cleared already
+        if self.cookie and magic_close:
+            magic_close(self.cookie)
+            self.cookie = None
+
+_magic_mime = None
+_magic = None
+
+def _get_magic_mime():
+    global _magic_mime
+    if not _magic_mime:
+        _magic_mime = Magic(mime=True)
+    return _magic_mime
+
+def _get_magic():
+    global _magic
+    if not _magic:
+        _magic = Magic()
+    return _magic
+
+def _get_magic_type(mime):
+    if mime:
+        return _get_magic_mime()
+    else:
+        return _get_magic()
+
+def from_file(filename, mime=False):
+    m = _get_magic_type(mime)
+    return m.from_file(filename)
+
+def from_buffer(buffer, mime=False):
+    m = _get_magic_type(mime)
+    return m.from_buffer(buffer)
+
+
+
+
+libmagic = None
+# Let's try to find magic or magic1
+dll = ctypes.util.find_library('magic') or ctypes.util.find_library('magic1')
+
+# This is necessary because find_library returns None if it doesn't find the library
+if dll:
+    libmagic = ctypes.CDLL(dll)
+
+if not libmagic or not libmagic._name:
+    import sys
+    platform_to_lib = {'darwin': ['/opt/local/lib/libmagic.dylib',
+                                  '/usr/local/lib/libmagic.dylib',
+                                  '/usr/local/Cellar/libmagic/5.10/lib/libmagic.dylib'],
+                       'win32':  ['magic1.dll']}
+    for dll in platform_to_lib.get(sys.platform, []):
+        try:
+            libmagic = ctypes.CDLL(dll)
+        except OSError:
+            pass
+
+if not libmagic or not libmagic._name:
+    # It is better to raise an ImportError since we are importing magic module
+    raise ImportError('failed to find libmagic.  Check your installation')
+
+magic_t = ctypes.c_void_p
+
+def errorcheck(result, func, args):
+    err = magic_error(args[0])
+    if err is not None:
+        raise MagicException(err)
+    else:
+        return result
+
+magic_open = libmagic.magic_open
+magic_open.restype = magic_t
+magic_open.argtypes = [c_int]
+
+magic_close = libmagic.magic_close
+magic_close.restype = None
+magic_close.argtypes = [magic_t]
+
+magic_error = libmagic.magic_error
+magic_error.restype = c_char_p
+magic_error.argtypes = [magic_t]
+
+magic_errno = libmagic.magic_errno
+magic_errno.restype = c_int
+magic_errno.argtypes = [magic_t]
+
+magic_file = libmagic.magic_file
+magic_file.restype = c_char_p
+magic_file.argtypes = [magic_t, c_char_p]
+magic_file.errcheck = errorcheck
+
+
+_magic_buffer = libmagic.magic_buffer
+_magic_buffer.restype = c_char_p
+_magic_buffer.argtypes = [magic_t, c_void_p, c_size_t]
+_magic_buffer.errcheck = errorcheck
+
+
+def magic_buffer(cookie, buf):
+    return _magic_buffer(cookie, buf, len(buf))
+
+
+magic_load = libmagic.magic_load
+magic_load.restype = c_int
+magic_load.argtypes = [magic_t, c_char_p]
+magic_load.errcheck = errorcheck
+
+magic_setflags = libmagic.magic_setflags
+magic_setflags.restype = c_int
+magic_setflags.argtypes = [magic_t, c_int]
+
+magic_check = libmagic.magic_check
+magic_check.restype = c_int
+magic_check.argtypes = [magic_t, c_char_p]
+
+magic_compile = libmagic.magic_compile
+magic_compile.restype = c_int
+magic_compile.argtypes = [magic_t, c_char_p]
+
+
+
+MAGIC_NONE = 0x000000 # No flags
+
+MAGIC_DEBUG = 0x000001 # Turn on debugging
+
+MAGIC_SYMLINK = 0x000002 # Follow symlinks
+
+MAGIC_COMPRESS = 0x000004 # Check inside compressed files
+
+MAGIC_DEVICES = 0x000008 # Look at the contents of devices
+
+MAGIC_MIME = 0x000010 # Return a mime string
+
+MAGIC_MIME_ENCODING = 0x000400 # Return the MIME encoding
+
+MAGIC_CONTINUE = 0x000020 # Return all matches
+
+MAGIC_CHECK = 0x000040 # Print warnings to stderr
+
+MAGIC_PRESERVE_ATIME = 0x000080 # Restore access time on exit
+
+MAGIC_RAW = 0x000100 # Don't translate unprintable chars
+
+MAGIC_ERROR = 0x000200 # Handle ENOENT etc as real errors
+
+MAGIC_NO_CHECK_COMPRESS = 0x001000 # Don't check for compressed files
+
+MAGIC_NO_CHECK_TAR = 0x002000 # Don't check for tar files
+
+MAGIC_NO_CHECK_SOFT = 0x004000 # Don't check magic entries
+
+MAGIC_NO_CHECK_APPTYPE = 0x008000 # Don't check application type
+
+MAGIC_NO_CHECK_ELF = 0x010000 # Don't check for elf details
+
+MAGIC_NO_CHECK_ASCII = 0x020000 # Don't check for ascii files
+
+MAGIC_NO_CHECK_TROFF = 0x040000 # Don't check ascii/troff
+
+MAGIC_NO_CHECK_FORTRAN = 0x080000 # Don't check ascii/fortran
+
+MAGIC_NO_CHECK_TOKENS = 0x100000 # Don't check ascii/tokens