     end
   end
 
-  # payload management, mimicking a GenServer by using directly the callback
-  def call(server, action) do
-    case get_ring(server) do
-      {:ok, ring} -> do_call(ring, action)
-    end
-  end
-
-  defp do_call(ring, action) do
-    payload = ring.payload
-    up_load = fn(load) -> update_payload(ring, load) end
-    case ring.callback.handle_call(action, self(), payload) do
-      {:reply, reply, new} -> {:reply, reply, up_load.(new)}
-      {:reply, reply, new, timeout} -> {:reply, reply, up_load.(new), timeout}
-      {:noreply, new} -> {:noreply, up_load.(new)}
-      {:noreply, new, timeout} -> {:noreply, up_load.(new), timeout}
-      {:stop, reason, reply, new} -> {:stop, reason, reply, up_load.(new)}
-      {:stop, reason, new} -> {:stop, reason, up_load.(new)}
-    end
-  end
-
-  def cast(server, action) do
-    case get_ring(server) do
-      {:ok, ring} -> do_cast(ring, action)
-    end
-  end
-  
-  defp do_cast(ring, action) do
-    payload = ring.payload
-    up_load = fn(load) -> update_payload(ring, load) end
-    case ring.callback.handle_cast(action, payload) do
-      {:noreply, new} -> {:noreply, up_load.(new)}
-      {:noreply, new, timeout} -> {:noreply, up_load.(new), timeout}
-      {:stop, reason, new} -> {:stop, reason, up_load.(new)}
-    end
-  end
-
-  def reply(client, term) do
-    send(client, term)
-    :ok
-  end
+  # payload management, mimicking a GenServer
+  def call(server, action), do: GenServer.call(server, action)
+
+  def cast(server, action), do: GenServer.cast(server, action)
+
+  def reply(client, term), do: GenServer.reply(server, term)
 
   # cluster_management
   # we have to stop all nodes

  defp merge(nil, crdt), do: crdt
  defp merge(crdt, crdt), do: crdt
  defp merge(crdt1, crdt2), do: Crdtex.merge(crdt1, crdt2)

end

    end
  end
  def handle_cast(other, ring) do
    payload = ring.payload
    up_load = fn(load) -> update_payload(ring, load) end
    case ring.callback.handle_cast(other, payload) do
      {:noreply, new} -> {:noreply, up_load.(new)}
      {:noreply, new, timeout} -> {:noreply, up_load.(new), timeout}
      {:stop, reason, new} -> {:stop, reason, up_load.(new)}
    end
  end

  def handle_info(:send_gossip, %GenServerring{node_set: node_set} = ring) do
