Protocollo HTTP
Un'interessante classe di oggetti di ns è la Http, che comprende tre sottoclassi: Http/Client, Http/Server e Http/Cache.
A livello di trasporto gli oggetti Http si appoggiano per default su Agent di tipo Tcp. E' ammesso farli appoggiare anche su Agent di tipo FullTcp, settando opportunamente la variabile TRANSPORT_:
Http set TRANSPORT_ FullTcp
La classe Http/Client modella il comportamento di un semplice browser web: genera una sequenza di richieste di pagine web con intervallo casuale tra una richiesta e un'altra e un identificatore di pagina anch'esso casuale.
Per creare un client e porlo su un nodo già esistente:
set client [new Http/Client $ns $node]
Per connettere un client a un server (che deve essere precedentemente creato):
$client connect $server
Per connettere un client a una cache (che deve essere precedentemente creata):
$client connect $cache
Ad un client è permesso connettersi ad una sola cache, ma esso può connettersi a più server.
Per indicare a un client quale sia il set di pagine disponibili:
$client set-page-generator $pgp
Il set di pagine è un oggetto appartenente alla classe PagePool e può contenere una sola pagina (come nel caso di PagePool/Math) o più pagine (come nel caso di PagePool/Trace).
Per assegnare al client una variabile casuale che determini gli intervalli di tempo tra una richiesta e un'altra:
$client set-interval-generator $ranvar
Per far iniziare il client a generare richieste di pagine:
$client start-session $cache $server
La classe Http/Server modella il comportamento di un server Http.
Per creare un server e porlo su un nodo già esistente:
set server [new Http/Server $ns $node]
Per indicare a un server quale sia il set di pagine disponibile (lo stesso indicato al client!):
$server set-page-generator $pgp
Quando inizia la simulazione il server attende di ricevere richieste.
La classe Http/Cache modella il comportamento di una semplice cache Http di ampiezza infinita.
Per creare una cache e porla su un nodo già esistente:
set cache [new HttpCache $ns $node]
Per connettere una cache a un server:
$cache connect $server
I trace file prodotti dagli Agent Http hanno estensione .log e consistono di una riga per ogni evento verificatosi nella simulazione.
Time ObjectID Object Values
Time è l'istante in cui si è verificato l'evento descritto.
ObjectID è un identificatore numerico.
Object Values è a sua volta costituito da più campi:
1)Object Type: è una lettera maiuscola che indica se l'oggetto che ha generato l'evento è un client (lettera C), una cache (lettera E), o un server (lettera S).
2)Event Type: è una sigla che indica il tipo di evento.
3)Values: è un elenco di valori diverso per ogni evento.
Seguono tre tabelle dei più significativi eventi associati a client, cache e server.
CACHE
|
||
| Event Type |
Values |
Spiegazioni |
| HIT |
p <pageID> c <clientID> s <serverID> |
La cache possiede già la pagina <pageID> il cui proprietario è il server <serverID> |
| MISS | p <pageID> c <clientID> s <serverID> z <RequestSize> |
La cache non possiede la pagina <pageID> e spedirà una richiesta al server <serverID> per ottenerla |
| IMS | p <pageID> c <clientID> s <serverID> z <RequestSize> t <CacheEntryTime> |
Una cache vuole sapere se la pagina <pageID> è stata modificata in quanto il suo timer-vita nella cache è scaduto |
| SND | p <pageID> m <LastModifiedTime> z <Size> t <RequestType> |
Il server invia una risposta |
| UPD | p <pageID> c <clientID> s <serverID> m <LastModifiedTime> z <PageSize> s <serverID> |
Aggiornamento di una pagina |
| ENT | p <pageID> c <clientID> s <serverID> m <LastModifiedTime> z <PageSize> s <serverID> |
Introduzione di una pagina nella cache |
| CLIENT |
||
| Event Type | Values | Spiegazione |
| GET | p <pageID> s <PageServerID> z <RequestTime> |
Il client richiede una pagina |
| STA | p <pageID> s <OrigServerID> l <StaleTime> |
Il client si è accorto all'istante l che la pagina ricevuta è uguale a quella che aveva già |
| RCV | p <pageID> s <PageServerID> l <ResponseTime> z <PageSize> |
Il client riceve una pagina |
| SERVER |
||
| Event Type | Values | Spiegazione |
| SND | p <pageID> m <LastModifiedTime> z <Size> t <RequestType> |
Il server invia una risposta |
| UPD | p <pageID> m <LastModifiedTime> z <Size> |
Il server invia alla cache un aggiornamento di una pagina |
| MOD | p <pageID> m <LastModifiedTime> |
Il server annuncia che la pagina è stata modificata |
Nell'esempio http1.tcl due client possiedono ognuno una propria cache e interrogano un server comune.
Siccome è stato scelto un PagePool di tipo Math, animando la simulazione nel nam si vede che solo la prima richiesta di ogni client viene inoltrata al server mentre successivamente, siccome il client continua a chiedere sempre la stessa pagina, la cache risponde direttamente. Un client in attesa di risposta viene circondato da un cerchietto lilla. Una cache inizialmente vuota, quando riceve per la prima volta una pagina e la memorizza, da gialla diviene blu. Nel log file è possibile notare alcuni degli eventi descritti nelle tabelle di questa pagina.
Potete prelevare l'esempio http1.tcl cliccando qui.
Purtroppo non è possibile sostituire il PagePool/Math con il più ampio PagePool/Trace per realizzare una più completa animazione del protocollo Http: infatti - a quanto ci è stato spiegato da alcuni ricercatori giapponesi iscritti alla mailing list di ns - il PagePool/Trace è stato concepito per generare solo dei trace file e non dei nam trace file, e inoltre esso funziona solo con la variante del simulatore implementata da Gwertzman: eecs.harvard.edu/pub/vino/usenixsim.tar.gz
Un altro PagePool esistente è il PagePool/ProxyTrace, ma per poterlo usare con ns si ha bisogno di un convertitore disponibile all'indirizzo:
http://www.isi.edu/~haoboy/files/tr-conv.tar.gz.Pur essendoci rassegnati ad usare solo il PagePool/Math, abbiamo pensato di realizzare comunque una animazione che dia un'idea del tipo di traffico generato tra un client e un server che usano il protocollo http. Nell'esempio http2.tcl abbiamo posto il client su un nodo n1, e la sua cache sullo stesso nodo (n2) dove si trova il server. In questo modo, non appena la cache memorizza per la prima volta l'unica pagina esistente, tutto procede come se la cache fosse il server; è così possibile visualizzare nel nam il tipico traffico generato da uno scambio di richieste e risposte tra un client e un server che usano il protocollo http. In pratica è come se il client non avesse più una sua memoria cache e richiedesse sempre la stessa pagina: dal punto di vista del traffico generato questa situazione è equivalente a quella di un client che ha una memoria cache ma richiede al server pagine sempre diverse.
Potete prelevare l'esempio http2.tcl cliccando qui.