bbblb 0.0.13__py3-none-any.whl

bbblb/__init__.py

@@ -0,0 +1,9 @@
+import logging
+
+__version__ = "0.0.13"
+VERSION = __version__.split(".", 2)
+VERSION[-1], _, BUILD = VERSION[-1].partition("-")
+
+ROOT_LOGGER = logging.getLogger(__name__)
+
+BRANDING = "BBBLB (AGPL-3, https://github.com/defnull/bbblb)"

bbblb/__main__.py

@@ -0,0 +1,3 @@
+from bbblb.cli import main
+
+main()

bbblb/asgi.py

@@ -0,0 +1,4 @@
+from bbblb.web import make_app
+
+app = make_app()
+__all__ = ["app"]

bbblb/cli/__init__.py

@@ -0,0 +1,167 @@
+import asyncio
+import functools
+import importlib
+import pkgutil
+import typing
+from bbblb.services import bootstrap
+from bbblb.settings import ConfigError, BBBLBConfig
+import click
+import os
+import tabulate
+import json
+
+
+def async_command():
+    """Decorator that wraps coroutine with asyncio.run and click.pass_obj."""
+
+    def decorator(func):
+        @functools.wraps(func)
+        @click.pass_obj
+        def sync_wrapper(*args, **kwargs):
+            return asyncio.run(func(*args, **kwargs))
+
+        return sync_wrapper
+
+    return decorator
+
+
+class MultiChoice(click.ParamType):
+    name = "list"
+
+    def __init__(self, choices):
+        self.choices = tuple(choices)
+
+    def convert(self, value, param, ctx):
+        if not value:
+            return []
+        if isinstance(value, (list, tuple)):
+            return tuple(value)
+        values = [v.strip() for v in value.split(",")]
+        for v in values:
+            if v not in self.choices:
+                self.fail(
+                    f"Invalid choice: '{v}'. Must be one of: {', '.join(self.choices)}",
+                    param,
+                    ctx,
+                )
+        return values
+
+    def to_info_dict(self):
+        info_dict = super().to_info_dict()
+        info_dict["choices"] = self.choices
+        return info_dict
+
+
+class Table:
+    formats = ["simple", "plain", "raw", "json"]
+    option = click.option(
+        "--table-format",
+        type=click.Choice(formats),
+        default=formats[0],
+        help="Change the result table format.",
+    )
+
+    def __init__(self):
+        self._rows: list[list[typing.Any]] = []
+        self._headers = {}
+
+    def headers(self, **headers):
+        """Map column names to human readable labels"""
+        self._headers.update(headers)
+
+    def row(self, **values):
+        """Add a row to the table, pamming column names ot values.
+
+        Missing columns are stored as `None`. Previously unknown columns
+        are added to the table.
+        """
+        for key in values:
+            if key not in self._headers:
+                self._headers[key] = key.title()
+                for row in self._rows:
+                    row.append(None)
+        self._rows.append([values.get(column, None) for column in self._headers])
+
+    def print(self, format="simple"):
+        if format == "json":
+            keys = list(self._headers)
+            for row in self._rows:
+                click.echo(json.dumps(dict(zip(keys, row))))
+        elif format == "raw":
+            for row in self._rows:
+                click.echo("\t".join(map(str, row)))
+        else:
+            click.echo(
+                tabulate.tabulate(
+                    self._rows,
+                    list(self._headers.values()),
+                    tablefmt=format,
+                    floatfmt=".2f",
+                )
+            )
+
+
+@click.group(
+    name="bbblb",
+    context_settings=dict(show_default=True, help_option_names=["--help", "-h"]),
+)
+@click.option(
+    "--config-file",
+    "-C",
+    metavar="FILE",
+    envvar="BBBLB_CONFIG",
+    help="Load config from file",
+)
+@click.option(
+    "--config",
+    "-c",
+    metavar="KEY=VALUE",
+    help="Set or unset a BBBLB config parameter",
+    multiple=True,
+)
+@click.option(
+    "-v", "--verbose", help="Increase verbosity. Can be repeated.", count=True
+)
+@async_command()
+@click.pass_context
+async def main(ctx, obj, config_file, config, verbose):
+    import logging
+
+    logging.basicConfig(
+        format="%(asctime)s %(levelname)s %(name)s %(message)s", level=logging.WARNING
+    )
+
+    if verbose == 0:
+        logging.getLogger("bbblb").setLevel(logging.WARNING)
+    elif verbose == 1:
+        logging.getLogger("bbblb").setLevel(logging.INFO)
+    elif verbose == 2:
+        logging.getLogger("bbblb").setLevel(logging.DEBUG)
+    elif verbose == 3:
+        logging.getLogger("bbblb").setLevel(logging.DEBUG)
+        logging.getLogger("sqlalchemy.engine").setLevel(logging.DEBUG)
+    elif verbose >= 4:
+        logging.root.setLevel(logging.DEBUG)
+
+    config_ = BBBLBConfig()
+
+    if config_file:
+        os.environ["BBBLB_CONFIG"] = config_file
+    for kv in config:
+        name, _, value = kv.partition("=")
+        name = name.upper()
+        if name not in config_._options:
+            raise ConfigError(f"Unknown config parameter: {name}")
+        env_name = f"BBBLB_{name}"
+        if value:
+            os.environ[env_name] = value
+        elif env_name in os.environ:
+            del os.environ[env_name]
+
+    config_.populate()
+    ctx.obj = await bootstrap(config_, autostart=False, logging=False)
+
+
+# Auto-load all modules in the bbblb.cli package to load all commands.
+for module in pkgutil.iter_modules(__path__):
+    importlib.import_module(f"{__package__}.{module.name}")

