pluginserver 0.8.1__tar.gz → 0.9.0__tar.gz

{pluginserver-0.8.1/pluginserver.egg-info → pluginserver-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pluginserver
-Version: 0.8.1
+Version: 0.9.0
 Summary: Plugin-driven API server
 Home-page: https://github.com/nicciniamh/pluginserver
 Author: Nicole Stevens

{pluginserver-0.8.1 → pluginserver-0.9.0}/plugincore/baseplugin.py

@@ -1,6 +1,7 @@
 import asyncio
 from aiohttp import web
 import inspect
+from plugincore import logjam
 
 class BasePlugin:
     """
@@ -14,6 +15,9 @@ class BasePlugin:
         self.config = kwargs.get('config')
         self._plugin_id = kwargs.get('route_path',self.__class__.__name__.lower())
         auth = kwargs.get('auth_type')
+        args = kwargs.get('prog_args')
+        if not args:
+            raise ValueError(f"no args were passed")
         if auth:
             auth = auth.lower()
         if auth:
@@ -28,8 +32,23 @@ class BasePlugin:
                 if not self._apikey:
                     raise ValueError('Auth is plugin but no plugin apikey')
                 self._auth_type = 'plugin'
+        if args.log:
+            self.log = logjam.LogJam(file=args.log, name=self._plugin_id,level=args.level)
+        else:
+            self.log = logjam.LogJam(name=self._plugin_id,level=args.level)
+        kwargs['log'] = self.log
         self.args = dict(kwargs)
 
+    def _get_client_ip(self,request):
+        # Check proxy headers first
+        forwarded_for = request.headers.get('X-Forwarded-For')
+        if forwarded_for:
+            return forwarded_for.split(',')[0].strip()
+
+        # Fall back to transport address
+        peername = request.transport.get_extra_info('peername')
+        return peername[0] if peername else 'unknown'
+
     def terminate_plugin(self):
         pass
 
@@ -77,13 +96,23 @@ class BasePlugin:
         return self._plugin_id
     
     async def handle_request(self, **data):
+        request = data.get('request',{})
         auth_check = self._check_auth(data)
+        data['client_ip'] = self._get_client_ip(data.get('request'))
         if auth_check:
             result = self.request_handler(**data)
             code, response = await result if inspect.isawaitable(result) else result
             #print(f"Got {code} - {response}")
         else:
+            self.log.error(f"{data['client_ip']} - request for {self._plugin_id} - Not authorized")
             code, response = 403, {'error': 'unauthorized'}
-        if not isinstance(response,web.Response):
-            response_obj = web.json_response(response,status=code)
-        return response_obj   
+
+        if isinstance(response, web.Response):
+            pass
+        elif isinstance(response, dict):
+            response = web.json_response(response)
+        elif isinstance(response, str):
+            response = web.Response(text=response, content_type='text/html')
+        else:
+            response = web.json_response({'result': str(response)})
+        return response

pluginserver-0.9.0/plugincore/logjam.py

@@ -0,0 +1,76 @@
+import logging
+import time
+import io
+import sys
+import os
+
+class LogJam:
+    def __init__(self, **kwargs):
+        self.log_level = kwargs.get('level', logging.DEBUG)
+        self.log_name = kwargs.get('name', 'NONAME')
+        self.log_file = kwargs.get('file', None)
+
+        # Convert string log level to logging constant if needed
+        if isinstance(self.log_level, str):
+            self.log_level = getattr(logging, self.log_level.upper(), logging.DEBUG)
+
+        self.logger = logging.getLogger(self.log_name)
+        self.logger.setLevel(self.log_level)
+
+        # Prevent duplicate handlers if logger already exists
+        if not self.logger.handlers:
+            if os.isatty(sys.stdout.fileno()):
+                formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+            else:
+                formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
+
+            # Console (stdout) handler
+            ch = logging.StreamHandler()
+            ch.setLevel(self.log_level)
+            ch.setFormatter(formatter)
+            self.logger.addHandler(ch)
+
+            # Optional file handler
+            if self.log_file:
+                fh = logging.FileHandler(self.log_file)
+                fh.setLevel(self.log_level)
+                fh.setFormatter(formatter)
+                self.logger.addHandler(fh)
+
+    def __call__(self,*args):
+        self.info(*args)
+
+    def common_log(self,**kwargs):
+        #ip, user_ident, user_auth, timestamp, method, path, protocol, status, size,file=None):
+        user_ident = kwargs.get('user_ident','-')
+        user_auth = kwargs.get('user_auth','-')
+        timestamp = kwargs.get('timestamp',time.time())
+        bad_keys = []
+        for k in ['ip','method','protocol','path','status','size']:
+            kv = kwargs.get(k) or None
+            if not kv:
+                bad_keys.append(k)
+        if len(bad_keys):
+            raise AttributeError(f"No value(s) given for {' '.join(bad_keys)}")
+        ip = kwargs.get('ip')
+        method = kwargs.get('method')
+        path = kwargs.get('path')
+        protocol = kwargs.get('protocol')
+        status  = kwargs.get('status')
+        size = kwargs.get('size')
+        file = kwargs.get('file')
+        time_str = time.strftime("%d/%b/%Y:%H:%M:%S %z",time.localtime(timestamp))
+        lstr = f'{ip} {user_ident} {user_auth} [{time_str}] "{method} {path} {protocol}" {status} {size}'
+        if type(file) is str:
+            with open(file,'a') as f:
+                print(lstr,file=f)
+        elif isinstance(file,io.IOBase):
+            print(lstr,file=file)
+        return lstr
+    
+    def debug(self, *args):     self.logger.debug(*args)
+    def info(self, *args):      self.logger.info(*args)
+    def warning(self, *args):   self.logger.warning(*args)
+    def error(self, *args):     self.logger.error(*args)
+    def critical(self, *args):  self.logger.critical(*args)
+    def exception(self, *args): self.logger.exception(*args)

{pluginserver-0.8.1 → pluginserver-0.9.0}/plugincore/pluginmanager.py

@@ -7,6 +7,7 @@ import glob
 from typing import Dict, List, Union
 from plugincore import baseplugin
 from urllib.parse import parse_qs
+import json
 
 def parse_parameter_string(s):
     return {key: value[0] for key, value in parse_qs(s).items()}
@@ -17,9 +18,18 @@ class PluginManager:
         self.plugins: Dict[str, baseplugin.BasePlugin] = {}
         self.modules: Dict[str, types.ModuleType] = {}
         self.config = kwargs.get('config')
+        self.task_callback = kwargs.get('task_callback')
+        self.log = kwargs.get('log')
+        self.prog_args = kwargs.get('args')
+        if not self.prog_args:
+            raise ValueError('PluginManager: no args object passed')
         self.kwargs = dict(kwargs)
 
-    def _load_module(self, filepath: str) -> types.ModuleType:
+    
+    def reset_config(self,config):
+        self.config = config
+
+    async def _load_module(self, filepath: str) -> types.ModuleType:
         mod_name = os.path.basename(filepath).replace(".py", "")
         spec = importlib.util.spec_from_file_location(mod_name, filepath)
         if spec is None or spec.loader is None:
@@ -35,63 +45,78 @@ class PluginManager:
                 classes.append(cls)
         return classes
 
-    def load_plugins(self):
+    async def load_plugins(self):
         plugin_files = glob.glob(os.path.join(self.plugin_dir, '*.py'))
-        print(f"Loading plugins from {self.plugin_dir}: {plugin_files}")
+        self.log(f"Loading plugins from {self.plugin_dir}")
         for path in plugin_files:
-            self.load_plugin(path)
+            await self.load_plugin(path)
 
-    def load_plugin(self, path: str):
+    async def load_plugin(self, path: str):
         plugin_module = os.path.splitext(os.path.basename(path))[0]  # strip .py
-        mod = self._load_module(path)
+        mod = await self._load_module(path)
         self.modules[plugin_module] = mod
 
         for cls in self._get_plugin_classes(mod):
-            adict = {}
+            adict = {'task_callback': self.task_callback}
             try:
                 adict = parse_parameter_string(self.config.plugin_parms[plugin_module])
             except (AttributeError, KeyError):
                 pass
+            adict['prog_args'] = self.prog_args
             kwargs = self.kwargs.copy()
             kwargs.update(adict)
             kwargs['config'] = self.config
-            instance = cls(**kwargs)
-            print(f"Loaded plugin {cls.__name__}: {instance}")
-            self.plugins[instance._get_plugin_id()] = instance
-
-    def remove_plugin(self, plugin_id: str):
+            if 'json' in adict:
+                jfilename= os.path.join(self.config.paths.plugins, adict['json'])
+                if os.path.exists(jfilename):
+                    try:
+                        with open(jfilename) as  f:
+                            kwargs.update(json.load(f))
+                    except Exception as e:
+                        self.log.warning(f"Plugin for {cls.__name__} could not load JSON settings from {jfilename}: {e}")
+            try:
+                instance = cls(**kwargs)
+                initialize = getattr(instance,'initialize',None)
+                if initialize and callable(initialize):
+                    await instance.initialize(**kwargs)
+                self.log(f"Loaded plugin {cls.__name__}")
+                self.plugins[instance._get_plugin_id()] = instance
+            except Exception as e:
+                self.log.exception(f"Exception loading plugin from {path}: {e}")
+                
+    async def remove_plugin(self, plugin_id: str):
         plugin = self.plugins.pop(plugin_id, None)
         if not plugin:
-            print(f"No plugin with ID {plugin_id}")
+            self.log(f"No plugin with ID {plugin_id}")
             return
 
         # Try to remove the module
         try:
             plugin.terminate_plugin()
         except Exception as e:
-            print(f"Exception {type(e)} Unloading plugin - terminate_plugin threw {e}")
+            self.log.exception(f"Exception {type(e)} Unloading plugin - terminate_plugin threw {e}")
         module_name = plugin.__class__.__module__
         module_file = os.path.basename(module_name + ".py")
-        print(f"Removing plugin {plugin_id} from module {module_name}")
+        self.log(f"Removing plugin {plugin_id} from module {module_name}")
 
         self.modules.pop(module_file, None)
         sys.modules.pop(module_name, None)
 
-    def reload_plugin(self, plugin_id: str):
+    async def reload_plugin(self, plugin_id: str):
         if plugin_id not in self.plugins:
-            print(f"No such plugin to reload: {plugin_id}")
+            self.log(f"No such plugin to reload: {plugin_id}")
             return
         plugin = self.plugins[plugin_id]
         module_name = plugin.__class__.__module__
         module_file = os.path.basename(module_name + ".py")
         full_path = os.path.join(self.plugin_dir, module_file)
 
-        self.remove_plugin(plugin_id)
-        self.load_plugin(full_path)
+        await self.remove_plugin(plugin_id)
+        await self.load_plugin(full_path)
 
-    def get_plugin(self, plugin_id: str):
+    async def get_plugin(self, plugin_id: str):
         return self.plugins.get(plugin_id)
 
-    def all_plugins(self):
+    async def all_plugins(self):
         return self.plugins
 

pluginserver-0.9.0/plugincore/pserv.py

@@ -0,0 +1,467 @@
+#!/usr/bin/env python3
+import argparse
+import inspect
+import asyncio
+import ssl
+import os
+import sys
+import signal
+import aiohttp_cors
+from aiohttp import web
+from plugincore import pluginmanager
+from plugincore import configfile
+from plugincore import logjam
+
+routes = web.RouteTableDef()
+manager = None
+globalCfg = None
+config_file = None
+
+async_tasks = []
+
+log = print
+
+globals()['_signal_exit_code'] = 0
+
+def cors_setup(app):
+    global globalCfg
+    global log
+    if 'cors' in globalCfg and 'enabled' in globalCfg['cors']:
+        rules = aiohttp_cors.ResourceOptions(
+            allow_credentials=True,
+            allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+            allow_headers=("Content-Type", "Authorization", "X-Requested-With", "Accept"),
+            expose_headers=("X-Custom-Header", "Content-Length"),
+            max_age=3600
+        )
+
+        settings = {}
+        for origin in globalCfg.cors.origin_url:
+            settings[origin] = rules
+
+        cors_configuration = aiohttp_cors.setup(app, defaults=settings)
+        
+        for route in list(app.router.routes()):
+            cors_configuration.add(route)
+            
+        log.info('CORS middleware enabled')
+
+def register_async_task(task):
+    global async_tasks
+    async_tasks.append(task)
+
+def get_signal_name(signal_number):
+    for name in dir(signal):
+        if name.startswith("SIG") and getattr(signal, name) == signal_number:
+            return name
+    return None
+
+on_shutdown_entered = False
+async def on_shutdown(*args):
+    global on_shutdown_entered
+    global manager
+    global async_tasks
+    global log
+    global globalCfg
+    if 'pidfile' in globalCfg.paths:
+        try:
+            os.unlink(globalCfg.paths.pidfile)
+        except:
+            pass
+    if on_shutdown_entered:
+        return
+    on_shutdown_entered = True
+    log(("Sending plugins the terminate signal"))
+    for id, plugin in manager.plugins.items():
+        try:
+            log(f"Terminating plugin {id}")
+            plugin.terminate_plugin()
+            await asyncio.sleep(1)
+        except Exception as e:
+            log(f"{type(e).__name__} Exception unloading plugin id {id}: {e}")
+    else:
+        log("Plugin manager or plugins not available for shutdown.")
+
+    #await asyncio.sleep(max(len(all_current_tasks)+1,5))
+    log("Waiting for terminate_plugins to complete.")
+    all_current_tasks = asyncio.all_tasks()
+    log.info(f"Ensuring tasks are ended")
+    current_shutdown_task = asyncio.current_task()
+
+    tasks_to_cancel = []
+    for task in all_current_tasks:
+        if task is not current_shutdown_task:
+            if task.get_name() != '::main::':
+                tasks_to_cancel.append(task)
+
+    if tasks_to_cancel:
+        for task_to_cancel_item in tasks_to_cancel:
+            if not task_to_cancel_item.done():
+                log(f"terminating task {task_to_cancel_item.get_name()}")
+                task_to_cancel_item.cancel()
+        log("Waiting for all other async tasks to complete cancellation...")
+        results = await asyncio.gather(*tasks_to_cancel, return_exceptions=True)
+        for i, result in enumerate(results):
+            task = tasks_to_cancel[i]
+            task_name = task.get_name() if hasattr(task, 'get_name') else f"Task-{id(task)}"
+            if isinstance(result, asyncio.CancelledError):
+                log(f"{task_name} was successfully cancelled.")
+            elif isinstance(result, Exception):
+                log(f"{task_name} finished with an exception: {type(result).__name__} - {result}")
+            else:
+                log(f"{task_name} finished. Result: {result}")
+    else:
+        log("No other async tasks found to cancel.")
+
+async def _sh_then_act(action_func, *action_args):
+    global log
+    try:
+        await on_shutdown()
+    except Exception as e:
+        current_log_func = log if callable(getattr(log, 'exception', None)) else lambda msg: print(msg, file=sys.stderr)
+        current_log_func(f"Exception during on_shutdown from signal: {type(e).__name__} - {e}")
+    finally:
+        if callable(action_func):
+            action_func(*action_args)
+
+def _sched_sh(async_wrapper_func, sync_action_func, *sync_action_args):
+    global log
+    current_log_func = log if callable(getattr(log, 'info', None)) else print
+    try:
+        loop = asyncio.get_running_loop()
+        if loop.is_running():
+            asyncio.create_task(async_wrapper_func(sync_action_func, *sync_action_args))
+        else:
+            if callable(sync_action_func):
+                sync_action_func(*sync_action_args)
+    except RuntimeError:
+        if callable(sync_action_func):
+            sync_action_func(*sync_action_args)
+    except Exception as e:
+        current_log_func(f"Error in _sched_sh: {type(e).__name__} - {e}")
+        if callable(sync_action_func): 
+             sync_action_func(*sync_action_args)
+
+def _act_execl():
+    global log
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os.execl(sys.executable, sys.executable, *sys.argv)
+
+def _act_exit(exit_code):
+    globals()['_signal_exit_code'] = exit_code
+    try:
+        asyncio.get_running_loop().stop()
+    except RuntimeError:
+        sys.exit(exit_code)
+
+async def pserve_main(args):
+    global log
+    global manager
+    global globalCfg
+    global config_file
+    global routes
+    global on_shutdown
+    asyncio.current_task().set_name("::main::")
+
+    we_are = os.path.splitext(os.path.basename(sys.argv[0]))[0]
+
+    config_file = args.ini_file
+    if args.log:
+        log = logjam.LogJam(file=args.log, name=we_are,level=args.level)
+    else:
+        log = logjam.LogJam(name=we_are)
+
+    signal.signal(signal.SIGUSR1, reload)
+    log(f"{we_are}({os.getpid()}): Installed SIGUSR1 handler for reload.")
+    for sig_val_item in []:
+        try:
+            signal.signal(sig_val_item, lambda signum_val, frame_val: terminate(signum_val, frame_val, sig_to_exit_code=signum_val))
+            log(f"Installed signal handler for {get_signal_name(sig_val_item)} to terminate wrapper")
+        except Exception as e:
+            log(f"{type(e).__name__} setting signal handler for {sig_val_item}: {e}")
+
+    globalCfg = configfile.Config(file=config_file)
+    if 'pidfile' in globalCfg.paths:
+        with open(globalCfg.paths.pidfile,'w') as f:
+            print(f"{os.getpid()}",file=f)
+    ssl_ctx = None
+    ssl_cert, ssl_key = (None, None)
+    enabled = False
+
+    try:
+        ssl_key = globalCfg.SSL.keyfile
+        ssl_cert = globalCfg.SSL.certfile
+        enabled = globalCfg.SSL.enabled
+    except AttributeError:
+        pass
+
+    if ssl_key and ssl_cert and enabled:
+        ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+        log("======== SSL Configuration ========")
+        log(f"SSL key {ssl_key}")
+        log(f"SSL certificate: {ssl_cert}")
+        try:
+            ssl_ctx.load_cert_chain(ssl_cert, ssl_key, None)
+            log(f"SSL context loaded with cert: {ssl_cert}, key: {ssl_key}")
+        except FileNotFoundError as e:
+            log(f"FileNotFoundError loading SSL cert/key: {e}. Check paths: Cert='{ssl_cert}', Key='{ssl_key}'")
+            ssl_ctx = None
+        except ssl.SSLError as e:
+            log(f"ssl.SSLError loading SSL cert/key: {e}. Plese check your key and certfiles.")
+            ssl_ctx = None
+        except Exception as e:
+            log(f"Exception({type(e).__name__}): Error loading ssl_cert_chain: {e}")
+            ssl_ctx = None
+        log("End of SSL configuration.")
+    elif enabled:
+        log("SSL is enabled in config, but certfile or keyfile is missing/not specified.")
+
+    if not 'paths' in globalCfg or  not 'plugins' in globalCfg.paths:
+        log(f"Configuration error: 'paths.plugins' not found in '{config_file}'. Cannot load plugins.")
+        sys.exit(1)
+    log("======== Loading plugin modules ========")
+    manager = pluginmanager.PluginManager(globalCfg.paths.plugins, config=globalCfg, log=log, task_callback=register_async_task, args=args)
+    await manager.load_plugins()
+
+    for plugin_id, instance in manager.plugins.items():
+        register_plugin_route(plugin_id, instance, globalCfg)
+
+    register_control_routes(globalCfg)
+
+    app = web.Application()
+    app.add_routes(routes)
+    app.on_shutdown.append(on_shutdown)
+    cors_setup(app)
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.TCPSite(runner, host=globalCfg.network.bindto, port=globalCfg.network.port, ssl_context=ssl_ctx)
+
+    try:
+        await site.start()
+        log(f"Server started on {globalCfg.network.bindto}:{globalCfg.network.port}")
+        await asyncio.Event().wait()
+    except OSError as e:
+        log.error(e)
+        sys.exit(1)
+    except (KeyboardInterrupt, asyncio.CancelledError) as e:
+        log(f"Exception({type(e).__name__}). Initiating shutdown.")
+        pass
+    except Exception as e:
+        log.exception(f"{type(e)}: Unexpected error in pserve_main server loop: {e}")
+    finally:
+        await runner.cleanup()
+
+def check_auth(data, config):
+    toktype = 'Undefined'
+    def get_token(data):
+        nonlocal toktype
+        headers = data.get('request_headers', {})
+        auth_header = headers.get('Authorization')
+        if auth_header and auth_header.startswith('Bearer '):
+            toktype = 'token'
+            return auth_header.split(' ', 1)[1].strip()
+        return None
+
+    def get_custom_header_token(data):
+        nonlocal toktype
+        headers = data.get('request_headers', {})
+        custom_header = headers.get('X-Custom-Auth')
+        toktype = 'custom'
+        if custom_header:
+            return custom_header.strip()
+        return None
+
+    def get_user_token(data):
+        nonlocal toktype
+        token = data.get('apikey')
+        if token:
+            toktype='userdata'
+        return token
+    try:
+        expected = config.auth.apikey
+    except AttributeError:
+        return True
+    if not expected:
+        return True
+
+    provided = get_token(data) or get_custom_header_token(data) or get_user_token(data)
+    if not provided:
+        return False
+    auth_ok = expected == provided
+    return auth_ok
+
+def register_plugin_route(plugin_id, instance, config):
+    global log
+    global manager
+    global routes
+
+    log(f"Registering route: /{plugin_id}")
+
+    @routes.route('GET', f'/{plugin_id}')
+    @routes.route('GET', f'/{plugin_id}/{{tail:.*}}')
+    @routes.route('POST', f'/{plugin_id}')
+    @routes.route('POST', f'/{plugin_id}/{{tail:.*}}')
+    async def handle(request, inst=instance, pid=plugin_id, cfg=config):
+        plugin = await manager.get_plugin(pid)
+        if plugin is None:
+            log(f"Plugin {pid} not found for request.")
+            return web.json_response({"error": f"Plugin {pid} not found"}, status=404)
+
+        data = {'log': log, 'request_headers': dict(request.headers), 'request': request}
+        if request.method == 'POST' and request.can_read_body:
+            try:
+                rqj = await request.json()
+                data.update(rqj)
+            except Exception as e:
+                log.exception(f"Cannot get request body for plugin {pid}: {e}")
+        data.update(request.query)
+        try:
+            data['subpath'] = request.match_info.get('tail')
+        except KeyError:
+            data['subpath'] = None
+
+        response_data = await maybe_async(inst.handle_request(**data))
+
+        if not isinstance(response_data, web.StreamResponse):
+            if isinstance(response_data, (dict, list)):
+                response = web.json_response(response_data)
+            elif isinstance(response_data, str):
+                response = web.Response(text=response_data)
+            else:
+                log(f"Plugin {pid} returned unexpected response type: {type(response_data)}")
+                response = web.json_response({"error": "Internal server error from plugin response"}, status=500)
+        else:
+            response = response_data
+        return response
+
+def register_control_routes(config):
+    global log
+    global manager
+    global globalCfg
+    global config_file
+    global routes
+
+    log("Registering Control Routes")
+    @routes.route('GET','/plugins')
+    @routes.route('POS','/plugins')
+    async def plugin_list(request):
+        data = {}
+        if request.method == 'POST' and request.can_read_body:
+            try:
+                data.update(await request.json())
+            except Exception: pass
+        data.update(request.query)
+        data['request_headers'] = dict(request.headers)
+        if not check_auth(data, config):
+            return web.json_response({'error': 'unauthorized'}, status=403)
+        
+        loaded_plugins = list(manager.plugins.keys()) if manager and manager.plugins else []
+        return web.json_response({'loaded_plugins': loaded_plugins})
+
+
+    @routes.route('GET','/reload/{plugin_id}')
+    @routes.route('POST','/reload/{plugin_id}')
+    async def reload_plugin(request):
+        current_config_for_auth = globalCfg
+
+        data = {}
+        if request.method == 'POST' and request.can_read_body:
+            try: data.update(await request.json())
+            except Exception: pass
+        data.update(request.query)
+        data['request_headers'] = dict(request.headers)
+        if not check_auth(data, current_config_for_auth):
+            return web.json_response({'error': 'unauthorized'}, status=403)
+
+        pid = request.match_info['plugin_id']
+        if manager and pid in manager.plugins:
+            try:
+                reloaded_cfg = configfile.Config(file=config_file)
+                globals()['globalCfg'] = reloaded_cfg
+                manager.reset_config(reloaded_cfg)
+                success = await manager.reload_plugin(pid)
+                web.json_response({'reloaded': pid, 'success': success})
+            except Exception as e:
+                log.exception(f"Error reloading plugin {pid}: {e}")
+                return web.json_response({'error': f'Failed to reload plugin {pid}'}, status=500)
+        web.json_response({'error': f'Plugin "{pid}" not found'}, status=404)
+
+    @routes.route('GET', '/reload/all')
+    @routes.route('POST', '/reload/all')
+    async def reload_all(request):
+        current_config_for_auth = globalCfg
+
+        data = {}
+        if request.method == 'POST' and request.can_read_body:
+            try: data.update(await request.json())
+            except Exception: pass
+        data.update(request.query)
+        data['request_headers'] = dict(request.headers)
+        if not check_auth(data, current_config_for_auth):
+            return web.json_response({'error': 'unauthorized'}, status=403)
+        
+        try:
+            reloaded_cfg = configfile.Config(file=config_file)
+            globals()['globalCfg'] = reloaded_cfg
+            if manager:
+                manager.reset_config(reloaded_cfg)
+                await manager.load_plugins()
+                return web.json_response({'status': 'All plugins reloaded', 'loaded_plugins': list(manager.plugins.keys())})
+            else:
+                return web.json_response({'error': 'Plugin manager not available'}, status=500)
+        except Exception as e:
+            log.exception(f"Error reloading all plugins: {e}")
+            return web.json_response({'error': 'Failed to reload all plugins'}, status=500)
+
+async def maybe_async(value):
+    return await value if inspect.isawaitable(value) else value
+
+def reload(signum, frame):
+    global log
+    log(f"Received {get_signal_name(signum)} - Terminating plugins")
+    _sched_sh(_sh_then_act, _act_execl)
+
+def terminate(signum, frame, sig_to_exit_code=None):
+    global log
+    actual_exit_code = sig_to_exit_code if sig_to_exit_code is not None else signum
+    log(f"Received {get_signal_name(signum)} - Terminating plugins")
+    _sched_sh(_sh_then_act, _act_exit, actual_exit_code)
+
+def main():
+    global log
+    global _signal_exit_code
+
+    we_are = os.path.splitext(os.path.basename(sys.argv[0]))[0]
+
+    parser = argparse.ArgumentParser(
+        description="Plugin Server - create a RESTapi using simple plugins",
+        epilog="Nicole Stevens/2025"
+        )
+    parser.add_argument('-i','--ini-file',default=f"{we_are}.ini",type=str, metavar='ini-file',help='Use an alternate config file')
+    parser.add_argument('-l','--log',default=None,type=str,metavar='file',help='Set a log file')
+    parser.add_argument('-v','--level',default='DEBUG',type=str,help="Logging level, INFO DEBUG ERROR CRITICAL", metavar='level')
+    args = parser.parse_args()
+
+    exit_code = 0
+    _signal_exit_code = 0
+
+    try:
+        asyncio.run(pserve_main(args))
+        exit_code = _signal_exit_code
+    except KeyboardInterrupt:
+        log.info("Application terminated by KeyboardInterrupt (caught in main).")
+        exit_code = getattr(signal.SIGINT, 'value', 2)
+    except SystemExit as e:
+        log.info(f"SystemExit caught in main with code: {e.code}")
+        exit_code = e.code if e.code is not None else 0
+    except Exception as e:
+        log.exception(f"Unhandled exception in main: {e}")
+        exit_code = 1
+    finally:
+        log.info(f"Application exiting with code {exit_code}.")
+
+    sys.exit(exit_code)
+    
+if __name__ == "__main__":
+    main()

{pluginserver-0.8.1 → pluginserver-0.9.0/pluginserver.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pluginserver
-Version: 0.8.1
+Version: 0.9.0
 Summary: Plugin-driven API server
 Home-page: https://github.com/nicciniamh/pluginserver
 Author: Nicole Stevens

{pluginserver-0.8.1 → pluginserver-0.9.0}/pluginserver.egg-info/SOURCES.txt

@@ -1,11 +1,10 @@
 LICENSE.txt
-MANIFEST.in
 README.md
 setup.py
 plugincore/__init__.py
 plugincore/baseplugin.py
 plugincore/configfile.py
-plugincore/cors.py
+plugincore/logjam.py
 plugincore/pluginmanager.py
 plugincore/pserv.py
 pluginserver.egg-info/PKG-INFO

{pluginserver-0.8.1 → pluginserver-0.9.0}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup
 
 setup(
     name='pluginserver',
-    version='0.8.1',
+    version='0.9.0',
     packages=['plugincore'],
     include_package_data=True,
     description='Plugin-driven API server',

pluginserver-0.8.1/MANIFEST.in

@@ -1,3 +0,0 @@
-# MANIFEST.in
-exclude examples/*
-

pluginserver-0.8.1/plugincore/cors.py

@@ -1,92 +0,0 @@
-from aiohttp import web
-import aiohttp_cors
-import aiohttp_cors
-from aiohttp import web
-import re
-from urllib.parse import urlparse
-
-class CORS:
-    def setup(self, app, globalCfg):
-        self.origins = []
-        self.acl = []
-        self.config = globalCfg
-        self.cors_enabled = False
-
-        # Check if CORS is enabled in the config
-        if 'cors' in self.config:
-            if 'enabled' in self.config.cors:
-                self.cors_enabled = self.config.cors.enabled  # Assuming this is a boolean
-            if self.cors_enabled:
-                # If enabled, fetch the allowed origins
-                if 'origin_url' in self.config.cors:
-                    self.origins = self.config.cors.origin_url  # List of allowed origins
-                else:
-                    # If origin_url is not set, disable CORS
-                    self.cors_enabled = False
-            if self.cors_enabled:
-                if 'acl' in self.config.cors:
-                    self.acl = self.config.cors.acl
-                    print(f"CORS setup, acl {self.acl}")
-
-        
-        # If CORS is enabled, set it up with aiohttp_cors
-        if self.cors_enabled:
-            print(f"CORS Setup - ORIGIN URLs: {self.origins}")
-            cors = aiohttp_cors.setup(app)
-            for route in list(app.router.routes()):
-                cors.add(route, {
-                    'origins': self.origins,
-                    'allow_credentials': True,
-                    'expose_headers': "*",
-                    'allow_headers': "*",
-                    'allow_methods': ["GET", "POST", "OPTIONS"]
-                })
-
-        return self
-
-    def _add_header(self, response, request):
-        """Add the CORS headers to the response."""
-        request_origin = request.headers.get('Origin')
-        if request_origin == 'null':
-            request_origin = None
-        if not request_origin:
-            return response
-        host_name = urlparse(request_origin).hostname
-
-        request_ok = True
-        if self.cors_enabled and request_origin:
-            if request_origin in self.origins:
-                response.headers['Access-Control-Allow-Origin'] = request_origin
-            else:
-                request_ok = False
-                if self.acl:
-                    for a in self.acl:
-                        pattern = r'^[a-zA-Z0-9.-]*\.' + re.escape(a) + r'$|^' + re.escape(a) + r'$'
-                        if re.match(pattern,urlparse(request_origin).hostname):
-                            request_ok = True
-                            break
-                if not request_ok:
-                    return web.HTTPForbidden(text="CORS origin not allowed")
-            
-            response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS'
-            response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
-            response.headers['Vary'] = 'Origin'
-        return response
-
-    def apply_headers(self, response, request):
-        """Apply CORS headers based on the response type."""
-        # Skip the CORS logic if CORS is disabled
-        if not self.cors_enabled:
-            return response  # No CORS logic applied
-
-        if isinstance(response, web.Response):
-            response = self._add_header(response, request)
-        elif isinstance(response, dict):
-            response = self._add_header(web.json_response(response), request)
-        elif isinstance(response, str):
-            response = self._add_header(web.Response(text=response, content_type='text/html'), request)
-        else:
-            response = self._add_header(web.json_response({'result': str(response)}), request)
-
-        response.headers['X-Content-Type-Options'] = 'nosniff'  # Security header
-        return response

pluginserver-0.8.1/plugincore/pserv.py

@@ -1,259 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import inspect
-import asyncio
-import ssl
-import os
-import sys
-import signal
-from aiohttp import web
-from plugincore import pluginmanager
-from plugincore import configfile
-import aiohttp_cors
-from plugincore.cors import CORS
-routes = web.RouteTableDef()
-manager = None  # PluginManager reference
-globalCfg = None
-import aiohttp_cors
-from aiohttp import web
-
-corsobj = CORS()
-
-async def on_shutdown(*args):
-    """
-    call terminate_plugin for active plugins
-    """
-    global manager
-    print(("Sending plugins the terminate signal"))
-    for id, plugin in manager.plugins.items():
-        try:
-            plugin.terminate_plugin()
-        except Exception as e:
-            print(f"{type(e)} Exception unloading plugin id {id}")
-    print("Waiting for tasks")
-    await  asyncio.sleep(3)
-
-def main():
-    global manager
-    global globalCfg
-
-    we_are = os.path.splitext(os.path.basename(sys.argv[0]))[0]
-
-    parser = argparse.ArgumentParser(
-        description="Plugin Server - create a RESTapi using simple plugins",
-        epilog="Nicole Stevens/2025"
-        )
-    parser.add_argument('-i','--ini-file',default=f"{we_are}.ini",type=str, metavar='ini-file',help='Use an alternate config file')
-    args = parser.parse_args()
-
-    signal.signal(signal.SIGHUP, reload)
-    print(f"{we_are}({os.getpid()}): Installed SIGHUP handler for reload.")
-
-    globalCfg = configfile.Config(file=args.ini_file)
-
-    ssl_ctx = None
-    ssl_cert, ssl_key = (None, None)
-    enabled = False
-
-    # SSL setup if enabled
-    try:
-        ssl_key = globalCfg.SSL.keyfile
-        ssl_cert = globalCfg.SSL.certfile
-        enabled = globalCfg.SSL.enabled
-    except AttributeError:
-        pass
-    if ssl_key and ssl_cert and enabled:
-        ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
-        print("======== SSL Configuration ========")
-        print(f"SSL key {ssl_key}")
-        print(f"SSL certificate: {ssl_cert}")
-        print(f"SSL context {ssl_ctx}")
-        print("Loading SSL cert chain")
-        try:
-            ssl_ctx.load_cert_chain(ssl_cert, ssl_key, None)
-        except Exception as e:
-            print(f"Exception({type(e)}): Error loading ssl_cert_chain({ssl_cert},{ssl_key})")
-            for p in [ssl_cert, ssl_key]:
-                if not os.path.exists(p):
-                    print(f"Path: {p} not found.")
-            ssl_ctx = None
-        print("End of SSL configuration.")
-
-    if not 'paths' in globalCfg:
-        print(f"no paths in {globalCfg}")
-        sys.exit(1)
-    print("======== Loading plugin modules ========")
-    manager = pluginmanager.PluginManager(globalCfg.paths.plugins, config=globalCfg)
-    manager.load_plugins()
-
-    # Register plugin routes
-    for plugin_id, instance in manager.plugins.items():
-        register_plugin_route(plugin_id, instance, globalCfg)
-
-    # Setup event loop for file watcher
-
-    # Management endpoints
-    register_control_routes(globalCfg)
-
-    app = web.Application()
-    
-    # CORS setup
-    corsobj.setup(app,globalCfg)
-
-    app.add_routes(routes)
-    app.on_shutdown.append(on_shutdown)
-    if 'documents' in globalCfg.paths:
-        """
-        if configured set up static page service
-        """
-        if ':' in globalCfg.paths.documents:
-            dname, dpath = globalCfg.paths.documents.split(':')
-        else:
-            dname, dpath = 'docs', globalCfg.paths.documents
-
-        if 'indexfile' in globalCfg.paths:
-            indexfile = globalCfg.paths.indexfile
-            print(f"indexfile for static service is {indexfile}")
-            # Route to handle /docs/ (with or without trailing slash)
-            async def default_doc_handler(request):
-                return web.FileResponse(os.path.join(dpath, indexfile))
-
-            app.router.add_get(f'/{dname}', default_doc_handler)
-            app.router.add_get(f'/{dname}/', default_doc_handler)
-
-        print(f"Setting up static page delivery for {dname} from {dpath}")
-        app.router.add_static(f"/{dname}/", path=dpath, name=dname)
-
-    try:
-        web.run_app(app, host=globalCfg.network.bindto, port=globalCfg.network.port, ssl_context=ssl_ctx)
-    except KeyboardInterrupt:
-        on_shutdown()
-
-# --- Auth Helper ---
-def check_auth(data, config):
-    toktype = 'Undefined'
-    def get_token(data):
-        nonlocal toktype
-        headers = data.get('request_headers', {})
-        auth_header = headers.get('Authorization')
-        if auth_header and auth_header.startswith('Bearer '):
-            toktype = 'token'
-            return auth_header.split(' ', 1)[1].strip()
-        return None
-
-    def get_custom_header_token(data):
-        nonlocal toktype
-        headers = data.get('request_headers', {})
-        custom_header = headers.get('X-Custom-Auth')
-        toktype = 'custom'
-        if custom_header:
-            return custom_header.strip()
-        return None
-
-    def get_user_token(data):
-        nonlocal toktype
-        token = data.get('apikey')
-        if token:
-            toktype='userdata'
-        return token
-    try:
-        expected = config.auth.apikey
-    except AttributeError:
-        return True
-    provided = get_token(data) or get_custom_header_token(data) or get_user_token(data)
-    #print(f"pserv:check_auth: provided/expected: {provided}/{expected}")
-    if not provided:
-        print("Returning false")
-        return False
-    auth_ok = expected == provided
-    #print("Returning {auth_ok}")
-    return auth_ok
-
-# --- Plugin Request Handler ---
-def register_plugin_route(plugin_id, instance, config):
-    print(f"Registering route: /{plugin_id} to {instance}")
-
-    @routes.route('*', f'/{plugin_id}')
-    @routes.route('*', f'/{plugin_id}/{{tail:.*}}')
-    async def handle(request, inst=instance, pid=plugin_id, cfg=config):
-        #print(request.remote, '- request -', pid)
-        plugin = manager.get_plugin(pid)
-        data = {}
-        if request.method == 'POST' and request.can_read_body:
-            try:
-                data.update(await request.json())
-            except Exception:
-                pass
-        data.update(request.query)
-        data['request_headers'] = dict(request.headers)
-        # You can also capture `tail` if you want to use the subpath
-        try:
-            data['subpath'] = request.match_info['tail']
-        except KeyError:
-            data['subpath'] = None
-        response = await maybe_async(plugin.handle_request(**data))
-        response = corsobj.apply_headers(response, request)
-        return response
-
-# --- Control Routes ---
-def register_control_routes(config):
-    print("Registering Control Routes")
-    @routes.route('*','/plugins')
-    async def plugin_list(request):
-        data = {}
-        if request.method == 'POST' and request.can_read_body:
-            try:
-                data.update(await request.json())
-            except Exception:
-                pass
-        data.update(request.query)
-        data['request_headers'] = dict(request.headers)
-        if not check_auth(data, config):
-            return web.json_response({'error': 'unauthorized'}, status=403)
-        return corsobj.apply_headers(web.json_response({'loaded_plugins': list(manager.plugins.keys())}),request)
-
-    @routes.route('*','/reload/{plugin_id}')
-    async def reload_plugin(request):
-        data = {}
-        if request.method == 'POST' and request.can_read_body:
-            try:
-                data.update(await request.json())
-            except Exception:
-                pass
-        data.update(request.query)
-        data['request_headers'] = dict(request.headers)
-        if not check_auth(data, config):
-            return corsobj.apply_headers(web.json_response({'error': 'unauthorized'}, status=403),request)
-
-        pid = request.match_info['plugin_id']
-        if pid in manager.plugins:
-            success = manager.reload_plugin(pid)
-            return corsobj.apply_headers(web.json_response({'reloaded': pid, 'success': success}),request)
-        return corsobj.apply_headers(web.json_response({'error': f'Plugin "{pid}" not found'}, status=404),request)
-
-    @routes.route('*', '/reload/all')
-    async def reload_all(request):
-        data = {}
-        if request.method == 'POST' and request.can_read_body:
-            try:
-                data.update(await request.json())
-            except Exception:
-                pass
-        data.update(request.query)
-        data['request_headers'] = dict(request.headers)
-        if not check_auth(data, config):
-            return corsobj.apply_headers(web.json_response({'error': 'unauthorized'}, status=403),request)
-        manager.load_plugins()
-        return corsobj.apply_headers(web.json_response({'status': 'All plugins reloaded', 'loaded_plugins': list(manager.plugins.keys())}),request)
-
-# --- Coroutine Await Helper ---
-async def maybe_async(value):
-    return await value if inspect.isawaitable(value) else value
-
-# ---- Reload handler ----
-def reload(signum, frame):
-    print("Received SIGHUP, restarting...")
-    os.execl(sys.executable, sys.executable, *sys.argv)
-
-if __name__ == "__main__":
-    main()