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#
| Attribute | Type | Description |
|---|---|---|
layer_memory | layer_.Layer[RunnerStorage] |
|
Classes#
Functions#
encode_runner#
encode_runner(runner) -> strA runner as stored: its JSON text.
| Parameter | Type | Description |
|---|---|---|
runner | Runner |
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| Parameter | Type | Description |
|---|---|---|
address | RunnerAddress |
Returns str
def encode_runner_address(address: RunnerAddress) -> str:
return f"{address.host}:{address.port}"make_encoded#
make_encoded(encoded) -> RunnerStorageServiceA runner storage on the driver encoded.
| Parameter | Type | Description |
|---|---|---|
encoded | EncodedRunnerStorage |
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)