smppex

v2.2.1

smppex v2.2.1 SMPPEX.Session behaviour View Source

Module for implementing custom SMPP Session entities.

To implement an Session entitiy, one should implement several callbacks (SMPPEX.Session behaviour). The most proper way to do it is to use SMPPEX.Session:

defmodule MySession do
  use SMPPEX.Session

  # ...Callback implementation

end

In this case all callbacks have reasonable defaults.

Link to this section Summary

Types

from()
reason()
reply()
request()
send_pdu_result()
session()
state()

Functions

call(pid, request, timeout \\ 5000)

Makes a syncronous call to the session

cast(pid, request)

Makes an asyncronous call to Session

code_change(old_vsn, st, extra)

Callback implementation for c:SMPPEX.TransportSession.code_change/3

handle_call(arg, from, st)

Callback implementation for c:SMPPEX.TransportSession.handle_call/3

handle_cast(arg, st)

Callback implementation for c:SMPPEX.TransportSession.handle_cast/2

handle_pdu(arg, st)

Callback implementation for c:SMPPEX.TransportSession.handle_pdu/2

handle_send_pdu_result(pdu, send_pdu_result, st)

Callback implementation for c:SMPPEX.TransportSession.handle_send_pdu_result/3

handle_socket_closed(st)

Callback implementation for c:SMPPEX.TransportSession.handle_socket_closed/1

handle_socket_error(error, st)

Callback implementation for c:SMPPEX.TransportSession.handle_socket_error/2

init(socket, transport, list)

Callback implementation for c:SMPPEX.TransportSession.init/3

reply(from, response)

Replies to a client calling Session.call method

send_pdu(pid, pdu)

Sends a PDU from the session to the peer

stop(pid, reason \\ :normal)

Stops the session syncronously

terminate(reason, st)

Callback implementation for c:SMPPEX.TransportSession.terminate/2

Callbacks

code_change(old_vsn, state, extra)

Invoked to change the state of the session when a different version of a module is loaded (hot code swapping) and the state’s term structure should be changed. The method has the same semantics as the original GenServer.code_change/3 callback

handle_call(request, from, state)

Invoked to handle an arbitrary syncronous request sent to the session with Session.call/3 method

handle_cast(request, state)

Invoked to handle an arbitrary asyncronous request sent to the session with Session.cast/2 method

handle_info(request, state)

Invoked to handle a generic message request sent to the session process

handle_pdu(pdu, state)

Invoked when the session receives an incoming PDU (which is not a response PDU)

handle_resp(pdu, original_pdu, state)

Invoked when the session receives a response to a previously sent PDU

handle_resp_timeout(pdus, state)

Invoked when the session does not receive a response to a previously sent PDU within the specified timeout

handle_send_pdu_result(pdu, send_pdu_result, state)

Invoked when the SMPP session successfully sent PDU to transport or failed to do this

handle_socket_closed(state)

Invoked when the connection is closed by the peer

handle_socket_error(error, state)

Invoked when the connection’s socket reported a error

handle_unparsed_pdu(pdu, error, state)

Invoked when the session receives an incoming PDU which couldn’t be correctly parsed

init(socket, transport, args)

Invoked when a session is started after a connection successfully established

terminate(reason, lost_pdus, state)

Invoked when the session process is about to exit

Link to this section Types

Link to this type from() View Source 
from() :: SMPPEX.TransportSession.from
Link to this type reason() View Source 
reason() :: term
Link to this type reply() View Source 
reply() :: term
Link to this type request() View Source 
request() :: term
Link to this type send_pdu_result() View Source 
send_pdu_result() :: SMPPEX.TransportSession.send_pdu_result
Link to this type session() View Source 
session() :: pid
Link to this type state() View Source 
state() :: term

Link to this section Functions

Link to this function call(pid, request, timeout \\ 5000) View Source 
call(session, request :: term, timeout) :: term

Makes a syncronous call to the session.

The call is handled by handle_call/3 SMPPEX.Session callback.

Link to this function cast(pid, request) View Source 
cast(session, request :: term) :: :ok

Makes an asyncronous call to Session.

The call is handled by handle_cast/2 SMPPEX.Session callback.

Link to this function code_change(old_vsn, st, extra) View Source

Callback implementation for c:SMPPEX.TransportSession.code_change/3.

