feat(server): Add CLI task to list organizations

In preparation of #8352, I needed to bootstrap the `tasks` cli group and investigate if it's doable to perform operation without relying on a running backend

Author: FirelightFlagboy

server/parsec/cli/__init__.py

@@ -18,6 +18,7 @@
 from parsec.cli.sequester_create import create_service, generate_service_certificate
 from parsec.cli.sequester_list import list_services
 from parsec.cli.sequester_revoke import generate_service_revocation_certificate, revoke_service
+from parsec.cli.tasks import server_tasks_cmd_group
 from parsec.cli.testbed import TESTBED_AVAILABLE, testbed_cmd
 
 __all__ = ("cli",)
@@ -53,6 +54,8 @@ def cli() -> None:
 cli.add_command(list_deletable_realms, "list_deletable_realms")
 cli.add_command(delete_realm, "delete_realm")
 cli.add_command(server_sequester_cmd, "sequester")
+cli.add_command(server_tasks_cmd_group)
+
 if TESTBED_AVAILABLE:
     cli.add_command(testbed_cmd, "testbed")
     # Since `render_email` is only for debugging purpose, we don't expose it

server/parsec/cli/tasks/__init__.py

@@ -0,0 +1,16 @@
+# Parsec Cloud (https://parsec.cloud) Copyright (c) BUSL-1.1 2016-present Scille SAS
+
+import click
+
+from parsec.cli.options import version_option
+
+from . import list_organization
+
+
+@click.group(name="tasks", short_help="Server tasks collections")
+@version_option
+def server_tasks_cmd_group() -> None:
+    pass
+
+
+server_tasks_cmd_group.add_command(list_organization.cmd)

server/parsec/cli/tasks/list_organization.py

@@ -0,0 +1,116 @@
+# Parsec Cloud (https://parsec.cloud) Copyright (c) BUSL-1.1 2016-present Scille SAS
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+import click
+import pydantic
+
+from parsec._parsec import EmailAddress, OrganizationID, ParsecAddr, SecretKey
+from parsec.cli.options import asyncio_run, db_server_options, logging_config_options
+from parsec.components.memory.datamodel import MemoryDatamodel
+from parsec.components.memory.events import event_bus_factory
+from parsec.components.memory.organization import MemoryOrganizationComponent
+from parsec.components.organization import BaseOrganizationComponent, OrganizationDump
+from parsec.components.postgresql.handler import asyncpg_pool_factory
+from parsec.components.postgresql.organization import PGOrganizationComponent
+from parsec.config import (
+    BackendConfig,
+    BaseDatabaseConfig,
+    LogLevel,
+    MockedBlockStoreConfig,
+    MockedEmailConfig,
+    PostgreSQLDatabaseConfig,
+)
+from parsec.webhooks import MockedWebhooksComponent
+
+
+@pydantic.dataclasses.dataclass()
+class OrganizationInfo:
+    id: OrganizationID
+    is_bootstrapped: bool
+    # bootstrapped_on: DateTime | None
+    is_expired: bool
+    # expired_on: DateTime | None
+    # active_users_limit: ActiveUsersLimit
+    user_profile_outsider_allowed: bool
+    realm_minimum_archiving_period_before_deletion: int
+    # tos: TermsOfService | None
+
+    @classmethod
+    def from_dump(cls, dump: OrganizationDump) -> OrganizationInfo:
+        return OrganizationInfo(
+            id=dump.organization_id,
+            is_bootstrapped=dump.is_bootstrapped,
+            is_expired=dump.is_expired,
+            user_profile_outsider_allowed=dump.user_profile_outsider_allowed,
+            realm_minimum_archiving_period_before_deletion=dump.realm_minimum_archiving_period_before_deletion,
+        )
+
+
+@click.command(name="list-organizations", short_help="List organization present on the server")
+@db_server_options
+@logging_config_options(default_log_level="INFO")
+@asyncio_run
+async def cmd(
+    db: BaseDatabaseConfig,
+    db_min_connections: int,
+    db_max_connections: int,
+    log_level: LogLevel,
+    log_format: str,
+    log_file: str | None,
+):
+    backend_config = BackendConfig(
+        debug=False,
+        db_config=db,
+        blockstore_config=MockedBlockStoreConfig(),
+        email_config=MockedEmailConfig(sender=EmailAddress("tasks@parsec.local")),
+        server_addr=ParsecAddr("tasks.parsec.local", None, True),
+        administration_token="",
+        fake_account_password_algorithm_seed=SecretKey.generate(),
+    )
+    async with organization_component_factory(backend_config) as component:
+        orgs = await list_organizations(component)
+
+    adapter = pydantic.TypeAdapter(
+        dict[
+            OrganizationID,
+            OrganizationInfo,
+        ]
+    )
+    click.echo_via_pager(adapter.dump_json(orgs, indent=4).decode())
+
+
+@asynccontextmanager
+async def organization_component_factory(
+    config: BackendConfig,
+) -> AsyncGenerator[BaseOrganizationComponent, None]:
+    if config.db_config.is_mocked():
+        data = MemoryDatamodel(
+            {} if config.backend_mocked_data is None else config.backend_mocked_data
+        )
+        async with event_bus_factory() as event_bus:
+            yield MemoryOrganizationComponent(data, event_bus, MockedWebhooksComponent(), config)
+
+    else:
+        assert isinstance(config.db_config, PostgreSQLDatabaseConfig)
+        async with asyncpg_pool_factory(
+            url=config.db_config.url,
+            min_connections=config.db_config.min_connections,
+            max_connections=config.db_config.max_connections,
+        ) as pool:
+            yield PGOrganizationComponent(
+                pool=pool,
+                webhooks=MockedWebhooksComponent(),
+                config=None,  # pyright: ignore [reportArgumentType]
+            )
+
+
+async def list_organizations(
+    component: BaseOrganizationComponent,
+) -> dict[OrganizationID, OrganizationInfo]:
+    return {
+        id: OrganizationInfo.from_dump(dump)
+        for id, dump in (await component.list_organizations()).items()
+    }

