mxx-tool 0.1.0__py3-none-any.whl

mxx/runner/core/runner.py

@@ -0,0 +1,128 @@
+
+
+from time import sleep
+from mxx.runner.core.callstack import MxxCallstack, PluginCallstackMeta
+from mxx.runner.core.plugin import MxxPlugin
+from mxx.runner.core.registry import MAPPINGS
+
+
+class MxxRunner:
+    def _exportCfgs(self, cfg : dict):
+        """
+        Export and separate plugin configs from global configs.
+        
+        Args:
+            cfg: Configuration dictionary
+        
+        Returns:
+            Tuple of (plugin_configs, global_configs)
+            - plugin_configs: Dict of plugin_name -> plugin_config
+            - global_configs: Dict of global configuration values
+        """
+        pcfg = {}
+        gcfg = {}
+
+        # Separate plugin-specific configs from global configs
+        for k, v in cfg.items():
+            if k in MAPPINGS:
+                # This is a plugin configuration
+                if isinstance(v, dict):
+                    pcfg[k] = v
+                else:
+                    gcfg[k] = v
+            else:
+                # Could be a global config or unknown
+                gcfg[k] = v
+
+        return pcfg, gcfg
+
+    def run(self, cfg : dict):
+        """
+        Run the MxxRunner with given configuration.
+        
+        Args:
+            cfg: Configuration dictionary where keys are plugin names
+                 and values are plugin-specific config dicts.
+                 Example: {"lifetime": {"lifetime": 3600}, "os": {"cmd": "echo"}}
+        """
+        pcfg, gcfg = self._exportCfgs(cfg)
+        self.gcfg = gcfg
+        plugins = {}
+        
+        for plugin_name, plugin_cfg in pcfg.items():
+            if plugin_name not in MAPPINGS:
+                raise Exception(f"Plugin '{plugin_name}' is not registered")
+
+            plugin_cls = MAPPINGS[plugin_name]
+            plugin_instance = plugin_cls(**plugin_cfg)
+            plugins[plugin_name] = plugin_instance
+
+        self.plugins = plugins
+
+        self.run_events(plugins)
+
+    def run_events(self, plugins : dict[str, MxxPlugin]):
+        callstack = MxxCallstack()
+        for plugin in plugins.values():
+            plugin_callstack = PluginCallstackMeta._callstackMap[plugin.__cmdname__]
+            callstack.merge(plugin_callstack)
+
+        try:
+            # Check initial conditions
+            # all_cond: all must return True (empty list = pass)
+            # any_cond: at least one must return True (empty list = pass)
+            all_cond_passed = all(self._run_action(cond) for cond in callstack.all_cond) if callstack.all_cond else True
+            any_cond_passed = any(self._run_action(cond) for cond in callstack.any_cond) if callstack.any_cond else True
+
+            if not all_cond_passed or not any_cond_passed:
+                return
+
+            # Execute pre-actions
+            for pre_action in callstack.pre_action:
+                self._run_action(pre_action)
+
+            # Execute main actions
+            for action in callstack.action:
+                self._run_action(action)
+
+            # Now run on_true/on_false loop
+            # on_true: return True to continue, False to stop
+            # on_false: return True to stop, False to continue
+            # Loop continues while: all on_true return True AND all on_false return False
+            # If no on_true/on_false hooks exist, skip the loop
+            if callstack.on_true or callstack.on_false:
+                while True:
+                    should_continue = True
+                    
+                    # Check on_true hooks - if any return False, stop
+                    if callstack.on_true:
+                        if not all(self._run_action(ontrue) for ontrue in callstack.on_true):
+                            should_continue = False
+                    
+                    # Check on_false hooks - if any return True, stop
+                    if callstack.on_false:
+                        if any(self._run_action(onfalse) for onfalse in callstack.on_false):
+                            should_continue = False
+                    
+                    if not should_continue:
+                        break
+                    
+                    sleep(0.5)
+
+            # Execute post-actions (cleanup)
+            for post_action in callstack.post_action:
+                self._run_action(post_action)
+
+        except Exception as e:
+            for onerror in callstack.on_error:
+                self.currentError = e
+                self._run_action(onerror)
+
+    def _run_action(self, func):
+        # check wehther func takes an argument, if yes, pass self
+        import inspect
+        sig = inspect.signature(func)
+        if len(sig.parameters) > 0:
+            return func(self)
+        return func()
+    

