ds04-slides

Commenti

Transcript

ds04-slides
Sistemi Distribuiti
Prof. Flavio De Paoli
1
Message Oriented communication
2
Message-oriented communication
Asincrona
Persistente
I messaggi vengono conservati dal sistema di comunicazione
Transiente
I messaggi non vengono conservati se sender/receiver non sono in
esecuzione
3
Persistence and Synchronicity in Communication (1)
General organization of a communication system in which hosts are connected
through a network
2-20
4
Persistence and Synchronicity in Communication (2)
Persistent communication of letters back in the days of the Pony
Express.
5
Persistence and Synchronicity in Communication (3)
a)
b)
Persistent asynchronous communication
Persistent synchronous communication
2-22.1
6
Persistence and Synchronicity in Communication (4)
2-22.2
c)
d)
Transient asynchronous communication
Receipt-based transient synchronous communication
7
Persistence and Synchronicity in Communication (5)
e)
f)
Delivery-based transient synchronous communication at message delivery
Response-based transient synchronous communication
8
Message-Oriented
Persistent Communication
9
Message-Queuing Model (1)
They offer intermediate-term storage capacity for messages, without requiring
either the sender or receiver to be active during message transmission.
Four combinations for loosely-coupled communications using queues.
2-26
10
Message-Queuing Model (2)
Basic interface to a queue in a message-queuing system.
Primitive
Meaning
Put
Append a message to a specified queue
Get
Block until the specified queue is nonempty, and remove the first
message
Poll
Check a specified queue for messages, and remove the first. Never block.
Notify
Install a handler to be called when a message is put into the specified
queue.
11
General Architecture of a Message-Queuing System (1)
The relationship between queue-level addressing and network-level
addressing.
12
General Architecture of a Message-Queuing System (2)
The general organization of a message-queuing system with routers.
2-29
13
Message Brokers
The general organization of a message broker in a message-queuing system.
2-30
14
Transient communication
15
L’interfaccia socket
L'interfaccia a socket è una API
Una socket è gestita come un file speciale di Unix (file di
input/output)
Il processo che crea una socket ottiene un file descriptor
Ci sono due tipi di socket
passive –> accettare chiamate (server)
attive –> iniziare una conversazione (client)
16
Funzioni per TCP/IP
socket
Crea una nuova socket
connect Stabilisce la connessione con il server
bind
Associa una socket a un indirizzo
listen
Rende una socket passiva
accept
Accetta connessioni su socket passive
17
Funzioni per TCP/IP
write
Per inviare messaggi
read
Per ricevere messaggi
close
Chiude la comunicazione rilasciando la
socket
18
Berkeley Sockets (1)
Socket primitives for TCP/IP.
Primitive
Meaning
Socket
Create a new communication endpoint
Bind
Attach a local address to a socket
Listen
Announce willingness to accept connections
Accept
Block caller until a connection request arrives
Connect
Actively attempt to establish a connection
Send
Send some data over the connection
Receive
Receive some data over the connection
Close
Release the connection
19
Client e server TCP/IP
(a) Server
(b) Client
20
Berkeley Sockets (2)
Connection-oriented communication pattern using sockets.
21
Processi e socket
ClientProcess
socket
socket-bind
connect
accept
write-read
read-write
host
Porte
ServerProcess
host
Porte
22
Client e server UDP/IP
(a) Server
(b) Client
23
Gli indirizzi dei processi
Un processo server è identificato da
un indirizzo IP
un identificatore di porta
struct sockaddr_in {
u_short sin_family;
/*tipo (es.
AF_INET)*/
u_short sin_port; /* protocol port number */
/* (2 bytes = 16 bit in network byte order) */
struct in_addr sin_addr;
/* indirizzo IP
*/
/* (4 bytes = 32 bit in network byte order) */
char sin_zero[8];
/* non usato (inizializzato a zero)*/
};
24
Come si definisce un indirizzo
Un indirizzo si costruisce con funzioni di libreria
struct sockaddr_in {
u_short sin_family;
= getprotobyname() -> h_addrtype
u_short sin_port;
= getservbyname() -> s_port
struct in_addr sin_addr;
= gethostbyname() -> h_addr
char sin_zero[8];
= bzero()
};
25
Unified Resource Locator (URL)
URL uniforma i riferimenti in Internet
protocollo://host[:porta]/[nome_risorsa]
Esempi
http://www.microsoft.com
http://developer.netscape.com/docs/wpapers/corba/index.html
ftp://sunsite.cnlab-switch.ch/mirror/javasoft/docs/
http://wwwcache.cilea.it:8080/
26
Esempio di socket attivo
La routine active_sock crea una socket attiva per un
client TCP/IP
int active_sock
(char *host, char *service, int port)
Restituisce un descrittore di socket attiva o un codice
d'errore
27
Esempio di socket passivo
La routine passive_sock crea una socket passiva per
un server TCP/IP
int passive_sock(int port, int qlen)
qlen è la lunghezza della coda di chiamate
Restituisce un descrittore di socket passiva o messaggio
d'errore.
28
Progettare un client
L'architettura di un client è concettualmente più semplice di
quella di un server
È spesso una applicazione convenzionale
Ha effetti solo sull’utente client
Non ci sono problemi di sicurezza
29
Un esempio di client TCP/IP
Il servizio echo
un client si connette ad un server remoto e gli invia un messaggio, il
server rimanda lo stesso messaggio al client
È uno strumento per
verificare la raggiungibilità di un server
provare un protocollo
studiare problemi di rotta
30
Un esempio di client TCP/IP
Tre tipi di collegamento ad un server per client_echo:
% client_echo
Client e server sono sulla stessa macchina;
% client_echo host_name
Il server sta sulla macchinahost_name;
% client_echo host_name port_number
Il server usa la porta port_number sulla macchinahost_name;
31
Progettare un server
Concettualmente un server deve
creare una socket
assegnargli una porta nota
entrare in un ciclo infinito in cui alternare
attesa richiesta
soddisfa richiesta
invia risposta
L’affidabilità di un server è strettamente dipendente
dall’affidabilità della comunicazione tra lui e i suoi client
32
Svantaggi nell’uso di TCP/IP
La modalità connection-oriented determina
l’impossibilità di rilevare interruzioni sulle connessioni
la necessità di prevedere una connessione (una socket) per ogni
comunicazione
33
Tipi di Server
I server possono essere:
iterativi
soddisfano una richiesta alla volta
concorrenti processo singolo
simulano la presenza di un server dedicato
concorrenti multi-processo
creano server dedicati
concorrenti multi-thread
creano thread dedicati
34
Progettare un server iterativo
Al momento di una richiesta di connessione il server crea
una socket temporanea per stabilire una connessione diretta
con il client
Le eventuali ulteriori richieste per il server verranno
accodate alla porta nota per essere successivamente
soddisfatte
35
Lo schema logico
server loop:
accept requests from other machines for
matrix multiplication;
call matrix_multiply;
send results back to requester;
----------------available on server-----double[] matrix_multiply() {
perform operation;
}
36
Progettare un server iterativo
Legenda:
Server
S1
S2
S1
Socket per accettare
richieste di connessione
Socket per connessioni
individuali
S2
.. .. .
server_echo_1
37
Svantaggi
Viene servito un cliente alla volta, gli altri devono attendere
Un server impedisce l’evoluzione di molti client
Non scala
Soluzione: server concorrenti
38
Progettare un server concorrente
Un server concorrente può gestire più connessioni
contemporaneamente
La sua realizzazione può essere
simulata con un solo processo
(uso della funzione select)
reale creando nuovi processi slave
(uso della funzione fork)
39
Single-Process (Thread)
Concurrent Server
40
Concurrent Single-Process Server in
C/Unix
Viene creata una socket per ogni client
Problema: le operazioni sono sincrone (sospensive)
La select() permette di leggere in modo asincrono dai
diversi canali di I/O
Sospende il processo finché non è possibile fare una operazione di I/O
server_echo_2
41
Select system call
select
Se il canale per le accept è pronto in lettura
accept
Per ogni canale pronto in lettura
read
write
42
Select system call
#include <sys/types.h>
#include <sys/time.h>
int select(int maxfdp, fd_set *readfds,
fd_set *writefds, fd_set *exceptfds,
struct timeval *timeout );
Usa una maschera di bit di lunghezza maxfdp (= max_canali
+ 1)
max_canali è definito in <stdio.h>
In System V è la costante FOPEN_MAX
In 4.3BSD è dato da getdtablesize()
43
Select system call
Usa la maschera di bit di descrittori di file fd_set definita
in <sys/types.h>
Le macro per manipolare la maschera:
FD_ZERO(fd_set *fdset);
/* clear all bits in fdset */
FD_SET(int fd, fd_set *fdset);
/* turn the bit for fd on in fdset */
FD_CLR(int fd, fd_set *fdset);
/* turn the bit for fd off in fdset */
FD_ISSET(int fd, fd_set *fdset);
/* test the bit for fd in fdset */
44
Select system call
Una invocazione di select segnala che
uno dei file descriptor di readfds è pronto per la lettura, o che
uno dei file descriptor di writefd è pronto per la scrittura, o che
uno dei file descriptor di exceptfds è in una eccezione pendente.
Il numero massimo di descrittori esaminati viene indicato
con maxfdp.
(È pari al massimo valore + 1)
45
Select system call
È possibile specificare un timeout
Se ha valore 0, allora ritorna subito dopo aver controllato i descrittori;
Se ha valore > 0, allora attende che uno dei descrittori sia pronto per
l'I/O, ma non oltre il tempo fissato da timeout;
Se timeout ha valore NULL, allora attende indefinitamente che uno dei
descrittori sia pronto per l'I/O.
(si può interrompere l'attesa con una signal)
46
Multi-Process (Thread)
Concurrent Server
47
Condivisione del canale
x=read(s);
println(x);
x=read(s);
println(x);
Process/Thread 1
Possibile output:
cef
Process/Thread 2
Possibile output:
abd
porta/socket
Client
write(s,“abcdef”);
48
Lo schema logico
server loop:
accetta richieste da altre macchine per la
moltiplicazione di matrici;
attiva un nuovo thread e passa ad esso la
richiesta;
----------------double[] matrix_multiply() {
fai l’operazione;
}
/* Ci sono altri modi per farlo */
49
Concurrent Multi-Process Server in
C/Unix
Ad ogni richiesta viene creata una socket dedicata
una fork genera un figlio per gestire la nuova socket
il padre resta in attesa di nuove connessioni
Bisogna gestire la corretta terminazione dei figli
server_echo_3
50
Concurrent Multi-Thread Server in
Java
Ad ogni richiesta viene creata una socket dedicata
viene generato un Thread per gestire la nuova socket
il Thread padre resta in attesa di nuove connessioni
server Java
51
Confronto tra i modelli
Mono processo (iterativo e concorrente)
gli utenti condividono lo stesso spazio di lavoro
adatto ad applicazioni cooperative che prevedono la modifica dello stato
(lettura e scrittura)
Multi processo
ogni utente ha uno spazio di lavoro autonomo
adatto ad applicazioni autonome o che non modificano lo stato del server
(sola lettura)
52
Ulteriori considerazioni
Ci sono piu’ clienti per lo stesso server
Ogni server puo’ fornire piu’ servizi
Ogni server deve gestire piu’ richieste
I client devono mandare le richieste ai server giusti
Si vorrebbe evitare che ogni client e ogni server si
preoccupino dei problemi legati alla rete
53
Strutture per i server
Sono possibili diverse architetture
Chi crea i thread?
Quando viene creato un thread?
Il numero di thread è fisso?
Esistono diversi design pattern
54
Un thread per client
Il thread coordinatore rileva la presenza di un nuovo client
Connette il nuovo client ad un nuovo thread
Il nuovo thread:
decodifica la richiesta
chiama la funzione servente che la soddisfa
torna in ciclo per leggere una nuova richiesta
55
Un thread per richiesta
Un thread coordinatore riceve una richiesta
Ricevuta una richiesta genera un nuovo thread per
processarla
Il nuovo thread:
decodifica la richiesta
chiama la funzione servente che la soddisfa
termina
56
Un thread per servente
Ogni servente ha un proprio thread e una coda
Il coordinatore riceve una richiesta e la inserisce nella coda
del servente giusto
Ogni thread servente legge ciclicamente una richiesta dalla
propria coda e la esegue
57
Un pool di thread
La creazione dei thread è costosa
Il costo di creazione puo’ essere ammortizzato facendo
gestire ad ogni thread molte richieste
Un pool di thread potebbe essere creato al momento
dell’avvio del sistema e assegnato alle richieste man mano
vengono ricevute
58
Conclusioni
Il protocollo
definito dal progettista
di basso livello (sequenza di caratteri)
codifica e decodifica dei dati
Connessione
indirizzo fisico conosciuto dal client
poca trasparenza
Non c’è supporto alla gestione
creazione e attivazione del server manuale
59