Esempio: advisor di esempio

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
Argomento di riferimento    

Clausole e condizioni per i centri informazioni | Feedback

Ultimo aggiornamento: May 14, 2012 01:50 PM EDT
Nome file: rprf_advexample.html