bbblb/cli/db.py

@@ -0,0 +1,42 @@
+import click
+from bbblb.services import ServiceRegistry
+from bbblb.services.db import check_migration_state, create_database, migrate_db
+from bbblb.settings import BBBLBConfig
+
+from bbblb.cli import async_command, main
+
+
+@main.group()
+def db():
+    """Manage database"""
+
+
+@db.command()
+@click.option(
+    "--create", help="Create database if needed (only postgres).", is_flag=True
+)
+@async_command()
+async def migrate(obj: ServiceRegistry, create: bool):
+    """
+    Migrate database to the current schema version.
+
+    WARNING: Make backups!
+    """
+    config = await obj.use(BBBLBConfig)
+
+    try:
+        if create:
+            await create_database(config.DB)
+        current, target = await check_migration_state(config.DB)
+        if current != target:
+            click.echo(
+                f"Migrating database schema from {current or 'empty'!r} to {target!r}..."
+            )
+            await migrate_db(config.DB)
+            click.echo("Migration complete!")
+        else:
+            click.echo("Database is up to date. Nothing to do")
+    except ConnectionRefusedError as e:
+        raise RuntimeError(f"Failed to connect to database: {e}")
+    except BaseException as e:
+        raise RuntimeError(f"Failed to migrate database: {e}")

bbblb/cli/maketoken.py

