Master Informatique M1

Plan de la suite

Problme x Raliser un service rparti en utilisant linterface de transport (TCP, UDP) Solutions x Sockets : mcanisme universel de bas niveau, utilisable depuis tout langage (exemple : C, Java) x Appel de procdure distance (RPC), dans un langage particulier ; exemple : C x Appel de mthode distance, dans les langages objets ; exemple : Java RMI x Middleware intgr : CORBA, EJB, .Net, Web Services Exemples x Exemples de services usuels : DNS, Web

Programmation client-serveur sockets - RPC

Cours 6 (aujourdhui) TP 4 Cours 7 TP 5-6 En Master 2

Sacha Krakowiak
Universit Joseph Fourier Projet Sardes (INRIA et IMAG-LSR) http://sardes.inrialpes.fr/people/krakowia

Cours 8

2003-2004, S. Krakowiak

Mise en uvre du schma client-serveur

Introduction aux sockets

socket : mcanisme de communication permettant dutiliser linterface de transport (TCP-UDP). Introduit dans Unix dans les annes 80 ; standard aujourdhui
Principe de fonctionnement : 3 phases - illustration ci-dessous avec TCP 1) le serveur cre une "socket serveur" (associe un port) et se met en attente

s Rappel du schma client-serveur

x Appel synchrone requte-rponse

requte excution service Client s Mise en uvre

x Bas niveau : utilisation directe du transport : sockets (construit sur TCP ou UDP) y Exemple : utilisation des sockets en Java x Haut niveau : intgration dans un langage de programmation : RPC (construit sur sockets) y Exemple : RPC en C

"socket serveur"

4321

rponse

Serveur

2) le client se connecte la socket serveur ; deux sockets sont alors cres : une " socket client", ct client, et une "socket service client" ct serveur. Ces sockets sont connectes entre elles
"socket serveur" "socket client" client 36243 "socket service client"

serveur

4321 56432

3) Le client et le serveur communiquent par les sockets. Linterface est celle des fichiers (read, write). La socket serveur peut accepter de nouvelles connexions
2003-2004, S. Krakowiak

2003-2004, S. Krakowiak

Deux ralisations possibles du client-serveur avec sockets

s Mode connect (protocole TCP)
x x x x x x x x x Ouverture dune liaison, suite dchanges, fermeture de la liaison Le serveur prserve son tat entre deux requtes Garanties de TCP : ordre, contrle de flux, fiabilit Adapt aux changes ayant une certaine dure (plusieurs messages) Les requtes successives sont indpendantes Pas de prservation de ltat entre les requtes Le client doit indiquer son adresse chaque requte (pas de liaison permanente) Pas de garanties particulires (UDP) Adapt aux changes brefs (rponse en 1 message)

Utilisation du mode connect

s Caractristiques
x tablissement pralable dune connexion (circuit virtuel) : le client demande au serveur sil accepte la connexion x fiabilit assure par le protocole (TCP) x mode dchange par flot doctets : le rcepteur na pas connaissance du dcoupage des donnes effectu par lmetteur x possibilit dmettre et de recevoir des caractres urgents (OOB : Out OF Band) x aprs initialisation, le serveur est passif : il est activ lors de larrive dune demande de connexion du client x un serveur peut rpondre aux demandes de service de plusieurs clients : les requtes arrives et non traites sont stockes dans une file dattente

s Mode non connect (protocole UDP)

s Points communs
x Le client a linitiative de la communication ; le serveur doit tre lcoute x Le client doit connatre la rfrence du serveur [adresse IP, n de port] (il peut la trouver dans un annuaire si le serveur ly a enregistre au pralable, ou la connatre par convention : ns de port praffcts) x Le serveur peut servir plusieurs clients (1 thread unique ou 1 thread par client)
2003-2004, S. Krakowiak

s Contraintes
x le client doit avoir accs ladresse du serveur (adresse IP, n de port)

s Modes de gestion des requtes

x itratif : le processus traite les requtes les unes aprs les autres x concurrent : par cration de processus fils pour les changes de chaque requte (ouverture de connexion)

2003-2004, S. Krakowiak

Serveur itratif en mode connect

