Download Error - Tecnologías Distribuidas Aplicadas a la Medicina

TEMA 4: PROGRAMACIÓN DISTRIBUIDA
%!
'(
! "
%
#! $
&
' ') * (+,
(
- ./0
( .40(
%
1'
%16
2%
%
1/../
-
3 % /.0
2%
..02 %
%
8 9:08
1
!
; 1 %<51 =/1+
?(
-
3 % 450
2%
%
1/../
7
!
"
>1499:
>
No existe memoria común
Comunicaciones
No existe un estado global del sistema
Grado de Transparencia
Escalables
Reconfigurables
?(
>
Modelos de Programación Distribuida
Modelo de Paso de Mensajes
Operaciones send y receive
Analizado en asignatura de S.O.
Modelo RPC
Stubs de cliente y servidor
Visión en Java es RMI
Modelos de Objetos Distribuidos
DCOM de Microsoft
Jini de Sun
CORBA de OMG
?(
>
Modelo de Paso de Mensajes
Mecanismo para comunicar y sincronizar entidades
concurrentes que no pueden o no quieren compartir
memoria
Llamadas send y receive
Tipología de las llamadas:
Bloqueadas-No bloqueadas
Almacenadas-No almacenadas (en buffer)
Fiables-No Fiables
En Unix:
Pipes con y sin nombre
En Java:
Sockets.
CTJ (Communicating Threads for Java)
?(
>
Modelo General
SOLICITUD
CLIENTE
SERVIDOR
RESPUESTA
NUCLEO
NUCLEO
RED
?(
>
%
%
#
>
"
%
%
B
@ A $
%
&
%;
%
CB
P
U
E
R
T
O
CLIENTE
SERVIDOR
TCP/UDP
?(
>
App B
App A
Port xxx
Port yyy
App C
Port zzz
PROTOCOLO TCP/UDP
0010111001100010101 Port yyy
Port kkk
P
U
E
R
T
O
CLIENTE
SERVIDOR
Solicitud de conexión
CLIENTE
?(
P
U
E
R
T
O
P
U
E
R
T
O
SERVIDOR
PUERTO
>
D
A
;
%
7
%
%
1
%
%;
% %
7
%
%%
%
Accept()
Socket()
Socket creado y activo
?(
>
%
ServerSocket
"
%
%
&
"
% %
Socket
%
ServerSocket L = newServerSocket (num_puerto)
'%B
%
L.accept();
)%
%
%B
%
?(
C%
>
Socket
%
%%
%
%
"
%
Socket (dirección_IP, puerto);
?(
>
%
4
/
<
E
5
G
?(
7
2
& ServerSocket
& Socket
InputStream
%
%%
OutputStream
%%
F
%
>
&
%# B
$
import java.io.*;
import java.net.*;
public class SocketServidor
{
public static final int port = 8080;
public static void main (String [] args)
throws IOException
{
ServerSocket GenSocket = new ServerSocket(port);
System.out.println("El servidor esta escuchando
en: "+ GenSocket);
try{//espera solicitud conexion desde cliente...
Socket enchufe = GenSocket.accept();
} finally { System.out.println("se cierra la
conexión...");
GenSocket.close();
}
}//main
}//SocketServidor
4
/
<
E
5
?(
7
2
& Socket
InputStream
%%
OutputStream
%%
F
%
%
>
!
import java.io.*;
import java.net.*;
public class SocketCliente
{
public static void main (String [] args)
throws IOException
{
//llamando ordenador despacho de al lado...
InetAddress dir_IP =
InetAddress.getByName("150.214.72.96");
Socket enchufe = new Socket (dir_IP, 8080);
System.out.println("Datos socket creado:
"+enchufe);
}//main
}//SocketCliente
"
A
%
!@
;
%
% %
socket
D 1
& socket
socket
getInputStream()
getOutputStream()
% %
&%
!
(3
&
SocketChannel
?(
7
%&
F
% %
>
>
#$
"
'
()***+
%&
%
%
8
8
%
%
">
7
#
%
"%
3
read-only
%
% %
%
%
&
! >
3 F
%
B
7
"% #
%
%
8!$
¡SE ELIMINA LA MEMORIA COMÚN!
?(
>
2%
A
@
wait(), notify(), notifyAll()
>
% "%
3
7
%
%
%
?(
7
%rendezvous
>
Emisor Listo
;
(synchronized).
D%
3
%
%
% 3
%
Canal
;
&
Receptor Listo
>
,
send (B, mensaje)
Proceso A
rendezvous
Proceso B
receive (A, mensaje)
tiempo
?(
>
&
%
7;
!@
run()
&
&
%
%
%
Canal de Salida
public void run()
{ //codigo ejec.
}
Canal de Entrada
#-
",Process
interfaz csp.lang.Process (análoga a java.lang.Runnable)
public interface csp.lang.Process{
public void run();
}
Procesos de usuario implementan la interfaz:
public class mi_proceso implements Process{
//dato locales al proceso
public mi_proceso(channels y parametros){
//codigo del constructor
}
public void run() //sobreescritura de run
{//código del proceso}
}
?(
>
",
7;
#
@
read >write
%
&
%
%
@
%
;
#
;$
H7 $ 3
%
#
H7
3
?(
>
import csp.lang.*;
import csp.lang.Process.*;
import csp.lang.Integer.*
class Producer implements Process{
ChannelOutput_of_Integer channel;
Integer object;
public Producer (ChannelOutput_of_Integer out){
channel = out;
object = new Integer();
}
public void run(){
object.value=100;
channel.write(object);
}
}? (
>
import csp.lang.*;
import csp.lang.Process.*;
import csp.lang.Integer.*
class Consumer implements Process{
ChannelInput_of_Integer channel;
Integer object;
public Consumer (ChannelInput_of_Integer out){
channel = in;
object = new Integer();
}
public void run(){
channel.read(object);
System.out.println(object);
}
}? (
>
import csp.lang.*;
import csp.lang.Process;
import csp.lang.Integer;
public class P_C_Main{
public static void main (String [] args){
Channel channel = new Channel();
Process modo = new Parallel(new Process[]
new Producer(channel),
new Consumer(channel));
modo.run();
}//main
}// P_C_Main
?(
>
#
#
' % (Channel_of_Boolean)+read/write
'> (Channel_of_Byte)+read/write
" (Channel_of_Char)+read/write
% (Channel_of_Double)+read/write
+%
(Channel_of_Float)+read/write
(Channel_of_Integer)+read/write
)
(Channel_of_Long)+read/write
" (Channel_of_Short)+read/write
7
(Channel_of_Reference)+read/write
& (Channel_of_Object)+read/write
( >(Channel_of_Any)+read/write
?(
>
#
Sequential (Process[] procesos)
Parallel (Process[] procesos)
PriParallel (Process[] procesos)
Con guardas:
Alternative
PriAlternative
?(
>
.
/
01
csp.io.linkdrivers.TCPIP (ó UDP)
%
public TCPIP(remotehost, remoteport, TCPIP.tipo)
#
REALTIME
ASYNCHRONOUS
%
?(
% %
% %
>
import
import
import
Import
csp.lang.*;
csp.lang.Process;
csp.lang.Integer;
csp.io.lindrivers.TCPIP;
public class Prod{
public static void main (String [] args){
final Channel_of_Integer canal =
new Channel_of_Integer new(
TCPIP(“sargo.uca.es”, 1701, TCPIP.REALTIME));
Process par = new Parallel(new Process[]
{new Producer(canal)});
par.run();
}//main
}//Prod
import
import
import
Import
csp.lang.*;
csp.lang.Process;
csp.lang.Integer;
csp.io.lindrivers.TCPIP;
public class Cons{
public static void main (String [] args){
final Channel_of_Integer canal =
new Channel_of_Integer new TCPIP(
(“delfin.uca.es”, 1701, TCPIP.REALTIME));
Process par = new Parallel(new Process[]
{new Consumer(canal)});
par.run();
}//main
}//Cons
!I
+ !( J
http://www.ce.utwente.nl/javapp/
2
3
3
Mayor nivel de abstracción
Llamadas a procedimiento local o remoto indistintamente
Necesita de stubs/skeletons (¡OCULTAMIENTO!)
Registro del servicio
En Unix:
Biblioteca rpc.h
Representación estándar XDR
Automatización parcial: especificación-compilador rpcgen
En Java:
Objetos remotos. Serialización
Paquete java.rmi
Automatización parcial: interfaz-compilador rmic
?(
>
%
%
%
func()
'
8
4 7
/
< KL
2
func(void)
{//codigo
………….
}
%%
%
C
%
%
% %
%MN
2
%
%
7 H
C
'%B
%
7
%
$
%%
%
%
%
&
%
A
?(
>
B
%
%
%
callrpc
+
llamada
normal
rpcreturn
%%
%
RED
H%
%
return
H%
.
/
1
7
7
%
C
7
7O
rpcgen # P
?(
7
%
3
7
D$F
rmic #
7;
$
>
4
5
Especificación Formal
Interface
Cliente
Ejecutable
C
O
M
P
I
L
A
R
?(
Servidor
Ejecutable
Precompilador
rpcgen o rmic
Resguardo
Stub
Ficheros
compartidos
Resguardo
Skeleton
Cliente
Representación
de datos
Servidor
>
C
O
M
P
I
L
A
R
Generador
de
Resguardos
Especificación Formal
Interface
Interfaz del
servidor+asa
create, read
delete, write
Res. Del Servidor
Res. Del Cliente
Read(f,d)
CONECTOR
SERVIDOR
d
CLIENTE
Petición de asa del servidor
?(
Envío de asa
>
6
3
7
%
7
7;
.x
%
7"
/*rand.x*/
program RAND_PROG{
version RAND_VER{
void inicia_aleatorio(long)=1;
double obtener_aleat(void)=2;
}=1;
}=0x3111111;
*
C
% 7"
>
%;
?(
$rpcgen rand.x
%
CB
%
Q
' %
xdr.h
>
32 3
2 $
Permite disponer de objetos distribuidos utilizando Java
Un objeto distribuido se ejecuta en una JVM diferente o remota
Objetivo: lograr una referencia al objeto remoto que permita utilizarlo
como si el objeto se estuviera ejecutando sobre la JVM local
Es similar a RPC, si bien el nivel de abstracción es más alto
Se puede generalizar a otros lenguajes utilizando JNI
RMI pasa los parámetros y valores de retorno utilizando serialización
de objetos.
Objeto
Cliente
Objeto
Servidor
JVM
JVM
?(
>
3
32
RPC
RMI
Carácter y Estructura de diseño
procedimental
Carácter y Estructura de diseño
orientada a objetos
Es dependiente del lenguaje
Es dependiente del lenguaje
Utiliza la representación externa de
datos XDR
Utiliza la serialización de objetos en
Java
El uso de punteros requiere el
manejo explícito de los mismos
El uso de referencias a objetos
locales y remotos es automático
NO hay movilidad de código
El código es móvil, mediante el uso
de bytecodes.
?(
>
'
Un objeto remoto es aquél que se ejecuta en una JVM diferente,
situada potencialmente en un host distinto.
RMI es la acción de invocar a un método de la interfaz de un objeto
remoto.
//ejemplo de llamada a método local
int dato;
dato = Suma (x,y);
//ejemplo de llamada a método remoto (no completo)
IEjemploRMI1 ORemoto =
(IEjemploRMI1)Naming.lookup(“//sargo:2005/EjemploRMI1”);
ORemoto.Suma(x,y);
7!
32
Cliente
Servidor
Stub
Skeleton
Referencia
Remota
Referencia
Remota
Transporte
Transporte
?(
El servidor debe extender RemoteObject
El servidor debe implementar una interfaz
diseñada previamente
El servidor debe tener como mínimo un
constructor (nulo) que lanzará la excepción
RemoteException
El método main del servidor debe lanzar
un gestor de seguridad
El método main crea los objetos remotos
El compilador de RMI (rmic) genera el stub
y el skeleton.
Los clientes de objetos remotos se comunican
con interfaces remotas (diseñadas antes de…)
Los objetos remotos son pasados por referencia
Los clientes que llaman a métodos remotos
deben manejar excepciones.
>
java.rmi.Naming
public static void bind(String name, Remote obj)
public static String[] list(String name)
public static Remote lookup(String name)
public static void rebind(String name, Remote obj)
public static void unbind(String name)
?(
>
K
%
%N
public interfaz
extends Remote
{signaturas métodos}
implements
resultado
ref.metodo(param)
Implementación
de la interfaz
Cliente
new
referencia a interfaz
6
lookup
?(
SERVIDOR
3"
"
bind ó rebind
>
implements
Definir Interfaz Remota
Implementar Interfaz
Remota
$ rmic .class
Skeleton
Stub
JVM
JVM
Implementar Servidor
Implementar Cliente
87
9:32 ;< 6# 387
Escribir el fichero de la interfaz remota.
Debe ser public y extender a Remote.
Declara todos los métodos que el servidor remoto ofrece, pero
NO los
implementa. Se indica nombre, parámetros y tipo de retorno.
Todos los métodos de la interfaz remota lanzan
obligatoriamente la excepción RemoteException
El propósito de la interface es ocultar la implementación de los
aspectos relativos a los métodos remotos.
De esta forma, cuando el cliente logra una referencia a un
objeto remoto, en realidad obtiene una referencia a una
interfaz.
Los clientes envían sus mensaje a los métodos de la interfaz
?(
>
2 : 8 & 3:
6# 387=
/**Ejemplo del interfaz remoto para implementar un RMI
* @author Antonio Tomeu
*Es un servidor remoto aritmético.
*/
//se importan las clases del paquete rmi
import java.rmi.*;
//toda interface remota debe extender la clase Remote
public interface IEjemploRMI1 extends Remote
{
//todo metodo de la interfaz remota debe lanzrar la
//excepcion RemoteException
int Suma(int x, int y) throws RemoteException;
int Resta(int x, int y) throws RemoteException;
int Producto(int x, int y) throws RemoteException;
float Cociente(int x, int y) throws RemoteException;
}
?(
>
87
9:32 )< 2
2 6#7 >6
La implementación del servidor es un fichero que realiza la
implementación de la interfaz definida previamente.
El servidor debe contener una clase que extienda a
UnicasRemoteObject.
Esa misma clase debe implementar a la interfaz remota
(implements)
Debe tener un constructor que lance RemoteException.
El método main debe lanzar un gestor de seguridad.
El método main debe crear los objetos remotos deseados.
El método main debe registrar al menos unos de los objetos
remotos.
?(
>
2 : 2
2 6#7 >6
6# 387=/
3? :3
/**Ejemplo de implementacion del interfaz remoto para
* @author Antonio Tomeu
*/
//se importan los paquetes necesarios
import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;
import java.net.*;
//el servidor debe siempre extender a UnicastRemoteObject
//el servidor debe simpre implementar la interfaz remota
public class EjemploRMI1
extends UnicastRemoteObject
implements IEjemploRMI1
{
un RMI
//aquí viene la implementación de los métodos que se
//declararon en la interfaz
public int Suma(int x, int y)
throws RemoteException
{return x+y;}
public int Resta(int x, int y)
throws RemoteException
{return x-y;}
public int Producto(int x, int y)
throws RemoteException
{return x*y;}
public float Cociente(int x, int y)
throws RemoteException
{ if(y == 0) return 1;
else return x/y;
}
//a continuacion viene el codigo del servidor. Hemos optado
//por incluirlo de manera conjunta, pero podia haber ido en
//un fichero aparte.
//es necesario que haya un constructor (nulo) como minimo, ya
//que debe lanzar RemoteException
public EjemploRMI1()
throws RemoteException
{//super();}
//el metodo main siguiente realiza el registro del servicio
public static void main(String[] args)
throws Exception
{
//crea e instala un gestor de seguridad que soporte RMI.
//el usado es distribuido con JDK. Otros son posibles.
System.setSecurityManager(
new RMISecurityManager());
//Se crea el objeto remoto. Podriamos crear mas si interesa.
EjemploRMI1 ORemoto = new EjemploRMI1();
//Se registra el objeto en la máquina remota. No hay que dar
//nombre de host, y se asume el puerto 1099.
Naming.bind(“Servidor",ORemoto);
System.out.println("Servidor Remoto Preparado");
}
}
87
9:32 @< 4
Fichero de
implementación
de Interfaz
compilado
(Imp.class)
Compilador de RMI
$ rmic imp
#A / B
#:6
Fichero de
stub
(Imp_Stub.class)
Fichero de
skeleton
(Imp_Skel.class)
$ rmic EjemploRMI1
Es necesario que en la máquina remota donde se aloje el servidor se sitúen también
los ficheros de stub y skeleton.
Con todo ello disponible, se lanza el servidor llamando a JVM del host remoto.
En nuestro caso, el servidor remoto se activó en hercules.uca.es sobre el puerto
1099.
$ java EjemploRMI1 &
?(
>
87
9:32 C<3 4 #3:
!@
Naming.bind(“Servidor",ORemoto);
para registrar el objeto remoto creado requiere que el servidor
de nombres esté activo. El nombre de ese servidor es
rmiregistry
Dicho servidor se activa con start rmiregistry en Win32
Dicho servidor se activa con rmiregistry & en Unix.
Se puede indicar como parámetro adicional el puerto que
escucha.
Si no se indica, por defecto es el puerto 1099.
El parámetro puede ser el nombre de un host como en
Naming.bind(“//sargo.uca.es:2005/Servidor",ORemoto);
?(
>
87
9:32 D<
6#
El objeto cliente procede siempre creando un objeto de
interfaz remota.
Posteriormente efectúa una llamada al método
Naming.lookup cuyo parámetro es el nombre y puerto
del host remoto junto con el nombre del servidor.
Naming.lookup devuelve una referencia que se
convierte a una referencia a la interfaz remota.
A partir de aquí, a través de esa referencia el programador
puede invocar todos los métodos de esa interfaz remota
como si fueran referencias a objetos en la JVM local.
?(
>
2 :
6#
/**Ejemplo de implementacion de un cliente para RMI
* @author Antonio Tomeu
*/
import java.rmi.*;
import java.rmi.registry.*;
public class ClienteEjemploRMI1
{
public static void main(String[] args) throws Exception
{
int a = 10;
int b = -10;
//Se obtiene una referencia a la interfaz del objeto remoto
//SIEMPRE debe convertirse el retorno del metodo Naming.lookup
//a un objeto de interfaz remoto
IEjemploRMI1 RefObRemoto =
(IEjemploRMI1)Naming.lookup("//hercules.uca.es/Servidor");
//Llamamos a los metodos del interfaz remoto.
System.out.println(RefObRemoto.Suma(a,b));
System.out.println(RefObRemoto.Resta(a,b));
System.out.println(RefObRemoto.Producto(a,b));
System.out.println(RefObRemoto.Cociente(a,b));
}
}
",Serializable
%;
1
%
H%
&
%
&
%&
Serializable #
%;
?(
%
% &
&
%&
!
%;
@
%
%
7
% $
>
7;
,
import java.io.*;
import java.util.*;
public class cuentabanca
implements Serializable
{ int ccc; float saldo; String Titular;
public cuentabanca(int codigo, float deposito, String
nombre)
{ccc = codigo; saldo = deposito; Titular = nombre;}
public String toString()
{return("codigo = "+ccc+" saldo= "+saldo+" titular=
"+Titular);}
}
",
import java.io.*;
import java.rmi.*;
public interface intefaz
extends Remote
{
boolean deposito(int codigo, float cantidad)
throws RemoteException;
boolean reintegro(int codigo, float cantidad)
RemoteException;
throws
String nomtit(int codigo) throws RemoteException;
int codtit(String nom) throws RemoteException;
/aquí la serializacion es necesaria*/
cuentabanca [] listado() throws RemoteException;
}
4
-policytool
%
System.setSecurityManager(new RMISecurityManager());
&
%
>
)%
%
% @
& SecurityManager
setSecurityManager (clase System)
RMISecurityManager
&
%
% %
Policy
%
Policy.getPolicy()
Policy.setPolicy()
7&
7"
/
?(
"
%
%
3
3
7
% policytool
>
(&
% %
3
%
%> % &
%
7"
.policy
/* AUTOMATICALLY GENERATED ON Fri May 28
19:23:13 CEST 2004*/
/* DO NOT EDIT */
grant {
permission java.net.SocketPermission
"*:1024-65535", "connect,accept, listen,
accept, connect, listen, resolve";
permission java.net.SocketPermission "*:80",
"connect, accept";
permission java.security.AllPermission;
};
(
%
&
&
% %
3
Java –Djava.security=fichero.policy
servidor|cliente
& RMISecurityManager > &
SetSecurityManager
% &
2
:
Microsoft DCOM
Utiliza DCE RPC
Está orientado a un solo sistema operativo
Sin acuerdo
Jini de Sun
Basado en RMI de Java
Muy ligado al lenguaje Java
En sistemas empotrados
CORBA de OMG
Independiente del lenguaje
Marco arquitectónico común
EJB
?(
>
:3 7
:
3!
7 $
ES una tecnología de integración
Resuelve RPC con independencia del lenguaje.
Se puede hacer RPC a métodos remotos de
objetos Java y no-Java
No es necesario conocer la ubicación física del
objeto servidor
Marco de interacción entre objetos distribuidos
estándar e independiente del lenguaje
Especificación de objetos remotos común a
todos los lenguajes a través de IDL
Desarrollado por el OMG (produce
especificaciones, no productos)
?(
>
Elementos de CORBA
OMA (Object Management Architecture): es la
especificación de la interoperabilidad entre
objetos
Core Object Model (Core Object Model):
establece los concepto básicos sobre un objeto,
interfaz, operación.
OMA Reference Architecture: define la
infraestructura de servicios y los mecanismos
subyacentes que permiten la interacción entre
objetos.
ORB (Object Request Broker): es el canal de
comunicación a través del cual los objetos se
solicitan servicios con independencia de la
ubicación física. Existen varias
(JavaIDL)
? implementaciones.
(
>
Todos los elementos de CORBA son objetos
Cada objeto tiene una interfaz e identidad únicos
Cada objeto se puede implementar en un lenguaje
distinto y ejecutarse sobre cualquier HW y SO
CORBA define el bus software que permite la
interoperabilidad entre esta diversidad de
objetos
?(
>
Modelo de Referencia OMA
No
estandarizados
Por OMG
APPLICATION
INTERFACES
Bussines
Healthcare
Finance
Telecom
DOMAIN
INTERFACES
Compound
Object Linking
Help
MOF
COMMON
FACILITIES
OBJECT REQUEST BROKER
Naming
Persistence
Transactions
Concurrency
SERVICIOS A
OBJETOS
Security
Time
Properties
Externalization
Cliente
Implementación del objeto
ORB
?(
>
Estructura del ORB
Invocación Estática
Servidor
Cliente
metodo(param)
rebObjeto.metodo(param)
IDL
Skeleton
IDL
Stub
marshalling
unmarshalling
ORB Core
Interface dependiente del ORB
Stub para cada tipo de objeto
Object
Adapter
Lenguaje de Definición de Interfaces (IDL)
Es un lenguaje de definición de interfaces
orientado a objetos
Especificación común a todos los lenguajes de
una interfaz (métodos y atributos) de objeto
Construye una representación del objeto
distribuido común a cliente y servidor
Soporta herencia
Sintaxis parecida a Java y C++
Precompila (map) a C, C++, Java, Ada, etc.
Ver:
http://java.sun.com/products/jdk/1.2/docs/guide/idl/
?(
>
JavaIDL
Tecnología que integra CORBA en el lenguaje
Java
En java, $idltojava fichero.idl
A partir de J2SE v1.4 es $idlj
Genera el stub del cliente y el skeleton del
servidor (con -fall)+otros ficheros
Ambos automatizan las siguientes tareas (junto
con el ORB):
Ordenamiento y serialización de parámetros (marshalling)
Generan la implementación de la clase de interfaz
Registro y activación de objetos
Localización y conexión (binding) a objetos
?(
>
Herramientas JavaIDL
idlj: compilador de IDL a Java
orbd: proceso demonio que contiene:
Boostrap Service
Servicio de Nombres Transitorios.
Servicio de Nombres Persistentes.
Un Gestor de Servidores
servertool:permite a los programadores de
aplicaciones registrar, dar de baja, arrancar y parar
servidores
tnameserv:Servicio de Nombres Transitorio en
versiones previas de JavaIDL. Se incluye por
compatibilidad hacia atrás.
?(
>
API JavaIDL Básica
org.omg.CORBA
org.omg.CosNaming
org.omg.PortableServer
org.omg.CORBA.ORB
org.omg.PortableInterceptor
org.omg.DynamicAny
?(
>
Compilando IDL
Stubs
Cliente
Interfaz
IDL
Aplicación
Cliente
-fclient
Compilador de IDL
($idltojava)
($idlj) en J2SE
-fserver
-fserver
A partir de J2SE
v1.4
-fall
Skeletons
Servidor
POA
Servidor
Aplicación
Servidor
Implemen.
Servidor
Portable Object Adapter (POA)
El adaptador de objetos conecta una solicitud de cliente al código
que le da servicio (servant) utilizando una referencia a objeto.
Java2SE da soporte POA a través del API correspondiente
POA establece el nexo entre un objeto CORBA y su
implementación (servant)
Establece la correspondencia entre peticiones de entrada y las
diferentes instancias de un mismo objeto.
POA define un espacio de nombres para los servants
Un POA puede tener varios servants
Un servant solo pertenece a un POA
Un servidor puede tener varios POAs activos
Al menos existe el POA raíz
Las relaciones entre un POA y sus servants vienes descritas por las
políticas del POA
POA es un tipo de OA particular, definido en la especificación
CORBA, para lograr:
Implementaciones de objetos portables entre diferentes ORB
Soporte a objetos de identidad persistente
Soporte a la activación transparente de objetos
Servant que soporte identidades simultáneas.
?(
>
Servants
POA
POA Manager
ORB
El Servicio de Nombres
El servicio nombre guarda pares
<nombre, referencia a objeto>
Los nombres están organizados
jerárquicamente (tree-type) en un S.N.
Servidor, crea un servant y lo registra en SN
asociando (bind) una referencia a objeto con un
nombre
Cliente pide al SN que a partir de un nombre le
dé (resolve) una referencia a objeto CORBA
En JavaIDL el SN se activa ejecutando
tnameserv. Por defecto, escucha al puerto 900
No es persistente y está derogado
A partir de J2SE 1.4 orbd proporciona
persistencia si se desea
resolve(A)
Cliente
Servidor
x
Jeraquía de
Nombres
bind(x, ref)
x
ref
NamingContext ncRef =
NamingContext ncRef =
NamingContextHelper.narrow(refObj); NamingContextHelper.narrow(refObj);
NameComponent nc = new
NameComponent nc = new
NameComponent("Impresor Remoto",
NameComponent("Impresor Remoto", "");
"");
NameComponent [] ruta ={nc};
NameComponent [] ruta = { nc };
HolaMundoDistribuido ObjImpresor =
ncRef.rebind(ruta, IRem);
HolaMundoDistribuidoHelper.narrow(ncR
ef.resolve(ruta));
Interacción Cliente/Servidor-Servicio de Nombres
'
Hola Mundo Distribuido Con CORBA1
Especificación IDL de la Interfaz Remota
/**Ejemplo de fichero de especificacion IDL
* @author Antonio Tomeu
*Es una especificacion de un objeto servidor remoto que recibe
como parametro
*una cadena de caracteres y la imprime en la salida estandar del
servidor
*
*/
interface HolaMundoDistribuido {
void Imprimir (in string mensaje);
};
1Utilizando el servicio de nombres no persistente tnameserv ya derogado. Se explica por
compatiblidad hacia atrás.
Hola Mundo Distribuido Con CORBA
Servidor
/**Ejemplo de fichero que implanta un servidor via CORBA
* @author Antonio Tomeu
*/
//CosNaming contiene aspectos relacionados con el servicio de nombre de JavaIDL
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
//Implementación del objeto servidor remoto. Es el codigo del futuro servant
//Debe extender siempre al skeleton generado con el compilador idlj
class ImpresorRemoto
extends _HolaMundoDistribuidoImplBase
{
public void Imprimir(String mensaje)
{System.out.println(mensaje);}
}
//Ahora se implementa la aplicación remota, que realiza las siguientes tareas:
//(1) Crea e inicializa el ORB
//(2) Crea un objeto servidor remoto (servant)
//(3) Lo registra en el ORB
//(4) Lo registra en el servidor de nombre
//(5) Queda a la espera de solicitudes del cliente
public class ServidorRemoto
{
public static void main(String[] args)
throws Exception
{
//se crea e inicializa el ORB El identificador orb es una referencia al
//ORB creado. Utilizamos el ORB propocionado con la distribución JavaIDL
//aunque otros son posibles.
ORB orb = ORB.init(args, null);
//crea un objeto servidor. Por ahora es un objeto java
ImpresorRemoto IRem = new ImpresorRemoto ();
//Se produce el registro de este objeto java en el servicio de nombres
//una vez concluida, es un objeto CORBA (servant)
orb.connect(IRem);
org.omg.CORBA.Object refObj=
orb.resolve_initial_references ("NameService");
//La referencia a tal servicio debe convertirse a una referencia a
//objetos NamingContext.
NamingContext ncRef = NamingContextHelper.narrow(refObj);
//Ahora damos un nombre que sera el utilizado por los clientes para
//enviar solicitudes al objeto servidor
NameComponent nc = new NameComponent("Impresor Remoto", "");
NameComponent [] ruta = { nc };
//Se vincula la referencia pasada a String con la referencia a objeto
ncRef.rebind(ruta, IRem);
//Se esperan peticiones de clientes.
java.lang.Object sinc = new java.lang.Object();
synchronized (sinc)
{sinc.wait();}
}
}
Hola Mundo Distribuido Con CORBA
Cliente
/**Ejemplo de fichero que implanta un servidor via CORBA
* @author Antonio Tomeu
*/
import org.omg.CosNaming.*;
import org.omg.CORBA.*;
public class ClienteHolaMundoDistribuido
{
public static void main(String[] args)
throws Exception
{
//Se crea el ORB del cliente. Se utiliza el proporcionado con JavaIDL.
//Otros son posibles.
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object refObj =
orb.resolve_initial_references ("NameService");
NamingContext ncRef = NamingContextHelper.narrow(refObj);
//Se le pide al Servicio de Nombres que resuelva la referencia para el
//servidor.
NameComponent nc = new NameComponent("Impresor Remoto", "");
NameComponent [] ruta = { nc };
HolaMundoDistribuido ObjImpresor =
HolaMundoDistribuidoHelper.narrow(ncRef.resolve(ruta));
ObjImpresor.Imprimir("Hola Mundoooooooooooooo");
}
}
Hola Mundo Distribuido Con CORBA
Ejecutando el Servicio de Nombres
?(
>
Hola Mundo Distribuido Con CORBA2
Especificación IDL
2Utilizando
el servicio de nombres persistente orbd. Es el estándar de Java IDL a partir
de J2SE y versiones del jdk 1.4 o superiores.