Aplicación Multicast -
Servidor / Cliente de
imagenes en movimiento.
Diego González - Diego del Valle
Indice
1....Resumen
2....Introducción
3....Conceptos
de Desarrollo
3.1....MulticastServer
3.2....MulticastClient
3.3....Sistema de
Mensajería
3.4....Modos de
Ejecución
4....Diagramas
UML
5....Archivos
6....Conclusiones
7....Anexo
Resumen
En este proyecto se busca incorporar un uso
útil de Multicast para efectos visuales en pantallas formadas
por un arreglo de monitores. La idea es poder crear una
aplicación multisistemas con Java que pueda desplegar
algún tipo
de mensaje o cadena de texto, o simplemente mostrar imagenes en este
arreglo.
Introducción
Multicast es un servicio de red de
distribución de flujos de datos a múltiples receptores
interesados desde una determinada fuente. Su función principal
es reducir el número de paquetes replicados dentro de una red,
liberando recursos en las rutas necesarias para envíar el
paquete, dejando la tarea de replicar el paquete a los routers.
Figura 1. Multicast
v/s Broadcast
A pesar de todas estas ventajas, dada su naturaleza,
multicast no
puede ser usado en sistemas masivos como internet por lo que
sólo se
puede usar en aplicaciones locales o de redes cerradas.
Nuestro trabajo será demostrar la utilidad de
Multicast en un
simple programa en el cual hay un balón que rebotará
dentro de un
arreglo de pantallas de distintos computadores que estén unidos
en este
dominio multicast.
Figura 2. Cliente
funcionando en distintos terminales
Para esta demostración sólo se
usará un
computador, el cual se unirá a
una red multicast con cuatro clientes independientes entre sí.
Figura 3. Cuatro
Clientes trabajando en el mismo terminal
Conceptos de Desarrollo
MulticastServer
Lo que buscamos es crear un servidor, el cual de
manera abstracta generará una pantalla donde hay un balón
dando botes, la información que contenga será enviada a
distintos clientes, los cuales deberán representar el panel
abstracto sobre una pantalla que es un arreglo de los monitores de
estos.
Esto implica que toda la información del
balón y de su comportamiento será comandada por el
Servidor por simple mensajería relativa a su espacio abstracto,
y los clientes para deberán traducir esta información al
espacio gráfico por los datos obtenidos al iniciar la
sesión multicast con el servidor (un pequeño handshaking).
MulticastClient
Para darle al sistema la posibilidad de
expansión a futuro, los clientes deben conectarse al Servidor,
el cual les dará su posición dentro del espacio virtual
de este, además el Servidor es quien le da el tamaño del
panel donde se moverá el balón. Finalmente se le entrega
que bordes debe pintar, para mostrar cuales son las paredes
límites del cuadro total.
Con lo dicho anteriormente, el cliente tiene su
propia referencia de posición, que será dependiente de
los datos otorgados por el servidor de la forma mostrada a
continuación.
x' = x - (nº_ventanas_horizontales - 1) *
tamaño_base_ventana
y' = y - (nº_ventanas_verticales - 1) *
tamaño_altura_ventana
Figura 4. Referencia
entre Server y Cliente 3
Sistema de
Mensajería
El sistema de Mensajería en la arquitectura
propuesta, consta de 3 mensajes: 1 mensaje del cliente al servidor y 2
mensajes del servidor al cliente.
La Figura a continuación muestra un esquema del funcionamiento
del sistema.
Figura 5. Diagrama
de Sistema de mensajería entre Cliente y Servidor
Explicaremos a continuación los pasos marcados en el diagrama de
flujo:
1.- Se inicia el servidor.
2.- Se inicia hebra para envio de datos a clientes. Aunque no hayan
conexiones este envia datos de posicion.
3.- Se inicia hebra para manejo de recepcion de conexiones. El servidor
esta disponible para aceptar conexiones de clientes
4.- Se inicia el cliente.
5.- Se solicita conexion con el servidor.
6.- Se envia mensaje "Hello" que indica solicitud de cliente.
7.- Hebra de manejo de conexiones acepta solicitud.
8.- Hebra de manejo de conexiones actualiza informacion de servidor por
cada nueva conexion de cliente
9.- Para clientes nuevos se envia informacion de datos de cliente, para
clientes antiguos se actualiza su informacion dada la cantidad de
clientes actual.
10.- Se recepcionan los datos de actualizacion enviados por el servidor
y se modifican los parametros recibidos.
11.- Los clientes recepcionan los datos de posicion enviados por el
receptor.
12.- Los datos de posicion que recibe constantemente el cliente son
dibujados por pantalla en la ventana del cliente.
Modos de
Ejecución
Las diferentes formas de ejecución del sistema se describen a
continuación:
Usage: java MulticastServer <Modo_arquitectura>
<Modo_circular> <Ancho_cliente> <Alto_cliente>
<Numero_de_servidores>
- Modo_arquitectura: rectangular o lineal.
- Modo_circular: true o false.
- Ancho_cliente: Ancho tamaño ventana clientes, mayor o
igual que 100,
menor o igual que 1500.
- Alto_cliente: Alto tamaño ventana clientes, mayor o igual
que 100,
menor o igual que 768.
- Numero_de_servidores: Número de servidores que se
conectarán.
Para activar el server con valores por defecto (rectangular false
640 480 1):
java MulticastServer
Diagramas UML
Para un mejor entendimiento de como están
relacionadas las clases del Cliente y del Servidor, mostramos los
diagramas UML de cada uno y sus relaciones.
Diagrama UML Cliente
Figura 6. Diagrama
UML Cliente
Diagrama UML Servidor
Figura 7. Diagrama
UML Servidor
Archivos
Los archivos necesarios de descarga para este
programa.
- Circulo.java
(docs)
- ClientCoordinates.java
(docs)
- ClientData.java
(docs)
- Coordenadas.java
(docs)
- Dibujo.java
(docs)
- EditorFrame.java
(docs)
- MulticastClient.java
(docs)
- MulticasServer.java
(docs)
Todos los Archivos del Cliente, descargar AQUI
Todos los Archivos del Servidor, descargar AQUI
Documentación en frames: JAVADOCS
Conclusiones
De esta implementación
podemos concluir que multicast ahorra muchos problemas en temas
de conexión, ya que simplemente se debe atender el canal y no
cliente por cliente.
De esto mismo nos pudimos dar
cuenta que para aplicaciones donde cada cliente debe obtener
algún tipo de identificador, se hace necesario crear un
mecanismo para diferenciar a los clientes con algún
método por software (ya que no existen los sockets para
diferenciar conexiones), en este caso, usamos un pequeño
protocolo donde cada cliente en el momento de conexión obtiene
su identificador. Un punto interesante sería comprobar que
pasaría si dos clientes esperando su identificador les llegara
un mensaje y ambos lo recibieran como si fuera su respuesta (ya que el
mensaje se manda a todo el canal).
Por el lado del software en
sí, pudimos observar las ventajas que nos proporcionaba dejar al
cliente como un simple expectador, ya que en un comienzo de las
implementaciones el cliente tenía incidencia sobre ciertas
configuraciones del balón. La independencia de este
significó una mayor versatilidad a la hora de escalar el plano
por donde el balón se mueve.
Referencias
Anexos
Programación de sockets
Multicast en Java
Ejemplo de Cliente Simple Multicast
/**
* MulticastClient.java
*
*
* Created: Sun Jul 22 19:21:13 2001
*
* @author <a href="mailto: "Jan Newmarch</a>
* @version
*/
import java.io.*;
import java.net.*;
public class MulticastClient{
public static final String MCAST_ADDR = "230.0.0.1";
public static final int MCAST_PORT = 9013;
public static final int DGRAM_BUF_LEN = 512;
public static void main(String[] args){
String msg = "Hello";
InetAddress group = null;
try {
group = InetAddress.getByName(MCAST_ADDR);
} catch(UnknownHostException e) {
e.printStackTrace();
System.exit(1);
}
try {
MulticastSocket socket = new MulticastSocket(MCAST_PORT);
socket.joinGroup(group);
DatagramPacket hi = new DatagramPacket(msg.getBytes(), msg.length(),
group, MCAST_PORT);
System.out.println("Sending: " + msg);
socket.send(hi);
// get their responses!
while (true) {
byte[] buf = new byte[DGRAM_BUF_LEN];
DatagramPacket recv = new DatagramPacket(buf, buf.length);
socket.receive(recv);
byte[] data = recv.getData();
System.out.println("Received: " + new String(data));
}
} catch(IOException e) {
e.printStackTrace();
System.exit(2);
}
// OK, I'm done talking - leave the group...
// s.leaveGroup(group);
// System.exit(0);
}
} // MulticastClient
Ejemplo de Servidor Simple Multicast
/**
* UDPTimeClient.java
*
*
* Created: Sun Jul 22 19:21:13 2001
*
* @author <a href="mailto: "Jan Newmarch</a>
* @version
*/
import java.io.*;
import java.net.*;
import java.util.Date;
public class MulticastServer {
public static final String MCAST_ADDR = "230.0.0.1";
public static final int MCAST_PORT = 9013;
public static final int DGRAM_BUF_LEN = 512;
public static void main(String[] args){
InetAddress group = null;
try {
group = InetAddress.getByName(MCAST_ADDR);
} catch(UnknownHostException e) {
e.printStackTrace();
System.exit(1);
}
MulticastSocket socket = null;
try {
socket = new MulticastSocket(MCAST_PORT);
socket.joinGroup(group);
} catch (IOException e) {
e.printStackTrace();
System.exit(3);
}
while (true) {
try {
byte[] buf = new byte[DGRAM_BUF_LEN];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
System.out.println("Received: " + new String(buf));
String date = new Date().toString();
buf = date.getBytes();
// get client info
InetAddress clientAddr = packet.getAddress();
int port = packet.getPort();
// prepare packet for return to client
packet = new DatagramPacket(buf, buf.length, clientAddr, port);
System.out.println("Sending: " + new String(buf));
socket.send(packet);
} catch(IOException e) {
e.printStackTrace();
}
}
}
} // UDPTimeServer
Volver
Para mayor información,
envianos un correo a: dgonza [@] elo.utfsm.cl ó ddelvalle [@]
elo.utfsm.cl