Delegate redis connections to Redix

mitchellhenke · mitchellhenke · commit e85d88c94fc9 · 2026-03-20T15:57:51.000-05:00
diff --git a/README.md b/README.md
@@ -19,22 +19,20 @@ children = [
   # ...,
   {Phoenix.PubSub,
    adapter: Phoenix.PubSub.Redis,
-   host: "192.168.1.100",
+   # redis_opts: [host: "example.com", port: 9999],
+   redis_opts: "redis://localhost:6379",
    node_name: System.get_env("NODE")}
 ```
 
 Config Options
 
-Option                  | Description                                                               | Default        |
-:-----------------------| :------------------------------------------------------------------------ | :------------- |
-`:name`                 | The required name to register the PubSub processes, ie: `MyApp.PubSub`    |                |
-`:node_name`            | The required and unique name of the node, ie: `System.get_env("NODE")`    |                |
-`:url`                  | The redis-server URL, ie: `redis://username:password@host:port`           |                |
-`:host`                 | The redis-server host IP                                                  | `"127.0.0.1"`  |
-`:port`                 | The redis-server port                                                     | `6379`         |
-`:password`             | The redis-server password                                                 | `""`           |
-`:compression_level`    | Compression level applied to serialized terms (`0` - none, `9` - highest) | `0`            |
-`:socket_opts`          | The redis-server network layer options                                    | `[]`           |
+Option                  | Description                                                                                | Default        |
+:-----------------------| :----------------------------------------------------------------------------------------- | :------------- |
+`:name`                 | The required name to register the PubSub processes, ie: `MyApp.PubSub`                     |                |
+`:node_name`            | The required and unique name of the node, ie: `System.get_env("NODE")`                     |                |
+`:compression_level`    | Compression level applied to serialized terms (`0` - none, `9` - highest)                  | `0`            |
+`:redis_pool_size`      | The size of the redis connection pool.                                                     | `5`            |
+`:redis_opts`           | Redis connection opts. See: https://hexdocs.pm/redix/Redix.html#start_link/1-redis-options |                |
 
 
 ## License
diff --git a/lib/phoenix_pubsub_redis/redis.ex b/lib/phoenix_pubsub_redis/redis.ex
@@ -6,32 +6,50 @@ defmodule Phoenix.PubSub.Redis do
 
       {Phoenix.PubSub,
        adapter: Phoenix.PubSub.Redis,
-       host: "192.168.1.100",
+       redis_opts: [host: "192.168.1.100"],
        node_name: System.get_env("NODE")}
 
   ## Options
 
     * `:url` - The url to the redis server ie: `redis://username:password@host:port`
     * `:name` - The required name to register the PubSub processes, ie: `MyApp.PubSub`
     * `:node_name` - The required name of the node, defaults to Erlang --sname flag. It must be unique.
-    * `:host` - The redis-server host IP, defaults `"127.0.0.1"`
-    * `:port` - The redis-server port, defaults `6379`
-    * `:username` - The redis-server username
-    * `:password` - The redis-server password, defaults `""`
-    * `:ssl` - The redis-server ssl option, defaults `false`
     * `:redis_pool_size` - The size of the redis connection pool. Defaults `5`
     * `:compression_level` - Compression level applied to serialized terms - from `0` (no compression), to `9` (highest). Defaults `0`
-    * `:socket_opts` - List of options that are passed to the network layer when connecting to the Redis server. Default `[]`
-    * `:sentinel` - Redix sentinel configuration. Default to `nil`
+    * `:redis_opts` - Redis connection opts. See: https://hexdocs.pm/redix/Redix.html#start_link/1-redis-options
 
   """
 
   use Supervisor
 
   @behaviour Phoenix.PubSub.Adapter
-  @redis_pool_size 5
-  @redis_opts [:host, :port, :username, :password, :database, :ssl, :socket_opts, :sentinel]
-  @defaults [host: "127.0.0.1", port: 6379]
+
+  @schema NimbleOptions.new!(
+            node_name: [
+              type: :atom,
+              doc: "The name of the node. Defaults to the Erlang `--sname` flag. Must be unique."
+            ],
+            redis_pool_size: [
+              type: :pos_integer,
+              default: 5,
+              doc: "The size of the Redis connection pool."
+            ],
+            compression_level: [
+              type: {:in, 0..9},
+              default: 0,
+              doc: "Compression level applied to serialized terms — `0` (none) to `9` (highest)."
+            ],
+            redis_opts: [
+              type: {:or, [:string, :keyword_list]},
+              default: [],
+              doc:
+                "Redix connection options — either a Redis URL string or a keyword list. " <>
+                  "See `Redix.start_link/1` for more information."
+            ]
+          )
+
+  # Using top-level configuration keys for Redis configuration is deprecated
+  @redis_top_level_keys [:host, :port, :password, :database, :ssl, :socket_opts, :sentinel, :url]
 
   ## Adapter callbacks
 
@@ -58,15 +76,14 @@ defmodule Phoenix.PubSub.Redis do
 
   @impl true
   def init(opts) do
+    opts = build_opts(opts)
     pubsub_name = Keyword.fetch!(opts, :name)
     adapter_name = Keyword.fetch!(opts, :adapter_name)
-    compression_level = Keyword.get(opts, :compression_level, 0)
-
-    opts = handle_url_opts(opts)
-    opts = Keyword.merge(@defaults, opts)
-    redis_opts = Keyword.take(opts, @redis_opts)
+    compression_level = Keyword.fetch!(opts, :compression_level)
+    redis_opts = Keyword.fetch!(opts, :redis_opts)
+    node_name = Keyword.fetch!(opts, :node_name)
+    redis_pool_size = Keyword.fetch!(opts, :redis_pool_size)
 
-    node_name = opts[:node_name] || node()
     validate_node_name!(node_name)
 
     :ets.new(adapter_name, [:public, :named_table, read_concurrency: true])
@@ -76,7 +93,7 @@ defmodule Phoenix.PubSub.Redis do
     pool_opts = [
       name: {:local, adapter_name},
       worker_module: Redix,
-      size: opts[:redis_pool_size] || @redis_pool_size,
+      size: redis_pool_size,
       max_overflow: 0
     ]
 
@@ -88,28 +105,53 @@ defmodule Phoenix.PubSub.Redis do
     Supervisor.init(children, strategy: :rest_for_one)
   end
 
-  defp handle_url_opts(opts) do
-    if opts[:url] do
-      merge_url_opts(opts)
-    else
-      opts
-    end
+  @doc false
+  def build_opts(opts) do
+    {internal, user_opts} =
+      Keyword.split(opts, [:name, :adapter_name, :adapter, :pool_size, :registry_size])
+
+    {top_level_redis, user_opts} = Keyword.split(user_opts, @redis_top_level_keys)
+
+    validated =
+      user_opts
+      |> Keyword.put_new(:node_name, node())
+      |> NimbleOptions.validate!(@schema)
+
+    redis_opts = build_redis_opts(top_level_redis, validated[:redis_opts])
+
+    internal
+    |> Keyword.put(:node_name, validated[:node_name])
+    |> Keyword.put(:compression_level, validated[:compression_level])
+    |> Keyword.put(:redis_pool_size, validated[:redis_pool_size])
+    |> Keyword.put(:redis_opts, redis_opts)
   end
 
-  defp merge_url_opts(opts) do
-    info = URI.parse(opts[:url])
+  defp build_redis_opts(top_level, redis_opts) do
+    provided =
+      Enum.filter([top_level != [] && :top_level_keys, redis_opts != [] && :redis_opts], & &1)
+
+    case provided do
+      [] ->
+        []
+
+      [:top_level_keys] ->
+        keys = top_level |> Keyword.keys() |> Enum.map_join(", ", &inspect/1)
 
-    user_opts =
-      case String.split(info.userinfo || "", ":") do
-        [""] -> []
-        [username] -> [username: username]
-        ["", password] -> [password: password]
-        [username, password] -> [username: username, password: password]
-      end
+        IO.warn(
+          "Passing Redis connection keys at the top level is deprecated. " <>
+            "Move #{keys} inside the :redis_opts option instead.",
+          []
+        )
 
-    opts
-    |> Keyword.merge(user_opts)
-    |> Keyword.merge(host: info.host, port: info.port || @defaults[:port])
+        if Keyword.keys(top_level) == [:url], do: top_level[:url], else: top_level
+
+      [:redis_opts] ->
+        redis_opts
+
+      _multiple ->
+        raise ArgumentError,
+              "only one of :redis_opts or top-level Redis keys may be provided, not both"
+    end
   end
 
   defp validate_node_name!(node_name) do
diff --git a/lib/phoenix_pubsub_redis/redis_server.ex b/lib/phoenix_pubsub_redis/redis_server.ex
@@ -61,7 +61,7 @@ defmodule Phoenix.PubSub.RedisServer do
       node_name: node_name,
       redix_pid: nil,
       reconnect_timer: nil,
-      redis_opts: [sync_connect: true] ++ redis_opts
+      redis_opts: redis_opts
     }
 
     {:ok, establish_conn(state)}
@@ -130,7 +130,7 @@ defmodule Phoenix.PubSub.RedisServer do
   end
 
   defp establish_conn(%{redis_opts: redis_opts} = state) do
-    case Redix.PubSub.start_link(redis_opts) do
+    case start_redix_pubsub(redis_opts) do
       {:ok, redix_pid} ->
         establish_success(%{state | redix_pid: redix_pid})
 
@@ -139,5 +139,13 @@ defmodule Phoenix.PubSub.RedisServer do
     end
   end
 
+  defp start_redix_pubsub(url) when is_binary(url) do
+    Redix.PubSub.start_link(url, sync_connect: true)
+  end
+
+  defp start_redix_pubsub(opts) do
+    Redix.PubSub.start_link([sync_connect: true] ++ opts)
+  end
+
   defp redis_namespace(adapter_name), do: "phx:#{adapter_name}"
 end
diff --git a/mix.exs b/mix.exs
@@ -30,6 +30,7 @@ defmodule PhoenixPubsubRedis.Mixfile do
     [
       phoenix_pubsub(),
       {:redix, "~> 1.0"},
+      {:nimble_options, "~> 1.0"},
       {:ex_doc, ">= 0.0.0", only: :docs},
       {:poolboy, "~> 1.5.1 or ~> 1.6"}
     ]
diff --git a/test/phoenix_pubsub_redis_test.exs b/test/phoenix_pubsub_redis_test.exs
@@ -2,9 +2,118 @@ Application.put_env(
   :phoenix_pubsub,
   :test_adapter,
   {Phoenix.PubSub.Redis,
-   url: System.get_env("REDIS_URL", "redis://localhost:6379"),
+   redis_opts: System.get_env("REDIS_URL", "redis://localhost:6379"),
    node_name: :SAMPLE,
    compression_level: 1}
 )
 
 Code.require_file("#{Mix.Project.deps_paths()[:phoenix_pubsub]}/test/shared/pubsub_test.exs")
+
+defmodule Phoenix.PubSub.RedisTest do
+  use ExUnit.Case, async: true
+
+  import ExUnit.CaptureIO
+
+  alias Phoenix.PubSub.Redis
+
+  describe "build_opts/1" do
+    test "build opts with defaults" do
+      assert Map.new(Redis.build_opts(name: Phoenix.TestName, adapter_name: :adapter_name)) ==
+               Map.new(
+                 node_name: node(),
+                 name: Phoenix.TestName,
+                 adapter_name: :adapter_name,
+                 redis_pool_size: 5,
+                 redis_opts: [],
+                 compression_level: 0
+               )
+    end
+
+    test "fill redis opts as-is" do
+      assert Map.new(
+               Redis.build_opts(
+                 name: Phoenix.TestName,
+                 adapter_name: :adapter_name,
+                 redis_opts: [
+                   host: "example.com",
+                   port: 5000,
+                   password: "password",
+                   database: 1,
+                   ssl: true,
+                   socket_opts: [verify: :no_verify],
+                   sentinel: [
+                     sentinels: [
+                       "redis://sent1.example.com:26379",
+                       "redis://sent2.example.com:26379"
+                     ],
+                     group: "main"
+                   ]
+                 ]
+               )
+             ) ==
+               Map.new(
+                 node_name: node(),
+                 name: Phoenix.TestName,
+                 adapter_name: :adapter_name,
+                 redis_pool_size: 5,
+                 compression_level: 0,
+                 redis_opts: [
+                   host: "example.com",
+                   port: 5000,
+                   password: "password",
+                   database: 1,
+                   ssl: true,
+                   socket_opts: [verify: :no_verify],
+                   sentinel: [
+                     sentinels: [
+                       "redis://sent1.example.com:26379",
+                       "redis://sent2.example.com:26379"
+                     ],
+                     group: "main"
+                   ]
+                 ]
+               )
+    end
+
+    test "warns when top-level Redis keys are used" do
+      warning =
+        capture_io(:stderr, fn ->
+          Redis.build_opts(name: Phoenix.TestName, adapter_name: :adapter_name, host: "localhost")
+        end)
+
+      assert warning =~ "Passing Redis connection keys at the top level is deprecated"
+      assert warning =~ ":host"
+    end
+
+    test "raises when both top-level keys and redis_opts are provided" do
+      assert_raise ArgumentError,
+                   "only one of :redis_opts or top-level Redis keys may be provided, not both",
+                   fn ->
+                     Redis.build_opts(
+                       name: Phoenix.TestName,
+                       adapter_name: :adapter_name,
+                       host: "example.com",
+                       redis_opts: [password: "password"]
+                     )
+                   end
+    end
+
+    test "url string is passed through directly as redis_opts" do
+      assert Map.new(
+               Redis.build_opts(
+                 name: Phoenix.TestName,
+                 adapter_name: :adapter_name,
+                 redis_opts: "rediss://username:password@example.com:5000/1"
+               )
+             ) ==
+               Map.new(
+                 node_name: node(),
+                 name: Phoenix.TestName,
+                 adapter_name: :adapter_name,
+                 redis_pool_size: 5,
+                 compression_level: 0,
+                 redis_opts: "rediss://username:password@example.com:5000/1"
+               )
+    end
+  end
+end

Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@ defmodule PhoenixPubsubRedis.Mixfile do`
`30`	`30`	`[`
`31`	`31`	`phoenix_pubsub(),`
`32`	`32`	`{:redix, "~> 1.0"},`
	`33`	`+ {:nimble_options, "~> 1.0"},`
`33`	`34`	`{:ex_doc, ">= 0.0.0", only: :docs},`
`34`	`35`	`{:poolboy, "~> 1.5.1 or ~> 1.6"}`
`35`	`36`	`]`