crazy-workers 1.2.0__tar.gz → 1.4.0__tar.gz

{crazy_workers-1.2.0 → crazy_workers-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crazy-workers
-Version: 1.2.0
+Version: 1.4.0
 Summary: A Python library for managing background worker processes with persistent state, automatic recovery, and a CLI.
 Author: GioVanni Colasanto
 License: MIT
@@ -139,8 +139,9 @@ See [CLI.md](https://github.com/Vanni-broUser/crazy-workers/blob/main/CLI.md) fo
 | `engine` | `Engine` | `None` | Reuse an existing SQLAlchemy engine so the tables live in your database; **not** disposed by crazy_workers |
 | `worker_env` | `dict` | `None` | Environment variables injected into **every** spawned worker (e.g. `DATABASE_URL`) |
 | `auto_recover` | `bool` | `True` | Recover dead-but-`RUNNING` workers when the manager is constructed |
+| `create_tables` | `bool` | `True` | Create crazy_workers' own tables on init; set `False` when the host owns the schema via its migrations |
 
-See [Backend integration](#backend-integration) for `db_url` / `engine` / `worker_env` / `auto_recover`.
+See [Backend integration](#backend-integration) for `db_url` / `engine` / `worker_env` / `auto_recover` / `create_tables`.
 
 ### `start_worker(worker_type, worker_key=None, parameters=None, env=None)`
 
@@ -338,6 +339,15 @@ the project instead of living off to the side:
   `workers` table inside your database and inherits its persistence and backups
   — so state survives even if the process/container is recreated. A shared
   engine is never disposed by crazy_workers; its owner manages it.
+- **Let your migrations own the schema.** If your project tracks its schema with
+  a migration tool (Alembic, etc.), pass `create_tables=False` so crazy_workers
+  issues no DDL: the `workers` table becomes a normal migration in your history,
+  with a single source of truth and no create-on-import side effect. You own the
+  ordering — the table must exist before the manager queries it, so build the
+  manager *after* your migrations run (and keep `auto_recover=False` until then,
+  since recovery reads that table). See the `workers` schema in
+  [`crazy_workers/database/schema.py`](https://github.com/Vanni-broUser/crazy-workers/blob/main/crazy_workers/database/schema.py)
+  for the columns your migration must create.
 - **Give workers the connection they need.** A worker is a separate process, so
   it can't receive a live DB connection — pass the *configuration* instead.
   `worker_env={'DATABASE_URL': ...}` is injected into every spawned worker

{crazy_workers-1.2.0 → crazy_workers-1.4.0}/README.md

@@ -104,8 +104,9 @@ See [CLI.md](https://github.com/Vanni-broUser/crazy-workers/blob/main/CLI.md) fo
 | `engine` | `Engine` | `None` | Reuse an existing SQLAlchemy engine so the tables live in your database; **not** disposed by crazy_workers |
 | `worker_env` | `dict` | `None` | Environment variables injected into **every** spawned worker (e.g. `DATABASE_URL`) |
 | `auto_recover` | `bool` | `True` | Recover dead-but-`RUNNING` workers when the manager is constructed |
+| `create_tables` | `bool` | `True` | Create crazy_workers' own tables on init; set `False` when the host owns the schema via its migrations |
 
-See [Backend integration](#backend-integration) for `db_url` / `engine` / `worker_env` / `auto_recover`.
+See [Backend integration](#backend-integration) for `db_url` / `engine` / `worker_env` / `auto_recover` / `create_tables`.
 
 ### `start_worker(worker_type, worker_key=None, parameters=None, env=None)`
 
@@ -303,6 +304,15 @@ the project instead of living off to the side:
   `workers` table inside your database and inherits its persistence and backups
   — so state survives even if the process/container is recreated. A shared
   engine is never disposed by crazy_workers; its owner manages it.
+- **Let your migrations own the schema.** If your project tracks its schema with
+  a migration tool (Alembic, etc.), pass `create_tables=False` so crazy_workers
+  issues no DDL: the `workers` table becomes a normal migration in your history,
+  with a single source of truth and no create-on-import side effect. You own the
+  ordering — the table must exist before the manager queries it, so build the
+  manager *after* your migrations run (and keep `auto_recover=False` until then,
+  since recovery reads that table). See the `workers` schema in
+  [`crazy_workers/database/schema.py`](https://github.com/Vanni-broUser/crazy-workers/blob/main/crazy_workers/database/schema.py)
+  for the columns your migration must create.
 - **Give workers the connection they need.** A worker is a separate process, so
   it can't receive a live DB connection — pass the *configuration* instead.
   `worker_env={'DATABASE_URL': ...}` is injected into every spawned worker

crazy_workers-1.4.0/crazy_workers/__init__.py

@@ -0,0 +1,6 @@
+from .client import WorkerClient
+from .core.manager import WorkerManager
+from .database.schema import DesiredStatus, WorkerStatus
+
+
+__all__ = ['WorkerManager', 'WorkerClient', 'WorkerStatus', 'DesiredStatus']

{crazy_workers-1.2.0 → crazy_workers-1.4.0}/crazy_workers/cli/commands/params.py

@@ -4,28 +4,21 @@ from rich.prompt import IntPrompt
 from ..ui import console, err_console
 
 
-def show_params(manager, worker_key):
-
-  workers = manager.list_workers()
+def show_params(client, worker_key):
+  workers = client.list()
   if not workers:
     console().print('[yellow]No workers found.[/yellow]')
     return False
 
   if not worker_key:
     # Interactive mode
-    active_workers = [w for w in workers if w['worker_key'] is not None]
-
-    if not active_workers:
-      console().print('[yellow]No registered workers to show parameters for.[/yellow]')
-      return False
-
     console().print('\n[bold cyan]Select a worker to show parameters:[/bold cyan]')
-    for i, w in enumerate(active_workers, 1):
+    for i, w in enumerate(workers, 1):
       status_style = 'green' if w['status'] == 'RUNNING' else 'dim'
       console().print(f'  [bold]{i})[/bold] {w["worker_key"]} [{status_style}]({w["status"]})[/{status_style}]')
 
-    choice = IntPrompt.ask('Enter the number', choices=[str(i) for i in range(1, len(active_workers) + 1)])
-    selected_worker = active_workers[choice - 1]
+    choice = IntPrompt.ask('Enter the number', choices=[str(i) for i in range(1, len(workers) + 1)])
+    selected_worker = workers[choice - 1]
   else:
     selected_worker = next((w for w in workers if w['worker_key'] == worker_key), None)
     if not selected_worker:

crazy_workers-1.4.0/crazy_workers/cli/commands/starter.py

@@ -0,0 +1,36 @@
+import os
+from rich.prompt import IntPrompt
+
+from ..ui import console, err_console
+
+
+def start_worker(client, workers_dir, worker_type, worker_key=None, parameters=None):
+  """Request a worker to run. The daemon performs the actual spawn."""
+  if not worker_type:
+    # Interactive mode: list .py files in workers_dir
+    try:
+      files = [f[:-3] for f in os.listdir(workers_dir) if f.endswith('.py') and f != '__init__.py']
+    except Exception as e:
+      err_console().print(f'[bold red]Error reading workers directory:[/bold red] {e}')
+      return False
+
+    if not files:
+      console().print(f'[yellow]No worker scripts found in {workers_dir}[/yellow]')
+      return False
+
+    console().print('\n[bold cyan]Select a worker type to start:[/bold cyan]')
+    for i, f in enumerate(files, 1):
+      console().print(f'  [bold]{i})[/bold] {f}')
+
+    choice = IntPrompt.ask('Enter the number', choices=[str(i) for i in range(1, len(files) + 1)])
+    worker_type = files[choice - 1]
+
+  # Surface a typo here rather than as a daemon CRASHED/retry loop later.
+  if not os.path.exists(os.path.join(workers_dir, f'{worker_type}.py')):
+    err_console().print(f'[bold red]Error:[/bold red] Worker file {worker_type}.py not found in {workers_dir}')
+    return False
+
+  key = client.request_start(worker_type, worker_key=worker_key, parameters=parameters)
+  console().print('[bold green]Requested:[/bold green] worker set to RUNNING (the daemon will start it)')
+  console().print(f'  [bold]Key:[/bold] {key}')
+  return True

crazy_workers-1.4.0/crazy_workers/cli/commands/status.py

@@ -0,0 +1,112 @@
+import json
+import os
+import re
+from datetime import datetime
+from rich.panel import Panel
+from rich.table import Table
+
+from ..ui import console
+
+
+def show_status(client, workers_dir):
+  """Observability hub: the target state store plus the worker table (desired vs actual)."""
+  console().print(_build_header(workers_dir))
+
+  workers = _merge_with_filesystem(client.list(), workers_dir)
+  if not workers:
+    console().print('[yellow]No workers found.[/yellow]')
+    return workers
+
+  console().print(_build_table(workers))
+  return workers
+
+
+def _build_header(workers_dir):
+  db_url = os.environ.get('CRAZY_WORKERS_DB_URL')
+  if db_url:
+    target = f'[green]shared DB[/green] [dim]({_redact(db_url)})[/dim]'
+  else:
+    target = '[dim]self-contained SQLite (.service/workers.db)[/dim]'
+  body = f'[bold]Workers dir:[/bold] {workers_dir}\n[bold]State store:[/bold] {target}'
+  return Panel.fit(body, border_style='cyan', title='[bold cyan]Crazy Workers status[/bold cyan]')
+
+
+def _redact(db_url):
+  """Hide the password in a SQLAlchemy URL for display."""
+  return re.sub(r'://([^:/@]+):[^@]*@', r'://\1:***@', db_url)
+
+
+def _merge_with_filesystem(db_workers, workers_dir):
+  """Append NEVER_STARTED rows for worker scripts that have no DB record yet."""
+  results = list(db_workers)
+  registered_types = {w['worker_type'] for w in results}
+  try:
+    available = sorted({f[:-3] for f in os.listdir(workers_dir) if f.endswith('.py') and f != '__init__.py'})
+  except OSError:
+    available = []
+  for worker_type in available:
+    if worker_type not in registered_types:
+      results.append(
+        {
+          'worker_key': None,
+          'worker_type': worker_type,
+          'parameters': {},
+          'desired_status': None,
+          'pid': None,
+          'status': 'NEVER_STARTED',
+          'last_started_at': None,
+          'last_stopped_at': None,
+        }
+      )
+  return results
+
+
+def _build_table(workers):
+  table = Table(
+    title='[bold cyan]Workers — desired vs actual[/bold cyan]', border_style='cyan', header_style='bold magenta'
+  )
+  table.add_column('#', justify='right', style='dim')
+  table.add_column('Key', style='bold')
+  table.add_column('Type')
+  table.add_column('Desired', justify='center')
+  table.add_column('Status', justify='center')
+  table.add_column('PID', justify='right', style='green')
+  table.add_column('Last Action', justify='center')
+  table.add_column('Params', overflow='ellipsis')
+
+  for i, w in enumerate(workers, 1):
+    status = w['status']
+    status_style = 'green' if status == 'RUNNING' else 'yellow'
+    if status in ('CRASHED', 'FAILED'):
+      status_style = 'bold red'
+    elif status == 'STOPPED':
+      status_style = 'dim'
+    elif status == 'NEVER_STARTED':
+      status_style = 'cyan'
+
+    desired = w.get('desired_status') or '-'
+    desired_style = 'green' if desired == 'RUNNING' else 'dim'
+
+    last_action = '-'
+    if status == 'RUNNING' and w.get('last_started_at'):
+      dt = datetime.fromisoformat(w['last_started_at'])
+      last_action = f'[green]Started {dt.strftime("%H:%M:%S")}[/green]'
+    elif w.get('last_stopped_at'):
+      dt = datetime.fromisoformat(w['last_stopped_at'])
+      last_action = f'[dim]Stopped {dt.strftime("%H:%M:%S")}[/dim]'
+
+    params_str = json.dumps(w['parameters']) if w['parameters'] else '-'
+    if len(params_str) > 30:
+      params_str = params_str[:27] + '...'
+
+    table.add_row(
+      str(i),
+      w['worker_key'] or '-',
+      w['worker_type'],
+      f'[{desired_style}]{desired}[/{desired_style}]',
+      f'[{status_style}]{status}[/{status_style}]',
+      str(w['pid']) if w['pid'] else '-',
+      last_action,
+      params_str,
+    )
+  return table

crazy_workers-1.4.0/crazy_workers/cli/commands/stopper.py

@@ -0,0 +1,28 @@
+from rich.prompt import IntPrompt
+
+from ..ui import console, err_console
+
+
+def stop_worker(client, worker_key):
+  """Request a worker to stop. The daemon performs the actual termination."""
+  if not worker_key:
+    # Interactive mode: offer the workers a stop is meaningful for.
+    candidates = [w for w in client.list() if w['desired_status'] == 'RUNNING']
+
+    if not candidates:
+      console().print('[yellow]No workers desired RUNNING to stop.[/yellow]')
+      return False
+
+    console().print('\n[bold cyan]Select a worker to stop:[/bold cyan]')
+    for i, w in enumerate(candidates, 1):
+      console().print(f'  [bold]{i})[/bold] {w["worker_key"]} [dim]({w["worker_type"]}, {w["status"]})[/dim]')
+
+    choice = IntPrompt.ask('Enter the number', choices=[str(i) for i in range(1, len(candidates) + 1)])
+    worker_key = candidates[choice - 1]['worker_key']
+
+  if client.request_stop(worker_key):
+    console().print(f'[bold green]Requested:[/bold green] worker {worker_key} set to STOPPED (the daemon will stop it)')
+    return True
+
+  err_console().print(f'[bold red]Error:[/bold red] Worker {worker_key} not found')
+  return False

{crazy_workers-1.2.0 → crazy_workers-1.4.0}/crazy_workers/cli/discovery.py

@@ -72,11 +72,16 @@ def resolve_workers_dir(flag_dir):
     if user_input:
       if os.path.isdir(user_input):
         abs_path = os.path.abspath(user_input)
-        try:
-          save_to_env('CRAZY_WORKERS_DIR', abs_path)
-          console().print(f'[bold green]Saved CRAZY_WORKERS_DIR={abs_path} to .env[/bold green]')
-        except Exception as e:
-          err_console().print(f'[bold red]Failed to save configuration:[/bold red] {e}')
+        # When pointed at a shared DB the cwd is the consumer app's, not ours —
+        # don't rewrite its .env (see T2). The env var lives only for this run.
+        if os.environ.get('CRAZY_WORKERS_DB_URL'):
+          os.environ.setdefault('CRAZY_WORKERS_DIR', abs_path)
+        else:
+          try:
+            save_to_env('CRAZY_WORKERS_DIR', abs_path)
+            console().print(f'[bold green]Saved CRAZY_WORKERS_DIR={abs_path} to .env[/bold green]')
+          except Exception as e:
+            err_console().print(f'[bold red]Failed to save configuration:[/bold red] {e}')
         return abs_path
       else:
         err_console().print(f'[bold red]Error:[/bold red] "{user_input}" is not a valid directory.')

crazy_workers-1.4.0/crazy_workers/cli/main.py

@@ -0,0 +1,117 @@
+import argparse
+import json
+import os
+import sys
+from rich.panel import Panel
+
+from ..client import WorkerClient
+from .commands import show_params, show_status, start_worker, stop_worker
+from .discovery import resolve_workers_dir
+from .ui import console, err_console
+
+
+def _db_url():
+  return os.environ.get('CRAZY_WORKERS_DB_URL')
+
+
+def _build_client(workers_dir):
+  """A control-plane client over the shared DB, or the local self-contained SQLite.
+
+  With CRAZY_WORKERS_DB_URL set the CLI talks to the same DB as the daemon and
+  issues no DDL (the daemon or host owns the schema). Otherwise it falls back to
+  the local ``.service/workers.db``, the self-contained mode.
+  """
+  db_url = _db_url()
+  if db_url:
+    return WorkerClient(db_url=db_url, create_tables=False)
+  service_dir = os.path.join(workers_dir, '.service')
+  os.makedirs(service_dir, exist_ok=True)
+  sqlite_path = os.path.join(service_dir, 'workers.db')
+  return WorkerClient(db_url=f'sqlite:///{sqlite_path}', create_tables=True)
+
+
+def _build_parser():
+  def formatter(prog):
+    return argparse.HelpFormatter(prog, max_help_position=32)
+
+  parser = argparse.ArgumentParser(description='Crazy Workers CLI', formatter_class=formatter)
+  parser.add_argument('--workers-dir', help='Directory containing worker scripts')
+
+  subparsers = parser.add_subparsers(dest='command', help='Commands')
+
+  subparsers.add_parser('status', help='Show workers (desired vs actual) and the target DB')
+
+  start_parser = subparsers.add_parser('start', help='Request a worker to run (interactive if type missing)')
+  start_parser.add_argument('worker_type', nargs='?', help='The type (filename) of worker to start')
+  start_parser.add_argument('--key', help='Optional custom key for the worker')
+  start_parser.add_argument('--params', help='JSON string of parameters for the worker')
+
+  stop_parser = subparsers.add_parser('stop', help='Request a worker to stop (interactive if key missing)')
+  stop_parser.add_argument('worker_key', nargs='?', help='The key of the worker to stop')
+
+  params_parser = subparsers.add_parser('params', help='Show parameters for a worker')
+  params_parser.add_argument('worker_key', nargs='?', help='The key of the worker')
+
+  daemon_parser = subparsers.add_parser('daemon', help='Run the reconcile loop (owns the worker processes)')
+  daemon_parser.add_argument('--interval', type=float, default=2.0, help='Seconds between reconcile passes')
+
+  return parser
+
+
+def main():
+  parser = _build_parser()
+  args = parser.parse_args()
+
+  if not args.command:
+    console().print(
+      Panel.fit(
+        '[bold cyan]Crazy Workers CLI[/bold cyan]\n[dim]Manage your background processes with ease[/dim]',
+        border_style='cyan',
+      )
+    )
+    parser.print_help()
+    sys.exit(1)
+
+  workers_dir = resolve_workers_dir(args.workers_dir)
+
+  # The daemon is the process owner, not a client — it builds its own manager.
+  if args.command == 'daemon':
+    from ..daemon.runner import main as daemon_main
+
+    argv = ['--workers-dir', workers_dir, '--interval', str(args.interval)]
+    db_url = _db_url()
+    if db_url:
+      argv += ['--db-url', db_url]
+    sys.exit(daemon_main(argv))
+
+  try:
+    with _build_client(workers_dir) as client:
+      if args.command == 'status':
+        show_status(client, workers_dir)
+      elif args.command == 'start':
+        params = _parse_params(args.params)
+        if not start_worker(client, workers_dir, args.worker_type, worker_key=args.key, parameters=params):
+          sys.exit(1)
+      elif args.command == 'stop':
+        if not stop_worker(client, args.worker_key):
+          sys.exit(1)
+      elif args.command == 'params':
+        if not show_params(client, args.worker_key):
+          sys.exit(1)
+  except ValueError as e:
+    err_console().print(f'[bold red]Error:[/bold red] {e}')
+    sys.exit(1)
+
+
+def _parse_params(raw):
+  if not raw:
+    return None
+  try:
+    return json.loads(raw)
+  except json.JSONDecodeError:
+    err_console().print('[bold red]Error:[/bold red] Invalid JSON in --params')
+    sys.exit(1)
+
+
+if __name__ == '__main__':
+  main()

crazy_workers-1.4.0/crazy_workers/client.py

@@ -0,0 +1,69 @@
+"""Control-plane client: writes desired state only, never spawns processes.
+
+Used by anything that is NOT the daemon (HTTP API, CLI, scripts). It shares the
+daemon's database; the daemon reconciles desired -> actual. A client touches the
+``workers`` table and nothing else — no OS processes, no boot hooks, no recovery.
+
+Three ways to point it at a database, mirroring :class:`Storage`:
+
+- ``engine``: reuse an existing SQLAlchemy engine (e.g. the host backend's).
+- ``db_url``: any SQLAlchemy URL.
+- neither: the caller must pass one — unlike WorkerManager, the client has no
+  workers_dir and therefore no implicit SQLite location.
+"""
+
+from .database.schema import DesiredStatus, Worker
+from .database.storage import Storage
+
+
+class WorkerClient:
+  def __init__(self, db_url=None, engine=None, create_tables=False):
+    self.storage = Storage(db_url=db_url, engine=engine, create_tables=create_tables)
+
+  def request_start(self, worker_type, worker_key=None, parameters=None):
+    """Declare that ``worker_key`` should be RUNNING (upserting its spec).
+
+    Returns the resolved worker_key. The worker is not started here; the daemon
+    notices the desired state and starts it.
+    """
+    worker_key = worker_key or worker_type
+    with self.storage.session_scope() as session:
+      worker = session.query(Worker).filter_by(worker_key=worker_key).first()
+      if not worker:
+        worker = Worker(worker_key=worker_key, worker_type=worker_type)
+        session.add(worker)
+      worker.worker_type = worker_type
+      worker.parameters = parameters or {}
+      worker.desired_status = DesiredStatus.RUNNING
+    return worker_key
+
+  def request_stop(self, worker_key):
+    """Declare that ``worker_key`` should be STOPPED.
+
+    Returns False if no such worker exists. The actual stop (and last_stopped_at)
+    is performed by the daemon when it reconciles.
+    """
+    with self.storage.session_scope() as session:
+      worker = session.query(Worker).filter_by(worker_key=worker_key).first()
+      if not worker:
+        return False
+      worker.desired_status = DesiredStatus.STOPPED
+    return True
+
+  def list(self):
+    with self.storage.session_scope() as session:
+      return [w.to_dict() for w in session.query(Worker).all()]
+
+  def get(self, worker_key):
+    with self.storage.session_scope() as session:
+      worker = session.query(Worker).filter_by(worker_key=worker_key).first()
+      return worker.to_dict() if worker else None
+
+  def dispose(self):
+    self.storage.dispose()
+
+  def __enter__(self):
+    return self
+
+  def __exit__(self, exc_type, exc_val, exc_tb):
+    self.dispose()

{crazy_workers-1.2.0 → crazy_workers-1.4.0}/crazy_workers/core/manager/__init__.py

@@ -19,12 +19,13 @@ class WorkerManager:
     workers_dir='workers',
     create_dir=True,
     backend=None,
-    auto_boot=True,
+    auto_boot=False,
     boot_provider=None,
     db_url=None,
     engine=None,
     worker_env=None,
     auto_recover=True,
+    create_tables=True,
   ):
     self.workers_dir = workers_dir
     self._validate_workers_dir(create_dir)
@@ -33,13 +34,16 @@ class WorkerManager:
     self.logs_dir = os.path.join(self.service_dir, 'logs')
     self.db_path = os.path.join(self.service_dir, 'workers.db')
 
-    self._initialize_storage(create_dir, db_url, engine)
+    self._initialize_storage(create_dir, db_url, engine, create_tables)
     # The backend is the only component that touches OS processes. The default
     # spawns real subprocesses; tests can swap in a fake one (see for_testing).
     self.backend = backend or SubprocessBackend()
-    # When True, starting a worker transparently installs the per-user OS
-    # boot-restore hook (see crazy_workers.boot). boot_provider is an injection
-    # seam for tests; None lets the platform default be auto-detected.
+    # Opt-in legacy behaviour: when True, starting a worker transparently
+    # installs the per-user OS boot-restore hook (see crazy_workers.boot). The
+    # default is now False — in the reconciler model, surviving a reboot is the
+    # deployment's job (a systemd unit / container that runs the daemon), not a
+    # per-worker hook. boot_provider is an injection seam for tests; None lets
+    # the platform default be auto-detected.
     self.auto_boot = auto_boot
     self._boot_provider = boot_provider
     # Environment variables injected into every spawned worker — e.g. the host
@@ -86,7 +90,7 @@ class WorkerManager:
       else:
         raise ValueError(f'Workers directory "{self.workers_dir}" does not exist.')
 
-  def _initialize_storage(self, create_dir, db_url, engine):
+  def _initialize_storage(self, create_dir, db_url, engine, create_tables):
     """Sets up service directories and storage if allowed or if they already exist."""
     if create_dir:
       os.makedirs(self.service_dir, exist_ok=True)
@@ -94,11 +98,12 @@ class WorkerManager:
 
     if engine is not None or db_url is not None:
       # External/shared database (e.g. the host backend's). crazy_workers' tables
-      # are created there; the local .service dir is still used for logs, the
-      # recovery lock and the boot marker.
-      self.storage = Storage(db_url=db_url, engine=engine)
+      # are created there unless the host owns the schema (create_tables=False);
+      # the local .service dir is still used for logs, the recovery lock and the
+      # boot marker.
+      self.storage = Storage(db_url=db_url, engine=engine, create_tables=create_tables)
     elif create_dir or os.path.exists(self.db_path):
-      self.storage = Storage(self.db_path)
+      self.storage = Storage(self.db_path, create_tables=create_tables)
     else:
       self.storage = None
 

{crazy_workers-1.2.0 → crazy_workers-1.4.0}/crazy_workers/core/manager/starter.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import re
+from datetime import datetime, timezone
 from sqlalchemy import func
 from sqlalchemy.exc import IntegrityError
 
@@ -60,7 +61,7 @@ def _check_already_running(manager, worker, session):
       return True
     else:
       logger.warning(f'Worker {worker.worker_key} found in RUNNING state but PID {worker.pid} is dead. Cleaning up.')
-      worker.status = WorkerStatus.CRASHED
+      _mark_crashed(worker)
       session.commit()
   return False
 
@@ -123,7 +124,7 @@ def _spawn_worker_process(manager, worker, worker_path, parameters, env, session
   )
 
   if handle is None:
-    worker.status = WorkerStatus.CRASHED
+    _mark_crashed(worker)
     worker.pid = None
     session.commit()
     return False, 'Worker process failed to start'
@@ -131,6 +132,8 @@ def _spawn_worker_process(manager, worker, worker_path, parameters, env, session
   worker.pid = handle.pid
   worker.status = WorkerStatus.RUNNING
   worker.last_started_at = func.now()
+  # A clean start clears the crash backoff so the next failure starts over.
+  worker.restart_count = 0
   session.commit()
 
   manager._active_processes[worker.worker_key] = handle
@@ -138,6 +141,15 @@ def _spawn_worker_process(manager, worker, worker_path, parameters, env, session
   return True, worker.to_dict()
 
 
+def _mark_crashed(worker):
+  # Record a death for crash backoff: bump the restart counter and stamp the
+  # exit time in UTC (Python-side, so the reconciler's backoff math does not
+  # depend on the DB dialect's now()/timezone semantics).
+  worker.status = WorkerStatus.CRASHED
+  worker.last_exit_at = datetime.now(timezone.utc)
+  worker.restart_count = (worker.restart_count or 0) + 1
+
+
 def _ensure_boot_restore(manager):
   # Best-effort and never raising: a freshly started worker transparently
   # registers the OS boot-restore hook so it survives a reboot.

crazy_workers-1.4.0/crazy_workers/daemon/__init__.py

@@ -0,0 +1,16 @@
+"""The reconcile daemon: the single owner of worker processes for a context.
+
+Clients (HTTP API, CLI, scripts) only write desired state to the shared DB; the
+daemon runs a loop that drives the observed state toward it — starting,
+stopping and crash-restarting processes. Exactly one daemon owns a given
+workers_dir/DB at a time (enforced by a lock in ``crazy_workers.daemon.runner``).
+
+Run it with ``python -m crazy_workers.daemon`` (a thin ``__main__`` shim over
+:func:`crazy_workers.daemon.runner.main`).
+"""
+
+from .reconciler import Reconciler
+from .runner import main
+
+
+__all__ = ['Reconciler', 'main']

crazy_workers-1.4.0/crazy_workers/daemon/__main__.py

@@ -0,0 +1,7 @@
+import sys
+
+from .runner import main
+
+
+if __name__ == '__main__':  # pragma: no cover
+  sys.exit(main())