ex_nsq v1.1.0 NSQ.Connection

Sets up a TCP connection to NSQD. Both consumers and producers use this.

Link to this section Summary

Types

A tuple with a string ID (used to target the connection in NSQ.Connection.Supervisor) and a PID of the connection

host_with_port()

A tuple with a host and a port

state()

A map, but we can be more specific by asserting some entries that should be set for a connection’s state map

Functions

close(conn, conn_state \\ nil)

cmd(conn_pid, cmd, timeout \\ 5000)

Calls the command and waits for a response. If a command shouldn’t have a response, use cmd_noresponse

cmd_noresponse(conn, cmd)

Calls the command but doesn’t expect any response. This is important if the NSQ command does not in fact generate a response. If you use cmd and a response is sent, it will live forever in the command queue

handle_call(arg1, from, state)

handle_cast(atom, state)

handle_info(arg, state)

init(conn_state)

start_link(parent, nsqd, config, topic, channel, conn_info_pid, event_manager_pid, opts \\ [])

terminate(reason, state)

Link to this section Types

connection()

connection() :: {String.t, pid}

A tuple with a string ID (used to target the connection in NSQ.Connection.Supervisor) and a PID of the connection.

host_with_port()

host_with_port() :: {String.t, integer}

A tuple with a host and a port.

state()

state() :: %{parent: pid, config: NSQ.Config.t, nsqd: host_with_port}

A map, but we can be more specific by asserting some entries that should be set for a connection’s state map.

Link to this section Functions

close(conn, conn_state \\ nil)

close(pid, state) :: any

cmd(conn_pid, cmd, timeout \\ 5000)

cmd(pid, tuple, integer) ::
  {:ok, binary} |
  {:error, String.t}

Calls the command and waits for a response. If a command shouldn’t have a response, use cmd_noresponse.

cmd_noresponse(conn, cmd)

cmd_noresponse(pid, tuple) ::
  {:ok, reference} |
  {:queued, :nosocket}

Calls the command but doesn’t expect any response. This is important if the NSQ command does not in fact generate a response. If you use cmd and a response is sent, it will live forever in the command queue.

get_state(pid)

get_state(pid) :: {:ok, state}

get_state(connection) :: {:ok, state}

handle_call(arg1, from, state)

handle_call({:cmd, tuple, atom}, {pid, reference}, state) ::
  {:reply, {:ok, reference}, state} |
  {:reply, {:queued, :nosocket}, state}

handle_call(:stop, {pid, reference}, state) :: {:stop, :normal, state}

handle_call(:state, {pid, reference}, state) :: {:reply, state, state}

handle_call({:nsq_msg, binary}, {pid, reference}, state) :: {:reply, :ok, state}

handle_cast(atom, state)

handle_cast(:flush_cmd_queue, state) :: {:noreply, state}

handle_cast(:reconnect, state) :: {:noreply, state}

handle_info(arg, state)

handle_info({reference, {:message_done, NSQ.Message.t, any}}, state) :: {:noreply, T.conn_state}

init(conn_state)

init(state) :: {:ok, state}

start_link(parent, nsqd, config, topic, channel, conn_info_pid, event_manager_pid, opts \\ [])

terminate(reason, state)