diracx-cli 0.0.1a6__tar.gz → 0.0.1a8__tar.gz

{diracx-cli-0.0.1a6 → diracx-cli-0.0.1a8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diracx-cli
-Version: 0.0.1a6
+Version: 0.0.1a8
 Summary: TODO
 License: GPL-3.0-only
 Classifier: Intended Audience :: Science/Research

diracx-cli-0.0.1a8/src/diracx/cli/internal/__init__.py

@@ -0,0 +1,188 @@
+from pathlib import Path
+from typing import Annotated, Optional
+
+import git
+import typer
+import yaml
+from pydantic import parse_obj_as
+
+from diracx.core.config import ConfigSource, ConfigSourceUrl
+from diracx.core.config.schema import (
+    Config,
+    DIRACConfig,
+    GroupConfig,
+    IdpConfig,
+    OperationsConfig,
+    RegistryConfig,
+    UserConfig,
+)
+
+from ..utils import AsyncTyper
+from . import legacy
+
+app = AsyncTyper()
+app.add_typer(legacy.app, name="legacy")
+
+
+@app.command()
+def generate_cs(
+    config_repo: str,
+):
+    """Generate a minimal DiracX configuration repository"""
+    # TODO: The use of parse_obj_as should be moved in to typer itself
+    config_repo = parse_obj_as(ConfigSourceUrl, config_repo)
+    if config_repo.scheme != "git+file":
+        raise NotImplementedError("Only git+file:// URLs are supported")
+    repo_path = Path(config_repo.path)
+    if repo_path.exists() and list(repo_path.iterdir()):
+        typer.echo(f"ERROR: Directory {repo_path} already exists", err=True)
+        raise typer.Exit(1)
+
+    config = Config(
+        Registry={},
+        DIRAC=DIRACConfig(),
+        Operations={"Defaults": OperationsConfig()},
+    )
+
+    update_config_and_commit(
+        repo_path=repo_path, config=config, message="Initial commit"
+    )
+    typer.echo(f"Successfully created repo in {config_repo}", err=True)
+
+
+@app.command()
+def add_vo(
+    config_repo: str,
+    *,
+    vo: Annotated[str, typer.Option()],
+    default_group: Optional[str] = "user",
+    idp_url: Annotated[str, typer.Option()],
+    idp_client_id: Annotated[str, typer.Option()],
+):
+    """Add a registry entry (vo) to an existing configuration repository"""
+
+    # TODO: The use of parse_obj_as should be moved in to typer itself
+    config_repo = parse_obj_as(ConfigSourceUrl, config_repo)
+    repo_path = Path(config_repo.path)
+
+    # A VO should at least contain a default group
+    new_registry = RegistryConfig(
+        IdP=IdpConfig(URL=idp_url, ClientID=idp_client_id),
+        DefaultGroup=default_group,
+        Users={},
+        Groups={
+            default_group: GroupConfig(
+                Properties={"NormalUser"}, Quota=None, Users=set()
+            )
+        },
+    )
+
+    config = ConfigSource.create_from_url(backend_url=repo_path).read_config()
+
+    if vo in config.Registry:
+        typer.echo(f"ERROR: VO {vo} already exists", err=True)
+        raise typer.Exit(1)
+
+    config.Registry[vo] = new_registry
+
+    update_config_and_commit(
+        repo_path=repo_path,
+        config=config,
+        message=f"Added vo {vo} registry (default group {default_group} and idp {idp_url})",
+    )
+    typer.echo(f"Successfully added vo to {config_repo}", err=True)
+
+
+@app.command()
+def add_group(
+    config_repo: str,
+    *,
+    vo: Annotated[str, typer.Option()],
+    group: Annotated[str, typer.Option()],
+    properties: list[str] = ["NormalUser"],
+):
+    """Add a group to an existing vo in the configuration repository"""
+
+    # TODO: The use of parse_obj_as should be moved in to typer itself
+    config_repo = parse_obj_as(ConfigSourceUrl, config_repo)
+    repo_path = Path(config_repo.path)
+
+    new_group = GroupConfig(Properties=set(properties), Quota=None, Users=set())
+
+    config = ConfigSource.create_from_url(backend_url=repo_path).read_config()
+
+    if vo not in config.Registry:
+        typer.echo(f"ERROR: Virtual Organization {vo} does not exist", err=True)
+        raise typer.Exit(1)
+
+    if group in config.Registry[vo].Groups.keys():
+        typer.echo(f"ERROR: Group {group} already exists in {vo}", err=True)
+        raise typer.Exit(1)
+
+    config.Registry[vo].Groups[group] = new_group
+
+    update_config_and_commit(
+        repo_path=repo_path, config=config, message=f"Added group {group} in {vo}"
+    )
+    typer.echo(f"Successfully added group to {config_repo}", err=True)
+
+
+@app.command()
+def add_user(
+    config_repo: str,
+    *,
+    vo: Annotated[str, typer.Option()],
+    groups: Annotated[Optional[list[str]], typer.Option("--group")] = None,
+    sub: Annotated[str, typer.Option()],
+    preferred_username: Annotated[str, typer.Option()],
+):
+    """Add a user to an existing vo and group"""
+
+    # TODO: The use of parse_obj_as should be moved in to typer itself
+    config_repo = parse_obj_as(ConfigSourceUrl, config_repo)
+
+    repo_path = Path(config_repo.path)
+
+    new_user = UserConfig(PreferedUsername=preferred_username)
+
+    config = ConfigSource.create_from_url(backend_url=repo_path).read_config()
+
+    if vo not in config.Registry:
+        typer.echo(f"ERROR: Virtual Organization {vo} does not exist", err=True)
+        raise typer.Exit(1)
+
+    if sub in config.Registry[vo].Users:
+        typer.echo(f"ERROR: User {sub} already exists", err=True)
+        raise typer.Exit(1)
+
+    config.Registry[vo].Users[sub] = new_user
+
+    if not groups:
+        groups = [config.Registry[vo].DefaultGroup]
+
+    for group in set(groups):
+        if group not in config.Registry[vo].Groups:
+            typer.echo(f"ERROR: Group {group} does not exist in {vo}", err=True)
+            raise typer.Exit(1)
+        if sub in config.Registry[vo].Groups[group].Users:
+            typer.echo(f"ERROR: User {sub} already exists in group {group}", err=True)
+            raise typer.Exit(1)
+
+        config.Registry[vo].Groups[group].Users.add(sub)
+
+    update_config_and_commit(
+        repo_path=repo_path,
+        config=config,
+        message=f"Added user {sub} ({preferred_username}) to vo {vo} and groups {groups}",
+    )
+    typer.echo(f"Successfully added user to {config_repo}", err=True)
+
+
+def update_config_and_commit(repo_path: Path, config: Config, message: str):
+    """Update the yaml file in the repo and commit it"""
+    repo = git.Repo.init(repo_path)
+    yaml_path = repo_path / "default.yml"
+    typer.echo(f"Writing back configuration to {yaml_path}", err=True)
+    yaml_path.write_text(yaml.safe_dump(config.dict(exclude_unset=True)))
+    repo.index.add([yaml_path.relative_to(repo_path)])
+    repo.index.commit(message)

{diracx-cli-0.0.1a6 → diracx-cli-0.0.1a8}/src/diracx_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diracx-cli
-Version: 0.0.1a6
+Version: 0.0.1a8
 Summary: TODO
 License: GPL-3.0-only
 Classifier: Intended Audience :: Science/Research

diracx-cli-0.0.1a8/tests/test_internal.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import pytest
+from typer.testing import CliRunner
+
+from diracx.cli import app
+from diracx.core.config import ConfigSource
+
+runner = CliRunner()
+
+
+@pytest.mark.parametrize("protocol", [None, "git+file://"])
+def test_generate_cs(tmp_path, protocol):
+    cs_repo = f"{tmp_path}"
+    if protocol is None:
+        cs_repo = f"git+file://{cs_repo}"
+
+    result = runner.invoke(app, ["internal", "generate-cs", cs_repo])
+    assert result.exit_code == 0
+    assert (tmp_path / ".git").is_dir()
+    assert (tmp_path / "default.yml").is_file()
+
+    # Running a second time should fail
+    result = runner.invoke(app, ["internal", "generate-cs", cs_repo])
+    assert result.exit_code != 0
+
+
+def test_add_vo(tmp_path):
+    cs_repo = f"git+file://{tmp_path}"
+
+    # Create the CS
+    runner.invoke(app, ["internal", "generate-cs", cs_repo])
+
+    # Add a VO to it
+    vo1 = "testvo"
+    result = runner.invoke(
+        app,
+        [
+            "internal",
+            "add-vo",
+            cs_repo,
+            f"--vo={vo1}",
+            "--idp-url=https://idp.invalid",
+            "--idp-client-id=idp-client-id",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+
+    config = ConfigSource.create_from_url(backend_url=cs_repo).read_config()
+
+    assert vo1 in config.Registry
+    assert config.Registry[vo1].DefaultGroup == "user"
+    assert config.Registry[vo1].IdP.URL == "https://idp.invalid"
+    assert config.Registry[vo1].IdP.ClientID == "idp-client-id"
+
+    # Add a second VO to it
+    vo2 = "lhcb"
+    result = runner.invoke(
+        app,
+        [
+            "internal",
+            "add-vo",
+            cs_repo,
+            f"--vo={vo2}",
+            "--idp-url=https://idp.example.invalid",
+            "--idp-client-id=idp-client-id2",
+            "--default-group",
+            "admin",
+        ],
+    )
+
+    config = ConfigSource.create_from_url(backend_url=cs_repo).read_config()
+    assert result.exit_code == 0, result.output
+
+    assert vo2 in config.Registry
+    assert config.Registry[vo2].DefaultGroup == "admin"
+    assert config.Registry[vo2].IdP.URL == "https://idp.example.invalid"
+    assert config.Registry[vo2].IdP.ClientID == "idp-client-id2"
+
+    # Try to insert a VO that already exists
+    result = runner.invoke(
+        app,
+        [
+            "internal",
+            "add-vo",
+            cs_repo,
+            f"--vo={vo1}",
+            "--idp-url=https://idp.invalid",
+            "--idp-client-id=idp-client-id",
+        ],
+    )
+    assert result.exit_code != 0, result.output
+
+
+def test_add_group(tmp_path):
+    cs_repo = f"git+file://{tmp_path}"
+    vo = "testvo"
+    group1 = "testgroup1"
+    group2 = "testgroup2"
+
+    # Create the CS
+    runner.invoke(app, ["internal", "generate-cs", cs_repo])
+    runner.invoke(
+        app,
+        [
+            "internal",
+            "add-vo",
+            cs_repo,
+            f"--vo={vo}",
+            "--idp-url=https://idp.invalid",
+            "--idp-client-id=idp-client-id",
+        ],
+    )
+
+    # Add a group to it
+    result = runner.invoke(
+        app, ["internal", "add-group", cs_repo, f"--vo={vo}", f"--group={group1}"]
+    )
+    assert result.exit_code == 0, result.output
+
+    config = ConfigSource.create_from_url(backend_url=cs_repo).read_config()
+
+    assert group1 in config.Registry[vo].Groups
+    assert config.Registry[vo].Groups[group1].JobShare == 1000
+    assert config.Registry[vo].Groups[group1].Properties == {"NormalUser"}
+    assert config.Registry[vo].Groups[group1].Users == set()
+
+    # Add a second group to it
+    result = runner.invoke(
+        app,
+        [
+            "internal",
+            "add-group",
+            cs_repo,
+            f"--vo={vo}",
+            f"--group={group2}",
+            "--properties",
+            "NormalUser",
+            "--properties",
+            "AdminUser",
+        ],
+    )
+    config = ConfigSource.create_from_url(backend_url=cs_repo).read_config()
+    assert result.exit_code == 0, result.output
+
+    assert group2 in config.Registry[vo].Groups
+    assert config.Registry[vo].Groups[group2].JobShare == 1000
+    assert config.Registry[vo].Groups[group2].Properties == {"AdminUser", "NormalUser"}
+    assert config.Registry[vo].Groups[group2].Users == set()
+
+    # Try to insert a group that already exists
+    result = runner.invoke(
+        app, ["internal", "add-group", cs_repo, f"--vo={vo}", f"--group={group1}"]
+    )
+    assert result.exit_code != 0, result.output
+
+    # Try to insert a group with a non-existing VO
+    result = runner.invoke(
+        app,
+        ["internal", "add-group", cs_repo, "--vo=nonexistingvo", f"--group={group1}"],
+    )
+    assert result.exit_code != 0, result.output
+
+
+@pytest.mark.parametrize("vo", ["nonexistingvo", "testvo"])
+@pytest.mark.parametrize(
+    "user_group", [["nonexisting_group"], ["user"], ["user", "admin"], []]
+)
+def test_add_user(tmp_path, vo, user_group):
+    cs_repo = f"git+file://{tmp_path}"
+
+    sub = "lhcb:chaen"
+    preferred_username = "dontCallMeShirley"
+
+    # Create the CS
+    runner.invoke(app, ["internal", "generate-cs", cs_repo])
+    runner.invoke(
+        app,
+        [
+            "internal",
+            "add-vo",
+            cs_repo,
+            "--vo=testvo",
+            "--idp-url=https://idp.invalid",
+            "--idp-client-id=idp-client-id",
+        ],
+    )
+    runner.invoke(
+        app, ["internal", "add-group", cs_repo, "--vo=testvo", "--group=user"]
+    )
+    runner.invoke(
+        app, ["internal", "add-group", cs_repo, "--vo=testvo", "--group=admin"]
+    )
+
+    config = ConfigSource.create_from_url(backend_url=cs_repo).read_config()
+
+    # Check the user isn't in it
+    if vo in config.Registry:
+        assert sub not in config.Registry[vo].Users
+
+    # Add a user to it
+    result = runner.invoke(
+        app,
+        [
+            "internal",
+            "add-user",
+            cs_repo,
+            f"--vo={vo}",
+            f"--sub={sub}",
+            f"--preferred-username={preferred_username}",
+        ]
+        + [f"--group={x}" for x in user_group],
+    )
+
+    if "nonexistingvo" in vo or "nonexisting_group" in user_group:
+        assert result.exit_code != 0
+        return
+
+    assert result.exit_code == 0, result.output
+
+    config = ConfigSource.create_from_url(backend_url=cs_repo).read_config()
+    # check the user is defined
+    assert vo in config.Registry
+    assert sub in config.Registry[vo].Users
+    for group in user_group or ["user"]:
+        assert config.Registry[vo].Groups[group].Users == {sub}

diracx-cli-0.0.1a6/src/diracx/cli/internal/__init__.py

@@ -1,104 +0,0 @@
-from pathlib import Path
-
-import git
-import typer
-import yaml
-from pydantic import parse_obj_as
-
-from diracx.core.config import ConfigSource, ConfigSourceUrl
-from diracx.core.config.schema import (
-    Config,
-    DIRACConfig,
-    GroupConfig,
-    IdpConfig,
-    OperationsConfig,
-    RegistryConfig,
-    UserConfig,
-)
-
-from ..utils import AsyncTyper
-from . import legacy
-
-app = AsyncTyper()
-app.add_typer(legacy.app, name="legacy")
-
-
-@app.command()
-def generate_cs(
-    config_repo: str,
-    *,
-    vo: str = "testvo",
-    user_group: str = "user",
-    idp_url: str = "https://idp.invalid",
-    idp_client_id: str = "idp-client-id",
-):
-    """Generate a minimal DiracX configuration repository"""
-    # TODO: The use of parse_obj_as should be moved in to typer itself
-    config_repo = parse_obj_as(ConfigSourceUrl, config_repo)
-    if config_repo.scheme != "git+file":
-        raise NotImplementedError("Only git+file:// URLs are supported")
-    repo_path = Path(config_repo.path)
-    if repo_path.exists() and list(repo_path.iterdir()):
-        typer.echo(f"ERROR: Directory {repo_path} already exists", err=True)
-        raise typer.Exit(1)
-
-    registry = RegistryConfig(
-        IdP=IdpConfig(URL=idp_url, ClientID=idp_client_id),
-        DefaultGroup=user_group,
-        Users={},
-        Groups={
-            user_group: GroupConfig(Properties={"NormalUser"}, Quota=None, Users=set())
-        },
-    )
-    config = Config(
-        Registry={vo: registry},
-        DIRAC=DIRACConfig(),
-        Operations={"Defaults": OperationsConfig()},
-    )
-
-    repo = git.Repo.init(repo_path, initial_branch="master")
-    yaml_path = repo_path / "default.yml"
-    typer.echo(f"Writing configuration to {yaml_path}", err=True)
-    yaml_path.write_text(yaml.safe_dump(config.dict(exclude_unset=True)))
-    repo.index.add([yaml_path.relative_to(repo_path)])
-    repo.index.commit("Initial commit")
-    typer.echo(f"Successfully created repo in {config_repo}", err=True)
-
-
-@app.command()
-def add_user(
-    config_repo: str,
-    *,
-    vo: str = "testvo",
-    user_group: str = "user",
-    sub: str = "usersub",
-    preferred_username: str = "preferred_username",
-):
-    """Add a user to an existing vo and group"""
-
-    # TODO: The use of parse_obj_as should be moved in to typer itself
-    config_repo = parse_obj_as(ConfigSourceUrl, config_repo)
-
-    repo_path = Path(config_repo.path)
-
-    new_user = UserConfig(PreferedUsername=preferred_username)
-
-    config = ConfigSource.create_from_url(backend_url=repo_path).read_config()
-
-    if sub in config.Registry[vo].Users:
-        typer.echo(f"ERROR: User {sub} already exists", err=True)
-        raise typer.Exit(1)
-
-    config.Registry[vo].Users[sub] = new_user
-
-    config.Registry[vo].Groups[user_group].Users.add(sub)
-
-    repo = git.Repo.init(repo_path)
-    yaml_path = repo_path / "default.yml"
-    typer.echo(f"Writing back configuration to {yaml_path}", err=True)
-    yaml_path.write_text(yaml.safe_dump(config.dict(exclude_unset=True)))
-    repo.index.add([yaml_path.relative_to(repo_path)])
-    repo.index.commit(
-        f"Added user {sub} ({preferred_username}) to vo {vo} and user_group {user_group}"
-    )
-    typer.echo(f"Successfully added user to {config_repo}", err=True)

diracx-cli-0.0.1a6/tests/test_internal.py

@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-import pytest
-from typer.testing import CliRunner
-
-from diracx.cli import app
-from diracx.core.config import ConfigSource
-
-runner = CliRunner()
-
-
-@pytest.mark.parametrize("protocol", [None, "git+file://"])
-def test_generate_cs(tmp_path, protocol):
-    cs_repo = f"{tmp_path}"
-    if protocol is None:
-        cs_repo = f"git+file://{cs_repo}"
-
-    result = runner.invoke(app, ["internal", "generate-cs", cs_repo])
-    assert result.exit_code == 0
-    assert (tmp_path / ".git").is_dir()
-    assert (tmp_path / "default.yml").is_file()
-
-    # Running a second time should fail
-    result = runner.invoke(app, ["internal", "generate-cs", cs_repo])
-    assert result.exit_code != 0
-
-
-@pytest.mark.parametrize("vo", ["nonexistingvo", "testvo"])
-@pytest.mark.parametrize("user_group", ["nonexisting_group", "user"])
-def test_add_user(tmp_path, vo, user_group):
-    cs_repo = f"git+file://{tmp_path}"
-
-    sub = "lhcb:chaen"
-    preferred_username = "dontCallMeShirley"
-
-    # Create the CS
-    runner.invoke(app, ["internal", "generate-cs", cs_repo])
-
-    config = ConfigSource.create_from_url(backend_url=cs_repo).read_config()
-
-    # Check the user isn't in it
-    if vo in config.Registry:
-        assert sub not in config.Registry[vo].Users
-
-    # Add a user to it
-    result = runner.invoke(
-        app,
-        [
-            "internal",
-            "add-user",
-            cs_repo,
-            "--vo",
-            vo,
-            "--user-group",
-            user_group,
-            "--sub",
-            sub,
-            "--preferred-username",
-            preferred_username,
-        ],
-    )
-
-    if "nonexisting" in vo or "nonexisting" in user_group:
-        assert result.exit_code != 0
-        return
-
-    assert result.exit_code == 0, result.output
-
-    config = ConfigSource.create_from_url(backend_url=cs_repo).read_config()
-    # check the user is defined
-    assert vo in config.Registry
-    assert sub in config.Registry[vo].Users