Indice general de los manuales

  1. Introducción, instalación en Ubuntu y creación de una calculadora.
  2. Modos de compartición de objetos. Creando nuestra primera calculadora distribuida.
    1. Modos de compartición de objetos: Singlecall.
    2. Modos de compartición de objetos: Singleton.
    3. Modos de compartición de objetos: CAO.  «  [Leyendo]
  3. Canales: TCP y HTTP. Configuración en archivo XML.
  4. Uso de interfaces para separar el código entre cliente y servidor.

CAO

La última de las formas de compartir los objetos desde el servidor es CAO: Client Activated Object. De esta forma, cada cliente que acceda al servidor, podrá crear un objeto en el y usarlo de forma independiente. En nuestro ejemplo, cada cliente tendrá su propia calculadora.

cao

Como vemos, cada cliente tiene su propia calculadora, y cada calculadora guarda su estado.

Aunque el nuevo código del servidor es muy parecido a los anteriores, pongo el cuerpo de Main entero:

  1. // Archivo: Servidor.cs
  2. // Descripcion: programa servidor que comparte
  3. // la clase Calculadora remotamente.
  4.  
  5. // Biblioteca estandar y remoting
  6. using System;
  7. using System.Runtime.Remoting;
  8.  
  9. // Bibliotecas para usar un canal HTTP
  10. using System.Runtime.Remoting.Channels;
  11. using System.Runtime.Remoting.Channels.Http;
  12. using Calculo;
  13.  
  14. public class Servidor
  15. {
  16.   // arg[0] representa el puerto del servidor
  17.   public static void Main (string[] args)
  18.   {
  19.     // Creamos un nuevo objeto para el canal HTTP
  20.     HttpChannel chnl = new HttpChannel(int.Parse(args[0]));
  21.  
  22.     // Le decimos a la máquina que nos reserve ese canal
  23.     ChannelServices.RegisterChannel(chnl);
  24.     
  25.     // Opciones para la comparticion de la clase
  26.     RemotingConfiguration.ApplicationName =
  27.        “ServidorDeCalculadoras”;
  28.     RemotingConfiguration.RegisterActivatedServiceType(
  29.       typeof(Calculo.Calculadora));
  30.  
  31.     // Mensajes de espera en la pantalla
  32.     Console.WriteLine(“Atendiendo las peticiones…”);
  33.     Console.WriteLine(“Pulse Enter para salir…”);
  34.     Console.ReadLine();
  35.   }
  36. }

La configuración del servidor la hemos dividido en dos partes, le hemos adjudicado un nombre que será el del servidor, no el de una calculadora; y después hemos compartido la calculadora.

Vamos a modificar el cliente por completo, para que no tengamos que hacer dos clientes diferentes para ver el funcionamiento de esta forma de compartir.

  1. // Archivo: Cliente.cs
  2. // Version: 2.0
  3. // Descripcion: cliente que usara la clase remota Calculadora
  4.  
  5. // Biblioteca estandar y remoting
  6. using System;
  7. using System.Runtime.Remoting;
  8.  
  9. // Bibliotecas para usar un canal HTTP
  10. using System.Runtime.Remoting.Channels;
  11. using System.Runtime.Remoting.Channels.Http;
  12. using Calculo;
  13.  
  14. public class Cliente
  15. {
  16.   // arg[0] representa el host del servidor
  17.   // arg[1] representa el puerto del servidor
  18.   // arg[2] representa el numero que guardamos en LaBase
  19.   public static void Main (string[] args)
  20.   {
  21.     // Creamos un nuevo objeto para el canal HTTP
  22.     HttpChannel chnl = new HttpChannel();
  23.  
  24.     // Le decimos a la máquina que nos reserve ese canal
  25.     ChannelServices.RegisterChannel(chnl);
  26.  
  27.     // Opciones para la utilizacion remota de la clase
  28.     RemotingConfiguration.RegisterActivatedClientType(
  29.       typeof(Calculo.Calculadora),
  30.       “http://” + args[0] + “:” + args[1]);
  31.  
  32.     // Creamos un objeto
  33.     Calculadora calc = new Calculadora();
  34.  
  35.     // Practicamos
  36.     calc.LaBase = int.Parse(args[2]);
  37.     Console.WriteLine(“Cambiado a: “ + cacl.LaBase);
  38.  
  39.     Console.WriteLine(“Pulse Enter para ver el estado…”);
  40.     Console.ReadLine();
  41.  
  42.     Console.WriteLine(“Hemos cambiado la base a “ + calc.LaBase);
  43.   }
  44. }

 

Podemos ver varios cambios en este nuevo cliente:

  • A diferencia de los anteriores, solo necesitamos saber el host y el puerto del servidor, no nos hace falta saber el nombre con el que el servidor se ha autodenominado.
  • Hemos añadido un nuevo argumento al ejecutar el programa, que será el número que queremos adjudicar a LaBase, y así poder hacer varias pruebas para cambiar el estado desde el cliente sin tener que crear dos.
  • Para comprobar que cada cliente tiene su propia calculadora, hemos interrumpido el programa a la mitad (pulsando Enter) para cambiar el estado desde dos clientes diferentes que se ejecutan a la misma vez y comprobar después que cada uno tiene una calculadora con su propio estado.

Ahora solo nos queda compilar los archivos:

mcs -target:library Calculo.cs
mcs -r:Calculo.dll -r:System.Runtime.Remoting.dll Servidor.cs
mcs -r:Calculo.dll -r:System.Runtime.Remoting.dll Cliente.cs

Ejecutaremos los archivos en diferentes consolas:

Ejecutar el servidor:

./Servidor.exe 9999

El cliente 1:

./Cliente.exe localhost 9999 5

Y su resultado:

Cambiado a: 5
Pulse Enter para ver el estado…

Y el cliente 2:

./Cliente2.exe localhost 9999 8

Y su resultado:

Cambiado a: 8
Pulse Enter para ver el estado…

Una vez que tenemos los dos clientes cargados, pulsamos Enter en cada uno de ellos y vemos que conservan su estado:

El Cliente 1:

Hemos cambiado la base a 5

El Cliente 2:

Hemos cambiado la base a 8

En el servidor solo veremos como cada cliente crea un nuevo objeto.

Atenciando las peticiones…
Pulse Enter para salir…
Contructor.
Constructor.

Ya que cada cliente puede crearse su propia calculadora, podríamos replantearnos dejar que cada objeto “muera” pasado un tiempo (el tiempo de vida que vimos en el capítulo anterior) o controlar todas las instancias que se hacen desde los servidores con un atributo estático que vaya aumentando por cada instancia. Deberíamos pensar esto ya que puede que alguien malintencionado haga miles de clientes que llamen a nuestro servidor, creando miles de instancias y bloqueando el servidor.

Aunque ya está escrita la parte más importante del manual, en los siguientes capítulos veremos trucos y formas de usar la teoría que hemos dado hasta ahora.

El código fuente de uno de los comentarios expuestos abajo, se encuentra aquí.

Indice general de los manuales

  1. Introducción, instalación en Ubuntu y creación de una calculadora.
  2. Modos de compartición de objetos. Creando nuestra primera calculadora distribuida.
    1. Modos de compartición de objetos: Singlecall.
    2. Modos de compartición de objetos: Singleton.
    3. Modos de compartición de objetos: CAO.  «  [Leyendo]
  3. Canales: TCP y HTTP. Configuración en archivo XML.
  4. Uso de interfaces para separar el código entre cliente y servidor.