Esempio di una semplice applicazione

La seguente applicazione realizzata con le tre tecniche di comunicazione (Socket, RPC, RMI) consiste in un server che
può fornire due tipi di servizi a un client che si connette ad esso: la data e l'ora di sistema. Il seguente esempio ha
l'obiettivo di mostrare quanto detto nel paragrafo 1.3, senza badare ad ulteriori dettagli implementativi.

Socket

Implementazione del client (Client.java):

import java.io.*;
import java.net.*;

public class Client

{
public static void main( String[] args ) throws IOException
{
Socket socket = null;
PrintStream out = null;
DataInputStream in = null;
String server = "127.0.0.1";

try {
socket = new Socket( server, 4321 );
out = new PrintStream( socket.getOutputStream() );
in = new DataInputStream( socket.getInputStream() );
}
catch( UnknownHostException e )
{
System.err.println("Impossibile collegarsi al server " + server );
System.exit(1);
}
catch( IOException e )
{
System.err.println( "Impossibile comunicare con il server " + server );
System.exit(1);
}

DataInputStream stdIn = new DataInputStream( System.in );

String fromServer;
String fromUser;

while( ( fromServer = in.readLine() ) != null )

{
System.out.println( "Server: " + fromServer );
if( fromServer.equals( "fine collegamento" ) ) break;

System.out.print( "> " );

fromUser = stdIn.readLine();
if( fromUser != null )
{
System.out.println("Client: " + fromUser);
out.println(fromUser);
}
}

out.close();
in.close();
stdIn.close();
socket.close();
}
}
Implementazione del server (Server.java):

import java.net.*;
import java.io.*;

public class Server

{
public static void main(String[] args) throws IOException
{
int porta = 4321;
ServerSocket serverSocket = null;

try {
serverSocket = new ServerSocket( porta );
}
catch (IOException e)
{
System.err.println( "Impossibile ascoltare sulla porta " + porta );
System.exit(1);
}

Socket clientSocket = null;

try {
clientSocket = serverSocket.accept();
}
catch (IOException e)
{
System.err.println( "Impossibile accettare il collegamento" );
System.exit(1);
}

PrintStream out = new PrintStream( new BufferedOutputStream(

clientSocket.getOutputStream(), 1024), false);
DataInputStream in = new DataInputStream( new BufferedInputStream(
clientSocket.getInputStream() ) );
String inputLine, outputLine;
Protocol p = new Protocol();

outputLine = p.processaInput(null);
out.println(outputLine);
out.flush();

while( (inputLine = in.readLine() ) != null)

{
outputLine = p.processaInput(inputLine);
out.println(outputLine);
out.flush();
if (outputLine.equals("fine collegamento") ) break;
}

out.close();
in.close();
clientSocket.close();
serverSocket.close();
}
}
Implementazione del protocollo di comunicazione (Protocol.java):

import java.net.*;
import java.io.*;
import java.util.Date;
import java.text.*;

public class Protocol

{
private boolean collegato = false;

public String processaInput( String input )

{
String output = null;

if( !collegato )
{
output = "pronto a ricevere richieste";
collegato = true;
}
else
{
if( input.equalsIgnoreCase("DATA"))
output = "" + DateFormat.getDateInstance().format( new Date() );
else if( input.equalsIgnoreCase("ORA"))
output = "" + DateFormat.getTimeInstance().format( new Date() );
else
output = "fine collegamento";
}

return output;
}
}
RPC (High Level RPC)

File include con le definizioni comuni per l'applicazione RPC (DOra.h)

#define REPLY_SIZE 256

#define DORAPROG ((u_long) 0x20000008)
#define DORAVERS ((u_long) 1)
#define READDATA ((u_long) 1)
#define READORA ((u_long) 2)

Implementazione delle routine di conversione condivise dal client e dal server (RDOra_xdr.c)

#include <rpc/rpc.h>
#include "rdora.h"

bool_t xdr_data( XDR *xdrs, char *objp )

{
return xdr_string( xdrs, &objp, REPLY_SIZE );
}

bool_t xdr_ora( XDR *xdrs, char *objp )

{
return xdr_string( xdrs, &objp, REPLY_SIZE );
}

Implementazione del server (RDOra_svc.c)

#include <rpc/rpc.h>
#include "rdora.h"

void main( void )

{
extern bool_t xdr_data();
extern bool_t xdr_ora();
extern char *read_data();
extern char *read_ora();

registerrpc( DORAPROG, DORAVERS, READDATA, read_data, xdr_data, xdr_data );

registerrpc( DORAPROG, DORAVERS, READORA, read_ora, xdr_ora, xdr_ora );

svc_run();
}

Implementazione della funzione che restituisce la data locale al server (Read_Data.c)

#include <stdio.h>
#include <time.h>
#include "rdora.h"

read_data( char *data )

{
struct tm *ptr;
time_t lt;

lt = time( NULL );
ptr = localtime( &lt );

data[0] = '\0';

sprintf( data, "%d/%d/%d", ptr->tm_mday, ptr->tm_mon, 1900 + ptr->tm_year );

return (int)data;
}
Implementazione della funzione che restituisce l'ora locale al server (Read_Ora.c)
#include <stdio.h>
#include <time.h>
#include "rdora.h"

