View Source RabbitMQStream.Connection.Behavior behaviour (rabbitmq_stream v0.4.0-rc.3)

Defines the interface a Connection Module that interacts with the Streams Protocol TCP/TLS API.

Summary

Callbacks

Link to this callback

close(server, reason, code)

View Source
@callback close(GenServer.server(), reason :: String.t(), code :: integer()) ::
  :ok | {:error, reason :: atom()}
@callback connect(GenServer.server()) :: :ok | {:error, reason :: atom()}
Link to this callback

create_stream(server, stream_name, arguments)

View Source
@callback create_stream(
  GenServer.server(),
  stream_name :: String.t(),
  arguments :: keyword(String.t()) | nil
) :: :ok | {:error, reason :: atom()}
Link to this callback

create_super_stream(server, name, partitions, arguments)

View Source
@callback create_super_stream(
  GenServer.server(),
  name :: String.t(),
  partitions :: [String.t()],
  arguments :: keyword(String.t()) | nil
) :: :ok | {:error, reason :: atom()}
Link to this callback

credit(server, subscription_id, credit)

View Source
@callback credit(
  GenServer.server(),
  subscription_id :: non_neg_integer(),
  credit :: non_neg_integer()
) ::
  :ok
Link to this callback

declare_producer(server, stream_name, producer_reference)

View Source
@callback declare_producer(
  GenServer.server(),
  stream_name :: String.t(),
  producer_reference :: String.t()
) ::
  {:ok, producer_id :: integer()} | {:error, reason :: atom()}
Link to this callback

delete_producer(server, producer_id)

View Source
@callback delete_producer(GenServer.server(), producer_id :: integer()) ::
  :ok | {:error, reason :: atom()}
Link to this callback

delete_stream(server, stream_name)

View Source
@callback delete_stream(GenServer.server(), stream_name :: String.t()) ::
  :ok | {:error, reason :: atom()}
Link to this callback

delete_super_stream(server, name)

View Source
@callback delete_super_stream(GenServer.server(), name :: String.t()) ::
  :ok | {:error, reason :: atom()}
Link to this callback

partitions(server, super_stream)

View Source
@callback partitions(GenServer.server(), super_stream :: String.t()) ::
  {:ok,
   partitions :: RabbitMQStream.Message.Types.PartitionsQueryResponseData.t()}
  | {:error, reason :: atom()}
Link to this callback

publish(server, producer_id, publishing_id, message, filter_value)

View Source
@callback publish(
  GenServer.server(),
  producer_id :: integer(),
  publishing_id :: integer(),
  message :: binary(),
  filter_value :: binary() | nil
) :: :ok
Link to this callback

query_metadata(server, streams)

View Source
@callback query_metadata(GenServer.server(), streams :: [String.t()]) ::
  {:ok, metadata :: RabbitMQStream.Message.Types.QueryMetadataResponseData.t()}
  | {:error, reason :: atom()}
Link to this callback

query_offset(server, stream_name, offset_reference)

View Source
@callback query_offset(
  GenServer.server(),
  stream_name :: String.t(),
  offset_reference :: String.t()
) ::
  {:ok, offset :: integer()} | {:error, reason :: atom()}
Link to this callback

query_producer_sequence(server, t, t)

View Source
@callback query_producer_sequence(GenServer.server(), String.t(), String.t()) ::
  {:ok, sequence :: integer()} | {:error, reason :: atom()}
Link to this callback

respond(server, request, opts)

View Source
@callback respond(
  GenServer.server(),
  request :: RabbitMQStream.Message.Request.t(),
  opts :: Keyword.t()
) ::
  :ok
Link to this callback

route(server, routing_key, super_stream)

View Source
@callback route(GenServer.server(), routing_key :: String.t(), super_stream :: String.t()) ::
  :ok | {:error, reason :: atom()}
Link to this callback

store_offset(server, stream_name, offset_reference, offset)

View Source
@callback store_offset(
  GenServer.server(),
  stream_name :: String.t(),
  offset_reference :: String.t(),
  offset :: integer()
) :: :ok
Link to this callback

stream_stats(server, stream_name)

View Source
@callback stream_stats(GenServer.server(), stream_name :: String.t()) ::
  {:ok, stats :: RabbitMQStream.Message.Types.StreamStatsResponseData.t()}
  | {:error, reason :: atom()}
Link to this callback

subscribe(server, stream_name, pid, offset, credit, properties)

View Source
@callback subscribe(
  GenServer.server(),
  stream_name :: String.t(),
  pid :: pid(),
  offset :: RabbitMQStream.Connection.offset(),
  credit :: non_neg_integer(),
  properties :: Keyword.t()
) :: {:ok, subscription_id :: non_neg_integer()} | {:error, reason :: atom()}
Link to this callback

supports?(server, command)

View Source
@callback supports?(GenServer.server(), command :: atom()) :: boolean()
Link to this callback

supports?(server, command, version)

View Source
@callback supports?(GenServer.server(), command :: atom(), version :: String.t()) ::
  boolean()
Link to this callback

unsubscribe(server, subscription_id)

View Source
@callback unsubscribe(GenServer.server(), subscription_id :: non_neg_integer()) ::
  :ok | {:error, reason :: atom()}