server/parsec/components/memory/organization.py

@@ -402,7 +402,7 @@ async def get_tos(
         return org.tos
 
     @override
-    async def test_dump_organizations(
+    async def list_organizations(
         self, skip_templates: bool = True
     ) -> dict[OrganizationID, OrganizationDump]:
         items = {}

server/parsec/components/organization.py

@@ -321,7 +321,7 @@ async def get_tos(
     ) -> TermsOfService | OrganizationGetTosBadOutcome | None:
         raise NotImplementedError
 
-    async def test_dump_organizations(
+    async def list_organizations(
         self, skip_templates: bool = True
     ) -> dict[OrganizationID, OrganizationDump]:
         raise NotImplementedError

server/parsec/components/postgresql/organization.py

@@ -38,13 +38,13 @@
 from parsec.components.postgresql.organization_bootstrap import organization_bootstrap
 from parsec.components.postgresql.organization_create import organization_create
 from parsec.components.postgresql.organization_get_tos import organization_get_tos
+from parsec.components.postgresql.organization_list_organizations import (
+    organization_list_organizations,
+)
 from parsec.components.postgresql.organization_stats import (
     organization_server_stats,
     organization_stats,
 )
-from parsec.components.postgresql.organization_test_dump_organizations import (
-    organization_test_dump_organizations,
-)
 from parsec.components.postgresql.organization_test_dump_topics import organization_test_dump_topics
 from parsec.components.postgresql.organization_update import organization_update
 from parsec.components.postgresql.test_queries import (
@@ -355,10 +355,10 @@ async def get_tos(
 
     @override
     @no_transaction
-    async def test_dump_organizations(
+    async def list_organizations(
         self, conn: AsyncpgConnection, skip_templates: bool = True
     ) -> dict[OrganizationID, OrganizationDump]:
-        return await organization_test_dump_organizations(conn, skip_templates)
+        return await organization_list_organizations(conn, skip_templates)
 
     @override
     @no_transaction

…/organization_test_dump_organizations.py …resql/organization_list_organizations.pyserver/parsec/components/postgresql/organization_test_dump_organizations.py renamed to server/parsec/components/postgresql/organization_list_organizations.py server/parsec/components/postgresql/organization_test_dump_organizations.py renamed to server/parsec/components/postgresql/organization_list_organizations.py

@@ -32,7 +32,7 @@
 """)
 
 
-async def organization_test_dump_organizations(
+async def organization_list_organizations(
     conn: AsyncpgConnection, skip_templates: bool = True
 ) -> dict[OrganizationID, OrganizationDump]:
     items = {}

server/parsec/webhooks.py

@@ -236,3 +236,55 @@ async def sequester_service_on_realm_rotate_key(
             return SequesterServiceUnavailable(
                 service_id=service_id,
             )
+
+
+class MockedWebhooksComponent(WebhooksComponent):
+    """
+    Webhooks that does nothing,
+
+    Used when creating components that require a webhook class but we do not except that component to use webhook (useful for tasks)"""
+
+    def __init__(self) -> None:
+        pass
+
+    async def on_organization_bootstrap(
+        self,
+        organization_id: OrganizationID,
+        device_id: DeviceID,
+        device_label: DeviceLabel,
+        human_email: EmailAddress,
+        human_label: str,
+    ) -> None:
+        return None
+
+    async def sequester_service_on_vlob_create_or_update(
+        self,
+        webhook_url: str,
+        service_id: SequesterServiceID,
+        organization_id: OrganizationID,
+        author: DeviceID,
+        realm_id: VlobID,
+        vlob_id: VlobID,
+        key_index: int,
+        version: int,
+        timestamp: DateTime,
+        blob: bytes,
+    ) -> SequesterServiceUnavailable | RejectedBySequesterService | None:
+        return None
+
+    async def sequester_service_on_realm_rotate_key(
+        self,
+        webhook_url: str,
+        service_id: SequesterServiceID,
+        organization_id: OrganizationID,
+        keys_bundle: bytes,
+        keys_bundle_access: bytes,
+        author: DeviceID,
+        timestamp: DateTime,
+        realm_id: VlobID,
+        key_index: int,
+        encryption_algorithm: SecretKeyAlgorithm,
+        hash_algorithm: HashAlgorithm,
+        key_canary: bytes,
+    ) -> SequesterServiceUnavailable | RejectedBySequesterService | None:
+        return None

server/src/ids.rs

@@ -2,7 +2,11 @@
 
 use std::str::FromStr;
 
-use pyo3::{exceptions::PyValueError, prelude::*, types::PyType};
+use pyo3::{
+    exceptions::PyValueError,
+    prelude::*,
+    types::{PyDict, PyList, PyType, PyTypeMethods},
+};
 
 // UUID based type
 
@@ -203,14 +207,55 @@ impl OrganizationID {
                 Err(err) => Err(PyValueError::new_err(err.to_string())),
             }
         } else {
-            Err(PyValueError::new_err("Unimplemented"))
+            // NOTE: We return `ValueError` instead of `TypeError` to be able to use it with
+            // pydantic `PlainValidator`
+            Err(PyValueError::new_err(format!(
+                "Does not support converting {} to OrganizationID",
+                organization_id.get_type().name()?.to_str()?
+            )))
         }
     }
 
     #[getter]
     fn str(&self) -> &str {
         self.0.as_ref()
     }
+
+    #[classmethod]
+    #[pyo3(name = "__get_pydantic_core_schema__")]
+    fn get_pydantic_core_schema<'py>(
+        cls: &Bound<'py, PyType>,
+        _source_type: &Bound<'_, PyType>,
+        _handler: &Bound<'_, PyAny>,
+        py: Python<'py>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let core_schema = py.import("pydantic_core")?.getattr("core_schema")?;
+
+        let str_schema = core_schema.call_method0("str_schema")?;
+
+        // Indicate to pydantic that it just need to call `str(val)` to serialize the value
+        let kwargs = PyDict::new(py);
+        let serialization = core_schema.call_method0("to_string_ser_schema")?;
+        kwargs.set_item("serialization", serialization)?;
+
+        // Create a string schema to load the value from string.
+        let from_str = core_schema.call_method(
+            "no_info_after_validator_function",
+            (cls, str_schema),
+            Some(&kwargs),
+        )?;
+
+        // Make pydantic accept own class as value
+        let instance_schema = core_schema.call_method1("is_instance_schema", (cls,))?;
+
+        // Build schema that accept both string or instance value.
+        let union_schema = core_schema.call_method1(
+            "union_schema",
+            (PyList::new(py, vec![instance_schema, from_str])?,),
+        )?;
+
+        Ok(union_schema)
+    }
 }
 
 crate::binding_utils::gen_py_wrapper_class_for_id!(

server/tests/administration/test_create_organization.py

@@ -198,7 +198,7 @@ async def test_ok(
         case tos:
             expected_tos = TermsOfService(updated_on=ANY, per_locale_urls=tos)
 
-    dump = await backend.organization.test_dump_organizations()
+    dump = await backend.organization.list_organizations()
     assert dump[org_id] == OrganizationDump(
         organization_id=org_id,
         bootstrap_token=bootstrap_token,
@@ -231,7 +231,7 @@ async def test_overwrite_existing(
     assert isinstance(outcome, AccessToken)
 
     # Sanity check
-    dump = await backend.organization.test_dump_organizations()
+    dump = await backend.organization.list_organizations()
     assert dump[org_id] == OrganizationDump(
         organization_id=org_id,
         bootstrap_token=bootstrap_token,
@@ -262,7 +262,7 @@ async def test_overwrite_existing(
     new_bootstrap_token = ParsecOrganizationBootstrapAddr.from_url(body["bootstrap_url"]).token
     assert new_bootstrap_token != bootstrap_token.hex
 
-    dump = await backend.organization.test_dump_organizations()
+    dump = await backend.organization.list_organizations()
     assert dump[org_id] == OrganizationDump(
         organization_id=org_id,
         bootstrap_token=new_bootstrap_token,