JN Signalling Processing Unit
Applicata JN Signalling Processing Unit (SPU) is a software-only implementation of signalling layer interface for applications/services/nodes running in SS7 and/or Evolved Packet Core Networks. It covers SS7, SIP† and DIAMETER protocols

1. Home
2. Products for GSM/UMTS Networks
3. JN Signalling Processing Unit

The Importance of Separation of Signalling and Application Planes

Non-Distributed
Architectures

Services and applications running in GSM, IMS and EPC networks require signalling protocol stacks. Embedding the stacks in the same process where the application runs is a solution that follows a non-distributed architecture.
.

A non-distributed architecture where the signalling and application planes are not separated has disadvantages, including limited scalability and performance capabilities, and higher costs in case of scaling by multiplying protocol layer licenses.

Applicata JN Signalling Processing Unit

Applicata JN SPU offers a cost effective and feature reach signalling solution with integrated protocol stacks, configuration and monitoring, rate control, message dispatching, very high performance, easy integration, network virtualisation, service high availability and scalability

Operation, Administration and Monitoring Interface

JN SPU Usage Examples

The usage of JN SPU from Erlang and Python 3 via corresponding language specific SPU Signalling Interface libraries is illustrated below.

Diameter 'Update-Location-Request' and 'Update-Location-Answer' belonging to Diameter S6ad application are included in the examples.

Erlang Example

-module(spu_test).
-compile(export_all).
-mode(compile).

main([]) ->
    {ok, S1} = gen_tcp:connect({127,0,0,1}, 9001, [{packet,2}
                                                   ,binary
                                                   ,{active, true}]),
    ok = gen_tcp:send(S1, registration(<<"realm1">>)),
    io:format("S1 RCV: ~p~n", [receive_message(S1)]),

    {ok, S2} = gen_tcp:connect({127,0,0,1}, 9001, [{packet,2}
                                                  ,binary
                                                  ,{active, true}]),
    ok = gen_tcp:send(S2, registration(<<"realm2">>)),
    io:format("S2 RCV: ~p~n", [receive_message(S2)]),

    ok = gen_tcp:send(S1, ulr(xxx)),
    {diameter, {request, s6ad, TID1, ULR}} = receive_message(S2),
    io:format("ULR(~p) ~p~n", [binary_to_term(TID1), ULR]),

    ok = gen_tcp:send(S2, ula(TID1)),
    {diameter, {answer, s6ad, OTID1, ULA}} = receive_message(S1),
    io:format("ULA(~p): ~p~n", [OTID1, ULA]),

receive_message(S) ->
    receive
        {tcp, S, Message} -> binary_to_term(Message)
    end.


registration(Realm) ->
    Registration = [{protocols, [{diameter, [{application, s6ad}
                                            ,{origin, Realm}
                                            ]}]}],
    term_to_binary({spu, {user, {register, Registration}}}).
            

Python 3 Example

import asyncio
import struct
import datetime
import time

from spuapi.transp import conn
from spuapi.prot import term
'''
...
'''
async def ulrula_task(loop):
    srv_ip = "127.0.0.1"
    srv_port1 = "9001"
    srv_port2 = "9001"
    connect_timeout = 4

    conn1 = conn.SPUConnection(srv_ip, srv_port1, loop, connect_timeout)
    await conn1.connect()
    print(" SPU connecttion 1 established")

    conn2 = conn.SPUConnection(srv_ip, srv_port2, loop, connect_timeout)
    await conn2.connect()
    print(" SPU connecttion 2 established")

    apps = ['s6ad']
    await spu_register(b'User1', apps, [b'realm1'], conn1)
    print(" User1 registered")
    await spu_register(b'User2', apps, [b'realm2'], conn2)
    print(" User2 registered")

    try:
        await asyncio.sleep(0.5)

        sess_id, tid, ulr_buff = dia_ulr_request(b'1111',
                                                 b'spu.realm1', b'realm1',
                                                 b'realm2')
        await conn1.send(ulr_buff)
        print(" ULR sent")

        rulr_buff = await conn2.recv(5)

        sess_id, tid_ula, ula_buff = dia_ula_answer(rulr_buff,
                                                    b'spu.realm2', b'realm2')

        await conn2.send(ula_buff)
        print(" ULA sent")

        ula_buff = await conn1.recv(5)
        print(" ULA received")
        ex = term.decode(ula_buff)
        (adiameter, (aanswer, as6ad, tid_rsp, data)) = ex
        assert tid_rsp == tid
    except asyncio.TimeoutError:
        print(" Receive Timeout exception")
    finally:
        await spu_unregister(conn1)
        print(" User1 unregistered")
        await spu_unregister(conn2)
        print(" User2 unregistered")


def run():
    loop = asyncio.get_event_loop()
    try:
        print("\nStart ULR-ULA task")
        task_coro = asyncio.ensure_future(ulrula_task(loop), loop=loop)
        loop.run_until_complete(task_coro)
        print("Finish ULR-ULA task successfully")
    except:
        print("ULR-ULA task error")
    loop.stop

if __name__ == "__main__":
    run()