[AIX HP-UX Linux Solaris Windows]

Ejemplo: asesor de ejemplo

A continuación se muestra un archivo de asesor de ejemplo denominado ADV_sample.

/ * * 
 * ADV_sample: Asesor HTTP de Load Balancer HTTP 
 * 
 * 
 * Esta clase define un asesor personalizado de ejemplo para Load Balancer. Al igual que todos los 
 * asesores, este asesor personalizado amplía la función de la base del asesor, 
 * denominada ADV_Base. La base del asesor efectúa la mayoría de las 
 * funciones del asesor, como informar de las cargas a Load Balancer 
 * para su uso en el algoritmo de peso de Load Balancer. La base del asesor también 
 * realiza operaciones de cierre y conexión de sockets y proporciona métodos de 
 * envío y recepción para que el asesor los utilice. El asesor sólo se utiliza para 
 * enviar y recibir datos a y desde el puerto del servidor que se está 
 * asesorando. Los métodos TCP incluidos en la base del asesor se temporizan para calcular 
 * la carga. Un distintivo dentro del constructor en ADV_base sobrescribe la 
 * carga existente con la nueva carga devuelta desde el asesor, si se desea. 
 * 
 * Nota: en función de un valor establecido en el constructor, la base del asesor proporciona 
 * la carga al algoritmo de peso a intervalos especificados. Si el asesor real 
 * no se ha completado de forma que pueda devolver una carga válida, la base 
 * del asesor utiliza la carga anterior. 
 * 
 * DENOMINACIÓN 
 * 
 * La convención de denominación es la siguiente: 
 * 
 * - El archivo debe estar en el directorio siguiente de Load Balancer: 
 * 
 *     ulb/servers/lib/CustomAdvisors/ (ulb\servers\lib\CustomAdvisors en Windows) 
 * 
 *  - El nombre del asesor debe ir precedido por "ADV_". El asesor se puede 
 *    iniciar, no obstante, sólo con el nombre; por ejemplo el asesor "ADV_sample" 
 *    se puede iniciar con "sample". 
 * 
 *  - El nombre del asesor debe estar en minúsculas. 
 * 
 * Teniendo en cuenta estas reglas, se hace referencia a este ejemplo como:
 * 
 *     <base directory="">/lib/CustomAdvisors/ADV_sample.class 
 * 
 *
 * Los asesores, al igual que el resto de Load Balancer, deben compilarse con la 
 * versión de requisito previo de Java. Para garantizar el acceso a las clases de Load Balancer, 
 * asegúrese de que el archivo ibmlb.jar (que se encuentra en el subdirectorio lib del 
 * directorio * de la base) está incluido en la CLASSPATH del sistema. 
 * 
 * Métodos proporcionados por ADV_Base: 
 * 
 * - ADV_Base (Constructor): 
 * 
 *   - Parámetros 
 *     - String sName = Nombre del asesor 
 *     - String sVersion = Versión del asesor 
 *     - int iDefaultPort = Número de puerto predeterminado en el que se asesorará 
 *     - int iInterval = Intervalo en el que se asesorará sobre los servidores 
 *     - String sDefaultName = No utilizado. Debe pasarse como "". 
 *     - boolean replace = True - se sustituye el valor de carga que se calcula 
 *                                por la base del asesor 
 *                           False - se añade al valor de carga que se calcula 
 *                                por la base del asesor 
 *   - Retorno 
 *     - Los constructores no tienen valores de retorno. 
 * 
 * Dado que la base del asesor se basa en hebras, tiene otros métodos 
 * disponibles para que los use un asesor. Se puede hacer referencia a estos métodos 
 * mediante el parámetro CALLER pasado en getLoad(). 
 * 
 * Estos métodos son los siguientes: 
 *  
 * - send - Envía un paquete de información en la conexión de socket establecida  
 *          al servidor en el puerto especificado. 
 *   - Parámetros 
 *   - String sDataString - Los datos deben enviarse en formato de serie 
 *   - Retorno
 *   - int RC - Indica si los datos se han enviado correctamente o no: cero indica 
 *              que se han enviado; un entero negativo indica un error. 
 * 
 * - receive - Recibe información de la conexión de socket. 
 *   - Parámetros 
 *     - StringBuffer sbDataBuffer - Los datos recibidos durante la llamada de recepción 
 *   - Retorno 
 *     - int RC - Si los datos se han recibido correctamente o no; cero 
 *                indica que los datos se recibieron; un entero negativo indica
 *                un error. 
 * 
 * Si la función que proporciona la base del asesor no es suficiente, 
 * puede crear la función adecuada dentro del asesor y 
 * los métodos que proporcione la base del asesor se pasarán por alto. 
 * 
 * Una cuestión importante en relación con la carga devuelta es si se aplica 
 * a la carga que se genera en la base del asesor 
 * o se sustituye; hay instancias válidas de ambas situaciones. 
 * 
 ' Este ejemplo es básicamente el asesor HTTP de Load Balancer. Funciona 
 * de manera muy sencilla: se emite una solicitud de envío --una solicitud HTTP HEAD--. Una vez 
 * que se recibe una respuesta, el método getLoad termina y señala la base del asesor 
 * para que deje de temporizar la solicitud. Entonces el método se ha completado. La 
 * información devuelta no se analiza; la carga se basa en el tiempo 
 * necesario para realizar las operaciones de envío y recepción. 
 */ 

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, Reservados todos los derechos.\n"
    static final String ADV_NAME = "Ejemplo"; 
    static final int ADV_DEF_ADV_ON_PORT = 80; 
    static final int ADV_DEF_INTERVAL = 7; 

    // Nota: la mayoría de protocolos de servidor requieren un retorno de carro ("\r") y 
    // un avance de línea ("\n") al final de los mensajes. Si es así, inclúyalos en 
    // su serie. 
    
    static final String ADV_SEND_REQUEST = 
       "HEAD / HTTP/1.0\r\nAccept:  */ *\r\nUser-Agent: " + 
       "IBM_Load_Balancer_HTTP_Advisor\r\n\r\n"; 

    /** 
     * Constructor. 
     * 
     * Parámetros: ninguno; pero el constructor de ADV_Base tiene varios parámetros 
     *   que deben pasarse a él. 
     * 
     */ 
     public ADV_sample() 
     { 
       super( ADV_NAME, 
          "2.0.0.0-03.27.98", 
               ADV_DEF_ADV_ON_PORT, 
               ADV_DEF_INTERVAL, 
               "", // not used false); 
       super.setAdvisor( this );
     } 


     /**
      * ADV_AdvisorInitialize  
      *
      * Se inicia cualquier inicialización específica de asesor que deba tener lugar 
      * después de iniciar la base del asesor. Sólo se llama a este método una vez y 
      * normalmente no se utiliza. 
      */
      public void ADV_AdvisorInitialize()
      {
        return;
      }

      /**
       * getLoad() 
       * 
       * Se llama a este método mediante la base del asesor para completar
       * el funcionamiento del asesor, según detalles específicos del protocolo. En este
       * asesor de ejemplo, sólo se necesitan un envío y una recepción; si es necesaria  
       * una lógica más compleja, pueden emitirse varios envíos y recepciones. Por  
       * ejemplo, puede recibirse y analizarse una respuesta. Según la  
       * información aprendida así, pueden emitirse otro envío y recepción.  
       *  
       * Parámetros:  
       *  
       * - iConnectTime - La carga actual referida al período de tiempo que  
       *                  se tardó en completar la conexión con el servidor  
       *                  a través del puerto especificado.  
       *  
       * - caller - Una referencia a la clase de base del asesor donde los  
       *            métodos proporcionados por Load Balancer deben realizar solicitudes TCP simples,  
       *            principalmente envíos y recepciones.
       * 
       * Resultados: 
       * 
       * - La carga - Un valor, expresado en milisegundos, que puede añadirse a la 
       *   carga existente o que puede sustituir la carga existente, como 
       *   determine el distintivo "replace" del constructor. 
       * 
       *   Cuanto mayor sea la carga, más tiempo tardará el servidor en responder;  
       *   por lo tanto, menor será el peso dentro de Load Balancer. 
       *  
       *   Si el valor es negativo, se da por supuesto un error. Un error de un  
       *   asesor indica que el servidor que el asesor intenta alcanzar no es  
       *   accesible y se ha identificado como inactivo. Load Balancer  
       *   intentará equilibrar la carga en un servidor inactivo. Load Balancer  
       *   reanudará el equilibrado de carga en el servidor cuando se reciba un valor positivo. 
       * 
       */ 
      public int getLoad(int iConnectTime, ADV_Thread caller) 
      { 
        int iRc; 
        int iLoad = ADV_HOST_INACCESSIBLE; // -1 

        // Send tcp request iRc = caller.send(ADV_SEND_REQUEST);
        if (iRc >= 0) 
        { 
            // Realizar una recepción 
            StringBuffer sbReceiveData = new StringBuffer(""); 
            iRc = caller.receive(sbReceiveData); 
         
         /**
          * En la modalidad de asesor normal (el valor del distintivo "replace" es false), la carga 
          * devuelta es 0 o 1, lo que indica que el servidor está activo o inactivo. 
          * Si la recepción es correcta, se devuelve una carga de cero 
          * que indica que debe utilizarse la carga construida en el asesor base. 
          * 
          * De lo contrario (el valor del distintivo "replace" es true), devuelva el valor de carga deseado. 
          */
 
          if (iRc >= 0) 
          {
             iLoad = 0; 
          } 
        } 
        return iLoad; 
      } 
  } // Fin de ADV_sample
Tema de referencia Tema de referencia    

Condiciones de uso | Comentarios

last-updated-altÚltima actualización: Jul 5, 2011 11:19:44 AM EDT
Nombre de archivo: rprf_advexample.html