mxx/server/__init__.py

@@ -0,0 +1,7 @@
+"""
+MXX Server - Flask-based scheduler service for MXX runner.
+
+Provides HTTP API for scheduling and managing MXX plugin jobs.
+"""
+
+__version__ = "0.1.0"

mxx/server/flask_runner.py

@@ -0,0 +1,114 @@
+"""
+Flask-integrated runner - thin wrapper around SchedulerService.
+
+This module provides Flask integration for the MXX scheduler service.
+It auto-loads configs from ~/.mxx/jobs/ and schedules them based on their
+schedule section.
+"""
+
+from flask import Flask
+from mxx.server.scheduler import SchedulerService
+from mxx.server.registry import JobRegistry
+from mxx.runner.core.config_loader import load_config
+from mxx.server.schedule import extract_schedule
+from pathlib import Path
+import logging
+
+
+class FlaskMxxRunner:
+    """
+    Flask-integrated runner with APScheduler support.
+    
+    This wrapper:
+    - Provides Flask app integration
+    - Manages scheduler lifecycle
+    - Auto-loads configs from ~/.mxx/jobs/ on startup
+    - Schedules configs that have a schedule section
+    - Exposes scheduler service for routes (dynamic scheduling)
+    """
+    
+    def __init__(self, app: Flask, max_workers: int = 10, jobs_dir: Path = None):
+        """
+        Initialize Flask runner with scheduler service.
+        
+        Args:
+            app: Flask application instance
+            max_workers: Maximum number of concurrent job workers
+            jobs_dir: Directory to load job configs from (default: ~/.mxx/jobs)
+        """
+        self.app = app
+        self.jobs_dir = jobs_dir or Path.home() / ".mxx" / "jobs"
+        self.jobs_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.registry = JobRegistry()
+        self.scheduler_service = SchedulerService(max_workers=max_workers, registry=self.registry)
+        
+        # Store reference in app context for routes
+        app.config['SCHEDULER_SERVICE'] = self.scheduler_service
+    
+    def load_configs_from_directory(self):
+        """
+        Load all config files from ~/.mxx/jobs/ and register them.
+        
+        This method:
+        1. Finds all config files (.toml, .yaml, .json) excluding templates
+        2. Parses each config
+        3. Checks if config has a 'schedule' section
+        4. If schedule exists: Scheduled automatically
+        5. If no schedule: Registered as on-demand job (trigger via API)
+        """
+        # Find all config files (exclude templates)
+        config_files = []
+        for pattern in ["*.toml", "*.yaml", "*.yml", "*.json"]:
+            config_files.extend([
+                f for f in self.jobs_dir.glob(pattern)
+                if not f.name.endswith(".template.toml") and
+                   not f.name.endswith(".template.yaml") and
+                   not f.name.endswith(".template.json")
+            ])
+        
+        logging.info(f"Loading {len(config_files)} config files from {self.jobs_dir}")
+        
+        for config_file in config_files:
+            try:
+                # Load config using config_loader
+                config = load_config(config_file)
+                
+                # Extract schedule
+                schedule_config = extract_schedule(config)
+                
+                # Use filename (without extension) as job_id
+                job_id = config_file.stem
+                
+                # Register the job (with or without schedule)
+                result = self.scheduler_service.schedule_job(
+                    job_id=job_id,
+                    config=config,
+                    schedule_config=schedule_config,
+                    replace_existing=True  # Allow server restarts to replace jobs
+                )
+                
+                # Update registry source to indicate config file origin
+                if self.registry.exists(job_id):
+                    entry = self.registry.get(job_id)
+                    entry.source = f"config:{config_file.name}"
+                    self.registry._save()
+                
+                if schedule_config:
+                    logging.info(f"Scheduled job '{job_id}' from {config_file.name}: {result}")
+                else:
+                    logging.info(f"Registered on-demand job '{job_id}' from {config_file.name}: {result}")
+                
+            except Exception as e:
+                logging.error(f"Failed to load config {config_file.name}: {e}", exc_info=True)
+    
+    def start(self):
+        """Start the scheduler and load configs from directory"""
+        self.load_configs_from_directory()
+        self.scheduler_service.start()
+        logging.info("Flask runner started")
+    
+    def stop(self):
+        """Stop the scheduler and wait for jobs to complete"""
+        self.scheduler_service.stop()
+        logging.info("Flask runner stopped")

