Merge pull request #236 from lsst-dm/u/tobyj/w_2026_04

DM-54101 : Allow Campaigns created by CLI to auto-start

Author: tcjennings

Makefile

@@ -120,6 +120,9 @@ run: PGPORT=$(shell docker compose port postgresql 5432 | cut -d: -f2)
 run: export DB__URL=postgresql://cm-service@localhost:${PGPORT}/cm-service
 run: export DB__PASSWORD=INSECURE-PASSWORD
 run: export DB__ECHO=true
+run: export FEATURE_API_V2=1
+run: export FEATURE_API_V1=0
+run: export FEATURE_DAEMON_V2=0
 run: run-compose
 	alembic upgrade head
 	python3 -m lsst.cmservice.main
@@ -129,6 +132,12 @@ run-worker: PGPORT=$(shell docker compose port postgresql 5432 | cut -d: -f2)
 run-worker: export DB__URL=postgresql://cm-service@localhost:${PGPORT}/cm-service
 run-worker: export DB__PASSWORD=INSECURE-PASSWORD
 run-worker: export DB__ECHO=true
+run-worker: export FEATURE_API_V2=0
+run-worker: export FEATURE_API_V1=0
+run-worker: export FEATURE_DAEMON_V2=1
+run-worker: export FEATURE_DAEMON_CAMPAIGNS=1
+run-worker: export FEATURE_DAEMON_NODES=1
+run-worker: export FEATURE_ALLOW_TASK_UPSERT=1
 run-worker: run-compose
 	alembic upgrade head
 	python3 -m lsst.cmservice.daemon

alembic/seed/seed_ci_campaign.yaml

@@ -14,8 +14,6 @@ metadata:
 # information parameters for a specific manifest type here, but the campaign
 # comes last in the configuration lookup hierarchy!
 spec:
-  # set the initial state of the campaign to "paused" so it can be step-advanced
-  auto_transition: false
   butlerSelector:
     instrument: lsstcam
     embargo: "false"

packages/cm-commandline/src/lsst/cmservice/commandline/arguments.py

@@ -1,26 +1,42 @@
+import re
 from typing import Annotated, Literal
-from uuid import UUID, uuid5
+from uuid import uuid5
 
 import typer
 
+from .models import TypedContext
 from .settings import settings
 
 
-def preprocess_campaign_name(campaign: str) -> str:
-    """Preprocesses a campaign NAME by translating it to a campaign ID"""
-    try:
-        campaign_id = UUID(campaign)
-        return str(campaign_id)
-    except ValueError:
-        return str(uuid5(settings.default_namespace, campaign))
+def as_snake_case(s: str) -> str:
+    """Preprocesses a string by sanitizing it and producing snake case."""
+    # TODO clean up unicode characters and etc
+    return re.sub(r"\W+?", "_", s)
 
 
-campaign_name = Annotated[str, typer.Argument()]
+def preprocess_campaign_name(ctx: TypedContext, campaign: str) -> str:
+    """Preprocesses a campaign NAME by translating it to a campaign ID and
+    storing the result in the application context
+    """
+    sanitized_campaign_name = as_snake_case(campaign)
+    ctx.obj.campaign_name = sanitized_campaign_name
+    ctx.obj.campaign_id = str(uuid5(settings.default_namespace, sanitized_campaign_name))
+    return sanitized_campaign_name
+
+
+campaign_name = Annotated[
+    str,
+    typer.Argument(
+        envvar="CM_CAMPAIGN",
+        callback=preprocess_campaign_name,
+        help="A campaign name that is coerced into a UUID, or a UUID.",
+    ),
+]
 
-campaign_id = Annotated[str, typer.Argument(envvar="CM_CAMPAIGN", callback=preprocess_campaign_name)]
 
 campaign_status = Annotated[
     Literal["paused", "rejected", "accepted", "failed"], typer.Argument(help="Campaign status name")
 ]
 
-node_id = Annotated[str, typer.Argument()]
+
+node_id = Annotated[str, typer.Argument(help="An id for a node, as a UUID value.")]

packages/cm-commandline/src/lsst/cmservice/commandline/campaigns/app.py

@@ -18,15 +18,17 @@
 
 from .. import arguments, formatters
 from ..client import http_client
+from ..loader.app import load_from_yaml
+from ..models import TypedContext
 
 app = typer.Typer()
 console = Console()
 
 
 @app.command()
