 	  # TODO: preserve counter
     File.rm(ring_path)
     :init.stop()
-    {:noreply,s}
+    {:noreply, s}
+  end
+  def handle_info(other, ring) do
+    up_load = fn(load) -> update_payload(ring, load) end
+    case ring.callback.handle_info(other, ring.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
 
   # small utilities functions

    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

  # cluster_management
  # we have to stop all nodes

    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