mxx/server/registry.py

@@ -0,0 +1,229 @@
+"""
+Job registry for persistent storage of registered jobs.
+
+Provides:
+- Persistent storage of job configurations in ~/.mxx/server/registry.json
+- Separation between scheduled jobs and on-demand jobs
+- Job execution history tracking
+- Registry operations (add, remove, list, trigger)
+"""
+
+from pathlib import Path
+from typing import Dict, List, Optional
+from mxx.server.schedule import ScheduleConfig
+import json
+import logging
+from datetime import datetime
+import threading
+
+
+class JobRegistryEntry:
+    """Entry in the job registry"""
+    def __init__(
+        self,
+        job_id: str,
+        config: dict,
+        schedule: Optional[ScheduleConfig] = None,
+        source: str = "api"
+    ):
+        self.job_id = job_id
+        self.config = config
+        self.schedule = schedule
+        self.source = source  # "api", "config:filename.toml", etc.
+        self.registered_at = datetime.now()
+        self.last_triggered: Optional[datetime] = None
+        self.execution_count = 0
+    
+    def to_dict(self) -> dict:
+        """Convert entry to dictionary for serialization"""
+        return {
+            "job_id": self.job_id,
+            "config": self.config,
+            "schedule": {
+                "trigger": self.schedule.trigger,
+                "hour": self.schedule.hour,
+                "minute": self.schedule.minute,
+                "second": self.schedule.second,
+                "day_of_week": self.schedule.day_of_week,
+                "day": self.schedule.day,
+                "interval_seconds": self.schedule.interval_seconds
+            } if self.schedule else None,
+            "source": self.source,
+            "registered_at": self.registered_at.isoformat(),
+            "last_triggered": self.last_triggered.isoformat() if self.last_triggered else None,
+            "execution_count": self.execution_count
+        }
+    
+    @staticmethod
+    def from_dict(data: dict) -> 'JobRegistryEntry':
+        """Create entry from dictionary"""
+        entry = JobRegistryEntry(
+            job_id=data["job_id"],
+            config=data["config"],
+            schedule=ScheduleConfig(**data["schedule"]) if data.get("schedule") else None,
+            source=data.get("source", "api")
+        )
+        entry.registered_at = datetime.fromisoformat(data["registered_at"])
+        if data.get("last_triggered"):
+            entry.last_triggered = datetime.fromisoformat(data["last_triggered"])
+        entry.execution_count = data.get("execution_count", 0)
+        return entry
+
+
+class JobRegistry:
+    """
+    Persistent registry for job configurations.
+    
+    Jobs are stored in two categories:
+    - Scheduled: Jobs with schedule config (auto-executed by scheduler)
+    - On-demand: Jobs without schedule (executed via trigger API)
+    
+    Registry is persisted to ~/.mxx/server/registry.json
+    """
+    
+    def __init__(self, registry_path: Optional[Path] = None):
+        """
+        Initialize job registry.
+        
+        Args:
+            registry_path: Path to registry file (default: ~/.mxx/server/registry.json)
+        """
+        if registry_path is None:
+            registry_path = Path.home() / ".mxx" / "server" / "registry.json"
+        
+        self.registry_path = registry_path
+        self.registry_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        self._entries: Dict[str, JobRegistryEntry] = {}
+        self._lock = threading.Lock()
+        
+        # Load existing registry
+        self._load()
+    
+    def _load(self):
+        """Load registry from disk"""
+        if not self.registry_path.exists():
+            logging.info(f"No existing registry found at {self.registry_path}")
+            return
+        
+        try:
+            with open(self.registry_path, "r") as f:
+                data = json.load(f)
+            
+            for entry_data in data.get("entries", []):
+                entry = JobRegistryEntry.from_dict(entry_data)
+                self._entries[entry.job_id] = entry
+            
+            logging.info(f"Loaded {len(self._entries)} jobs from registry")
+        except Exception as e:
+            logging.error(f"Failed to load registry: {e}", exc_info=True)
+    
+    def _save(self):
+        """Save registry to disk"""
+        try:
+            data = {
+                "version": "1.0",
+                "entries": [entry.to_dict() for entry in self._entries.values()]
+            }
+            
+            with open(self.registry_path, "w") as f:
+                json.dump(data, f, indent=2)
+            
+            logging.debug(f"Saved registry with {len(self._entries)} entries")
+        except Exception as e:
+            logging.error(f"Failed to save registry: {e}", exc_info=True)
+    
+    def register(
+        self,
+        job_id: str,
+        config: dict,
+        schedule: Optional[ScheduleConfig] = None,
+        source: str = "api",
+        replace_existing: bool = False
+    ) -> JobRegistryEntry:
+        """
+        Register a job in the registry.
+        
+        Args:
+            job_id: Unique job identifier
+            config: Job configuration dict
+            schedule: Optional schedule configuration
+            source: Source of the job ("api", "config:filename.toml", etc.)
+            replace_existing: Whether to replace existing entry
+            
+        Returns:
+            JobRegistryEntry object
+            
+        Raises:
+            ValueError: If job_id already exists and replace_existing is False
+        """
+        with self._lock:
+            if job_id in self._entries and not replace_existing:
+                raise ValueError(f"Job '{job_id}' already registered. Use replace_existing=True to replace.")
+            
+            entry = JobRegistryEntry(
+                job_id=job_id,
+                config=config,
+                schedule=schedule,
+                source=source
+            )
+            
+            self._entries[job_id] = entry
+            self._save()
+            
+            logging.info(f"Registered job '{job_id}' ({source})")
+            return entry
+    
+    def unregister(self, job_id: str) -> bool:
+        """
+        Remove a job from registry.
+        
+        Args:
+            job_id: Job identifier
+            
+        Returns:
+            True if job was removed, False if not found
+        """
+        with self._lock:
+            if job_id not in self._entries:
+                return False
+            
+            del self._entries[job_id]
+            self._save()
+            
+            logging.info(f"Unregistered job '{job_id}'")
+            return True
+    
+    def get(self, job_id: str) -> Optional[JobRegistryEntry]:
+        """Get a job entry by ID"""
+        return self._entries.get(job_id)
+    
+    def list_all(self) -> List[JobRegistryEntry]:
+        """List all registered jobs"""
+        return list(self._entries.values())
+    
+    def list_scheduled(self) -> List[JobRegistryEntry]:
+        """List jobs with schedules"""
+        return [e for e in self._entries.values() if e.schedule is not None]
+    
+    def list_on_demand(self) -> List[JobRegistryEntry]:
+        """List jobs without schedules (on-demand only)"""
+        return [e for e in self._entries.values() if e.schedule is None]
+    
+    def mark_triggered(self, job_id: str):
+        """
+        Mark a job as triggered (update last_triggered time and count).
+        
+        Args:
+            job_id: Job identifier
+        """
+        with self._lock:
+            entry = self._entries.get(job_id)
+            if entry:
+                entry.last_triggered = datetime.now()
+                entry.execution_count += 1
+                self._save()
+    
+    def exists(self, job_id: str) -> bool:
+        """Check if job exists in registry"""
+        return job_id in self._entries