Modifiche al codice sorgente

Per poter sfruttare tutte le potenzialità di HAProxy è stato necessario modificarne il codice sorgente in alcuni punti, in modo da aggiungere alcune funzionalità necessarie per l'utilizzo in collaborazione con gli altri elementi del sistema autoscalabile. Molte funzioni sono state implementate per essere utilizzate tramite il socket unix fornito dal load balancer. In particolare è stato implementato un filtro per l'opzione di dump delle tabelle per permettere al sistema di verificare in maniera molto veloce se sono presenti delle sessioni attive su un determinato server. HAProxy fornisce dalla versione 1.5 un comando, utilizzabile tramite il socket unix, per visualizzare il contenuto di una sticky table, fornendo il nome del backend a cui essa è associata. I dati visualizzabili sono molteplici, a seconda di come è stata definita la sticky table, ma il dato di fondamentale interesse per la nostra applicazione è il valore server_id; questo parametro rappresenta l'ID del server a cui è associata una determinata sessione. È stato necessario però applicare a questi risultati un filtro per ottenere le informazioni relative alle sessioni attive su un server a partire dal nome e non dall'ID, visto che questi vengono scelti da HAProxy in maniera automatica, mentre i nomi dei server sono personalizzabili. Questa funzionalità però non si limita a filtrare il contenuto della tabella, infatti l'informazione di cui si necessita per il corretto funzionamento dell'applicazione è quella di sapere se ci sono sessioni attive su un determinato server o meno. La procedura implementata effettua una scansione del contenuto della tabella, cercando una corrispondenza tra l’ID associato al nome del server passato come parametro e l'id di ogni entry; quando una corrispondenza viene riscontrata, la procedura invia un messaggio di output e termina la sia esecuzione, evitando di continuare la scansione dell'intera tabella, operazione che non aggiunge informazioni utili di alcun tipo. Il servizio implementato si può richiamare tramite una comunicazione sul socket unix del tipo: show table <nome> data.act_session srv <srvname>, dove il nome si riferisce al backend di cui si vuole visualizzare la tabella e srvname è il nome del server preso in considerazione.

9.3. Load balancer - HAProxy 137 Le modifiche apportate al codice sorgente riguardano le funzioni che gestiscono l'interazione con i dati ricevuti sul socket unix, il dumping dei dati delle sticky-table e le operazioni di filtraggio delle entry ottenute.

Filtro act_sessions srv <srvname>

Per prima cosa sono stati definiti i tipi di dati mancanti per poter applicare un filtro personalizzato sul nome dei server, passato come array di char. Nel file types/stick_table.h si è definito il tipo di dati STD_T_STRING aggiungendo l'istruzione:

enum {

STD_T_SINT = 0, /* data is of type signed int */

STD_T_UINT, /* data is of type unsigned int */

STD_T_ULL, /* data is of type unsigned long long */

STD_T_FRQP, /* data is of type freq_ctr_period */

STD_T_STRING, /* data is of type string */

};

Per definire il tipo di dato “act_session”, necessario poi per applicare il filtro, si deve aggiungere nel file stick_table.c (che importa il file stick_table.h precedente) la definizione di tale dato:

struct stktable_data_type stktable_data_types[STKTABLE_DATA_TYPES] = {

[STKTABLE_DT_SERVER_ID] = { .name = "server_id", .std_type =

STD_T_SINT },

…...

Infine nel file standard.h è stato aggiungo un comparatore srv modificando la sezione di codice: /* operators to compare values. They're ordered that way so that the lowest bit

* serves as a negation for the test and contains all tests that are not equal. */ enum { STD_OP_LE = 0, STD_OP_GT = 1, STD_OP_EQ = 2, STD_OP_NE = 3, STD_OP_GE = 4, STD_OP_LT = 5, STD_OP_SRV = 5, };

Nel file standard.c associato si deve verificare la presenza della keywork “srv” utilizzata come comparatore:

}elseif (*str == 's' && str[1] == 'r'&& str[2] == 'v')

returnSTD_OP_SRV;

Una volta definiti i dati, si aggiungere la gestione del filtro vero e proprio nel codice contenuto nel file dumpstats.c, modificando la sezione dedicata al comando “show table”, facendo in modo di riconoscere il filtro del tipo data.act_session srv <nomesrv>: se l'operatore è “srv” salva il nome del server passato come parametro per potervi accedere successivamente:

