TEMA 4: PROGRAMACIÓN DISTRIBUIDA

Transcripción

1 TEMA 4: PROGRAMACIÓN DISTRIBUIDA!" #!$ %! % & '( '')* (+,( -./0%1' 2%1/../ -3% 450 -(.40( %16 2%1/../ -3% /.0-2%..02%% 7-89:08 1! "!;1 %<51=/1+>1499:

2 No existe memoria común Comunicaciones No existe un estado global del sistema Grado de Transparencia Escalables Reconfigurables

3 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

4 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)

5 Modelo General SOLICITUD CLIENTE RESPUESTA SERVIDOR NUCLEO NUCLEO RED

6 % % #>@A$%;% "%% B& CB CLIENTE P U E R T O SERVIDOR TCP/UDP

7 App A App B App C Port xxx Port yyy Port zzz Port kkk PROTOCOLO TCP/UDP Port yyy

8 CLIENTE P U E R T O SERVIDOR Solicitud de conexión CLIENTE P U E R T O P U E R T O SERVIDOR PUERTO

9 D A;% 1% 7 % % %; %%%% 7%%% Socket() Accept() Socket creado y activo

10 ServerSocket " % % & %%Socket "% ServerSocket L = newserversocket (num_puerto) '% B % L.accept(); )%% % B % C%

11 Socket % %% % % % "% Socket (dirección_ip, puerto);

12 4 & ServerSocket / & Socket < InputStream% %% E OutputStream 7 %% 5 2F G %

13 &% #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

14 4 & Socket / InputStream% %% < OutputStream 7 %% E 2F 5 %

15 ! 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(" "); Socket enchufe = new Socket (dir_ip, 8080); System.out.println("Datos socket creado: "+enchufe); }//main }//SocketCliente

16 " socket A; % D1 > % & socket!@ %%socket getinputstream() getoutputstream() %%!&% 7%& F (3 & %% SocketChannel

17 #$" # %& '( )***+ % % "% % 3 8% read-only 8% 7% % %% "> % & 3F7 %!> %B"% # 8!$ SE ELIMINA LA MEMORIA COMÚN!

18 wait(), notify(), notifyall() A > %"% 7 3 (synchronized). %% ;7 D%3 % %rendezvous % ; % %3 & > % Emisor Listo Canal Receptor Listo

19 , send (B, mensaje) Proceso A rendezvous Proceso B receive (A, mensaje) tiempo

20 & % 7;!@ run() & % & %% Canal de Salida public void run() { //codigo ejec. } Canal de Entrada

21 #- ", 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} }

22 ", # read >write % % #H7$3 # ; ;$ % H7 3

23 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); } }

24 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); } }

25 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

26 # # ' %(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

27 # Sequential (Process[] procesos) Parallel (Process[] procesos) PriParallel (Process[] procesos) Con guardas: Alternative PriAlternative

28 ./ 01 csp.io.linkdrivers.tcpip (ó UDP) % public TCPIP(remotehost, remoteport, TCPIP.tipo) REALTIME # ASYNCHRONOUS %%% %%

29 import csp.lang.*; import csp.lang.process; import csp.lang.integer; Import 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

30 import csp.lang.*; import csp.lang.process; import csp.lang.integer; Import 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

31 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

32 % % % func() func(void) {//codigo. } '8 4 7%% C% % / % < KL % % MN 2 % % 2

33 7H% $ C '% B%%%% % & 7 %% A

34 B % % % + callrpc rpcreturn llamada normal return %% % RED H% % H%

35 ./ 1 7 % 7 C 77 %7; 7O37 rpcgen#pd$frmic#$

36 4 5 Especificación Formal Interface Cliente Ejecutable Precompilador rpcgen o rmic Servidor Ejecutable C O M P I L A R Resguardo Stub Cliente Ficheros compartidos Representación de datos Resguardo Skeleton Servidor C O M P I L A R

37 Especificación Formal Interface Generador de Resguardos Interfaz del servidor+asa create, read delete, write Res. Del Servidor Read(f,d) Res. Del Cliente CONECTOR SERVIDOR d CLIENTE Petición de asa del servidor Envío de asa

38 6 3 7%7;% 7" 7.x /*rand.x*/ program RAND_PROG{ version RAND_VER{ void inicia_aleatorio(long)=1; double obtener_aleat(void)=2; }=1; }=0x ; *C $rpcgen rand.x > %7" %CB% %;Q '% xdr.h

39 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 Servidor Objeto Cliente JVM JVM

40 3 32 RPC Carácter y Estructura de diseño procedimental Es dependiente del lenguaje Utiliza la representación externa de datos XDR El uso de punteros requiere el manejo explícito de los mismos NO hay movilidad de código RMI Carácter y Estructura de diseño orientada a objetos Es dependiente del lenguaje Utiliza la serialización de objetos en Java El uso de referencias a objetos locales y remotos es automático El código es móvil, mediante el uso de bytecodes.

41 ' 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);

42 7! 32 Cliente Stub Referencia Remota Transporte Servidor Skeleton Referencia Remota 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.

43 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)

