genocide 236__tar.gz → 237__tar.gz

{genocide-236/genocide.egg-info → genocide-237}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genocide
-Version: 236
+Version: 237
 Summary: Since 4 March 2019
 Author-email: Bart Thate <bthate@dds.nl>
 License-Expression: Unlicense

genocide-237/genocide/booting.py

@@ -0,0 +1,148 @@
+# This file is placed in the Public Domain.
+
+
+"in the beginning"
+
+
+import os
+import threading
+import time
+import _thread
+
+
+from .clients import Broker, Client
+from .command import Commands
+from .configs import Main
+from .package import Mods
+from .persist import Workdir
+from .tasking import Task
+from .utility import MD5, Event, Log, Logging, Utils
+
+
+logger = Log(__name__)
+
+
+class Boot:
+
+    "at startup"
+
+    running = Event()
+    stopped = Event()
+
+    @classmethod
+    def banner(cls, force=False):
+        "hello"
+
+    @classmethod
+    def boot(cls):
+        "prepare for runtime."
+        cls.configure()
+        MD5.core()
+        if Main.verbose:
+            cls.banner()
+        if Main.all:
+            Main.mods = ",".join(Mods.list())
+        Commands.table()
+        Mods.table()
+        if Main.scanner:
+            Commands.scanner()
+
+    @classmethod
+    def configure(cls, wdr=""):
+        "setup basic variables"
+        Workdir.wdr = wdr or Main.wdr or Workdir.wdr or Workdir.home(Main.name)
+        Workdir.skel()
+        Main.level = Main.level or "warning"
+        Logging.size(len(Main.name))
+        Logging.level(Main.level)
+        # Mods.dir("modules", Workdir.moddir())
+        Mods.dir(f"{Main.name}.miminal", Mods.moddir("minimal"))
+        Mods.dir(f"{Main.name}.modules", Mods.moddir())
+        if Main.path:
+            for pth in Utils.spl(Main.path):
+                pth = os.path.normpath(pth)
+                pkgname = pth.rsplit(os.sep, maxsplit=1)[-1]
+                Mods.dir(pkgname, pth)
+
+    @classmethod
+    def forever(cls):
+        "run forever until ctrl-c."
+        cls.running.set()
+        while cls.running.is_set():
+            try:
+                time.sleep(0.1)
+            except (KeyboardInterrupt, EOFError):
+                break
+        cls.stopped.set()
+
+    @classmethod
+    def init(cls, names, wait=False):
+        "call init of modules that have an init function."
+        thrs = []
+        for name in Utils.spl(names):
+            mod = Mods.get(name)
+            if not mod or "init" not in dir(mod):
+                continue
+            thrs.append(Task.start(mod.init))
+        if thrs and wait:
+            for thr in thrs:
+                thr.join()
+        return True
+
+    @classmethod
+    def shutdown(cls, wait=True):
+        "call stop on clients."
+        logger.info("shutdown")
+        for client in Broker.objs("wait"):
+            logger.debug("wait %s", client)
+            try:
+                client.wait()
+            except (KeyboardInterrupt, EOFError):
+                pass
+        time.sleep(0.01)
+        for client in Broker.objs("stop"):
+            logger.debug("stop %s", client)
+            try:
+                client.stop()
+            except (KeyboardInterrupt, EOFError):
+                pass
+        time.sleep(0.01)
+        if wait:
+            while True:
+                if len(threading.enumerate()) <= 1:
+                    break
+                time.sleep(0.01)
+        cls.stopped.set()
+
+    @classmethod
+    def wrapped(cls, func, *args):
+        "wrap function in a try/except, silence ctrl-c/ctrl-d."
+        try:
+            func(*args)
+        except (KeyboardInterrupt, EOFError):
+            Client.block.set()
+            _thread.interrupt_main()
+
+    @classmethod
+    def wrap(cls, func, *args, dofinal=None):
+        "restore console."
+        import sys
+        import termios
+        try:
+            old = termios.tcgetattr(sys.stdin.fileno())
+        except termios.error:
+            old = None
+        try:
+            cls.wrapped(func, *args)
+        except (KeyboardInterrupt, EOFError):
+            pass
+        if old and old[0]:
+            termios.tcsetattr(sys.stdin.fileno(), termios.TCSADRAIN, old)
+        if dofinal:
+            dofinal()
+
+
+def __dir__():
+    return (
+        'Boot',
+    )

