Phoenix PubSub

https://hexdocs.pm/phoenix_pubsub/
Admin
Phoenix.PubSub is a realtime Publisher/Subscriber service for Elixir applications, designed to...
Tokens:24,639
Snippets:313
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Supervisor Integration

Source: https://hexdocs.pm/phoenix_pubsub_redis/Phoenix.PubSub.Redis.html

Example of how to start the Phoenix.PubSub.Redis adapter within your application's supervision tree.

```APIDOC
## Supervisor Integration

To start the Phoenix.PubSub.Redis adapter, list it in your supervision tree as follows:

```elixir
{Phoenix.PubSub, adapter: Phoenix.PubSub.Redis, redis_opts: "redis://localhost:6379", node_name: System.get_env("NODE")}
```
```

--------------------------------

### Start Tracker Pool

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

Use `start_link/3` to start a tracker pool, which manages multiple tracker shards. Requires `:name` and `:pubsub_server` in `pool_opts`.

```elixir
Phoenix.Tracker.start_link(MyTracker, tracker_arg, pool_opts)
```

--------------------------------

### Start Phoenix.PubSub.EventStore Server

Source: https://hexdocs.pm/phoenix_pubsub_eventstore/Phoenix.PubSub.EventStore.html

This function is called by Phoenix.PubSub to start the server. It accepts options for configuration.

```elixir
start_link(opts)
```

--------------------------------

### start_link(opts)

Source: https://hexdocs.pm/phoenix_pubsub_eventstore/index.html

Starts the Phoenix.PubSub.EventStore server. This function is intended to be called by Phoenix.PubSub.

```APIDOC
## start_link(opts)

### Description
Starts the server. This function is called by `Phoenix.PubSub`.

### Function Signature
`start_link(opts)`

### Parameters
#### Keyword List (`opts`)
- **name** (atom) - The name of the PubSub server.
- **adapter** (module) - Must be `Phoenix.PubSub.EventStore`.
- **eventstore** (module) - The EventStore module to use.
- **serializer** (module, optional) - The serializer to use for converting messages. Defaults to `Phoenix.PubSub.EventStore.Serializer.Base64`.
- **unique_id_fn** (function, optional) - A function that generates a unique ID for each pubsub instance. Defaults to `UUID.uuid4()`.
```

--------------------------------

### Start PhoenixPubSubBuffered in Supervision Tree

Source: https://hexdocs.pm/phoenix_pubsub_buffered/PhoenixPubSubBuffered.html

To start PhoenixPubSubBuffered, list it in your application's supervision tree with the desired name and adapter. This registers the PubSub process.

```elixir
{Phoenix.PubSub, name: MyApp.PubSub, adapter: PhoenixPubSubBuffered}
```

--------------------------------

### start_link/1

Source: https://hexdocs.pm/phoenix_pubsub_postgresql/Phoenix.PubSub.PostgreSQL.html

Starts the PubSub adapter process. This function is typically called by a supervisor.

```APIDOC
## Functions

### start_link(opts)

```elixir
@spec start_link(keyword()) :: :ignore | {:error, any()} | {:ok, pid()}
```

Starts the PubSub adapter process. This function is typically called by a supervisor.
```

--------------------------------

### Start Link Function Signature

Source: https://hexdocs.pm/phoenix_pubsub_postgresql/Phoenix.PubSub.PostgreSQL.html

The `start_link` function is used to start the PubSub process. It accepts keyword options and returns a process identifier or an error tuple.

```elixir
@spec start_link(keyword()) :: :ignore | {:error, any()} | {:ok, pid()}
```

--------------------------------

### start_link/1

Source: https://hexdocs.pm/phoenix_pubsub_eventstore/Phoenix.PubSub.EventStore.html

Starts the Phoenix.PubSub.EventStore server process. This function is intended to be called by the Phoenix.PubSub module during its own startup process.

```APIDOC
## start_link/1

### Description
Start the server. This function is called by `Phoenix.PubSub`.

### Function Signature
`start_link(opts)`

### Parameters
* `opts` - A list of options for configuring the PubSub adapter. Supported options include:
  * `name` (atom()): The name of the PubSub server.
  * `adapter` (module()): Must be `Phoenix.PubSub.EventStore`.
  * `eventstore` (module()): The EventStore module to use.
  * `serializer` (module(), optional): The serializer to use for messages. Defaults to `Phoenix.PubSub.EventStore.Serializer.Base64`.
  * `unique_id_fn` (function(), optional): A function to generate a unique ID for the pubsub instance. Defaults to generating a UUID.
```

--------------------------------

### start_link/3

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

Starts a tracker pool. This function is used to initialize and launch the tracker shards under a supervisor.

```APIDOC
## start_link(tracker, tracker_arg, pool_opts)

### Description
Starts a tracker pool.

* `tracker` - The tracker module implementing the `Phoenix.Tracker` behaviour
* `tracker_arg` - The argument to pass to the tracker handler `init/1`
* `pool_opts` - The list of options used to construct the shard pool

## Required `pool_opts` :

* `:name` - The name of the server, such as: `MyApp.Tracker` This will also form the common prefix for all shard names
* `:pubsub_server` - The name of the PubSub server, such as: `MyApp.PubSub`

## Optional `pool_opts` :

* `:broadcast_period` - The interval in milliseconds to send delta broadcasts across the cluster. Default `1500`
* `:max_silent_periods` - The max integer of broadcast periods for which no delta broadcasts have been sent. Default `10` (15s heartbeat)
* `:down_period` - The interval in milliseconds to flag a replica as temporarily down. Default `broadcast_period * max_silent_periods * 2` (30s down detection). Note: This must be at least 2x the `broadcast_period`.
* `permdown_on_shutdown` - boolean; whether to immediately call `graceful_permdown/1` on the tracker during a graceful shutdown. See 'Application Shutdown' section. You can only safely set this if `Phoenix.Tracker` is mounted at the root of your supervision tree and the strategy is `:one_for_one`. Default `false`.
* `:permdown_period` - The interval in milliseconds to flag a replica as permanently down, and discard its state. Note: This must be at least greater than the `down_period`. Default `1_200_000` (20 minutes)
* `:clock_sample_periods` - The numbers of heartbeat windows to sample remote clocks before collapsing and requesting transfer. Default `2`
* `:max_delta_sizes` - The list of delta generation sizes to keep before falling back to sending entire state. Defaults `[100, 1000, 10_000]`.
* `:log_level` - The log level to log events, defaults `:debug` and can be disabled with `false`
* `:pool_size` - The number of tracker shards to launch. Default `1`
```

