BINETIX NETWORK

Each node of BINETIX's Advanced Grid Environment (AGE) has a special communication layer managed by set of system modules named "The Gateway".

This Gateway orchestrates the entire connectivity between the Node and "the rest of the world" by various functionality which includes but it is not limited to:

✓Overall administration and automation of communication channels;

✓Control of the Node's system communication with other nodes connected to AGE;

✓Control of the Node's services communication with external services via TCP/SSL, UDP and SCTP;

✓Active monitoring of all inbound and outbound connections (called "links");

✓Uni- or Bidirectional routing of the exchanged data over the links.

You can use the Gateway API to create your own software to work as SaaS into AGE's ecosystem.

For example, this API with "age_net" and other toolkits were actively used during the development of the following services:

•FTP Server (File Service)

•SMTP Server (Mail Service)

•IMAP Server (Mail Service)

•XMPP Server (Chat and Presentation) (still under development)

The Gateway has its own Router, Load Balancer and Firewall. These system entities are specifically designed to work in the heart of each AGE Node as a part of AGE's ecosystem. Despite the similarities, this functionality has nothing to do with other external software, like a firewall of the Operating system, for example. However, AGE itself doesn't operate in vacuum. Of course, it is working under an Operating system and any communication outside of the AGE's ecosystem needs to be managed by the tools and the rules of the respective OS.

       Gateway Router

       Gateway Load-Balancer

       Gateway Firewall

-define(GATEWAY_ROUTER_TIMEOUT,                 4567).

-define(GATEWAY_FIREWALL_PROTOCOL_DEFAULT,      unknown).

-define(GATEWAY_FIREWALL_RULES_DEFAULT,         [incoming, outgoing]).

-define(GATEWAY_FIREWALL_STATE_DEFAULT,         enabled).

-type age_net_hostname()                        :: atom() | string().

-type age_ip4_address()                         :: {0..255, 0..255, 0..255, 0..255}.

-type age_ip6_address()                         :: {0..65535, 0..65535, 0..65535, 0..65535, 0..65535, 0..65535, 0..65535, 0..65535}.

% @type age_route_type() = listener | observer | inbound | outbound

-type(age_net_route()                           :: listener | observer | inbound | outbound).

% @type age_protocol_address() = string()

-type(age_net_address()                         :: age_ip4_address() | age_ip6_address()).

% @type age_protocol_port() = integer()

-type(age_net_port()                            :: 0..65535).

% @type age_route() = {age_route, pid(), any(), age_net_route(), age_net_address(), integer(), age_net_address(), integer(), list(tuple()), age_time_stamp(), pid()}

-type(age_route() :: {age_route, pid(), any(), age_net_route(), age_net_address(), integer(), age_net_address(), integer(), list(tuple()), age_time_stamp(), pid()}).

-record(age_route, {

  % Connection PID /mandatory/

  pid                                           :: pid(),

  % Target identifier.

  target = undefined                            :: age_node() | any(),

  % Handler type

  type                                          :: age_net_route(),

  % Connection local address

  local_address                                 :: age_net_address(),

  % Connection local port

  local_port                                    :: age_net_port(),

  % Connection remote address

  remote_address                                :: age_net_address(),

  % Connection remote port

  remote_port                                   :: age_net_port(),

  % Socket statistics

  stats = []                                    :: list(tuple()),

  % Last update stamp

  stamp = {0, 0, 0}                             :: age_time_stamp(),

  % Process which receives messages from the socket

  owner                                         :: pid() | atom()

}).

% @type age_firewall_protocol() = tcp | sctp | udp | unknown

-type(age_firewall_protocol()                   :: tcp | sctp | udp | unknown).

% @type age_firewall_rule() = incoming | outgoing | server | {connect, Server} | sustain

-type(age_firewall_rule()                       :: incoming | outgoing | server | sustain).

% @type age_firewall_state() = enabled | disabled

-type(age_firewall_state()                      :: enabled | disabled).

% @type age_firewall() = {age_firewall, integer(), age_firewall_protocol(), age_firewall_state(), list(age_firewall_rule()), list(atom()), list(atom() | tuple()), age_time_stamp(), tuple()}

-record(age_firewall, {

  % Gateway connection port if the type is server or system

  port = 0                                      :: integer(),

  % Gateway standard connection protocol

  protocol = ?GATEWAY_FIREWALL_PROTOCOL_DEFAULT :: age_firewall_protocol(),

  % Operational status

  state = ?GATEWAY_FIREWALL_STATE_DEFAULT       :: age_firewall_state(),

  % Rules restrictions

  rules = ?GATEWAY_FIREWALL_RULES_DEFAULT       :: list(age_firewall_rule()),

  % Connection (Socket) options

  options = []                                  :: list(atom() | tuple()),

  % Time stamp of the last update

  stamp = {0, 0, 0}                             :: age_time_stamp(),

  % Schedule plan. *** Reserved for future use

  schedule                                      :: tuple()

}).

add_rule/5

add_tcp_rule/3

add_udp_rule/3

add_sctp_rule/3

delete_rule/1

enable_rule/1

disable_rule/1

update_rule/2

get_rule/1

list_rules/1

is_rule_enabled/1

connect/3

link/3

unlink/1

unlink/2

link_info/1

mark_link/2

mark_links/3

list_links/1

list/3

send/2