genocide-237/genocide/clients.py

@@ -0,0 +1,206 @@
+# This file is placed in the Public Domain.
+
+
+"displaying messages"
+
+
+import _thread
+
+
+from .handler import Handler
+from .tasking import Task
+from .utility import Event, RLock, Queue
+
+
+class Broker:
+
+    "map repr(obj) to obj"
+
+    objects = {}
+
+    @classmethod
+    def add(cls, obj):
+        "add object to the broker, key is repr(obj)."
+        cls.objects[repr(obj)] = obj
+
+    @classmethod
+    def get(cls, origin):
+        "object by repr(obj)."
+        return cls.objects.get(origin)
+
+    @classmethod
+    def has(cls, obj):
+        "whether the Broker has object."
+        return repr(obj) in cls.objects
+
+    @classmethod
+    def like(cls, text):
+        "all keys with a substring in their key."
+        for orig in cls.objects:
+            if text in orig.split()[0]:
+                yield (orig, cls.get(orig))
+
+    @classmethod
+    def objs(cls, attr):
+        "objects with a certain attribute."
+        for obj in cls.objects.values():
+            if attr in dir(obj):
+                yield obj
+
+    @classmethod
+    def remove(cls, obj):
+        "remove object."
+        del cls.objects[repr(obj)]
+
+
+class Display:
+
+    "unit of display"
+
+    block = Event()
+    last = ""
+
+    def __init__(self):
+        self.olock = RLock()
+        self.silent = False
+        Broker.add(self)
+
+    def announce(self, text):
+        "announce text to all channels."
+        if not self.silent:
+            self.raw(text)
+
+    def display(self, msg):
+        "display msg results."
+        with self.olock:
+            for txt in msg.result:
+                if self.block.is_set():
+                    return
+                self.dosay(msg.channel, txt)
+                del txt
+        del msg
+
+    def dosay(self, channel, text):
+        "say called by display."
+        self.say(channel, text)
+
+    def raw(self, text):
+        "raw output."
+        raise NotImplementedError
+
+    def say(self, channel, text):
+        "say text in channel."
+        self.last = channel
+        self.raw(text)
+
+
+class Output(Display):
+
+    "dedicated output loop"
+
+    def __init__(self):
+        Display.__init__(self)
+        self.oqueue = Queue()
+        self.ostopped = Event()
+
+    def display(self, msg):
+        "do actual display."
+
+    def output(self):
+        "output loop."
+        while not self.ostopped.is_set():
+            try:
+                msg = self.oqueue.get()
+            except (KeyboardInterrupt, EOFError):
+                _thread.interrupt_main()
+            if msg is None:
+                self.oqueue.task_done()
+                break
+            self.display(msg)
+            self.oqueue.task_done()
+
+    def raw(self, text):
+        "raw output."
+        raise NotImplementedError
+
+    def start(self, daemon=True, name=None):
+        "start output loop."
+        self.ostopped.clear()
+        Task.start(self.output, daemon=daemon, name=name)
+
+    def stop(self):
+        "stop output loop."
+        self.ostopped.set()
+        self.oqueue.put(None)
+
+    def wait(self):
+        "wait for output to finish."
+        try:
+            self.oqueue.join()
+        except (KeyboardInterrupt, EOFError):
+            _thread.interrupt_main()
+
+
+class Client(Handler, Display):
+
+    "display with coupled handler"
+
+    def __init__(self):
+        Handler.__init__(self)
+        Display.__init__(self)
+
+    def raw(self, text):
+        "raw output."
+        raise NotImplementedError
+
+
+class BufferedClient(Handler, Output):
+
+    "buffered output"
+
+    def __init__(self):
+        Handler.__init__(self)
+        Output.__init__(self)
+
+    def raw(self, text):
+        "raw output."
+        raise NotImplementedError
+
+    def start(self, daemon=True, name=None):
+        "start output loop."
+        Handler.start(self)
+        Output.start(self, daemon=daemon, name=name)
+
+    def stop(self):
+        "stop output loop."
+        Handler.stop(self)
+        Output.stop(self)
+
+
+class Clients:
+
+    "collection of clients"
+
+    @staticmethod
+    def announce(text):
+        "announce text on all clients."
+        for obj in Broker.objs("announce"):
+            obj.announce(text)
+
+    @staticmethod
+    def display(msg):
+        "display results."
+        bot = Broker.get(msg.orig)
+        if bot:
+            bot.display(msg)
+
+
+def __dir__():
+    return (
+        'Broker',
+        'BufferedClient',
+        'Client',
+        'Clients',
+        'Display',
+        'Output'
+    )

