Encode config values with Keyset

lib/cluster_config.ex

···
 defmodule Hobbes.ClusterConfig do
   alias Hobbes.ClusterConfig
+  alias Hobbes.Encoding.Keyset
 
   import Hobbes.Utils
 
   @type t :: %__MODULE__{
+    num_replicas: pos_integer,
     num_begin_buffers: pos_integer,
     num_commit_buffers: pos_integer,
     num_tlog_teams: pos_integer,
     num_storage_teams: pos_integer,
+    initial_shards: [binary],
   }
   @defaults [
+    num_replicas: 3,
     num_begin_buffers: 1,
     num_commit_buffers: 3,
     num_tlog_teams: 1,
     num_storage_teams: 2,
+    initial_shards: [""],
   ]
   @keys Enum.map(@defaults, fn {k, _v} -> k end)
 
···
       key = coordinator_config_prefix() <> Atom.to_string(k)
 
       case List.keyfind(pairs, key, 0) do
-        {^key, value} -> {k, String.to_integer(value)}
+        {^key, value} -> {k, hd(Keyset.unpack(value))}
         nil -> {k, v}
       end
     end)
···
       value = Map.fetch!(config, k)
       {
         coordinator_config_prefix() <> Atom.to_string(k),
-        Integer.to_string(value),
+        Keyset.pack([value]),
       }
     end)
   end

lib/hobbes.ex

···
 
     config = ClusterConfig.from_opts(opts)
     config_pairs = ClusterConfig.to_pairs(config)
-    initial_shards_pairs = Keyword.get(opts, :initial_shards, [""]) |> Enum.map(fn k -> {"config/initial_shards/" <> k, ""} end)
-    :ok = Coordinator.write(hd(coordinators), config_pairs ++ initial_shards_pairs)
+    :ok = Coordinator.write(hd(coordinators), config_pairs)
 
     {
       :ok,

lib/servers/manager.ex

···
   end
 
   defp load_config(pairs) when is_list(pairs) do
-    initial_shards =
-      Enum.reduce(pairs, [], fn
-        {"config/initial_shards/" <> shard_key, ""}, acc -> [shard_key | acc]
-        {_, _}, acc -> acc
-      end)
-      |> Enum.reverse()
-
     fields =
       ClusterConfig.from_pairs(pairs)
       |> Map.from_struct()
-      |> Map.put(:initial_shards, initial_shards)
-      |> Map.put(:num_replicas, 3)
     struct!(Config, fields)
   end