-def list(ctx: typer.Context) -> None:
+def list(ctx: TypedContext) -> None:
     """list all campaigns"""
-    output_format = formatters.Formatters[ctx.obj.get("output_format")]
+    output_format = formatters.Formatters[ctx.obj.output_format]
     with http_client(ctx) as session:
         try:
             r = session.get("/campaigns")
@@ -48,36 +50,26 @@ def list(ctx: typer.Context) -> None:
 
 @app.command(name="new")
 def new_campaign(
-    ctx: typer.Context,
+    ctx: TypedContext,
     campaign: arguments.campaign_name,
-    *,
-    auto_transition: Annotated[
-        bool,
-        typer.Option(
-            "--auto-transition/--no-auto-transition",
-            help="Whether the new campaign should be handled by the Daemon or created in a paused state.",
-        ),
-    ] = True,
 ) -> None:
-    """create a new empty campaign"""
-    output_format = formatters.Formatters[ctx.obj.get("output_format")]
+    """Create a new empty campaign"""
+    output_format = formatters.Formatters[ctx.obj.output_format]
     data = {
         "apiVersion": "io.lsst.cmservice/v1",
         "kind": "campaign",
         "metadata_": {
             "name": campaign,
         },
-        "spec": {
-            "auto_transition": auto_transition,
-        },
+        "spec": {},
     }
     with http_client(ctx) as session:
         r = session.post("/campaigns", json=data)
         r.raise_for_status()
 
     match output_format:
         case formatters.Formatters.table:
-            t = formatters.as_table(r.json())
+            t = formatters.as_table([r.json()])
             Console().print(t)
         case formatters.Formatters.json:
             pretty = JSONHighlighter()