genocide-237/genocide/command.py

@@ -0,0 +1,192 @@
+# This file is placed in the Public Domain.
+
+
+"program your own commands"
+
+
+import inspect
+
+
+from .clients import Clients
+from .message import Message
+from .methods import Method
+from .package import Mods
+from .utility import Utils
+
+
+class Commands:
+
+    "command dispatch"
+
+    cmds = {}
+    names = {}
+
+    @classmethod
+    def add(cls, *funcs):
+        "register a command."
+        for func in funcs:
+            name = Utils.funcname(func)
+            cls.cmds[name] = func
+
+    @classmethod
+    def cmd(cls, txt):
+        "parse single line to command and run it."
+        msg = Message()
+        msg.text = txt
+        msg.kind = "command"
+        cls.command(msg)
+        return msg.result
+
+    @classmethod
+    def command(cls, msg):
+        "command callback."
+        Parser.parse(msg, msg.text)
+        func = cls.cmds.get(msg.cmd, cls.ondemand(msg.cmd))
+        if func:
+            func(msg)
+            Clients.display(msg)
+        msg.ready()
+
+    @classmethod
+    def list(cls):
+        "scan for a list of all commands."
+        result = []
+        for modname in Mods.list():
+            mod = Mods.get(modname)
+            if not mod:
+                continue
+            result.extend([Utils.funcname(x) for x in cls.scan(mod, True)])
+        return result
+
+    @classmethod
+    def ondemand(cls, name):
+        "ondemand loading of commands."
+        modname = cls.names.get(name, None)
+        if not modname:
+            return None
+        mod = Mods.get(modname)
+        if not mod:
+            return None
+        cls.scan(mod)
+        return cls.cmds.get(name, None)
+
+    @classmethod
+    def scan(cls, mod, skip=False):
+        "scan module for commands."
+        result = []
+        for nme, func in inspect.getmembers(mod, inspect.isfunction):
+            if "cb_" in nme:
+                continue
+            if 'msg' in inspect.signature(func).parameters:
+                if not skip:
+                    cls.add(func)
+                result.append(func)
+        return result
+
+    @classmethod
+    def scanner(cls):
+        "scan all modules."
+        for name in Mods.list():
+            mod = Mods.get(name)
+            if not mod:
+                continue
+            cls.scan(mod)
+
+    @classmethod
+    def statics(cls):
+        "read table."
+        try:
+            from .statics import NAMES
+            cls.names.update(NAMES)
+        except (ImportError, SyntaxError, ValueError):
+            pass
+
+    @classmethod
+    def table(cls):
+        "read static tables."
+        cls.statics()
+        if not cls.names:
+            cls.scanner()
+
+
+cmd = Commands.cmd
+typed = Method.typed
+
+
+class Parser:
+
+    "parsing for commands"
+
+    @classmethod
+    def init(cls, obj, text, clean=False):
+        "set default values."
+        data = {
+            "args": [],
+            "cmd": "",
+            "gets": {},
+            "index": None,
+            "init": "",
+            "mod": "",
+            "opts": "",
+            "otxt": text,
+            "rest": "",
+            "silent": {},
+            "sets": {},
+            "text": text
+        }
+        for k, v in data.items():
+            if not clean:
+                setattr(obj, k, data.get(k, v) or v)
+            else:
+                setattr(obj, k, v)
+
+    @classmethod
+    def parse(cls, obj, text, clean=False):
+        "parse text for command and arguments."
+        cls.init(obj, text, clean)
+        args = []
+        nr = -1
+        for spli in text.split():
+            if spli.startswith("--"):
+                obj.opts += f",{spli[2:]}"
+                continue
+            if spli.startswith("-"):
+                try:
+                    obj.index = int(spli[1:])
+                except ValueError:
+                    obj.opts += spli[1:]
+                continue
+            if "-=" in spli:
+                key, value = spli.split("-=", maxsplit=1)
+                typed(obj.silent, key, value)
+                typed(obj.gets, key, value)
+                continue
+            if "==" in spli:
+                key, value = spli.split("==", maxsplit=1)
+                typed(obj.gets, key, value)
+                continue
+            if "=" in spli:
+                key, value = spli.split("=", maxsplit=1)
+                typed(obj.sets, key, value)
+                continue
+            nr += 1
+            if nr == 0:
+                obj.cmd = spli
+                continue
+            args.append(spli)
+        if args:
+            obj.args = args
+            obj.rest = " ".join(obj.args)
+            obj.text = obj.cmd + " " + obj.rest
+        if "v" in obj.opts:
+            obj.verbose = True
+        if "t" in obj.opts:
+            obj.threaded = True
+
+
+def __dir__():
+    return (
+        'Commands',
+        'Parser',
+        'cmd'
+    )

