GitHub

runner_storage

API reference for runner_storage.

Where runners register and lock the shards they own (Effect's RunnerStorage). make_memory / layer_memory keep everything in the process: one runner, no locking. make_encoded wraps a driver that stores addresses, runners and shard ids as text (pyfect.cluster.sql_runner_storage).

Re-exports

Values

AttributeTypeDescription
layer_memorylayer_.Layer[RunnerStorage]

RunnerStorage in memory (make_memory), for a single process or tests.

Classes

Functions

encode_runner

encode_runner(runner) -> str

A runner as stored: its JSON text.

ParameterTypeDescription
runnerRunner

Returns str

def encode_runner(runner: Runner) -> str:
    """A runner as stored: its JSON text."""
    return _encode_runner(runner)

encode_runner_address

encode_runner_address(address) -> str
ParameterTypeDescription
addressRunnerAddress

Returns str

def encode_runner_address(address: RunnerAddress) -> str:
    return f"{address.host}:{address.port}"

make_encoded

make_encoded(encoded) -> RunnerStorageService

A runner storage on the driver encoded.

ParameterTypeDescription
encodedEncodedRunnerStorage

Returns RunnerStorageService

def make_encoded(encoded: EncodedRunnerStorage) -> RunnerStorageService:
    """A runner storage on the driver ``encoded``."""

    def acquire(
        address: RunnerAddress, shard_ids: Iterable[ShardId]
    ) -> Effect[list[ShardId], PersistenceError]:
        shards = [str(s) for s in shard_ids]
        if not shards:
            return succeed([])
        return encoded.acquire(encode_runner_address(address), shards).map(_shard_ids)

    def refresh(
        address: RunnerAddress, shard_ids: Iterable[ShardId]
    ) -> Effect[list[ShardId], PersistenceError]:
        shards = [str(s) for s in shard_ids]
        return encoded.refresh(encode_runner_address(address), shards).map(_shard_ids)

    return RunnerStorageService(
        register=lambda runner, healthy: encoded.register(
            encode_runner_address(runner.address), encode_runner(runner), healthy
        ).map(MachineId),
        unregister=lambda address: encoded.unregister(encode_runner_address(address)),
        get_runners=encoded.get_runners.map(_decode_runners),
        set_runner_health=lambda address, healthy: encoded.set_runner_health(
            encode_runner_address(address), healthy
        ),
        acquire=acquire,
        refresh=refresh,
        release=lambda address, shard: encoded.release(encode_runner_address(address), str(shard)),
        release_all=lambda address: encoded.release_all(encode_runner_address(address)),
    )

make_memory

make_memory() -> Effect[RunnerStorageService]

Runner storage in memory (Effect's makeMemory).

Returns Effect[RunnerStorageService]

def make_memory() -> Effect[RunnerStorageService]:
    """Runner storage in memory (Effect's ``makeMemory``)."""
    return sync(_make_memory)