@@ -88,12 +80,12 @@ def new_campaign(
 
 @app.command(name="describe")
 def describe_campaign(
-    ctx: typer.Context,
-    campaign: arguments.campaign_id,
+    ctx: TypedContext,
+    campaign: arguments.campaign_name,
 ) -> None:
     """describe a specific campaign"""
     with http_client(ctx) as session:
-        r = session.get(f"/campaigns/{campaign}/summary")
+        r = session.get(f"/campaigns/{ctx.obj.campaign_id}/summary")
         r.raise_for_status()
         # edges_url = r.headers["Edges"]
         # nodes_url = r.headers["Nodes"]
@@ -155,14 +147,14 @@ def describe_campaign(
 
 
 @app.command(name="start")
-def start_campaign(ctx: typer.Context, campaign: arguments.campaign_id) -> None:
+def start_campaign(ctx: TypedContext, campaign: arguments.campaign_name) -> None:
     """start a campaign"""
     data = {"status": "running"}
     status_update_url = None
 
     with http_client(ctx) as session:
         r = session.patch(
-            f"/campaigns/{campaign}",
+            f"/campaigns/{ctx.obj.campaign_id}",
             json=data,
             headers={"Content-Type": "application/merge-patch+json"},
         )
@@ -205,8 +197,8 @@ def start_campaign(ctx: typer.Context, campaign: arguments.campaign_id) -> None:
 
 @app.command(name="set")
 def set_campaign_status(
-    ctx: typer.Context,
-    campaign: arguments.campaign_id,
+    ctx: TypedContext,
+    campaign: arguments.campaign_name,
     desired_state: arguments.campaign_status,
     *,
     force: Annotated[
@@ -223,7 +215,7 @@ def set_campaign_status(
 
     with http_client(ctx) as session:
         r = session.patch(
-            f"/campaigns/{campaign}",
+            f"/campaigns/{ctx.obj.campaign_id}",
             json=data,
             headers={"Content-Type": "application/merge-patch+json"},
         )
@@ -264,15 +256,15 @@ def set_campaign_status(
 
 
 @app.command(name="advance")
-def advance_campaign(ctx: typer.Context, campaign: arguments.campaign_id) -> None:
+def advance_campaign(ctx: TypedContext, campaign: arguments.campaign_name) -> None:
     """advances a paused campaign"""
 
     status_update_url = None
 
     with http_client(ctx) as session:
         r = session.post(
             "/rpc/process",
-            json={"campaign_id": campaign},
+            json={"campaign_id": ctx.obj.campaign_id},
             headers={},
         )
         r.raise_for_status()
@@ -317,3 +309,30 @@ def advance_campaign(ctx: typer.Context, campaign: arguments.campaign_id) -> Non
     #             )
 
     #     console.print(result_text)
+
+
+@app.command(name="load")
+def load_campaign(
+    ctx: TypedContext,
+    filename: Annotated[
+        str,
+        typer.Argument(help="A name or path to a YAML file containing a complete set of campaign manifests"),
+    ],
+    campaign: arguments.campaign_name,
+    *,
+    auto_run: Annotated[
+        bool,
+        typer.Option(
+            "--start",
+            help="Start campaign automatically after loading",
+        ),
+    ] = False,
+) -> None:
+    """Loads a campaign from a YAML file, optionally starting it."""
+
+    ctx.invoke(load_from_yaml, ctx=ctx, filename=filename, campaign=campaign, strict=True)
+
+    # If argument "auto-start" is set, try to set campaign status after loading
+    if auto_run:
+        typer.echo(f"Starting campaign {ctx.obj.campaign_name}")
+        ctx.invoke(start_campaign, ctx=ctx, campaign=campaign)

packages/cm-commandline/src/lsst/cmservice/commandline/cli.py

@@ -4,6 +4,7 @@
 from .campaigns.app import app as campaigns_app
 from .loader.app import app as loader_app
 from .manifests.app import app as manifests_app
+from .models import AppContext, TypedContext
 from .nodes.app import app as nodes_app
 from .settings import settings
 
@@ -16,14 +17,12 @@
 
 @app.callback()
 def build_context(
-    ctx: typer.Context,
+    ctx: TypedContext,
     output: options.output = "table",
     endpoint: options.endpoint = settings.endpoint,
     token: options.token = settings.token,
 ) -> None:
-    ctx.ensure_object(dict)
-    ctx.obj["output_format"] = output
-    ctx.obj["cm_endpoint_url"] = endpoint
+    ctx.obj = AppContext(output_format=output, endpoint_url=endpoint, auth_token=token)
 
 
 if __name__ == "__main__":

packages/cm-commandline/src/lsst/cmservice/commandline/client.py

@@ -4,25 +4,24 @@
 from contextlib import contextmanager
 from uuid import uuid4
 
-import typer
 from httpx import Client, HTTPStatusError, HTTPTransport
 
 from .logging import LOGGER
-from .settings import settings
+from .models import TypedContext
 
 logger = LOGGER.bind(module=__name__)
 
 
 @contextmanager
-def http_client(ctx: typer.Context) -> Generator[Client]:
+def http_client(ctx: TypedContext) -> Generator[Client]:
     """Generate a client session for cmclient API operations."""
     transport = HTTPTransport(
         verify=False,
         retries=3,
     )
-    endpoint_url = ctx.obj.get("endpoint_url", settings.endpoint)
-    api_version = ctx.obj.get("api_version", settings.api_version)
-    auth_token = ctx.obj.get("auth_token", settings.token)
+    endpoint_url = ctx.obj.endpoint_url
+    api_version = ctx.obj.api_version
+    auth_token = ctx.obj.auth_token
 
     with Client(
         base_url=f"{endpoint_url}/{api_version}",

packages/cm-commandline/src/lsst/cmservice/commandline/loader/app.py

@@ -5,22 +5,32 @@
 from rich.console import Console
 from rich.table import Table
 
-from .loader import load_selected_file
+from .. import arguments
+from ..models import TypedContext
+from .loader import StrictModeViolationError, load_selected_file
 
 app = typer.Typer()
 
 
 @app.command(name="yaml")
 def load_from_yaml(
-    ctx: typer.Context,
+    ctx: TypedContext,
     filename: str,
-    campaign_name: Annotated[str | None, typer.Argument(envvar="CM_CAMPAIGN")] = None,
+    campaign: arguments.campaign_name,
+    *,
+    strict: Annotated[
+        bool, typer.Option(help="Load YAML in strict mode (file must have only a single campaign)")
+    ] = False,
 ) -> None:
     """Load manifests from a YAML file"""
-    headers = load_selected_file(ctx, Path(filename), campaign_name)
+    try:
+        headers = load_selected_file(ctx, yaml_file=Path(filename), campaign=campaign, strict=strict)
+    except StrictModeViolationError as e:
+        typer.echo(e, err=True)
+        raise typer.Exit(1)
 
     if headers:
-        table = Table(title=campaign_name)
+        table = Table(title=ctx.obj.campaign_name)
         table.add_column("Link Name")
         table.add_column("Link")