Ferricstore.Raft.WARaftBackend (ferricstore v0.4.1)

Copy Markdown View Source

Production WARaft backend boundary.

WARaft is the only default-instance runtime backend.

Summary

Functions

add_member(shard_index, node_name, opts \\ [])

@spec add_member(non_neg_integer(), node(), keyword()) ::
  {:ok, tuple()} | {:error, term()}

add_participant(shard_index, node_name, opts \\ [])

@spec add_participant(non_neg_integer(), node(), keyword()) ::
  {:ok, tuple()} | {:error, term()}

adjust_membership(shard_index, action, node_name)

@spec adjust_membership(non_neg_integer(), atom(), node()) ::
  {:ok, tuple()} | {:error, term()}

bootstrap_cluster(nodes)

@spec bootstrap_cluster([node()]) :: :ok | {:error, term()}

context!(table)

@spec context!(atom()) :: FerricStore.Instance.t()

create_snapshot(shard_index)

@spec create_snapshot(non_neg_integer()) :: {:ok, tuple()} | {:error, term()}

inflight_commit_bytes(shard_index)

@spec inflight_commit_bytes(non_neg_integer()) :: non_neg_integer()

install_snapshot(shard_index, snapshot_path, position)

@spec install_snapshot(non_neg_integer(), charlist() | binary(), tuple()) ::
  :ok | {:error, term()}

local_get(shard_index, key)

@spec local_get(term(), term()) :: binary() | nil | {:error, term()}

membership(shard_index)

@spec membership(non_neg_integer()) :: term()

pause_writes_for_sync(shard_index, timeout \\ 30000)

@spec pause_writes_for_sync(non_neg_integer(), timeout()) :: :ok | {:error, term()}

peer_ready(shard_index, node_name)

@spec peer_ready(non_neg_integer(), node()) :: :ok | {:error, term()}

resume_writes_for_sync(shard_index, timeout \\ 5000)

@spec resume_writes_for_sync(non_neg_integer(), timeout()) :: :ok | {:error, term()}

segment_log_memory_status(shard_index)

@spec segment_log_memory_status(non_neg_integer()) :: map()

start(ctx, opts \\ [])

@spec start(
  FerricStore.Instance.t(),
  keyword()
) :: :ok | {:error, term()}

status(shard_index)

@spec status(non_neg_integer()) :: keyword() | term()

stop()

@spec stop() :: :ok

storage_position(shard_index)

@spec storage_position(non_neg_integer()) :: {:ok, tuple()} | {:error, term()}

transfer_leadership(shard_index, target_node)

@spec transfer_leadership(non_neg_integer(), node()) :: :ok | {:error, term()}

trigger_election(shard_index)

@spec trigger_election(non_neg_integer()) :: :ok | term()

write(shard_index, command)

@spec write(non_neg_integer(), tuple()) :: term()

write_batch(shard_index, commands)

@spec write_batch(non_neg_integer(), [tuple()]) :: term()

write_delete_batch(shard_index, keys)

@spec write_delete_batch(non_neg_integer(), [binary()]) :: term()

write_delete_batch_async(shard_index, keys, from)

@spec write_delete_batch_async(non_neg_integer(), [binary()], GenServer.from()) ::
  :ok | {:direct, term()}

write_many(shard_commands)

@spec write_many([{non_neg_integer(), tuple()}]) :: [term()]

write_put_batch(shard_index, entries)

@spec write_put_batch(non_neg_integer(), [{binary(), binary(), non_neg_integer()}]) ::
  term()

write_put_batch_async(shard_index, entries, from)

@spec write_put_batch_async(
  non_neg_integer(),
  [{binary(), binary(), non_neg_integer()}],
  GenServer.from()
) :: :ok | {:direct, term()}