Link to this function handle_call(arg, from, st) View Source

Callback implementation for c:SMPPEX.TransportSession.handle_call/3.

Link to this function handle_cast(arg, st) View Source

Callback implementation for c:SMPPEX.TransportSession.handle_cast/2.

Link to this function handle_pdu(arg, st) View Source

Callback implementation for c:SMPPEX.TransportSession.handle_pdu/2.

Link to this function handle_send_pdu_result(pdu, send_pdu_result, st) View Source

Callback implementation for c:SMPPEX.TransportSession.handle_send_pdu_result/3.

Link to this function handle_socket_closed(st) View Source

Callback implementation for c:SMPPEX.TransportSession.handle_socket_closed/1.

Link to this function handle_socket_error(error, st) View Source

Callback implementation for c:SMPPEX.TransportSession.handle_socket_error/2.

Link to this function init(socket, transport, list) View Source

Callback implementation for c:SMPPEX.TransportSession.init/3.

Link to this function reply(from, response) View Source 
reply(from, response :: term) :: :ok

Replies to a client calling Session.call method.

This function can be used to explicitly send a reply to a client that called call/3.

from must be the from argument (the second argument) accepted by handle_call/3 callbacks.

The return value is always :ok.

Link to this function send_pdu(pid, pdu) View Source 
send_pdu(session, SMPPEX.Pdu.t) :: :ok

Sends a PDU from the session to the peer.

Link to this function stop(pid, reason \\ :normal) View Source

Stops the session syncronously.

Link to this function terminate(reason, st) View Source

Callback implementation for c:SMPPEX.TransportSession.terminate/2.

Link to this section Callbacks

Link to this callback code_change(old_vsn, state, extra) View Source 
code_change(old_vsn :: term | {:down, term}, state, extra :: term) ::
  {:ok, state} |
  {:error, reason}

Invoked to change the state of the session when a different version of a module is loaded (hot code swapping) and the state’s term structure should be changed. The method has the same semantics as the original GenServer.code_change/3 callback.

Link to this callback handle_call(request, from, state) View Source 
handle_call(request, from, state) ::
  {:reply, reply, state} |
  {:reply, reply, [SMPPEX.Pdu.t], state} |
  {:noreply, state} |
  {:noreply, [SMPPEX.Pdu.t], state} |
  {:stop, reason, reply, state} |
  {:stop, reason, state}

Invoked to handle an arbitrary syncronous request sent to the session with Session.call/3 method.

from argument can be used to send a response asyncronously via Session.reply/2.

The returned values indicate the following:

  • {:reply, reply, state} — reply with reply and use state as the new state;
  • {:reply, reply, pdus, state} — reply with reply, use state as the new state and additionally send pdus to the peer;
  • {:noreply, state} — do not reply and use state as the new state. The reply can be send later via Session.reply;
  • {:noreply, pdus, state} — do not reply, use state as the new state and additionally send pdus to the peer. The reply can be send later via Session.reply;
  • {:stop, reason, reply, state} — reply with reply, use state as the new state and exit with reason;
  • {:stop, reason, state} — do not reply, use state as the new state and exit with reason.
Link to this callback handle_cast(request, state) View Source 
handle_cast(request, state) ::
  {:noreply, state} |
  {:noreply, [SMPPEX.Pdu.t], state} |
  {:stop, reason, state}

Invoked to handle an arbitrary asyncronous request sent to the session with Session.cast/2 method.

The returned values indicate the following:

  • {:noreply, state} — use state as the new state;
  • {:noreply, pdus, state} — use state as the new state and additionally send pdus to the peer.;
  • {:stop, reason, state} — use state as the new state and exit with reason.
Link to this callback handle_info(request, state) View Source 
handle_info(request, state) ::
  {:noreply, state} |
  {:noreply, [SMPPEX.Pdu.t], state} |
  {:stop, reason, state}

Invoked to handle a generic message request sent to the session process.

The returned values indicate the following:

  • {:noreply, state} — use state as the new state;
  • {:noreply, pdus, state} — use state as the new state and additionally send pdus to the peer.;
  • {:stop, reason, state} — use state as the new state and exit with reason.
Link to this callback handle_pdu(pdu, state) View Source 
handle_pdu(pdu :: SMPPEX.Pdu.t, state) ::
  {:ok, state} |
  {:ok, [SMPPEX.Pdu.t], state} |
  {:stop, reason, state}