s Principes
s

Programmation avec sockets

Le client ouvre une connexion avec le serveur avant de pouvoir lui adresser des appels, puis ferme la connexion la fin de la suite doprations x dlimitation temporelle des changes x maintien de ltat de connexion pour la gestion des paramtres de qualit de service y traitement des pannes, proprit dordre

x Les diffrentes oprations de gestion de sockets (socket, bind, etc.) sont fournies comme primitives (appel systmes) dans Unix (et dautres systmes dexploitation) x Si intresss, lirer les pages man de ces oprations x On peut utiliser directement ces oprations, mais les langages usuels fournissent des outils facilitant leur usage et couvrant les cas courants, ct client et ct serveur y bibliothques spcialises en C y classes en Java

Orient vers x le traitement ordonn dune suite dappels y ordre local (requtes dun client traites dans leur ordre dmission), global ou causal x la gestion de donnes persistantes ou de protocoles avec tat

s La suite
x Nous allons regarder de plus prs (cours et TP) la programmation des sockets en Java x Si intresss par la programmation de sockets en C, voir rfrences cidessous (contiennent des exemples)
Livres J. M. Rifflet, J.-B. Yuns. Unix - Programmation et Communication, Dunod (2003), chap. 19 R. Stevens. Unix Network Programming. Prentice-Hall. http://www.eng.auburn.edu/department/cse/classes/cse605/examples/index.html http://www.scit.wlv.ac.uk/~jphb/comms/sockets.html

Web

2003-2004, S. Krakowiak

2003-2004, S. Krakowiak

Programmation des sockets en Java (mode connect)

s Deux classes de base
x ServerSocket : socket ct serveur (attend connexions et cre socket service client) x Socket : sockets ordinaires, pour les changes. Fournissent des classes InputStream et OutputStream (flots doctets) pour changer de linformation. Exemple : PrintWriter out = new PrintWriter(mySocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader( mySocket.getInputStream())); Analogie avec fichiers (les sockets sutilisent comme des fichiers) : BufferedReader in = new BufferedReader(new FileReader("myFile")); PrintWriter out = new PrintWriter(new FileWriter("myFile"), true);

Client-serveur avec sockets TCP en Java (trs simplifi)

Sur une machine client doit tre connu du client Sur la machine serveur (ex : "goedel.imag.fr") serverSocket = new ServerSocket(7654); clientServiceSocket = serverSocket.accept();

mySocket = new Socket("goedel.imag.fr", 7654);

Maintenant le client et le serveur sont connects PrintWriter out = new PrintWriter( mySocket.getOutputStream(), true); BufferedReader in = new BufferedReader( new InputStreamReader( mySocket.getInputStream())); PrintWriter out = new PrintWriter( clientServicetSocket.getOutputStream(), true); BufferedReader in = new BufferedReader( new InputStreamReader( clientServiceSocket.getInputStream()));

Utilisables ainsi : String s1, s2; out.println(s1); s2 = in.readLine();