genocide-237/genocide/configs.py

@@ -0,0 +1,44 @@
+# This file is placed in the Public Domain.
+
+
+"one config to rule them all"
+
+
+from .methods import Method
+
+
+class Config(type):
+
+    "config meta class"
+
+    def __getattr__(cls, key):
+        if key in dir(cls):
+            return cls.__getattribute__(key)
+        return ""
+
+    def __str__(cls):
+        return str(Method.skip(cls))
+
+
+class Main(metaclass=Config):
+
+    "main config"
+
+    level = ""
+    mods = ""
+    name = Method.pkgname(Config)
+    otxt = ""
+    path = ""
+
+
+class Cfg(metaclass=Config):
+
+    "inheritable config"
+
+
+def __dir__():
+    return (
+        'Cfg',
+        'Config',
+        'Main'
+    )

genocide-237/genocide/daemons.py

@@ -0,0 +1,61 @@
+# This file is placed in the Public Domain.
+
+
+"background daemon"
+
+
+from .configs import Main
+from .persist import Workdir
+
+
+class Daemon:
+
+    "detach from console"
+
+    @classmethod
+    def daemon(cls):
+        "run in the background."
+        import os
+        import sys
+        pid = os.fork()
+        if pid != 0:
+            os._exit(0)
+        os.setsid()
+        pid2 = os.fork()
+        if pid2 != 0:
+            os._exit(0)
+        if not Main.verbose:
+            cls.null(sys.stdin)
+            cls.null(sys.stdout)
+            cls.null(sys.stderr)
+        os.umask(0o077)
+        os.chdir("/")
+        os.nice(10)
+
+    @classmethod
+    def null(cls, iostream):
+        "route to /dev/null."
+        import os
+        with open('/dev/null', 'r', encoding="utf-8") as sis:
+            os.dup2(sis.fileno(), iostream.fileno())
+
+    @classmethod
+    def pid(cls):
+        "return pid path."
+        return Workdir.pid(Main.name)
+
+    @classmethod
+    def privileges(cls):
+        "drop privileges."
+        import getpass
+        import os
+        import pwd
+        pwnam2 = pwd.getpwnam(getpass.getuser())
+        os.setgid(pwnam2.pw_gid)
+        os.setuid(pwnam2.pw_uid)
+
+
+def __dir__():
+    return (
+        'Daemon',
+    )