if(s->data_ctx.table.data_op == STD_OP_SRV){ strcpy(s->srvname,args[5]);

Nella funzione stats_dump_table_to_buffer è stata aggiunta nella prima parte una sezione di codice che scandisce i server presenti nel backend associato alla tabella selezionata, verifica se c'è una corrispondenza e manda un messaggio di errore se non è stato trovato nessun server. Per scandire tutti i server si deve utilizzare un ciclo in grado di scandire una lista di strutture di tipo server, sfruttando il campo “next” presente in ognuna di esse. Quando un server viene trovato, si applica un filtro sull'ID ad esso associato, così nella fase di dump il sistema automaticamente visualizzerà solo i dati richiesti.

/* if a filter for active session has been applies, search for the srv name and bind it with its id * otherwise return error

*/

if(s->data_ctx.table.data_op == STD_OP_SRV){

struct proxy* px;

px= s->data_ctx.table.target;

//set comparation parameters to -1 in case there will be no matches

s->data_ctx.table.value = -1;

if(px != NULL){

struct server* ser;

s->data_ctx.table.data_op = STD_OP_EQ;

/*added*/

for(ser = px->srv;ser != NULL;ser=ser->next){

//check which server id to filter based on name

if(strcmp(s->srvname , ser->id) ==0){ s->data_ctx.table.value = ser->puid; s->data_ctx.table.data_op = STD_OP_EQ;

printf("filter applied for server with name %s with id %d\n", ser->id,ser->puid);

} }

/* no server has been found, send erros message*/

if(s->data_ctx.table.value == -1){

chunk_printf(&msg, "No server Found with Name: %s\n",s->srvname);

if (buffer_feed_chunk(rep, &msg) >= 0) return 0; s->data_state = DATA_ST_FIN; } } }

Infine nella fase di filtraggio vero e proprio si è aggiunto il caso relativo al tipo di dato STD_T_STRING, che controlla se vi è un match tra il server ID precedentemente impostato e quello della entry da analizzare, se il valore è lo stesso, viene inviato un messaggio sul socket e l'operazione viene terminata.

/* compare values

* if a match has been found, stop the search and print * the output message

*/

if(data == s->data_ctx.table.value){

printf("session found! stopping the search\n"); s->data_state = DATA_ST_FIN;

//output message

chunk_printf(&msg, "%s has still active sessions\n",s->srvname); }

Questa nuova funzione è molto simile al comando show table, già presente in HAProxy, ma risulta essere più facile da utilizzare, dato che si deve semplicemente conoscere il nome di un server per poter accedere alle informazioni di cui si necessita, inoltre il tempo richiesto per eseguire questa operazione sarà sicuramente minore rispetto al dump dell'intera tabella, infatti la ricerca viene effettuata solo fino alla prima occorrenza utile, evitando così di dover accedere a tutti i dati della tabella.

9.3. Load balancer - HAProxy 139 Stick-store solo per server non-running

Un'altra modifica apportata al codice di HAProxy riguarda la gestione delle sticky table, per fare in modo che le sole sessioni associate a server in maintenance mode vengano inserite nella tabella. È importante sottolineare che senza questa modifica non sarebbe possibile avere la certezza che su un server in zombie mode non siano presenti sessioni attive. Le modifiche apportate al codice interessano le procedure di gestione delle sessioni e del parsing dei dati dei pacchetti ricevuti.

Nel file session.c, è stata modificata la sezione di codice in cui il load balancer decide se avviare la funzione per l'inserimento della entry nella sticky-table; è stata aggiunta una condizione che si verifica solamente se il server non è nello stato running.

struct server* srv= s->srv;

int state = srv->state;

if(!(state & SRV_RUNNING)){

Prima di applicare questa condizione è necessario accedere allo stato attuale del server corretto, tramite un puntatore della struttura session, che permette di accedere direttamente alla struttura del server in questione.

/* questa modifica attiva la sticky table solamente per i server che non sono nella fase running

* così si salveranno solamente le sessioni attive su un server in fase di spegnimento*/

if(s->srv){

struct server* srv= s->srv;

int state = srv->state;

if(!(state & SRV_RUNNING)){

ts = stksess_new(rule->table.t, key);

if (ts) {

s->store[s->store_count].table = rule->table.t; s->store[s->store_count++].ts = ts;

} }

}

Durante la fase di sperimentazione sono state effettuate ulteriori modifiche al codice sorgente di HAProxy, in primo luogo è stato modificato il codice che si occupa delle policy di inserimento delle entry nella sticky-table, facendo in modo che il sistema inserisca una entry per ogni richiesta ricevuta, anche se queste hanno la chiave in comune; tuttavia questa funzionalità non si è rivelata utile ai fini dell'implementazione del servizio di autoscaling.

Un'altra modifica è stata effettuata per poter aggiungere e togliere server da un backend inviando dei comandi tramite il socket di amministrazione, evitando quindi di dover riavviare il load balancer tutte le volte. Questa funzionalità può rivelarsi molto utile per uno sviluppo futuro del sistema, se si volesse rendere il load balancer in grado di mantenere tutti i dati in memoria. Per fare ciò si richiede di non

riavviare mai il processo, nemmeno in modalità soft-restart, il che rende fondamentali queste due funzioni.