@@ -0,0 +1,86 @@
+from bbblb import model
+from bbblb.services import ServiceRegistry
+import secrets
+import sys
+import time
+import click
+import jwt
+
+from bbblb.services.db import DBContext
+from bbblb.settings import BBBLBConfig
+
+from . import main, async_command
+
+
+@main.command()
+@click.option("--tenant", "-t", help="Create a Tenant-Token instead of an Admin-Token.")
+@click.option("--server", "-s", help="Create a Server-Token instead of an Admin-Token.")
+@click.option(
+    "--expire",
+    "-e",
+    metavar="SECONDS",
+    default=-1,
+    help="Number of seconds after which this token should expire.",
+)
+@click.option(
+    "--verbose", "-v", help="Print the clear-text token to stdout.", is_flag=True
+)
+@click.argument("subject")
+@click.argument("scope", nargs=-1)
+@async_command()
+async def maketoken(
+    obj: ServiceRegistry, subject, expire, server, tenant, scope, verbose
+):
+    """Generate an Admin Token that can be used to authenticate against the BBBLB API.
+
+    The SUBJECT should be a short name or id that identifies the token
+    or token owner. It will be logged when the token is used.
+
+    SCOPEs limit the capabilities and permissions for this token. If no scope
+    is defined, the token will have `admin` privileges.
+
+    Tenant or Server tokens do not have scopes, their permissions are hard
+    coded because tenants or servers can create their own tokens.
+    """
+    config = await obj.use(BBBLBConfig)
+    db = await obj.use(DBContext)
+
+    headers = {}
+    payload = {
+        "sub": subject,
+        "aud": config.DOMAIN,
+        "scope": " ".join(sorted(set(scope))) or "admin",
+        "jti": secrets.token_hex(8),
+    }
+    if expire > 0:
+        payload["exp"] = int(time.time() + int(expire))
+
+    if server:
+        async with db.session() as session:
+            stmt = model.Server.select(domain=server)
+            try:
+                server = (await session.execute(stmt)).scalar_one()
+            except model.NoResultFound:
+                raise RuntimeError(f"Server not found in database: {server}")
+        headers["kid"] = f"bbb:{server.domain}"
+        del payload["scope"]
+        key = server.secret
+    elif tenant:
+        async with db.session() as session:
+            stmt = model.Tenant.select(name=tenant)
+            try:
+                tenant = (await session.execute(stmt)).scalar_one()
+            except model.NoResultFound:
+                raise RuntimeError(f"Tenant not found in database: {tenant}")
+        headers["kid"] = f"tenant:{tenant.name}"
+        del payload["scope"]
+        key = tenant.secret
+    else:
+        key = config.SECRET
+
+    token = jwt.encode(payload, key, headers=headers)
+
+    if verbose:
+        click.echo(f"Token Header: {headers}", file=sys.stderr)
+        click.echo(f"Token Payload: {payload}", file=sys.stderr)
+    click.echo(token)

bbblb/cli/override.py

@@ -0,0 +1,143 @@
+import re
+from bbblb import model
+from bbblb.services import ServiceRegistry
+from bbblb.services.db import DBContext
+import click
+
+
+from . import MultiChoice, main, async_command
+
+
+@main.group()
+def override():
+    """Manage tenant overrides"""
+
+
+type_choices = MultiChoice(["create", "join"])
+type_choice = click.Choice(type_choices.choices)
+
+
+@override.command("list")
+@click.argument("tenant", required=False)
+@click.option(
+    "--type",
+    help="List specific override types only",
+    type=type_choices,
+    default=",".join(type_choices.choices),
+)
+@async_command()
+async def override_list(obj: ServiceRegistry, tenant: str, type: list[str]):
+    """List create or join overrides by tenant."""
+    db = await obj.use(DBContext)
+
+    async with db.session() as session:
+        if tenant:
+            stmt = model.TenantOverride.select(
+                model.TenantOverride.tenant.name == tenant
+            )
+        else:
+            stmt = model.TenantOverride.select()
+        if type:
+            stmt = stmt.where(model.TenantOverride.type.in_(type))
+        stmt = stmt.options(model.joinedload(model.TenantOverride.tenant))
+
+        overrides = (await session.execute(stmt)).scalars().all()
+        for ovr in overrides:
+            click.echo(f"{ovr.tenant.name} {ovr.type} {ovr.param}{ovr.op}{ovr.value}")
+
+
+@override.command("set")
+@click.option(
+    "--clear",
+    help="Remove all overrides for that tenant and type before adding new ones.",
+    is_flag=True,
+)
+@click.argument("tenant")
+@click.argument("type", type=type_choice)
+@click.argument("overrides", nargs=-1, metavar="NAME=VALUE")
+@async_command()
+async def override_set(
+    obj: ServiceRegistry, clear: bool, tenant: str, type: str, overrides: list[str]
+):
+    """Override create or join call parameters for a given tenant.
+
+    You can define any number of overrides per tenant as PARAM=VALUE
+    pairs. PARAM should match a BBB API parameter supported by the given
+    type (create or join) and the given VALUE will be enforced on all
+    future API calls issued by this tenant. If VALUE is empty, then the
+    parameter will be removed from API calls.
+
+    Instead of the '=' operator you can also use '?' to define a
+    fallback for missing parameters instead of an override, '<' to
+    define a maximum value for numeric parameters (e.g. duration
+    or maxParticipants), or '+' to add items to a comma separated list
+    parameter (e.g. disabledFeatures).
+    """
+    db = await obj.use(DBContext)
+    async with db.session() as session:
+        db_tenant = (
+            await session.execute(
+                model.Tenant.select(name=tenant).options(
+                    model.selectinload(model.Tenant.overrides)
+                )
+            )
+        ).scalar_one_or_none()
+        if not db_tenant:
+            click.echo(f"Tenant {tenant!r} not found")
+            raise SystemExit(1)
+
+        if clear:
+            db_tenant.overrides.clear()
+        elif not overrides:
+            click.echo("Set at least one override, see --help")
+            raise SystemExit(1)
+
+        for override in overrides:
+            split = re.split(r"([?=<+])", override, maxsplit=1)
+            param, op, value = split if len(split) == 3 else (override, "=", "")
+            if op not in model.OPERATOR__ALL:
+                raise ValueError(
+                    f"Operator must be one of: {', '.join(model.OPERATOR__ALL)}"
+                )
+            to_update = next(
+                (o for o in db_tenant.overrides if o.type == type and o.param == param),
+                None,
+            )
+            if not to_update:
+                to_update = model.TenantOverride(type=type, param=param)
+                db_tenant.overrides.append(to_update)
+            to_update.op = op
+            to_update.value = value
+
+        await session.commit()
+        click.echo("OK")
+
+
+@override.command("unset")
+@click.argument("tenant")
+@click.argument("type", type=type_choice)
+@click.argument("overrides", nargs=-1, metavar="NAME")
+@async_command()
+async def override_unset(
+    obj: ServiceRegistry, tenant: str, type: str, overrides: list[str]
+):
+    """Remove specific overrides on a tenant."""
+    db = await obj.use(DBContext)
+    async with db.session() as session:
+        db_tenant = (
+            await session.execute(
+                model.Tenant.select(name=tenant).options(
+                    model.selectinload(model.Tenant.overrides)
+                )
+            )
+        ).scalar_one_or_none()
+        if not db_tenant:
+            click.echo(f"Tenant {tenant!r} not found")
+            raise SystemExit(1)
+
+        for override in list(db_tenant.overrides):
+            if override.type == type and override.param in overrides:
+                db_tenant.overrides.remove(override)
+                click.echo(f"Removed {override.param}")
+
+        await session.commit()