--------------------------------

### Minimal Conduit AMQP Broker Example

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/index.html

A minimal example of a Conduit broker configured for Phoenix PubSub, including exchange, queue, and pipelines for incoming and outgoing messages.

```elixir
defmodule MyApp.Broker do
  use Conduit.Broker, otp_app: :my_app

  configure do
    # All messages published to this exchange will be published to every bound queue
    exchange "phoenix.pubsub", type: :fanout

    # Will create queue name based on hostname and bind it to the fanout exchange. If the
    # server restarts, the queue will be removed and recreated, since the messages in the
    # queue are for websocket connections that no longer exist.
    queue &Phoenix.PubSub.ConduitAMQP.queue_name/0,
      exchange: "phoenix.pubsub",
      auto_delete: false,
      from: ["#"]
  end

  pipeline :phoenix_pubsub_incoming do
    # plug Conduit.Plug.LogIncoming
    # plug Conduit.Plug.AckException

    # Turns erlang binary into data
    plug Conduit.Plug.Parse
  end

  incoming Phoenix.PubSub.ConduitAMQP do
    pipe_through [:phoenix_pubsub_incoming]

    # Subscribe to messages published to the phoenix.pubsub exchange that are deposited in this
    # server specific queue.
    subscribe :phoenix_pubsub_receive, Subscriber,
      from: &Phoenix.PubSub.ConduitAMQP.queue_name/1
  end

  pipeline :phoenix_pubsub_outgoing do
    # plug Conduit.Plug.LogOutgoing

    # Turns data into erlang binary, other formats are lossy
    plug Conduit.Plug.Format,
      content_type: "application/x-erlang-binary",
      compressed: 6
  end

  outgoing do
    pipe_through [:phoenix_pubsub_outgoing]

    # Publish to phoenix.pubsub exchange with phoenix.pubsub routing key
    publish :phoenix_pubsub_broadcast,
      exchange: "phoenix.pubsub",
      to: "phoenix.pubsub"
  end
end

```

--------------------------------

### Application Startup Configuration

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/index.html

Ensure your broker is configured to start after your endpoint in your application's startup file.

```elixir
# my_app.ex or application.ex
def start(_type, _args) do
  import Supervisor.Spec

  children = [
    supervisor(MyApp.Endpoint, []),
    supervisor(MyApp.Broker, [])
  ]

  opts = [strategy: :one_for_one, name: MyApp.Supervisor]
  Supervisor.start_link(children, opts)
end

```

--------------------------------

### Add Phoenix.PubSub.PostgreSQL to Supervision Tree

Source: https://hexdocs.pm/phoenix_pubsub_postgresql/Phoenix.PubSub.PostgreSQL.html

To start the adapter, include it in your application's supervision tree. Ensure you specify the name and the Ecto repository to use.

```elixir
{
  Phoenix.PubSub,
  name: MyApp.PubSub,
  adapter: Phoenix.PubSub.PostgreSQL,
  repo: MyApp.Repo
}
```

--------------------------------

### Configure Application Startup

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/readme.html

Ensure your Conduit broker is started after your Phoenix endpoint in your application's supervisor.

```elixir
def start(_type, _args) do
  import Supervisor.Spec

  children = [
    supervisor(MyApp.Endpoint, []),
    supervisor(MyApp.Broker, [])
  ]

  opts = [strategy: :one_for_one, name: MyApp.Supervisor]
  Supervisor.start_link(children, opts)
end
```

--------------------------------

### child_spec/1

Source: https://hexdocs.pm/phoenix_pubsub_redis/Phoenix.PubSub.Redis.html

Returns a specification to start the Phoenix.PubSub.Redis module under a supervisor.

```APIDOC
## child_spec(init_arg)

Returns a specification to start this module under a supervisor.
See `Supervisor`.
```

--------------------------------

### child_spec(init_arg)

Source: https://hexdocs.pm/phoenix_pubsub_eventstore/index.html

Returns a supervisor child specification for starting Phoenix.PubSub.EventStore under a supervisor.

```APIDOC
## child_spec(init_arg)

### Description
Returns a specification to start this module under a supervisor. See `Supervisor`.

### Function Signature
`child_spec(init_arg)`

### Parameters
#### `init_arg`
This argument is passed to the `start_link/1` function when the child process starts.
```

--------------------------------

### child_spec/1

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.Adapter.html

Returns a child specification for starting the adapter's processes within a supervisor.

```APIDOC
## child_spec(keyword)

### Description
Returns a child specification that mounts the processes required for the adapter.
`child_spec` will receive all options given `Phoenix.PubSub`. Note, however, that the `:name` under options is the name of the complete PubSub system. The reserved key space to be used by the adapter is under the `:adapter_name` key.

### Parameters
- **keyword** (keyword()) - Description not available.

### Returns
- `Supervisor.child_spec()`
```

--------------------------------

### child_spec/1

Source: https://hexdocs.pm/phoenix_pubsub_nats/Nats.NatsPubsub.html

Returns a specification to start the NatsPubsub module under a supervisor.

```APIDOC
## child_spec(init_arg)

### Description
Returns a specification to start this module under a supervisor.
See `Supervisor`.

### Function Signature
child_spec(init_arg)
```

--------------------------------

### Tracker Callback: init

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

The `init/1` callback is called when the tracker process starts. It receives initialization arguments and should return `{:ok, state}` or `{:error, reason}`.

```elixir
@callback init(Keyword.t()) :: {:ok, state :: term()} | {:error, reason :: term()}
```

--------------------------------

