/**
Distributed TCP/IP Client-Server Networking Example
The TCP networking predicates
are primarily intended for internal , i.e. DLP run-time system
use only. The primitives are used in the current DLP run-time system to
implement a high-level distributed communication framework.
However, occasionally it will be useful to implement a dedicated
distributed communication infrastructure.
The following source code example illustrates how TCP predicates
can be used to build special purpose distributed processing
systems in DLP itself.
The program example consists of two objects: pxserver and pxclient.
Object pxserver is used as a stand-alone program;
once invoked by a "dlp pxserver" command, it will handle multiple
pxclient connections. Each client connection will be processed
by a separate pxserver thread. When client programs
run in a browser, the
server should run on the same machine from which the client code is
loaded. This is the only way to connect a client to a server without
changing the access policy of a browser. See the Java
policy tool
documentation. No need to say that you should check the current firewall
settings of the workstations used for a particular distributed processing
problem.
Server execution :
- invocation of a pxserver object as a stand-alone program
results in the exectution of method main.
- method main creates a server socket handle ServerSocket
by means of the library built-in tcp_server and creates a new
active pxserver object. A ServerSocket is
unique for a particular port / machine combination.
- an active pxserver object invokes tcp_accept : the
current active pxserver thread will block until a client
invokes a tcp_client method.
- after accepting a connection, a ServerStreamIn and ServerStreamOut
is returned as well as the ClientHostName of the client.
The ServerStreamIn is connected to a ClientStreamOut
and a ServerStreamOut is connected to a ClientStreamIn.
- the server starts a new active pxserver thread that will
handle the next client connection after which it starts its own
server loop :
- the server loop reads an arbitrary term from ServerStreamIn
by means of tcp_get_term and processes the received information.
- an answer is sent back to the client : tcp_put_term writes a
ServerReply term to ServerStreamOut.
**/
:-object pxserver.
var port = 4321.
main :-
tcp_server(port, ServerSocket),
format('Server ~w : socket = ~w~n', [this, ServerSocket]),
new(pxserver(ServerSocket), _),
format('end of ~w main~n', [this]).
pxserver(ServerSocket) :-
server_init(ServerSocket, ServerStreamIn, ServerStreamOut),
server_loop(ServerStreamIn, ServerStreamOut).
server_init(ServerSocket, ServerStreamIn, ServerStreamOut) :-
tcp_accept(ServerSocket, ServerStreamIn, ServerStreamOut, ClientHostName),
format('Server ~w : accepting new client connection from ~w~n',
[this, ClientHostName]),
new(pxserver(ServerSocket), _).
server_loop(ServerStreamIn, ServerStreamOut) :-
repeat,
tcp_get_term(ServerStreamIn, ClientRequest),
process_mesg(ClientRequest, ServerReply),
tcp_put_term(ServerStreamOut, ServerReply),
ServerReply = thread_shutdown,
!,
tcp_close(ServerStreamIn),
tcp_close(ServerStreamOut).
process_mesg(Input, Reply) :-
format('Server ~w : tcp get = ~w~n', [this, Input]),
message_type(Input, Reply),
format('Server ~w : tcp put = ~w~n', [this, Reply]).
message_type(mul_int(I0,I1), ReplyTerm) :-
integer(I0),
integer(I1),
!,
IR is I0 * I1,
ReplyTerm = mul_val(IR).
message_type(InputTerm, ReplyTerm) :-
InputTerm = [client, [_]],
!,
ReplyTerm = [server, [ServerHost]],
local_host(ServerHost, _).
message_type(client_shutdown, thread_shutdown) :- !,
format('~nServer Thread ~w shutdown~n~n', [this]).
message_type(shutdown, thread_shutdown) :-
!.
message_type(Input, Reply) :-
Reply = unknown_message_type(Input).
:-end_object pxserver.
/**
A pxclient object can execute as a stand-alone client or
can execute in a browser.
Typically, several active pxclient objects will connect
to a single multi-threaded pxserver object simultaneously.
In case one or more pxclient objects are running in a browser
on different machines, the pxserver should run on the same
machine from which the pxclient code is loaded.
**/
:-object pxclient.
var port = 4321, loop = 5 .
main :-
text_area(BrowserTextArea),
set_output(BrowserTextArea),
code_base_host(ServerHost),
pxclient(ServerHost, port),
format('end of ~w main~n', [this]).
pxclient(ServerHost, ServerPort) :-
format('Code base host = ~w~n', [ServerHost]),
tcp_client(ServerHost, ServerPort, 10, StreamIn, StreamOut),
format('client socket = ~w, ~w~n', [StreamIn,StreamOut]),
client_init(StreamIn, StreamOut),
client_loop(StreamIn, StreamOut),
client_exit(StreamIn, StreamOut),
tcp_close(StreamIn),
tcp_close(StreamOut).
client_init(StreamIn, StreamOut) :-
local_host(ClientHost, _),
%% ClientHost = localhost,
format('Client host = ~w~n', [ClientHost]),
tcp_put_term(StreamOut, [client, [ClientHost]]),
tcp_get_term(StreamIn, OK),
format('server answer = ~w~n', [OK]).
client_loop(StreamIn, StreamOut) :-
repeat,
ServerInput = mul_int(loop, 100),
format('Client ~w : tcp put = ~w~n', [this, ServerInput]),
tcp_put_term(StreamOut, ServerInput),
tcp_get_term(StreamIn, ServerReply),
format('Client ~w : tcp get = ~w~n', [this, ServerReply]),
-- loop,
loop =:= 0,
!.
client_exit(StreamIn, StreamOut) :-
tcp_put_term(StreamOut, client_shutdown),
tcp_get_term(StreamIn, thread_shutdown).
:-end_object pxclient.
/**
Another (somewhat unusual) example of running the client - server objects
is shown below. When the object pxsock is executed by means of a
"dlp pxsock" command, it will create an active
pxserver as well as several active pxclient
threads. These active threads will communicate within the context of a
single program by means of the established socket connections.
**/
:-object pxsock.
var port = 4321.
main :-
tcp_server(port, Socket),
local_host(Host, _),
new(pxserver(Socket), _), %% server thread
new(pxclient(Host,port), _), %% client thread 1
new(pxclient(Host,port), _), %% client thread 2
new(pxclient(Host,port), _), %% client thread 3
format('end of ~w main~n', [this]).
:-end_object pxsock.
/**
**/