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
Reference topic    

Terms and conditions for information centers | Feedback

Last updated: May 23, 2013 03:57 PM EDT
File name: rprf_advexample.html