Overall fixes and enhancements (#24)

Overall fixes and enhancements
- Remove `:nebulex_cluster` dependency
- Make dependencies optional

Author: cabol

.github/workflows/ci.yml

@@ -12,6 +12,7 @@ jobs:
   nebulex_test:
     name: 'NebulexRedisAdapter Test (Elixir ${{ matrix.elixir }} OTP ${{ matrix.otp }})'
     runs-on: ubuntu-latest
+
     strategy:
       matrix:
         include:
@@ -26,14 +27,17 @@ jobs:
       MIX_ENV: test
       NBX_TEST: true
       REDIS_CLUSTER_IP: '0.0.0.0'
+
     steps:
       - uses: actions/checkout@v2
+
       - name: Start Redis
         run: docker-compose up -d
       - uses: actions/setup-elixir@v1
         with:
           otp-version: '${{ matrix.otp }}'
           elixir-version: '${{ matrix.elixir }}'
+
       - uses: actions/cache@v1
         with:
           path: deps
@@ -42,6 +46,7 @@ jobs:
             hashFiles(format('{0}{1}', github.workspace, '/mix.lock')) }}
           restore-keys: |
             ${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-mix-
+
       - uses: actions/cache@v1
         with:
           path: _build
@@ -50,25 +55,33 @@ jobs:
             hashFiles(format('{0}{1}', github.workspace, '/mix.lock')) }}
           restore-keys: |
             ${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-build-
+
       - name: Install Dependencies
-        run: mix deps.get
-      - name: Compile Code
-        run: mix compile --warnings-as-errors
-      - name: Check Format
-        run: mix format --check-formatted
-      - name: Check Style
-        run: mix credo --strict
-      - name: Run Tests
+        run: |
+          mix local.hex --force
+          mix local.rebar --force
+          mix deps.get
+
+      - name: Run style and code consistency checks
+        run: |
+          mix compile --warnings-as-errors
+          mix format --check-formatted
+          mix credo --strict
+
+      - name: Run tests
         run: |
           epmd -daemon
           mix coveralls.github
+
       - uses: actions/cache@v1
         with:
           path: priv/plts
           key: '${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-plt-v1'
           restore-keys: |
             ${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-plt-v1
-      - name: Run Dialyzer
+
+      - name: Run dialyzer
         run: mix dialyzer --format short
-      - name: Report Doc Coverage
+
+      - name: Doc Coverage Report
         run: MIX_ENV=docs mix inch.report

README.md

@@ -25,11 +25,21 @@ Add `nebulex_redis_adapter` to your list of dependencies in `mix.exs`:
 ```elixir
 defp deps do
   [
-    {:nebulex_redis_adapter, "~> 1.1"}
+    {:nebulex_redis_adapter, "~> 2.0.0-rc.1"},
+    {:crc, "~> 0.10"},    #=> Needed when using Redis Cluster
+    {:jchash, "~> 0.1.2"} #=> NNeeded when using consistent-hashing
   ]
 end
 ```
 
+In order to give more flexibility and loading only needed dependencies, this
+adapter makes all its dependencies as optional. For example:
+
+  * `:crc` - Required when using the adapter in mode `:redis_cluster`.
+    See [Redis Cluster](https://redis.io/topics/cluster-tutorial).
+  * `:jchash` - Required if you want to use consistent-hashing when using the
+    adapter in mode `:cluster`.
+
 Then run `mix deps.get` in your shell to fetch the dependencies.
 
 ## Usage
@@ -92,7 +102,7 @@ end
 The config:
 
 ```elixir
-config :my_app, MayApp.RedisClusterCache,
+config :my_app, MyApp.RedisClusterCache,
   # Enable redis_cluster mode
   mode: :redis_cluster,
 
@@ -138,31 +148,13 @@ defmodule MyApp.ClusteredCache do
 end
 ```
 
-The Keyslot module using consistent hashing:
-
-```elixir
-defmodule MyApp.ClusteredCache.Keyslot do
-  use Nebulex.Adapter.Keyslot
-
-  @impl true
-  def hash_slot(key, range) do
-    key
-    |> :erlang.phash2()
-    |> :jchash.compute(range)
-  end
-end
-```
-
-And then, within the config:
+The config:
 
 ```elixir
-config :my_app, MayApp.ClusteredCache,
+config :my_app, MyApp.ClusteredCache,
   # Enable client-side cluster mode
   mode: :cluster,
 
-  # Keyslot with consistent hashing
-  keyslot: MyApp.ClusteredCache.Keyslot,
-
   # Nodes config (each node has its own options)
   nodes: [
     node1: [
@@ -191,11 +183,42 @@ config :my_app, MayApp.ClusteredCache,
   ]
 ```
 
-> **NOTE:** It is highly recommendable to provide a consistent hashing
-  implementation for `Nebulex.Adapter.Keyslot`.
+By default, the adapter uses `NebulexRedisAdapter.Cluster.Keyslot` for the
+keyslot. Besides, if `:jchash` is defined as dependency, the adapter will use
+consistent-hashing automatically.
+
+> **NOTE:** It is highly recommended to define the `:jchash` dependency
+  when using the adapter in `:cluster` mode.
+
+However, you can also provide your own implementation by implementing the
+`Nebulex.Adapter.Keyslot` and set it into the `:keyslot` option. For example:
+
+```elixir
+defmodule MyApp.ClusteredCache.Keyslot do
+  use Nebulex.Adapter.Keyslot
+
+  @impl true
+  def hash_slot(key, range) do
+    # your implementation goes here
+  end
+end
+```
+
+And the config:
+
+```elixir
+config :my_app, MyApp.ClusteredCache,
+  # Enable client-side cluster mode
+  mode: :cluster,
+
+  # Provided Keyslot implementation
+  keyslot: MyApp.ClusteredCache.Keyslot,
 
-That's all, the rest of the work is done by **NebulexRedisAdapter**
-automatically.
+  # Nodes config (each node has its own options)
+  nodes: [
+    ...
+  ]
+```
 
 ### Using `Nebulex.Adapters.Dist`
 
@@ -311,7 +334,7 @@ to learn more, see the [benchmarks](./benchmarks) directory.
 To run the benchmarks:
 
 ```
-$ mix deps.get && mix run benchmarks/benchmark.exs
+$ MIX_ENV=test mix run benchmarks/benchmark.exs
 ```
 
 > Benchmarks use default Redis options (`host: "127.0.0.1", port: 6379`).
@@ -329,16 +352,8 @@ When submitting a pull request you should not update the [CHANGELOG.md](CHANGELO
 and also make sure you test your changes thoroughly, include unit tests
 alongside new or changed code.
 
-Before to submit a PR it is highly recommended to run:
-
- * `export NBX_TEST=true` to fetch Nebulex from GH directly and be able to
-   re-use shared tests.
- * `mix coveralls.html && open cover/excoveralls.html` to run tests and check
-   out code coverage (expected 100%).
- * `mix format && mix credo --strict` to format your code properly and find code
-   style issues
- * `mix dialyzer` to run dialyzer for type checking; might take a while on the
-   first invocation
+Before to submit a PR it is highly recommended to run `mix check` and ensure
+all checks run successfully.
 
 ## Copyright and License
 

benchmarks/benchmark.exs

@@ -14,7 +14,7 @@ keys = Enum.to_list(1..10_000)
 bulk = for x <- 1..100, do: {x, x}
 
 # init caches
-Enum.each(1..5000, &BenchCache.set(&1, &1))
+Enum.each(1..5000, &BenchCache.put(&1, &1))
 
 inputs = %{
   "Redis Cache" => BenchCache
@@ -24,23 +24,20 @@ benchmarks = %{
   "get" => fn {cache, random} ->
     cache.get(random)
   end,
-  "set" => fn {cache, random} ->
-    cache.set(random, random)
+  "get_all" => fn {cache, _random} ->
+    cache.get_all([1, 2, 3, 4, 5, 6, 7, 8, 9])
   end,
-  "add" => fn {cache, random} ->
-    cache.add(random, random)
+  "put" => fn {cache, random} ->
+    cache.put(random, random)
+  end,
+  "put_new" => fn {cache, random} ->
+    cache.put_new(random, random)
   end,
   "replace" => fn {cache, random} ->
     cache.replace(random, random)
   end,
-  "add_or_replace!" => fn {cache, random} ->
-    cache.add_or_replace!(random, random)
-  end,
-  "get_many" => fn {cache, _random} ->
-    cache.get_many([1, 2, 3, 4, 5, 6, 7, 8, 9])
-  end,
-  "set_many" => fn {cache, _random} ->
-    cache.set_many(bulk)
+  "put_all" => fn {cache, _random} ->
+    cache.put_all(bulk)
   end,
   "delete" => fn {cache, random} ->
     cache.delete(random)
@@ -54,35 +51,26 @@ benchmarks = %{
   "size" => fn {cache, _random} ->
     cache.size()
   end,
-  "object_info" => fn {cache, random} ->
-    cache.object_info(random, :ttl)
+  "ttl" => fn {cache, random} ->
+    cache.ttl(random)
   end,
   "expire" => fn {cache, random} ->
-    cache.expire(random, 1)
+    cache.expire(random, 1000)
+  end,
+  "incr" => fn {cache, _random} ->
+    cache.incr(:counter, 1)
+  end,
+  "update" => fn {cache, random} ->
+    cache.update(random, 1, &Kernel.+(&1, 1))
   end,
   "get_and_update" => fn {cache, random} ->
     cache.get_and_update(random, fn
       nil -> {nil, 1}
       val -> {val, val * 2}
     end)
   end,
-  "update" => fn {cache, random} ->
-    cache.update(random, 1, &Kernel.+(&1, 1))
-  end,
-  "update_counter" => fn {cache, _random} ->
-    cache.update_counter(:counter, 1)
-  end,
   "all" => fn {cache, _random} ->
     cache.all()
-  end,
-  "transaction" => fn {cache, random} ->
-    cache.transaction(
-      fn ->
-        cache.update(random, 1, &Kernel.+(&1, 1))
-        :ok
-      end,
-      keys: [random]
-    )
   end
 }
 
@@ -92,23 +80,14 @@ Benchee.run(
   before_scenario: fn cache ->
     {cache, Enum.random(keys)}
   end,
-  console: [
-    comparison: false,
-    extended_statistics: true
-  ],
   formatters: [
-    Benchee.Formatters.Console,
-    Benchee.Formatters.HTML
-  ],
-  formatter_options: [
-    html: [
-      auto_open: false
-    ]
+    {Benchee.Formatters.Console, comparison: false, extended_statistics: true},
+    {Benchee.Formatters.HTML, extended_statistics: true, auto_open: false}
   ],
   print: [
     fast_warning: false
   ]
 )
 
 # stop caches s
-if Process.alive?(local), do: BenchCache.stop(local)
+if Process.alive?(local), do: Supervisor.stop(local)

config/test.exs

@@ -10,7 +10,6 @@ config :nebulex_redis_adapter, NebulexRedisAdapter.TestCache.Standalone,
 # Redis test cache
 config :nebulex_redis_adapter, NebulexRedisAdapter.TestCache.Cluster,
   mode: :cluster,
-  keyslot: NebulexRedisAdapter.TestCache.Keyslot,
   nodes: [
     node1: [
       conn_opts: [