read_ora( char *ora )

{
struct tm *ptr;
time_t lt;

lt = time( NULL );
ptr = localtime( &lt );

ora[0] = '\0';

sprintf( ora, "%d.%d.%d", ptr->tm_hour, ptr->tm_min, ptr->tm_sec );

return (int)ora;
}

Implementazione del client RPC (RDora.c)

#include <stdio.h>
#include <string.h>
#include <rpc/rpc.h>

#include "rdora.h"

int main( int argc, char *argv[] )

{
char inputTastiera[REPLY_SIZE];

printf("> ");
scanf( "%s", &inputTastiera );
while(1)
{
if( strcmp( inputTastiera, "ora" ) == 0 )
{
char ora[REPLY_SIZE];
read_ora( argv[1], ora );
printf( "Server: %s\n", ora );
}
else if( strcmp( inputTastiera, "data" ) == 0 )
{
char data[REPLY_SIZE];
read_data( argv[1], data );
printf( "Server: %s\n", data );
}
else break;
scanf( "%s", &inputTastiera );
}

return 0;
}

read_data( char *host, char *data )

{
extern bool_t xdr_data();
enum clnt_stat clnt_stat;

clnt_stat = callrpc(host,DORAPROG,DORAVERS,READDATA,xdr_data,data,xdr_data,data);

if( clnt_stat != 0 ) clnt_perrno( clnt_stat );

}
read_ora( char *host, char *ora )
{
extern bool_t xdr_ora();
enum clnt_stat clnt_stat;

clnt_stat = callrpc(host,DORAPROG,DORAVERS,READORA,xdr_ora,ora,xdr_ora,ora);

if( clnt_stat != 0 ) clnt_perrno( clnt_stat );

}

Makefile per la compilazione dell'applicazione (makefile)

#Make file per il programma DORA

CC = cc

rdora : rdora.o rdora_xdr.o

${CC} -o rdora rdora.o rdora_xdr.o

rdora_svc : rdora_svc.o read_data.o read_ora.o rdora_xdr.o

${CC} -o rdora_svc rdora_svc.o read_data.o read_ora.o rdora_xdr.o

rdora.o : rdora.c rdora.h

${CC} -c rdora.c

rdora_svc.o : rdora_svc.c rdora.h

${CC} -c rdora_svc.c

read_data.o : read_data.c rdora.h

${CC} -c read_data.c

read_ora.o : read_ora.c rdora.h

${CC} -c read_ora.c

rdora_xdr.o : rdora_xdr.c rdora.h

${CC} -c rdora_xdr.c
RMI
Implementazione del client (Client.java)

import java.io.*;
import java.net.*;
import java.rmi.*;

public class Client

{
public Client() throws IOException
{
DataInputStream stdIn = new DataInputStream( System.in );
String fromUser = null;
String server = "localhost";

while( true )
{
System.out.print( "> " );

fromUser = stdIn.readLine();
if( fromUser != null )
{
System.out.println("Client: " + fromUser);
DOra ds = null;

try {
ds = (DOra) Naming.lookup( "//" + server + ":1099/DOra" );
} catch ( RemoteException e )
{
System.out.println( "Impossibile connettersi al server " + server );
System.exit(1);
}
catch ( NotBoundException e )
{
System.out.println("Server impossibilitato a fornire il servizio" );
System.exit(1);
}

if( fromUser.equalsIgnoreCase( "ora" ) )

System.out.println( "Server: " + ds.getOra() );
else if( fromUser.equalsIgnoreCase( "data" ) )
System.out.println( "Server: " + ds.getData() );
else break;
}
}
}

public static void main( String[] args )

{
try {
new Client();
} catch ( IOException e )
{
System.out.println( "Eccezione " + e );
System.exit(1);
}
}
}
Interfaccia della classe remota (DOra.java)

import java.util.Date;
import java.rmi.*;

public interface DOra extends java.rmi.Remote

{
public String getData() throws java.rmi.RemoteException;
public String getOra() throws java.rmi.RemoteException;
}

Implementazione dell'interfaccia della classe remota (DOraImpl.java)

import java.util.Date;
import java.text.*;
import java.rmi.*;

public class DOraImpl extends java.rmi.server.UnicastRemoteObject

implements DOra
{

public DOraImpl() throws java.rmi.RemoteException

{
}

public String getData() throws java.rmi.RemoteException

{
return ( "" + DateFormat.getDateInstance().format( new Date() ) );
}

public String getOra() throws java.rmi.RemoteException

{
return ( "" + DateFormat.getTimeInstance().format( new Date() ) );
}
}

Implementazione del server (Server.java)

import java.rmi.*;
import java.net.*;

public class Server

{
public Server()
{
try {
DOraImpl dora = new DOraImpl();
String URLCompleta = "//"+InetAddress.getLocalHost().getHostName() + "/DOra";

Naming.rebind( URLCompleta, dora );

}
catch (Exception e) { e.printStackTrace(System.out); }
}

public static void main( String[] args )

{
new Server();
}
}