bbblb/cli/recording.py

@@ -0,0 +1,178 @@
+import asyncio
+import click
+import sqlalchemy.orm
+
+from bbblb import model
+
+from bbblb.services import ServiceRegistry
+from bbblb.services.db import DBContext
+from bbblb.services.recording import RecordingManager
+
+from . import main, async_command
+
+
+@main.group()
+@async_command()
+async def recording(obj: ServiceRegistry):
+    """Recording management."""
+    # Disable auto-import for use in a cli context
+    obj.get(RecordingManager, uninitialized_ok=True).auto_import = False
+
+
+@recording.command("list")
+@async_command()
+async def _list(obj: ServiceRegistry):
+    """List all recordings and their formats"""
+    db = await obj.use(DBContext)
+    async with db.session() as session, session.begin():
+        stmt = model.Recording.select().options(
+            sqlalchemy.orm.joinedload(model.Recording.tenant),
+            sqlalchemy.orm.selectinload(model.Recording.formats),
+        )
+        for record in (await session.execute(stmt)).scalars():
+            click.echo(
+                f"{record.tenant.name} {record.record_id} {','.join(f.format for f in record.formats)}"
+            )
+
+
+@recording.command("delete")
+@click.argument("record_id", nargs=-1)
+@async_command()
+async def _delete(obj: ServiceRegistry, record_id):
+    """Delete recordings (all formats)"""
+    importer = await obj.use(RecordingManager)
+
+    db = await obj.use(DBContext)
+    async with db.session() as session, session.begin():
+        stmt = model.Recording.select(model.Recording.record_id.in_(record_id))
+        for record in (await session.execute(stmt)).scalars().all():
+            await session.delete(record)
+            importer.delete(record.tenant.name, record.record_id)
+            click.echo(f"Deleted {record.record_id}")
+
+
+@recording.command()
+@click.argument("record_id", nargs=-1)
+@async_command()
+async def publish(obj: ServiceRegistry, record_id):
+    """Publish recordings"""
+    await _change_publish_flag(obj, record_id, model.RecordingState.PUBLISHED)
+
+
+@recording.command()
+@click.argument("record_id", nargs=-1)
+@async_command()
+async def unpublish(obj: ServiceRegistry, record_id):
+    """Unpublish recordings"""
+    await _change_publish_flag(obj, record_id, model.RecordingState.UNPUBLISHED)
+
+
+async def _change_publish_flag(
+    obj: ServiceRegistry, record_id, state: model.RecordingState
+):
+    importer = await obj.use(RecordingManager)
+    db = await obj.use(DBContext)
+
+    async with db.session() as session:
+        stmt = model.Recording.select(model.Recording.record_id.in_(record_id)).options(
+            sqlalchemy.orm.joinedload(model.Recording.tenant)
+        )
+        records = (await session.execute(stmt)).scalars().all()
+        for record in records:
+            if record.state != state:
+                record.state = state
+                await session.commit()
+            if state == model.RecordingState.PUBLISHED:
+                await asyncio.to_thread(
+                    importer.publish, record.tenant.name, record.record_id
+                )
+            else:
+                await asyncio.to_thread(
+                    importer.unpublish, record.tenant.name, record.record_id
+                )
+
+
+@recording.command("import")
+@click.option("--tenant", help="Override the tenant found in the recording")
+@click.option(
+    "--publish/--unpublish",
+    help="Publish or unpublish recording after import",
+    default=None,
+)
+@click.argument("FILE", type=click.Path(dir_okay=True), default="-")
+@async_command()
+async def _import(obj: ServiceRegistry, tenant: str, publish: bool | None, file: str):
+    """Import one or more recordings from a tar archive"""
+    importer = await obj.use(RecordingManager)
+
+    async def reader(file):
+        with click.open_file(file, "rb") as fp:
+            while chunk := fp.read(1024 * 64):
+                yield chunk
+
+    task = await importer.start_import(reader(file), force_tenant=tenant)
+    await task.wait()
+
+    for format in task.formats:
+        click.echo(
+            f"Imported: {format.recording.tenant.name}/{format.recording.record_id} ({format.format})"
+        )
+        if (
+            publish is True
+            and format.recording.started != model.RecordingState.PUBLISHED
+        ):
+            await _change_publish_flag(
+                obj, [format.recording.record_id], model.RecordingState.PUBLISHED
+            )
+        elif (
+            publish is False
+            and format.recording.started != model.RecordingState.UNPUBLISHED
+        ):
+            await _change_publish_flag(
+                obj, [format.recording.record_id], model.RecordingState.UNPUBLISHED
+            )
+    for error in task.errors:
+        click.echo(f"ERROR: {error}")
+    if task.errors:
+        raise SystemExit(1)
+
+
+@recording.command()
+@click.option(
+    "--dry-run", "-n", help="Do not actually remove any recordings.", is_flag=True
+)
+@async_command()
+async def remove_orphans(obj: ServiceRegistry, dry_run: bool):
+    """Remove recording DB entries that do not exist on disk."""
+    db = await obj.use(DBContext)
+    importer = await obj.use(RecordingManager)
+    async with db.session() as session, session.begin():
+        stmt = model.Recording.select().options(
+            sqlalchemy.orm.joinedload(model.Recording.tenant),
+            sqlalchemy.orm.selectinload(model.Recording.formats),
+        )
+        records = await session.execute(stmt)
+        for record in records.scalars():
+            populated = False
+            for format in record.formats:
+                sdir = importer.get_storage_dir(
+                    record.tenant.name,
+                    record.record_id,
+                    format.format,
+                )
+                if sdir.exists():
+                    populated = True
+                    continue
+                click.echo(
+                    f"Deleting orphan format: {record.tenant.name}/{record.record_id}/{format.format}"
+                )
+                await session.delete(format)
+            if not populated:
+                click.echo(
+                    f"Deleting record without formats: {record.tenant.name}/{record.record_id}"
+                )
+                await session.delete(record)
+
+        if dry_run:
+            click.echo("Rolling back changes (dry run)")
+            await session.rollback()