Questo è un file dell'advisor di esempio denominato ADV_sample.
/ * *
* ADV_sample: Advisor HTTP di Load Balancer
*
*
* Questa classe definisce un advisor personalizzato di esempio per Load Balancer. Come tutti
* gli advisor, questo advisor personalizzato estende la funzione dell'advisor di base,
* denominato ADV_Base. Questo è l'advisor che esegue la maggior parte
* delle funzioni dell'advisor, come ad esempio la notifica dei carichi al Load Balancer
* da utilizzare nell'algoritmo di valutazione. L'advisor di base, inoltre,
* effettua le operazioni di connessione e chiusura del socket e fornisce
* i metodi di invio e ricezione che devono essere utilizzati dall'advisor. L'advisor viene utilizzato
* esclusivamente per l'invio e la ricezione dei dati a e dalla porta sul server
* esaminato. I metodi TCP forniti con l'advisor di base sono programmati per calcolare
* il carico. Se necessario, un indicatore all'interno del costruttore dell'advisor
* di base sostituisce il carico esistente con il nuovo carico restituito dall'advisor.
*
* Nota: in base al valore impostato nel costruttore, l'advisor di base fornisce
* il carico all'algoritmo di valutazione ad intervalli specificati. Se
* l'advisor effettivo non è stato completato in modo che restituisca un carico valido,
* l'advisor di base utilizza il carico precedente.
*
* DENOMINAZIONE
*
* La convenzione di denominazione è la seguente:
*
* - Il file deve essere presente nella seguente directory di Load Balancer:
*
* ulb/servers/lib/CustomAdvisors/ (ulb\servers\lib\CustomAdvisors in Windows)
*
* - Il nome Advisor deve essere preceduto da "ADV_". Tuttavia, è possibile
* avviare l'advisor solo con il nome; ad esempio, l'advisor "ADV_sample"
* può essere avviato con "sample".
*
* - Il nome dell'advisor deve avere caratteri minuscoli.
*
* Quindi, tenendo presente quanto riportato sopra, questo esempio viene definito:
*
* <base directory="">/lib/CustomAdvisors/ADV_sample.class
*
*
* Gli advisor, come i restanti componenti di Load Balancer, devono essere compilati con
* la versione prerequisita di Java. Per garantire l'accesso alle classi di Load Balancer,
* verificare che il file ibmlb.jar (situato nella sottodirectory lib della directory
* base) sia contenuto nella variabile CLASSPATH del sistema.
*
* Metodi forniti da ADV_Base:
*
* - ADV_Base (Costruttore):
*
* - Parametri
* - String sName = Nome dell'advisor
* - String sVersion = Versione dell'advisor
* - int iDefaultPort = Numero porta predefinita su cui effettuare l'esame
* - int iInterval = Intervallo durante il quale eseguire l'esame dei server
* - String sDefaultName = Non utilizzato. Deve essere inoltrato come "".
* - boolean replace = True - sostituisce il valore del carico calcolato
* dall'advisor di base
* False - aggiunge il valore del carico calcolato
* dall'advisor di base
* - Ritorno
* - I costruttori non dispongono di valori di ritorno.
*
* Poiché l'advisor di base è basato sul thread, sono disponibili
* altri metodi a cui è possibile fare riferimento utilizzando
* il parametro CALLER inviato in getLoad().
*
* Questi metodi sono:
*
* - send - Invia un pacchetto di informazioni sulla connessione socket stabilita
* al server sulla porta specificata.
* - Parametri
* - String sDataString - I dati da inviare sotto forma di una stringa
* - Ritorno
* - int RC - Invio dei dati riuscito o meno: zero indica che
* che i dati sono stati inviati; un intero negativo indica un errore.
*
* - receive - Riceve le informazioni dalla connessione socket.
* - Parametri
* - StringBuffer sbDataBuffer - I dati ricevuti durante la chiamata di ricezione
* - Ritorno
* - int RC - Ricezione dei dati riuscita o meno; zero
* indica che i dati sono stati ricevuti; un valore intero negativo indica
* un errore.
*
* Se la funzione fornita dall'advisor di base non è sufficiente,
* è possibile creare la funzione appropriata all'interno dell'advisor ed
* i metodi forniti dall'advisor di base verranno ignorati.
*
* Una domanda importante sul carico restituito è se applicare
* tale carico a quello generato nell'advisor di base
* oppure se sostituirlo; sono presenti istanze valide di entrambe le situazioni.
*
* Questo esempio corrisponde essenzialmente all'advisor HTTP di Load Balancer. * Esso è molto semplice: viene emessa una richiesta di invio, una richiesta head http. Una volta
* ricevuta la risposta, il metodo getLoad termina, indicando all'advisor
* di base di arrestare la tempificazione della richiesta. Il metodo è quindi completo. Le
* informazioni restituite non vengono analizzate; il carico si basa sul tempo
* necessario per eseguire le operazioni di invio e ricezione.
*/
package CustomAdvisors;
import com.ibm.internet.nd.advisors.*;
public class ADV_sample extends ADV_Base implements ADV_MethodInterface
{
String COPYRIGHT =
"(C) Copyright IBM Corporation 1997, All Rights Reserved.\n";
static final String ADV_NAME = "Sample";
static final int ADV_DEF_ADV_ON_PORT = 80;
static final int ADV_DEF_INTERVAL = 7;
// Nota: la maggior parte dei protocolli del server richiede un ritorno a capo ("\r")
// e un avanzamento riga ("\n") alla fine dei messaggi. In questo caso, includerli
// nella stringa.
static final String ADV_SEND_REQUEST =
"HEAD / HTTP/1.0\r\nAccept: */*\r\nUser-Agent: " +
"IBM_Load_Balancer_HTTP_Advisor\r\n\r\n";
/**
* Costruttore.
*
* Parametri: Nessuno; tuttavia, il costruttore per ADV_Base ha diversi parametri
* che devono essere inoltrati.
*
*/
public ADV_sample()
{
super( ADV_NAME,
"2.0.0.0-03.27.98",
ADV_DEF_ADV_ON_PORT,
ADV_DEF_INTERVAL,
"", // non utilizzato false);
super.setAdvisor( this );
}
/**
* ADV_AdvisorInitialize
*
* Qualsiasi inizializzazione specifica dell'advisor che deve essere effettuata
* in seguito all'avvio dell'advisor di base. Questo metodo viene richiamato solo
* una volta e, generalmente, non viene utilizzato.
*/
public void ADV_AdvisorInitialize()
{
return;
}
/**
* getLoad()
*
* Questo metodo viene chiamato dall'advisor di base per completare il funzionamento
* dell'advisor, in base ai dettagli specifici del protocollo. In questo advisor
* di esempio, è necessaria solo una singola operazione di invio e di ricezione; in
* caso di logiche più complesse, è possibile emettere più operazioni di invio e
* ricezione. Ad esempio, una risposta potrebbe essere ricevuta e analizzata. In base alle
* informazioni apprese, potrebbe essere emessa un'altra operazione di invio e di ricezione.
*
* Parametri:
*
* - iConnectTime - Il carico corrente poiché fa riferimento al tempo impiegato
* per completare la connessione al server attraverso
* la porta specificata.
*
* - caller - Un riferimento alla classe dell'advisor di base in cui i metodi forniti da Load
* Balancer devono eseguire richieste TCP semplici,
* principalmente di invio e ricezione.
*
* Risultati:
*
* - Carico - Un valore, espresso in millisecondi, che può essere aggiunto
* o sostituito al carico esistente, come specificato
* dall'indicatore "replace" del costruttore.
*
* Più è grande il carico e maggiore sarà il tempo necessario al server per rispondere;
* quindi, il peso all'interno di Load Balancer sarà minore.
*
* Se il valore è negativo, potrebbe essersi verificato un errore. Un errore proveniente
* da un advisor indica che il server che l'advisor sta tentando di raggiungere non
* è accessibile ed è stato identificato come inattivo. Load Balancer
* non tenterà di eseguire il bilanciamento del carico su un server non attivo. Load Balancer
* riprenderà tale operazione quando riceverà un valore positivo da tale server.
*
*/
public int getLoad(int iConnectTime, ADV_Thread caller) {
int iRc;
int iLoad = ADV_HOST_INACCESSIBLE; // -1
// Invia la richiesta tcp iRc = caller.send(ADV_SEND_REQUEST);
if (iRc >= 0)
{
// Esegue una ricezione
StringBuffer sbReceiveData = new StringBuffer("");
iRc = caller.receive(sbReceiveData);
/**
* In modalità advisor normale (l'indicatore "replace" è false), il carico
* restituito è 0 o 1 a seconda se il server è attivo o meno.
* Se la ricezione è avvenuta con esito positivo, viene restituito un carico con valore
* zero che indica che è necessario utilizzare il carico creato nell'advisor di base.
*
* Altrimenti (l'indicatore "replace" è true), viene restituito il valore di carico
* desiderato.
*/
if (iRc >= 0)
{
iLoad = 0;
}
}
return iLoad;
}
} // Fine - ADV_sample