### Start Phoenix.PubSub in Supervision Tree

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

Configure Phoenix.PubSub as a child in your application's supervision tree. The `:name` option specifies how to reference the PubSub instance.

```elixir
{Phoenix.PubSub, name: :my_pubsub}
```

--------------------------------

### Add Dependency to mix.exs

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/readme.html

Install the phoenix_pubsub_conduit_amqp package by adding it to your project's dependencies in mix.exs.

```elixir
def deps do
  [
    {:phoenix_pubsub_conduit_amqp, "~> 0.1.0"}
  ]
end
```

--------------------------------

### Add Phoenix Pubsub Nats to Mix Dependencies

Source: https://hexdocs.pm/phoenix_pubsub_nats/index.html

Add this dependency to your `mix.exs` file to install the library.

```elixir
def deps do
  [
    {:phoenix_pubsub_nats, "~> 0.2"}
  ]
end
```

--------------------------------

### Start Phoenix.PubSub.Redis in Supervision Tree

Source: https://hexdocs.pm/phoenix_pubsub_redis/index.html

Integrate Phoenix.PubSub.Redis into your application's supervision tree by listing it with the adapter and Redis connection options. Ensure 'redis_opts' points to your Redis instance and 'node_name' is set, typically from an environment variable.

```elixir
{Phoenix.PubSub,
 adapter: Phoenix.PubSub.Redis,
 redis_opts: "redis://localhost:6379",
 node_name: System.get_env("NODE")}
```

--------------------------------

### PhoenixPubsubNats Supervision Tree Configuration

Source: https://hexdocs.pm/phoenix_pubsub_nats/PhoenixPubsubNats.html

Add this configuration to your supervision tree to start the PhoenixPubsubNats adapter. Ensure the Nats connection details are correctly specified.

```elixir
{
    Phoenix.PubSub,
    name: Phoenix.PubSubTest,
    adapter: PhoenixPubsubNats,
    connection: %{host: '127.0.0.1', port: 4222}
  }
```

--------------------------------

### get_by_key/3

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

Gets presences tracked under a specific topic and key pair.