Maintenant le client et le serveur peuvent communiquer via les canaux BufferedReader stdIn = new BufferedReader( new InputStreamReader(System.in)); String request; String reply; while (true) { request = stdln.readLine(); // l'utilisateur entre la requte out.println(request); // envoyer la requte au serveur reply = in.readLine() // attendre la rponse System.out.println(reply); // imprimer la rponse }
2003-2004, S. Krakowiak

String request; String reply; while (true) { request = in.readLine() // executer le service // traiter request pour fournir reply out.println(reply); }

Voir http://java.sun.com/docs/books/tutorial/networking/sockets/

2003-2004, S. Krakowiak

Complments divers
Importer les packages utiles
import java.io.*; import java.net.*; import java.io.*; import java.net.*;

Gestion du paralllisme sur le serveur

s Avec le schma prcdent, un seul processus serveur
x Sil y a des clients multiples, ils sont traits en squence (les requtes sont conserves dans une file dattente associe la socket serveur) y N.B. La longueur max de cette file dattente peut tre spcifie lors de la cration de la socket serveur. Valeur par dfaut : 50

Prvoir les cas derreur

Socket mySocket = null; try { mySocket = new Socket("goedel.imag.fr", 7654); } catch (IOException e) { System.out.println("connexion impossible"); System.exit(-1); } try { serverSocket = new ServerSocket(7654); } catch (IOException e) { System.out.println("port 7654 non utilisable"); System.exit(-1); } Socket clientServiceSocket = null; try { serverSocket.accept(); } catch (IOException e) { System.out.println(accept impossible sur port 7654"); System.exit(-1); } out.close(); in.close(); clientServiceSocket.close(); serverSocket.close();

s On peut aussi utiliser un schma veilleur-excutants

x Le thread veilleur doit crer explicitement un nouveau thread excutant chaque nouvelle connexion dun client (donc lexcution de accept()) x Une socket service client diffrente est cre pour chaque client x Le thread veilleur se remet ensuite en attente
socket serveur

Prvoir terminaison
(dpend de lapplication)

Terminer proprement
out.close(); in.close(); mySocket.close();

while (true) { accepter la connexion dun nouveau client et crer une socket service client; crer un thread pour interagir avec ce client sur la nouvelle socket service client; }

client 1 crer

client 2

sockets service client

2003-2004, S. Krakowiak 1 2003-2004, S. Krakowiak 1

Un serveur multi-thread
programme des excutants programme du veilleur serverSocket = new ServerSocket(7654); while (true) { Socket clientServiceSocket = serverSocket.accept() ; Service myService = new Service(clientServiceSocket) ; // cre un nouveau thread // pour le nouveau client myService.start () ; // lance lexcution du thread }
public class Service extends Thread { protected final Socket socket ; String request, reply; public myService(Socket socket) { this.socket - socket ; { public void run () { PrintWriter out = new PrintWriter( clientServicetSocket.getOutputStream(), true); BufferedReader in = new BufferedReader( new InputStreamReader( clientServiceSocket.getInputStream())); try { request = in.readLine() ; // excuter le service // traiter request pour fournir reply out.println(reply); } finally { socket.close () ; } } }
2003-2004, S. Krakowiak

Utilisation du mode non connect (datagrammes, UDP)

s Caractristiques
x pas dtablissement pralable dune connexion x Pas de garantie de fiabilit x adapt aux applications pour lesquelles les rponses aux requtes des clients sont courtes (1 message) x le rcepteur reoit les donnes selon le dcoupage effectu par lmetteur

s Contraintes
x le client doit avoir accs ladresse du serveur (adr. IP, port) x le serveur doit rcuprer ladresse de chaque client pour lui rpondre (primitives sendto, recvfrom)

s Mode de gestion des requtes

x itratif (requtes traites lune aprs lautre) x concurrent (1 processus ou thread par client)

Le programme du client est inchang

1 2003-2004, S. Krakowiak

Serveur itratif en mode non connect

Programmation des sockets en Java (mode non connect)

s Deux classes : DatagramSocket et DatagramPacket

s Le client peut envoyer un appel au serveur tout

moment
x mode lger permettant y le traitement non ordonn des appels y labsence de mmorisation entre appels successits (serveur sans donnes rmanentes et sans tat) x exemples y calcul de fonction numrique y DNS (service de noms) y NFS (service de fichiers rpartis)

x DatagramSocket : un seul type de socket x DatagramPacket : format de message pour UDP y Conversion entre donnes et paquet (dans les 2 sens)
packet = new DatagramPacket(data, data.length, adresseIP, port)

data

donnes envoyer (byte [ ])

packet

DatagramPacket

donnes recevoir (byte [ ])

dat

packet = new DatagramPacket(data, data.length)

s Utilisation
x changes simples (question-rponse) x Messages brefs x "Streaming temps rel (performances)
2003-2004, S. Krakowiak 1 2003-2004, S. Krakowiak 1

Client-serveur en mode non connect

Sur une machine client DatagramSocket socket = new DatagramSocket(); byte [ ] sendBuffer = new byte [1024] ; byte [ ] receiveBuffer = new byte [1024] ; String request, reply; request = // dpend de lapplication sendBuffer = request.getBytes() ; DatagramPacket outpacket = new DatagramPacket (sendBuffer, sendBuffer.length, Sur la machine serveur (ex : "goedel.imag.fr") DatagramSocket socket = new DatagramSocket(7654); byte [ ] receiveBuffer = new byte [1024] ; byte [ ] sendBuffer = new byte [1024] ; String request, reply;

Appel de procdure distance : dfinition

x Appel de procdure distance (Remote Procedure Call, ou RPC) : un outil pour construire des applications client-serveur dans un langage de haut niveau x Lappel et le retour ont lieu sur un site ; lexcution se droule sur un site distinct

processus p

processus p
P(x, y, )

while (true) { DatagramPacket inpacket = new DatagramPacket (receiveBuffer, receiveBuffer.length); socket.receive(inpacket ) ; request = InetAddress.getbyname("goedel.imag.fr"), new String(receiveBuffer.getData); 7654) ; // dterminer adresse et port du client socket.send(outpacket) ; doit tre connu du client Rception InetAddress clentAddress = inpacket.getAddress( int clienPort = inpacket. DatagramPacket inpacket = requte // executer service : traiter request pour fournir rep new DatagramPacket (receiveBuffer, sendBuffer = reply.getBytes() ; receiveBuffer.length); DatagramPacket outpacket = socket.receive(inpacket ); Envoi new DatagramPacket (sendBuffer, reply = new String(inpacket.getData()); rponse sendBuffer.length, clientAddress, clienPort); Envoi requte socket.send(outpacket); Rception rponse }
2003-2004, S. Krakowiak

procedure P(x, y, )

P(x, y, )

Leffet de lappel doit tre identique dans les deux situations. Mais cet objectif ne peut tre atteint en toute rigueur en prsence de dfaillances (cf plus loin)

1 2003-2004, S. Krakowiak

Appel de procdure distance : avantages et problmes

s Avantages attendus
x Facilit de programmation y La complexit des protocoles de communication est cache x Facilit de mise au point : une application peut tre mise au point sur un site unique, puis dploye sur plusieurs sites x Portabilit : rsulte de lusage dun langage de haut niveau y Indpendance par rapport au systme de communication

Appel de procdure distance : principes de mise en uvre

P(x, y, )

niveau application

P(x, y, )

s Problmes de ralisation
x Transmission des paramtres (conversion entre la forme interne, propre un langage, et une forme adapte la transmission) x Gestion des processus x Raction aux dfaillances y Trois modes de dfaillance indpendants : client, serveur, rseau

Talon (stub) client

emballer paramtres envoyer paramtres attente recevoir rsultats dballer resultats send receive
logiciel de communication (sockets)

niveau middleware

recevoir paramtres dballer paramtres appel procdure emballer rsultats envoyer rsultats

Talon (stub serveu

rseau

receive send
logiciel de communication (sockets)

Les talons client et serveur sont crs partir dune description dinterface
2

2003-2004, S. Krakowiak

1 2003-2004, S. Krakowiak

Utilisation de lappel de procdure distance (1)

Exemple (en langage C) : un service dannuaire Les tapes : 1) Prparer une description de linterface (cf plus loin) : fichier annuaire.x
dcrit les types de donnes et les oprations (fonctions de lannuaire : init, ajouter, supprimer, consulter)

Utilisation de lappel de procdure distance (2)

Description dinterface (fichier annuaire.x)

/* constantes et types */ const max_nom = 20 ; const max_adr = 50 ; const max_numero = 16 ; typedef string typenom<max_nom> ; typedef string typeadr<max_adr> ; typedef string typenumero<max_numero> ; struct personne { typenumero numero ; typenom nom ; typeadr adresse ; }; typedef struct personne personne ; /* description de l interface */ program ANNUAIRE { version V1 { void INIT(void) = 1; int AJOUTER(personne p) = 2 ; int SUPPRIMER (personne p) = 3 ; personne CONSULTER (typenom nom) = 4 ; }=1; } = 0x23456789 ;

2) Compiler ce fichier laide du gnrateur de talons :

rpcgen annuaire.x rsultat : les fichiers suivants : annuaire.h include annuaire_clnt.c talon client annuaire_svc.c talon serveur annuaire_xdr.c proc. conversion donnes fournit aussi des fichiers auxiliaires (modles de prog. client, serveur, Makefile)

3) Sur le site client, construire lexcutable client (programme : annuaire_client.c)

gcc -o client annuaire_client.c annuaire_clnt.c

4) Sur le site serveur, construire lexcutable serveur (programme : annuaire_serveur.c)

gcc -o server annuaire_server.c annuaire_svc.c

5) Sur le site serveur, lancer lexcutable serveur

server &

6) Sur le site client, lancer lexcutable client

client
2003-2004, S. Krakowiak 2 2003-2004, S. Krakowiak 2

Description dinterface

RPC : structure du programme serveur

N.B. : ce programme ne contient que les fonctions appeler. La procdure main est contenue dans le talon. Ce programme est crire par le dveloppeur, alors que le talon est engendr automatiquement

s Interface = contrat entre client et serveur

x Dfinition commune abstraite y Indpendante dun langage particulier (adapte des langages multiples) y Indpendante de la reprsentation des types C S y Indpendante de la machine (htrognit) x Contenu minimal Interface y Identification des procdures (nom, version) y Dfinition des types des paramtres, rsultats, exceptions y Dfinition du mode de passage (IN, OUT, IN-OUT) x Extensions possibles y Procdures de conversion pour types complexes y Proprits non-fonctionnelles (qualit de service), non standard)

#include "annuaire.h" void * nit_1_svc(void *argp, struct svc_req *rqstp) { static char * result; /* le programme de la fonction init */ return (void *) &result; } nt * ajouter_1_svc(personne *argp, struct svc_req *rqstp) { static int result; /* le programme de la fonction ajouter */ return &result; }

int * supprimer_1_svc(personne *argp, struct svc_req *rqstp) { static int result; /* le programme de la fonction supprimer */ return &result; } personne * consulter_1_svc(typenom *argp, struct svc_req *rqstp) { static personne result; /* le programme de la fonction consulter */ return &result; }

2003-2004, S. Krakowiak

2 2003-2004, S. Krakowiak

RPC : structure du talon serveur

es parties en gras ne sont pas dtailles includes ... */ atic void nnuaire_1(struct svc_req *rqstp, register SVCXPRT *transp){ union { personne ajouter_1_arg; personne supprimer_1_arg; typenom consulter_1_arg; } argument; char *result; xdrproc_t _xdr_argument, _xdr_result; char *(*local)(char *, struct svc_req *); switch (rqstp->rq_proc) { case NULLPROC: (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL); return; case INIT: _xdr_argument = (xdrproc_t) xdr_void; _xdr_result = (xdrproc_t) xdr_void; local = (char *(*)(char *, struct svc_req *)) init_1_svc; break; case AJOUTER: _xdr_argument = (xdrproc_t) xdr_personne; _xdr_result = (xdrproc_t) xdr_int; local = (char *(*)(char *, struct svc_req *)) ajouter_1_svc; break; 2003-2004, S. Krakowiak case SUPPRIMER: /* idem */ case CONSULTER: /* idem */ default: svcerr_noproc (transp); return; } /* prparer arguments dans zone argument */ result = (*local)((char *)&argument, rqstp); /* excution */ if (result != NULL && !svc_sendreply(transp, /* envoi rsultats */ (xdrproc_t) _xdr_result, result)) { svcerr_systemerr (transp); } /* librer arguments */ return; } Int main (int argc, char **argv) { /* crer une socket serveur TCP sur un port p */ /* crer une socket serveur UDP sur un port p1 */ /* enregistrer le service annuaire_1 sous TCP (port p) */ /* enregistrer le service annuaire_1 sous UDP (port p1) */ svc_run () ; /* se mettre en attente d'un appel du client */ }

RPC : structure du programme client

annuaire_client.c /* include */ /* dclarations */ main(argc, argv) int argc ; char * argv ; { CLIENT *clnt ; char * host if (argc <2) { printf(usage: %s server_host\n, argv[0]) ; exit(1) { host = argv[1] ; clnt = clnt_create (host, ANNUAIRE, V1, netpath) ; if (clnt == (CLIENT *) NULL { {clnt_pcreateerror(host) ; exit(1) ; { result_2 = ajouter_1(&ajouter_1_arg, clnt) if (result_2 == (int *) NULL) { clnt_perror(clnt, call failed) ; { }
2 2003-2004, S. Krakowiak

/* poigne d accs au serveur */

/* saisir paramtres */

/* afficher rsultats */

Structure du talon client

#include <memory.h> /* for memset */ #include "annuaire.h" /* Default timeout can be changed using clnt_control() */ static struct timeval TIMEOUT = {25, 0 }; void * init_1(void *argp, CLIENT *clnt) { static char clnt_res; int * supprimer_1(personne *argp, CLIENT *clnt) { static int clnt_res; memset((char *)&clnt_res, 0, sizeof(clnt_res)); if (clnt_call (clnt, SUPPRIMER, (xdrproc_t) xdr_personne, (caddr_t) argp, (xdrproc_t) xdr_int, (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } return (&clnt_res);

Chane de production pour lappel de procdure distance

gcc
application client proc_client.c talon client proc_clnt.c

L'appel via la socket est cach dans clnt_call

excutable client

memset((char *)&clnt_res, 0, sizeof(clnt_res)); if (clnt_call (clnt, INIT, (xdrproc_t) xdr_void, (caddr_t) argp, (xdrproc_t) xdr_void, (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } return ((void *)&clnt_res); } int * ajouter_1(personne *argp, CLIENT *clnt) { static int clnt_res; memset((char *)&clnt_res, 0, sizeof(clnt_res)); if (clnt_call (clnt, AJOUTER, (xdrproc_t) xdr_personne, (caddr_t) argp, (xdrproc_t) xdr_int, (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } return (&clnt_res); } 2003-2004, S. Krakowiak

} personne * consulter_1(typenom *argp, CLIENT *clnt) { static personne clnt_res; memset((char *)&clnt_res, 0, sizeof(clnt_res)); if (clnt_call (clnt, CONSULTER, (xdrproc_t) xdr_typenom, (caddr_t) argp, (xdrproc_t) xdr_personne, (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } return (&clnt_res); }

description dinterface proc.x

rpcgen

conversion proc_xdr.c

dfinitions proc.h

bibliothques

talon serveur proc_svc.c application serveur proc_server.c fourni par programmeur outils et services engendr automatiquement
2

gcc

excutable serveur

2 2003-2004, S. Krakowiak

Appel de procdure distance : dtails de ralisation

La ralisation de lappel de procdure distance soulve divers problmes techniques que nous nexaminons pas en dtail

Traitement des dfaillances (rsum)

s Difficults du traitement des dfaillances
x Le client na pas reu de rponse au bout dun dlai de garde fix. 3 possibilits : y a) Le message dappel sest perdu sur le rseau y b) Lappel a t excut, mais le message de rponse sest perdu y c) Le serveur a eu une dfaillance
v c1: Avant davoir excut la procdure v c2 : Aprs avoir excut la procdure mais avant davoir envoy la rponse

s Passage de paramtres
x Pas de passage par rfrence (car les pointeurs perdent leur signification) x Conversion des donnes (dpend du type et des conventions de reprsentation - il existe des standards)

s Dsigantion
x Comment le client dtermine ladresse du serveur (et vice-versa)

s Traitement des dfaillances

x cf rsum plus loin

x Si le client envoie de nouveau la requte y Pas de problme dans le cas a) y Lappel sera excut 2 fois dans le cas b)
v Remde : associer un numro unique chaque requte

s Serveurs multi-threads s Outils

x Gnration de talons x Mise au point
Rfrences pour aller plus loin : Exemples en ligne http://www.cs.cf.ac.uk/Dave/C/node33.html J.-M. Rifflet et J.-B. Yuns, UNIX, Programmation et communication, Dunod (2003), chap. 21 R. Stevens, Unix Network Programming, vol. 2, 2nd ed., Prentice Hall (1999)
2003-2004, S. Krakowiak

y Divers rsultats possibles dans le cas c) selon remise en route du serveur

s Consquences pratiques sur la conception des applications

x Construire des serveurs sans tat (donc toute requte doit tre self-contenue, sans rfrence un tat mmoris par le serveur) x Prvoir des appels idempotents (2 appels successifs ont le mme effet quun appel unique). Exemple : dplacer un objet y move(deplacement_relatif) : non idempotent y move_to(position absolue) : idempotent
2 2003-2004, S. Krakowiak 3

Conclusions sur lappel de procdure distance

s Avantages
x Abstraction (les dtails de la communication sont cachs) x Intgration dans un langage : facilite portabilit, mise au point x Outils de gnration, facilitent la mise en uvre

Matriau complmentaire
(non prsent en cours)

s Limitations
x La structure de lapplication est statique : pas de cration dynamique de serveur, pas de possibilit de redploiement entre sites x Pas de passage des paramtres par rfrence x La communication est rduite un schma synchrone x La persistance des donnes nest pas assure (il faut la raliser explicitement par sauvegarde des donnes dans des fichiers) x Des mcanismes plus volus visent remdier ces limitations y Objets rpartis (ex : Java RMI, voir en cours) y Composants rpartis (ex : EJB, Corba CCM, .Net)
2003-2004, S. Krakowiak 3 2003-2004, S. Krakowiak

Algorithme dun serveur en mode connect

Algorithme dun client en mode connect

x 1. Cration de la socket serveur x 2. Rcupration de ladresse IP et du numro de port du serveur ; lien de la socket ladresse du serveur x 3. Mise en mode passif de la socket : elle est prte accepter les requtes des clients x 4. (opration bloquante) : acceptation dune connexion dun client et cration dune socket service client, dont lidentit est rendue en retour x 5. et 6. Lecture, traitement et criture (selon algorithme du service) x 7. Fermeture et remise en attente

1 2 3 4 5

t=socket() bind() listen() s=accept()

read()

write()

x 1. Cration de la socket x 2. Connexion de la socket au serveur y choix dun port libre pour la socket par la couche TCP y attachement automatique de la socket ladresse (IP machine locale + n de port) y connexion de la socket au serveur en passant en paramtre ladresse IP et le n de port du serveur x 3. et 4. Dialogue avec le serveur (selon algorithme du service) x 5. Fermeture de la connexion avec le serveur

1 2

socket() connect()

read()

write()

close(s)

close() shutdown()

2003-2004, S. Krakowiak

3 2003-2004, S. Krakowiak

Gestion des processus (mode connect)

Serveur itratif

Algorithme dun serveur en mode non connect

Veilleur

t=socket() bind()
Client x 1. Cration de la socket x 2. Rcupration de ladresse IP et du numro de port du serveur ; lien de la socket ladresse du serveur x 3. Rception dune requte de client x 4. Traitement de la requte ; prparation de la rponse x 5. Rponse la requte en utilisant la socket et ladresse du client obtenues par recvfrom ; retour pour attente dune nouvelle requte 3 1 2

t=socket() bind() listen() s=accept() read()

traitement
Excutant

socket() bind()

listen() s=accept() fork() close(t) read()

traitement Serveur avec veilleur

socket() connect() write() close(s) read() close() shutdown()

recvfrom()

traitement

write() close(s)

write() close(s) exit()

NB : cet exemple utilise des processus. On peut selon le mme principe utiliser des threads

sendto()

2003-2004, S. Krakowiak

3 2003-2004, S. Krakowiak

Algorithme dun client en mode non connect

Gestion des processus (mode non connect)

Serveur itratif Serveur avec veilleur
NB : cet exemple utilise des processus. On peut selon le mme principe utiliser des threads

Veilleur

x 1. Cration de la socket (lassociation une adresse locale [adresse IP + n port] est faite automatiquement lors de lenvoi de la requte) x 2. Envoi dune requte au serveur en spcifiant son adresse dans lappel x 3. Rception de la rponse la requte x 4. Fermeture de la socket

socket() socket() bind() socket() bind() recvfrom()

Excutant Client

socket() sendto() recvfrom() close()

sendto()

recvfrom()
traitement

fork()
traitement

recvfrom()

[bloquant]

sendto()
4

close()

sendto() exit()
suite du programme

2003-2004, S. Krakowiak

3 2003-2004, S. Krakowiak