44 K % % N public interfaz extends Remote {signaturas métodos} implements resultado Cliente ref.metodo(param) Implementación de la interfaz new referencia a interfaz SERVIDOR 6 3" lookup " bind ó rebind

45 Definir Interfaz Remota implements Implementar Interfaz Remota $ rmic.class Skeleton Stub JVM JVM Implementar Servidor Implementar Cliente

46 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

47 2: 8&3: 6#387= /**Ejemplo del interfaz remoto para implementar un RMI 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; }

48 87 9: 32 )<226#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.

49 2: 226#7>6 6#387= / 3?:3 /**Ejemplo de implementacion del interfaz remoto para un RMI 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 {

50 //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.

51 //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 Naming.bind( Servidor",ORemoto); System.out.println("Servidor Remoto Preparado"); } }

52 87 9: 4 #A / B#:6 Fichero de implementación de Interfaz compilado (Imp.class) Compilador de RMI $ rmic imp 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 $ java EjemploRMI1 &

53 87 9: 32 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 El parámetro puede ser el nombre de un host como en Naming.bind( //sargo.uca.es:2005/servidor",oremoto);

54 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.

55 2: 6# /**Ejemplo de implementacion de un cliente para RMI 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)); } }

56 ", Serializable %; & % 1 % & % H% & %&! %; & %& %%7; Serializable #7%$ %;

57 , 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);} }

58 ", 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) throws RemoteException; String nomtit(int codigo) throws RemoteException; } int codtit(string nom) throws RemoteException; /aquí la serializacion es necesaria*/ cuentabanca [] listado() throws RemoteException;

59 4 - policytool % System.setSecurityManager(new RMISecurityManager()); &% > & SecurityManager )% %@ setsecuritymanager (clase System) %RMISecurityManager &%%% Policy Policy.getPolicy() %% Policy.setPolicy() 7& %3 7" 37 / "%policytool

60 (&% %3 % %> %&% 7".policy /* AUTOMATICALLY GENERATED ON Fri May 28 19:23:13 CEST 2004*/ /* DO NOT EDIT */ grant { permission java.net.socketpermission "*: ", "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 % &

61 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

62 :37 : 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)

63 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?( implementaciones. (JavaIDL) >

64 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

65 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

66 Cliente Implementación del objeto ORB

67 Estructura del ORB

68 Invocación Estática Cliente rebobjeto.metodo(param) metodo(param) Servidor IDL Stub marshalling unmarshalling IDL Skeleton Object Adapter ORB Core Interface dependiente del ORB Stub para cada tipo de objeto

69 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:

70 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

71 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.

72 API JavaIDL Básica org.omg.corba org.omg.cosnaming org.omg.portableserver org.omg.corba.orb org.omg.portableinterceptor org.omg.dynamicany

73 Compilando IDL Interfaz IDL Stubs Cliente -fclient Aplicación Cliente Compilador de IDL ($idltojava) ($idlj) en J2SE -fserver -fall Skeletons Servidor Aplicación Servidor -fserver A partir de J2SE v1.4 POA Servidor Implemen. Servidor

74 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.

75 Servants POA POA Manager ORB

76 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

77 Servidor resolve(a) Cliente x bind(x, ref) Jeraquía de Nombres ref x 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));

78 Interacción Cliente/Servidor-Servicio de Nombres '

79 Hola Mundo Distribuido Con CORBA 1 Especificación IDL de la Interfaz Remota /**Ejemplo de fichero de especificacion IDL 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); }; 1 Utilizando el servicio de nombres no persistente tnameserv ya derogado. Se explica por compatiblidad hacia atrás.

80 Hola Mundo Distribuido Con CORBA Servidor /**Ejemplo de fichero que implanta un servidor via CORBA 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

81 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();} } }

82 Hola Mundo Distribuido Con CORBA Cliente /**Ejemplo de fichero que implanta un servidor via CORBA 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"); } }

83 Hola Mundo Distribuido Con CORBA Ejecutando el Servicio de Nombres

84 Hola Mundo Distribuido Con CORBA 2 Especificación IDL 2 Utilizando 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.