```APIDOC
## get_by_key(tracker_name, topic, key)

### Description
Gets presences tracked under a given topic and key pair.

* `tracker_name` - The registered name of the tracker server
* `topic` - The `Phoenix.PubSub` topic
* `key` - The key of the presence

Returns a list of presence metadata.

### Request Example
```iex
Phoenix.Tracker.get_by_key(MyTracker, "lobby", "user1")
[{#PID<0.88.0>, %{name: "User 1"}}, {#PID<0.89.0>, %{name: "User 1"}}]
```
```

--------------------------------

### child_spec/1

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.PG2.html

Returns a specification to start the Phoenix.PubSub.PG2 module under a supervisor. This is useful for integrating the PubSub adapter into your application's supervision tree.

```APIDOC
## child_spec/1

### Description
Returns a specification to start this module under a supervisor.
See `Supervisor`.

### Function Signature
child_spec(init_arg)
```

--------------------------------

### Child specification

Source: https://hexdocs.pm/phoenix_pubsub/index.html

Returns a child specification for Phoenix.PubSub, which can be used when starting the application in a supervision tree.

```APIDOC
## child_spec/1

### Description
Returns a child specification for pubsub with the given `options`.

### Function Signature
child_spec(options)

### Parameters
- **options** (keyword()) - Options for configuring the PubSub child specification.
```

--------------------------------

### Generate PubSub Child Specification

Source: https://hexdocs.pm/phoenix_pubsub/index.html

Returns a child specification for starting a PubSub process. The `:name` option is required. Other options like `:adapter`, `:pool_size`, `:registry_size`, and `:broadcast_pool_size` can be configured.

```elixir
@spec child_spec(keyword()) :: Supervisor.child_spec()
```

--------------------------------

### Minimal Conduit Broker Example

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/readme.html

A minimal Conduit broker configuration for Phoenix PubSub. It sets up a fanout exchange and a server-specific queue that automatically deletes when the server restarts.

```elixir
defmodule MyApp.Broker do
  use Conduit.Broker, otp_app: :my_app

  configure do
    # All messages published to this exchange will be published to every bound queue
    exchange "phoenix.pubsub", type: :fanout

    # Will create queue name based on hostname and bind it to the fanout exchange. If the
    # server restarts, the queue will be removed and recreated, since the messages in the
    # queue are for websocket connections that no longer exist.
    queue &Phoenix.PubSub.ConduitAMQP.queue_name/0,
      exchange: "phoenix.pubsub",
      auto_delete: false,
      from: ["#"]
  end

  pipeline :phoenix_pubsub_incoming do
    # plug Conduit.Plug.LogIncoming
    # plug Conduit.Plug.AckException

    # Turns erlang binary into data
    plug Conduit.Plug.Parse
  end

  incoming Phoenix.PubSub.ConduitAMQP do
    pipe_through [:phoenix_pubsub_incoming]

    # Subscribe to messages published to the phoenix.pubsub exchange that are deposited in this
    # server specific queue.
    subscribe :phoenix_pubsub_receive, Subscriber,
      from: &Phoenix.PubSub.ConduitAMQP.queue_name/1
  end

  pipeline :phoenix_pubsub_outgoing do
    # plug Conduit.Plug.LogOutgoing

    # Turns data into erlang binary, other formats are lossy
    plug Conduit.Plug.Format,
      content_type: "application/x-erlang-binary",
      compressed: 6
  end

  outgoing do
    pipe_through [:phoenix_pubsub_outgoing]

    # Publish to phoenix.pubsub exchange with phoenix.pubsub routing key
    publish :phoenix_pubsub_broadcast,
      exchange: "phoenix.pubsub",
      to: "phoenix.pubsub"
  end
end
```

--------------------------------

### child_spec/1

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

Returns a child specification for starting a pubsub process within a supervisor. It requires a `:name` option and accepts other configuration options.

```APIDOC
## child_spec/1

### Description
Returns a child specification for pubsub with the given `options`.

### Parameters
#### Path Parameters
- `options` (keyword()) - A keyword list of options for the pubsub child specification.
  * `:name` - The name of the pubsub to be started (required).
  * `:adapter` - The adapter to use (defaults to `Phoenix.PubSub.PG2`).
  * `:pool_size` - Number of pubsub partitions to launch (defaults to one partition for every 4 cores).
  * `:registry_size` - Number of `Registry` partitions to launch (defaults to `:pool_size`).
  * `:broadcast_pool_size` - Number of pubsub partitions used for broadcasting messages (defaults to `:pool_size`).

### Request Example
```elixir
Phoenix.PubSub.child_spec(name: :my_pubsub, adapter: Phoenix.PubSub.PG2)
```

### Response
#### Success Response (200)
- `Supervisor.child_spec()` - A child specification suitable for use with `Supervisor.start_link/2`.
```

--------------------------------

### Subscribe and Broadcast Messages with Phoenix.PubSub

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

Example of subscribing to a topic and broadcasting a message. Messages are received by the calling process and can be inspected using `Process.info/2`.

```elixir
alias Phoenix.PubSub
PubSub.subscribe(:my_pubsub, "user:123")
Process.info(self(), :messages)
PubSub.broadcast(:my_pubsub, "user:123", {:user_update, %{id: 123, name: "Shane"}})
Process.info(self(), :messages)
```

--------------------------------

### child_spec/1

Source: https://hexdocs.pm/phoenix_pubsub_eventstore/Phoenix.PubSub.EventStore.html

Returns a supervisor specification for starting Phoenix.PubSub.EventStore within a supervision tree. This is typically used when configuring your application's supervisor.

```APIDOC
## child_spec/1

### Description
Returns a specification to start this module under a supervisor.
See `Supervisor`.

### Function Signature
`child_spec(init_arg)`
```

--------------------------------

### Phoenix.PubSub Child Specification

Source: https://hexdocs.pm/phoenix_pubsub/index.html

Generates a child specification for Phoenix.PubSub, which can be used when starting the application in a supervision tree. Accepts various options.

```elixir
Phoenix.PubSub.child_spec(name: :my_pubsub, pool_size: 2)
```

--------------------------------

### List All Presences in a Topic

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

Use `list/2` to get a list of all presences currently tracked under a given topic. Each presence is returned as a key/metadata tuple.

```elixir
iex> Phoenix.Tracker.list(MyTracker, "lobby")
[{123, %{name: "user 123"}}, {456, %{name: "user 456"}}]
```

--------------------------------

### Phoenix.Tracker Functions

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

Commonly used functions for interacting with a Phoenix.Tracker, including starting, tracking, untracking, updating presences, and retrieving presence information.

```elixir
child_spec(init_arg)
Returns a specification to start this module under a supervisor.
```

```elixir
get_by_key(tracker_name, topic, key)
Gets presences tracked under a given topic and key pair.
```

```elixir
graceful_permdown(tracker_name)
Gracefully shuts down by broadcasting permdown to all replicas.
```

```elixir
list(tracker_name, topic)
Lists all presences tracked under a given topic.
```

```elixir
start_link(tracker, tracker_arg, pool_opts)
Starts a tracker pool.
```

```elixir
track(tracker_name, pid, topic, key, meta)
Tracks a presence.
```

```elixir
untrack(tracker_name, pid)
untrack(tracker_name, pid, topic, key)
Untracks a presence.
```

```elixir
update(tracker_name, pid, topic, key, meta)
Updates a presence's metadata.
```

--------------------------------

### Get Presence by Key

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

Use `get_by_key/3` to retrieve all presences associated with a specific topic and key. This is useful for finding all users with a particular identifier within a topic.

```elixir
iex> Phoenix.Tracker.get_by_key(MyTracker, "lobby", "user1")
[{#PID<0.88.0>, %{name: "User 1"}}, {#PID<0.89.0>, %{name: "User 1"}}]
```

--------------------------------

### Get Supervisor Child Specification

Source: https://hexdocs.pm/phoenix_pubsub_buffered/PhoenixPubSubBuffered.html

Use the `child_spec/1` function to generate a supervisor child specification for PhoenixPubSubBuffered. This is useful when integrating it into a larger supervision tree.

```elixir
child_spec(init_arg)
```

--------------------------------

### Configuration Options

Source: https://hexdocs.pm/phoenix_pubsub_postgresql/Phoenix.PubSub.PostgreSQL.html

Lists and explains the available configuration options for the Phoenix.PubSub.PostgreSQL adapter.

```APIDOC
## Options

* `:name` - The required name for registering the PubSub process (e.g., `MyApp.PubSub`).
* `:repo` - An `Ecto.Repo` module to be used for database connectivity.
* `:otp_app` - The OTP application used to find the repo configuration (usually auto-detected from the repo).
* `:node_name` - Allows overriding the PubSub node name (defaults to the Erlang node name, then the system hostname).
* `:post_init_func` - A function to be executed after initialization, commonly used for testing.
* `:pg_config` - PostgreSQL configuration options that override any inferred from the repo.
```

--------------------------------

### Get node name

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

Returns the node name of the PubSub server.

```APIDOC
## node_name

### Description
Returns the node name of the PubSub server.

### Function Signature
node_name(pubsub)

### Parameters
* `pubsub` - The PubSub server name (atom).

### Returns
* The node name (atom or binary).
```

--------------------------------

### Basic PubSub Usage

Source: https://hexdocs.pm/phoenix_pubsub_postgresql/index.html

Demonstrates how to subscribe to a topic and broadcast a message using the configured Phoenix.PubSub instance.

```elixir
# Subscribe to a topic
Phoenix.PubSub.subscribe(MyApp.PubSub, "my_topic")

# Broadcast a message
Phoenix.PubSub.broadcast(MyApp.PubSub, "my_topic", {:some, "message"})
```

--------------------------------

### Get PubSub Node Name

Source: https://hexdocs.pm/phoenix_pubsub/index.html

Returns the node name of the PubSub server.

```elixir
@spec node_name(t()) :: node_name()
```

--------------------------------

### init/1

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/Phoenix.PubSub.ConduitAMQP.Subscriber.html

Callback implementation for Conduit.Plug.init/1. Initializes the plug with given options.

```APIDOC
## init/1

### Description
Callback implementation for `Conduit.Plug.init/1`.

### Parameters
- `opts` - Options for initialization.
```

--------------------------------

### Configuration Options

Source: https://hexdocs.pm/phoenix_pubsub_redis/Phoenix.PubSub.Redis.html

Available options for configuring the Phoenix.PubSub.Redis adapter.

```APIDOC
## Options

* `:name` - The required name to register the PubSub processes, e.g. `MyApp.PubSub`.
* `:node_name` - The name of the node, used to filter out messages broadcast by the same node. Defaults to `node()`. Must be unique.
* `:redis_pool_size` - The size of the Redis connection pool. Defaults to `5`.
* `:compression_level` - Compression level applied to serialized terms - `0` (none) to `9` (highest). Defaults to `0`.
* `:redis_opts` - Redix connection options - either a Redis URL string or a keyword list. See `Redix.start_link/1` for more information.
```

--------------------------------

### Supervisor Integration

Source: https://hexdocs.pm/phoenix_pubsub_postgresql/Phoenix.PubSub.PostgreSQL.html

Demonstrates how to include the Phoenix.PubSub.PostgreSQL adapter in your application's supervision tree.

```APIDOC
## Supervisor Integration

To start the Phoenix.PubSub.PostgreSQL adapter, include it in your supervision tree as follows:

```elixir
{Phoenix.PubSub, 
 name: MyApp.PubSub, 
 adapter: Phoenix.PubSub.PostgreSQL, 
 repo: MyApp.Repo}
```

Ensure you have added `:phoenix_pubsub_postgresql` to your project's dependencies:

```elixir
defp deps do
  [{:phoenix_pubsub_postgresql, "~> 0.1"}]
end
```
```

--------------------------------

### Configure Phoenix.PubSub.EventStore Adapter

Source: https://hexdocs.pm/phoenix_pubsub_eventstore/Phoenix.PubSub.EventStore.html

Add this configuration to your supervision tree to use the EventStore adapter for Phoenix PubSub. Ensure MyApp.EventStore is configured separately.

```elixir
{Phoenix.PubSub,
 [name: MyApp.PubSub,
  adapter: Phoenix.PubSub.EventStore,
  eventstore: MyApp.EventStore]
}
```

--------------------------------

### Configure Phoenix PubSub with Nats Adapter

Source: https://hexdocs.pm/phoenix_pubsub_nats/readme.html

Add this to your `application.ex` file's supervision tree to configure Phoenix.PubSub to use the Nats adapter. Ensure the `connection` details are configured according to Nats documentation.

```elixir
children = [
   {
      Phoenix.PubSub,
        name: Phoenix.PubSubTest,
        adapter: PhoenixPubsubNats,
        connection: %{host: '127.0.0.1', port: 4222}
   }
  ]
  
```

--------------------------------

### Configure PubSub Adapter in Application Supervision Tree

Source: https://hexdocs.pm/phoenix_pubsub_postgresql/index.html

Integrate the Phoenix.PubSub.PostgreSQL adapter into your application's supervision tree by specifying the adapter and Ecto.Repo module.

```elixir
children = [
  MyApp.Repo,
  {Phoenix.PubSub,
   name: MyApp.PubSub,
   adapter: Phoenix.PubSub.PostgreSQL,
   repo: MyApp.Repo}
]
```

--------------------------------

### Implement a Minimal Phoenix.Tracker

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

A basic implementation of a custom tracker using the Phoenix.Tracker behavior. It handles initialization and presence diffs, broadcasting join and leave events.

```elixir
defmodule MyTracker do
  use Phoenix.Tracker

  def start_link(opts) do
    opts = Keyword.merge([name: __MODULE__], opts)
    Phoenix.Tracker.start_link(__MODULE__, opts, opts)
  end

  def init(opts) do
    server = Keyword.fetch!(opts, :pubsub_server)
    {:ok, %{pubsub_server: server, node_name: Phoenix.PubSub.node_name(server)}}
  end

  def handle_diff(diff, state) do
    for {topic, {joins, leaves}} <- diff do
      for {key, meta} <- joins do
        IO.puts "presence join: key \"#{key}\" with meta #{inspect meta}"
        msg = {:join, key, meta}
        Phoenix.PubSub.direct_broadcast!(state.node_name, state.pubsub_server, topic, msg)
      end
      for {key, meta} <- leaves do
        IO.puts "presence leave: key \"#{key}\" with meta #{inspect meta}"
        msg = {:leave, key, meta}
        Phoenix.PubSub.direct_broadcast!(state.node_name, state.pubsub_server, topic, msg)
      end
    end
    {:ok, state}
  end
end
```

--------------------------------

### Configure Phoenix.PubSub with RedisZ Adapter

Source: https://hexdocs.pm/phoenix_pubsub_redis_z/readme.html

Integrate Phoenix.PubSub with the RedisZ adapter in your application's supervisor tree. Specify the `redis_urls` for your Redis instances.

```elixir
children = [
  {
    Phoenix.PubSub,
    name: MyApp.PubSub,
    adapter: Phoenix.PubSub.RedisZ,
    redis_urls: ["redis://redis01:6379/0", "redis://redis02:6379/0"]
  }
  # ...
]
```

--------------------------------

### Implementing a Tracker

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

This section shows how to implement a custom tracker by defining the necessary callbacks for the Phoenix.Tracker behaviour.

```APIDOC
## Implementing a Tracker
To start a tracker, first add the tracker to your supervision tree:
```elixir
children = [
  # ...
  {MyTracker, [name: MyTracker, pubsub_server: MyApp.PubSub]}
]
```

Next, implement `MyTracker` with support for the `Phoenix.Tracker` behaviour callbacks. An example of a minimal tracker could include:
```elixir
defmodule MyTracker do
  use Phoenix.Tracker

  def start_link(opts) do
    opts = Keyword.merge([name: __MODULE__], opts)
    Phoenix.Tracker.start_link(__MODULE__, opts, opts)
  end

  def init(opts) do
    server = Keyword.fetch!(opts, :pubsub_server)
    {:ok, %{pubsub_server: server, node_name: Phoenix.PubSub.node_name(server)}}
  end

  def handle_diff(diff, state) do
    for {topic, {joins, leaves}} <- diff do
      for {key, meta} <- joins do
        IO.puts "presence join: key \"#{key}\" with meta #{inspect meta}"
        msg = {:join, key, meta}
        Phoenix.PubSub.direct_broadcast!(state.node_name, state.pubsub_server, topic, msg)
      end
      for {key, meta} <- leaves do
        IO.puts "presence leave: key \"#{key}\" with meta #{inspect meta}"
        msg = {:leave, key, meta}
        Phoenix.PubSub.direct_broadcast!(state.node_name, state.pubsub_server, topic, msg)
      end
    end
    {:ok, state}
  end
end
```

Trackers must implement `start_link/1`, `init/1`, and `handle_diff/2`. The `init/1` callback allows the tracker to manage its own state when running within the `Phoenix.Tracker` server. The `handle_diff` callback is invoked with a diff of presence join and leave events, grouped by topic. As replicas heartbeat and replicate data, the local tracker state is merged with the remote data, and the diff is sent to the callback. The handler can use this information to notify subscribers of events, as done above.
An optional `handle_info/2` callback may also be invoked to handle application specific messages within your tracker.
```

--------------------------------

### Configure PubSub Adapter

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/index.html

Configure your application's endpoint to use the Phoenix.PubSub.ConduitAMQP adapter and specify a broker.

```elixir
# config.exs
config :my_app, MyApp.Endpoint,
  url: [host: "localhost"],
  secret_key_base: "i5mdMSK9FcLUMAyIqtyptYPQrWTdIZJJ8N8eSseqn/LrW3ynJcTexai990u9Ea/K",
  render_errors: [view: MyApp.ErrorView, accepts: ~w(json)],
  pubsub: [
    name: MyApp.PubSub,
    adapter: Phoenix.PubSub.ConduitAMQP,
    broker: MyApp.Broker]

```

--------------------------------

### Configure PhoenixPubSubBuffered in application.ex

Source: https://hexdocs.pm/phoenix_pubsub_buffered/readme.html

Register PhoenixPubSubBuffered as the adapter for your PubSub process in your `application.ex` file. Ensure the `:name` option matches your application's PubSub name.

```elixir
children = [
  # ...,
  {Phoenix.PubSub, name: MyApp.PubSub, adapter: PhoenixPubSubBuffered}
]
```

--------------------------------

### Configure Phoenix PubSub with Nats Adapter

Source: https://hexdocs.pm/phoenix_pubsub_nats/index.html

Add this to your application's supervision tree to configure Phoenix PubSub to use the Nats adapter. The `connection` map should be configured according to the `gnat` documentation.

```elixir
children = [
   {
      Phoenix.PubSub,
        name: Phoenix.PubSubTest,
        adapter: PhoenixPubsubNats,
        connection: %{host: '127.0.0.1', port: 4222}
   }
  ]
```

--------------------------------

### Configure Phoenix PubSub Adapter

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/readme.html

Configure your application's endpoint to use the ConduitAMQP adapter for Phoenix PubSub. Ensure the broker is also specified.

```elixir
config :my_app, MyApp.Endpoint,
  url: [host: "localhost"],
  secret_key_base: "i5mdMSK9FcLUMAyIqtyptYPQrWTdIZJJ8N8eSseqn/LrW3ynJcTexai990u9Ea/K",
  render_errors: [view: MyApp.ErrorView, accepts: ~w(json)],
  pubsub: [
    name: MyApp.PubSub,
    adapter: Phoenix.PubSub.ConduitAMQP,
    broker: MyApp.Broker]

```

--------------------------------

### Configure ConduitAMQP Adapter

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/Phoenix.PubSub.ConduitAMQP.html

Add this to your Endpoint's config to use ConduitAMQP as the PubSub adapter. Ensure the adapter name is spelled correctly.

```elixir
config :my_app, MyApp.Endpoint,
  pubsub: [name: MyApp.PubSub,
            adapter: Phoenix.PubSub.ConduitAQMP]
```

--------------------------------

### Add PhoenixPubsubRedisZ to Mix Dependencies

Source: https://hexdocs.pm/phoenix_pubsub_redis_z/readme.html

Include the `phoenix_pubsub_redis_z` package in your `mix.exs` file to add it as a project dependency.

```elixir
def deps do
  [
    {:phoenix_pubsub_redis_z, "~> 0.4"}
  ]
end
```

--------------------------------

### Configure Phoenix.PubSub.PG2 with Pool Size

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

When using the default PG2 adapter, you can configure a `:pool_size`. This value must be consistent across the cluster.

```elixir
{Phoenix.PubSub, name: :my_pubsub, pool_size: 1}
```

--------------------------------

### Add Dependency to mix.exs

Source: https://hexdocs.pm/phoenix_pubsub_postgresql/index.html

Add the phoenix_pubsub_postgresql package to your project's dependencies in the mix.exs file.

```elixir
def deps do
  [
    {:phoenix_pubsub_postgresql, "~> 0.6.0"}
  ]
end
```

--------------------------------

### Child Specification Callback

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.Adapter.html

Callback to return a child specification for mounting adapter processes. Receives all options given to Phoenix.PubSub.

```elixir
@callback child_spec(keyword()) :: Supervisor.child_spec()
```

--------------------------------

### Add phoenix_pubsub_buffered to Dependencies

Source: https://hexdocs.pm/phoenix_pubsub_buffered/PhoenixPubSubBuffered.html

Ensure the `:phoenix_pubsub_buffered` package is added to your project's dependencies in `mix.exs`. This makes the adapter available for use.

```elixir
defp deps do
  [{:phoenix_pubsub_buffered, "~> 0.1.0"}]
end
```

--------------------------------

### run/2

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/Phoenix.PubSub.ConduitAMQP.Subscriber.html

Callback implementation for Conduit.Plug.run/2. Executes the plug's logic.

```APIDOC
## run/2

### Description
Callback implementation for `Conduit.Plug.run/2`.

### Parameters
- `message` - The message to run.
- `opts` - Options for the run function (defaults to `[]`).
```

--------------------------------

### Track a Presence

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

Use `track/5` to register a presence with a topic, key, and metadata. It returns an `{:ok, ref}` on success or `{:error, reason}` if already tracked.

```elixir
iex> Phoenix.Tracker.track(MyTracker, self(), "lobby", u.id, %{stat: "away"})
{:ok, "1WpAofWYIAA="}

iex> Phoenix.Tracker.track(MyTracker, self(), "lobby", u.id, %{stat: "away"})
{:error, {:already_tracked, #PID<0.56.0>, "lobby", "123"}}
```

--------------------------------

### Add PhoenixPubSubBuffered to Dependencies

Source: https://hexdocs.pm/phoenix_pubsub_buffered/readme.html

Add the `phoenix_pubsub_buffered` package to your project's dependencies in `mix.exs`.

```elixir
def deps do
  [
    {:phoenix_pubsub_buffered, "~> 0.1.0"}
  ]
end
```

--------------------------------

### list/2

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

Lists all presences tracked under a given topic.

```APIDOC
## list(tracker_name, topic)

### Description
Lists all presences tracked under a given topic.

* `tracker_name` - The registered name of the tracker server
* `topic` - The `Phoenix.PubSub` topic

Returns a list of presences in key/metadata tuple pairs.

### Request Example
```iex
Phoenix.Tracker.list(MyTracker, "lobby")
[{123, %{name: "user 123"}}, {456, %{name: "user 456"}}]
```
```

--------------------------------

### Child specification

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

Returns a child specification for the PubSub server with the given options, suitable for use in a supervision tree.

```APIDOC
## child_spec

### Description
Returns a child specification for pubsub with the given `options`.

### Function Signature
child_spec(options)

### Parameters
* `options` - A list of options to configure the PubSub server (e.g., `name`, `pool_size`, `adapter`).

### Returns
* A child specification (tuple) for use in a supervisor.
```

--------------------------------

### Safely Increase Pool Size for PG2 Adapter (Step 2)

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

After the first deployment step, update all nodes to use the new pool size. This completes the safe migration process.

```elixir
{Phoenix.PubSub, name: :my_pubsub, pool_size: 2}
```

--------------------------------

### serialize/1

Source: https://hexdocs.pm/phoenix_pubsub_eventstore/Phoenix.PubSub.EventStore.Serializer.Base64.html

Serializes the message as a base64 encoded binary and wraps it in a %Phoenix.PubSub.EventStore.Serializer.Base64{} struct.

```APIDOC
## serialize(msg)

### Description
Serializes the message as a base64 encoded binary and wraps it in a `%Phoenix.PubSub.EventStore.Serializer.Base64{}` struct.

### Function Signature
serialize(msg)
```

--------------------------------

### Phoenix.PubSub.PostgreSQL.State Struct Definition

Source: https://hexdocs.pm/phoenix_pubsub_postgresql/Phoenix.PubSub.PostgreSQL.State.html

Defines the structure of the state for the PostgreSQL PubSub adapter. It includes fields for the adapter name, PubSub name, notifier process ID, and the Ecto repository.

```elixir
@type t() :: %Phoenix.PubSub.PostgreSQL.State{
  adapter_name: term(),
  name: term(),
  notifier_pid: term(),
  repo: term()
}
```

--------------------------------

### Tracker Callback: handle_info

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

The optional `handle_info/2` callback can be implemented to handle custom messages sent to the tracker process. It receives the message and current state, returning the new state.

```elixir
@callback handle_info(message :: term(), state :: term()) :: {:noreply, state :: term()}
```

--------------------------------

### Add Dependency to mix.exs

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/index.html

Add the phoenix_pubsub_conduit_ammp package to your project's dependencies in mix.exs.

```elixir
# mix.exs
def deps do
  [
    {:phoenix_pubsub_conduit_amqp, "~> 0.1.0"}
  ]
end

```

--------------------------------

### Broadcast a message from a specific process (raising version)

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

A raising version of `broadcast_from/5`. It will raise an error if the broadcast fails.

```APIDOC
## broadcast_from!

### Description
Raising version of `broadcast_from/5`.

### Function Signature
broadcast_from!(pubsub, from, topic, message, dispatcher \\ __MODULE__)

### Parameters
* `pubsub` - The PubSub server name (atom).
* `from` - The process identifier (pid) to broadcast from.
* `topic` - The topic to broadcast on (atom or binary).
* `message` - The message to broadcast (term).
* `dispatcher` - The dispatcher module to use (defaults to `__MODULE__`).

### Returns
* `:ok` on successful broadcast.

### Raises
* Raises an error if the broadcast fails.
```

--------------------------------

### Broadcast Message from Specific Process (Raising)

Source: https://hexdocs.pm/phoenix_pubsub/index.html

The raising version of `broadcast_from/5`. It will raise an error if the broadcast fails.

```elixir
@spec broadcast_from!(t(), pid(), topic(), message(), dispatcher()) :: :ok
```

--------------------------------

### Subscribe to a Topic

Source: https://hexdocs.pm/phoenix_pubsub_postgresql/readme.html

Use the Phoenix.PubSub.subscribe function to subscribe to a specific topic for receiving messages.

```elixir
Phoenix.PubSub.subscribe(MyApp.PubSub, "my_topic")
```

--------------------------------

### broadcast_from/5

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

Broadcasts a message on a given topic from a specific process across the whole cluster. It takes the pubsub system name, sender PID, topic, message, and an optional dispatcher.

```APIDOC
## broadcast_from/5

### Description
Broadcasts message on given topic from the given process across the whole cluster.

### Parameters
#### Path Parameters
- `pubsub` (t()) - The name of the pubsub system
- `from` (pid()) - The pid that will send the message
- `topic` (topic()) - The topic to broadcast to, ie: `"users:123"`
- `message` (message()) - The payload of the broadcast
- `dispatcher` (dispatcher()) - Optional custom dispatcher.

### Request Example
```elixir
Phoenix.PubSub.broadcast_from(pubsub, from, topic, message, dispatcher)
```

### Response
#### Success Response (200)
- `:ok`
#### Error Response
- `{:error, term()}`
```

--------------------------------

### local_broadcast_from/5

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

Broadcasts a message on a given topic from a specific process, restricted to the current node. It takes the pubsub system name, sender PID, topic, message, and an optional dispatcher.

```APIDOC
## local_broadcast_from/5

### Description
Broadcasts message on given topic from a given process only for the current node.

### Parameters
#### Path Parameters
- `pubsub` (t()) - The name of the pubsub system
- `from` (pid()) - The pid that will send the message
- `topic` (topic()) - The topic to broadcast to, ie: `"users:123"`
- `message` (message()) - The payload of the broadcast
- `dispatcher` (dispatcher()) - Optional custom dispatcher.

### Request Example
```elixir
Phoenix.PubSub.local_broadcast_from(pubsub, from, topic, message, dispatcher)
```

### Response
#### Success Response (200)
- `:ok`
```

--------------------------------

### Serialize EventStore Messages

Source: https://hexdocs.pm/phoenix_pubsub_eventstore/Phoenix.PubSub.EventStore.Serializer.Base64.html

Serializes a message into a Base64 encoded binary and wraps it in a %Phoenix.PubSub.EventStore.Serializer.Base64{} struct before publishing to EventStore.

```elixir
serialize(msg)
```

--------------------------------

### Subscribe to a Topic

Source: https://hexdocs.pm/phoenix_pubsub/index.html

Subscribes the calling process to a given topic. Options can be passed to modify subscription behavior.

```elixir
Phoenix.PubSub.subscribe(:my_pubsub, "user:123")
Phoenix.PubSub.subscribe(:my_pubsub, "user:123", metadata: :fastlane)
```

--------------------------------

### Node Name Callback

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.Adapter.html

Callback to return the node name as an atom or a binary.

```elixir
@callback node_name(adapter_name()) :: Phoenix.PubSub.node_name()
```

--------------------------------

### call/3

Source: https://hexdocs.pm/phoenix_pubsub_conduit_amqp/Phoenix.PubSub.ConduitAMQP.Subscriber.html

Callback implementation for Conduit.Plug.call/3. Handles incoming messages.

```APIDOC
## call/3

### Description
Callback implementation for `Conduit.Plug.call/3`.

### Parameters
- `message` - The incoming message.
- `next` - The next function in the pipeline.
- `opts` - Options for the call.
```

--------------------------------

### Broadcast Message Locally from Specific Process

Source: https://hexdocs.pm/phoenix_pubsub/index.html

Broadcasts a message on a given topic from a specific process, but only for the current node. The default dispatcher excludes the originating process. A custom dispatcher can be provided.

```elixir
@spec local_broadcast_from(t(), pid(), topic(), message(), dispatcher()) :: :ok
```

--------------------------------

### Subscribe to a topic

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

Subscribes the caller to the PubSub adapter's topic. This allows the caller to receive messages broadcast on that topic.

```APIDOC
## subscribe

### Description
Subscribes the caller to the PubSub adapter's topic.

### Function Signature
subscribe(pubsub, topic, opts \\ [])

### Parameters
* `pubsub` - The PubSub server name (atom).
* `topic` - The topic to subscribe to (atom or binary).
* `opts` - Optional arguments (list).

### Returns
* `:ok` on successful subscription.
```

--------------------------------

### Local broadcast from a specific process

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html

Broadcasts a message on a given topic from a specific process, only for the current node.

```APIDOC
## local_broadcast_from

### Description
Broadcasts message on given topic from a given process only for the current node.

### Function Signature
local_broadcast_from(pubsub, from, topic, message, dispatcher \\ __MODULE__)

### Parameters
* `pubsub` - The PubSub server name (atom).
* `from` - The process identifier (pid) to broadcast from.
* `topic` - The topic to broadcast on (atom or binary).
* `message` - The message to broadcast (term).
* `dispatcher` - The dispatcher module to use (defaults to `__MODULE__`).

### Returns
* `:ok` on successful broadcast.
```

--------------------------------

### Phoenix.Tracker Functions

Source: https://hexdocs.pm/phoenix_pubsub/Phoenix.Tracker.html

This section lists the public functions available for interacting with the Phoenix.Tracker.

```APIDOC
## Functions
child_spec(init_arg)
Returns a specification to start this module under a supervisor.
get_by_key(tracker_name, topic, key)
Gets presences tracked under a given topic and key pair.
graceful_permdown(tracker_name)
Gracefully shuts down by broadcasting permdown to all replicas.
list(tracker_name, topic)
Lists all presences tracked under a given topic.
start_link(tracker, tracker_arg, pool_opts)
Starts a tracker pool.
track(tracker_name, pid, topic, key, meta)
Tracks a presence.
untrack(tracker_name, pid)
untrack(tracker_name, pid, topic, key)
Untracks a presence.
update(tracker_name, pid, topic, key, meta)
Updates a presence's metadata.
```

--------------------------------

### Direct broadcast to a node (raising version)

Source: https://hexdocs.pm/phoenix_pubsub/index.html

Raising version of `direct_broadcast/5`. This function will raise an error if the broadcast fails.

```APIDOC
## direct_broadcast!/5

### Description
Raising version of `direct_broadcast/5`.

### Function Signature
direct_broadcast!(node_name, pubsub, topic, message, dispatcher \\ __MODULE__)

### Parameters
- **node_name** (node_name()) - The name of the node to broadcast to.
- **pubsub** (t()) - The PubSub server name.
- **topic** (topic()) - The topic to broadcast on.
- **message** (message()) - The message to broadcast.
- **dispatcher** (module()) - The dispatcher module to use for message delivery.
```
Tokens:
Raw