An event log server that reads the entries it stores (Effect's
eventlog/EventLogServerUnencrypted).
Writes are authorized, mapped to a store, run through the server's own
group handlers (with their conflicts) and stored; change streams compact
the backlog with the registered compactors. EventLogServerUnencrypted
writes events from the server itself.
Values#
| Attribute | Type | Description |
|---|---|---|
layer_rpc_handlers | Layer[HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication, Never, Storage | StoreMapping | EventLogServerAuthorization | Registry] | The RPC handlers of an unencrypted server. |
make_storage_memory | Effect[StorageService, Never, Scope] | Storage kept in memory (sequences start at 1), its pubsubs shut down when the scope closes. |
layer_storage_memory | Layer[Storage] |
|
layer_server | Layer[EventLogServerUnencrypted | Registry, Never, Storage] |
|
Classes#
Functions#
layer_store_mapping_static#
layer_store_mapping_static(*, store_id) -> Layer[StoreMapping]Every public key maps store_id to itself; other stores are not found.
| Parameter | Type | Description |
|---|---|---|
store_id | StoreId |
Returns Layer[StoreMapping]
def layer_store_mapping_static(*, store_id: StoreId) -> Layer[StoreMapping]:
"""Every public key maps ``store_id`` to itself; other stores are not found."""
return layer_succeed(StoreMapping, _StaticMapping(store_id))compact_backlog#
compact_backlog(remote_entries, compactors) -> Effect[list[RemoteEntry]]Runs of entries sharing a compactor, compacted; outputs take the sequences of their run's first entries and its last (a run that cannot be renumbered stays as it was).
| Parameter | Type | Description |
|---|---|---|
remote_entries | Sequence[RemoteEntry] | |
compactors | Mapping[str, RegisteredCompactor] |
Returns Effect[list[RemoteEntry]]
def compact_backlog(
remote_entries: Sequence[RemoteEntry], compactors: Mapping[str, RegisteredCompactor]
) -> Effect[list[RemoteEntry]]:
"""Runs of entries sharing a compactor, compacted; outputs take the
sequences of their run's first entries and its last (a run that
cannot be renumbered stays as it was)."""
if not compactors or not remote_entries:
return succeed(list(remote_entries))
def body():
result: list[RemoteEntry] = []
index = 0
while index < len(remote_entries):
compactor = compactors.get(remote_entries[index].entry.event)
if compactor is None:
result.append(remote_entries[index])
index += 1
continue
group: list[RemoteEntry] = []
while index < len(remote_entries) and (
compactors.get(remote_entries[index].entry.event) is compactor
):
group.append(remote_entries[index])
index += 1
entries = [e.entry for e in group]
positions: dict[bytes, int] = {e.id: i for i, e in enumerate(entries)}
compacted: list[list[Entry]] = [[] for _ in entries]
def write(
entry: Entry,
source: Entry | None,
positions: dict[bytes, int] = positions,
compacted: list[list[Entry]] = compacted,
) -> Effect[None]:
return sync(lambda: compacted[positions.get((source or entry).id, 0)].append(entry))
yield from compactor.effect(entries, write)
flat = [e for part in compacted for e in part]
sequences = _representative_sequences(group, len(flat))
if sequences is None:
result.extend(group)
else:
unchecked = new(RemoteEntry, disable_checks=True)
result.extend(
unchecked(remote_sequence=s, entry=e)
for s, e in zip(sequences, flat, strict=True)
)
return result
return gen(body)make_write#
make_write(schema) -> Effect[ServerWrite, Never, EventLogServerUnencrypted]The server's write(store_id=, event=, payload=) for schema.
| Parameter | Type | Description |
|---|---|---|
schema | EventLogSchema[EventGroup[AnyEvent]] |
Returns Effect[ServerWrite, Never, EventLogServerUnencrypted]
def make_write(
schema: EventLogSchema[EventGroup[AnyEvent]],
) -> Effect[ServerWrite, Never, EventLogServerUnencrypted]:
"""The server's ``write(store_id=, event=, payload=)`` for ``schema``."""
return EventLogServerUnencrypted().map(lambda server: server.make_write(schema))layer#
layer[E = Never](schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, Registry]) -> Layer[Never, E, EventLogServerAuthorization | ServerProtocol | Storage | StoreMapping]
layer[E = Never, R = Never](schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]) -> Layer[Never, E, R | EventLogServerAuthorization | ServerProtocol | Storage | StoreMapping]An unencrypted server of schema with the group handlers,
over the ServerProtocol. The server gives the handlers its
Registry.
| Parameter | Type | Description |
|---|---|---|
schema | ||
handlers |
@overload
def layer[E = Never](
schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, Registry]
) -> Layer[Never, E, EventLogServerAuthorization | ServerProtocol | Storage | StoreMapping]: ...
@overload
def layer[E = Never, R = Never](
schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]
) -> Layer[Never, E, R | EventLogServerAuthorization | ServerProtocol | Storage | StoreMapping]: ...
def layer[E = Never, R = Never](
schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]
) -> Layer[
Never,
E,
R | EventLogServerAuthorization | ServerProtocol | Storage | StoreMapping,
]:
"""An unencrypted server of ``schema`` with the group ``handlers``,
over the ``ServerProtocol``. The server gives the handlers its
``Registry``."""
require_layer(handlers, "handlers")
del schema
# pyright cannot take Registry out of ``R | Registry``; layer_server gives it.
erased = cast("Layer[Any, E, Any]", handlers)
return (
rpc_server_layer(EventLogRemoteRpcs)
.pipe(layer_provide(layer_rpc_handlers))
.pipe(layer_provide(erased))
.pipe(layer_provide(layer_server))
)layer_no_rpc_server#
layer_no_rpc_server[E = Never](schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, Registry]) -> Layer[HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication, E, EventLogServerAuthorization | Storage | StoreMapping]
layer_no_rpc_server[E = Never, R = Never](schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]) -> Layer[HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication, E, R | EventLogServerAuthorization | Storage | StoreMapping]The RPC handlers of an unencrypted server, without the server.
| Parameter | Type | Description |
|---|---|---|
schema | ||
handlers |
@overload
def layer_no_rpc_server[E = Never](
schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, Registry]
) -> Layer[
HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication,
E,
EventLogServerAuthorization | Storage | StoreMapping,
]: ...
@overload
def layer_no_rpc_server[E = Never, R = Never](
schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]
) -> Layer[
HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication,
E,
R | EventLogServerAuthorization | Storage | StoreMapping,
]: ...
def layer_no_rpc_server[E = Never, R = Never](
schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]
) -> Layer[
HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication,
E,
R | EventLogServerAuthorization | Storage | StoreMapping,
]:
"""The RPC handlers of an unencrypted server, without the server."""
require_layer(handlers, "handlers")
del schema
rpc_handlers = cast(
"Layer[HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication, E, Any]",
layer_rpc_handlers,
)
erased = cast("Layer[Any, E, Any]", handlers)
return merge(rpc_handlers, erased).pipe(layer_provide(layer_server))