Invoked when the session receives an incoming PDU (which is not a response PDU).

The callback return values indicate the following:

  • {:ok, state} — use state as the new session state;
  • {:ok, pdus, state} — use state as the new session state and additionally send pdus to the connection;
  • {:stop, reason, state} — stop with reason reason and use state as the new session state.
Link to this callback handle_resp(pdu, original_pdu, state) View Source 
handle_resp(pdu :: SMPPEX.Pdu.t, original_pdu :: SMPPEX.Pdu.t, state) ::
  {:ok, state} |
  {:ok, [SMPPEX.Pdu.t], state} |
  {:stop, reason, state}

Invoked when the session receives a response to a previously sent PDU.

pdu argument contains the received response PDU, original_pdu contains the previously sent pdu for which the handled response is received.

The callback return values indicate the following:

  • {:ok, state} — use state as the new session state;
  • {:ok, pdus, state} — use state as the new session state and additionally send pdus to the connection;
  • {:stop, reason, state} — stop with reason reason and use state as the new session state.
Link to this callback handle_resp_timeout(pdus, state) View Source 
handle_resp_timeout(pdus :: [SMPPEX.Pdu.t], state) ::
  {:ok, state} |
  {:ok, [SMPPEX.Pdu.t], state} |
  {:stop, reason, state}

Invoked when the session does not receive a response to a previously sent PDU within the specified timeout.

pdu argument contains the PDU for which no response was received. If the response will be received later it will be dropped (with an info log message).

The callback return values indicate the following:

  • {:ok, state} — use state as the new session state;
  • {:ok, pdus, state} — use state as the new session state and additionally send pdus to the connection;
  • {:stop, reason, state} — stop with reason reason and use state as the new session state.
Link to this callback handle_send_pdu_result(pdu, send_pdu_result, state) View Source 
handle_send_pdu_result(pdu :: SMPPEX.Pdu.t, send_pdu_result, state) :: state

Invoked when the SMPP session successfully sent PDU to transport or failed to do this.

pdu argument contains the PDU for which send status is reported. send_pdu_result can be either :ok or {:error, reason}.

The returned value is used as the new state.

Link to this callback handle_socket_closed(state) View Source 
handle_socket_closed(state) :: {exit_reason :: term, state}

Invoked when the connection is closed by the peer.

The returned value should be {reason, state}. The session stops then with reason.

Link to this callback handle_socket_error(error, state) View Source 
handle_socket_error(error :: term, state) :: {exit_reason :: term, state}

Invoked when the connection’s socket reported a error.

The returned value should be {reason, state}. The session stops then with reason.

Link to this callback handle_unparsed_pdu(pdu, error, state) View Source 
handle_unparsed_pdu(pdu :: RawPdu.t, error :: term, state) ::
  {:ok, state} |
  {:ok, [SMPPEX.Pdu.t], state} |
  {:stop, reason, state}

Invoked when the session receives an incoming PDU which couldn’t be correctly parsed.

The callback return values indicate the following:

  • {:ok, state} — use state as the new session state;
  • {:ok, pdus, state} — use state as the new session state and additionally send pdus to the connection;
  • {:stop, reason, state} — stop with reason reason and use state as the new session state.
Link to this callback init(socket, transport, args) View Source 
init(socket :: SMPPEX.TransportSession.socket, transport :: SMPPEX.TransportSession.transport, args :: term) ::
  {:ok, state} |
  {:stop, reason}

Invoked when a session is started after a connection successfully established.

args argument is taken directly from ESME.start_link or MC.start call. The return value should be either {:ok, state}, then the session will successfully start and the returned state will be later passed to the other callbacks, or {:stop, reason}, then the session will stop with the returned reason.

Link to this callback terminate(reason, lost_pdus, state) View Source 
terminate(reason, lost_pdus :: [SMPPEX.Pdu.t], state) ::
  :stop |
  {:stop, [SMPPEX.Pdu.t], state}

Invoked when the session process is about to exit.

lost_pdus contain a list of nonresp pdus sent by the session to the peer and which have not yet received a response.

The returned value is ignored.

This callback is called from the underlying GenServer terminate callbacks, so it has all the corresponding caveats, see GenServer.terminate/2 docs.