UNIVERSIDAD AUTONOMA METROPOLITANA UNIDAD IZTAPALAPA

Transcripción

1 UNIVERSIDAD AUTONOMA METROPOLITANA UNIDAD IZTAPALAPA División de Ciencias Básicas e Ingeniería Departamento de Ingeniería Eléctrica Licenciatura en Computación PROPUESTA DE UNA PLATAFORMA DE ESTUDIO DE LA ARQUITECTURA CORBA UTILIZANDO JAVA Reporte de Proyecto Terminal Alumno: Christofer Bernardo Estebanez Ruiz Matrícula: Asesor: Dra. Graciela Román Alonso

2 Índice. I Objetivos... 3 II Introducción... 3 III CORBA...5 III.I Arquitectura...5 III.II Lenguaje Java-IDL...6 IV Propuestas de ejercicios básicos usando CORBA...7 IV.I Aplicación de acceso local... 7 IV.II Aplicación de acceso remoto V Conclusiones VI Referencias VII Anexo

3 I Objetivos. 1. Estudiar la arquitectura de manejo de objetos distribuidos CORBA. 2. Construir una plataforma basada en Java, que permita el manejo mediante CORBA. II Introducción. Actualmente los sistemas distribuidos basados en objetos son una tecnología que es cada vez más utilizada en el desarrollo de aplicaciones. El tener las bases para construir aplicaciones que usan los recursos localizados en diversas computadoras abre el panorama para abordar diferentes problemáticas de la vida diaria. Modelos orientados a objetos. En un modelo orientado a objetos (OO), una aplicación distribuida es considerada como una colección de objetos autónomos especializados en diferentes funcionalidades, que existen independientemente en un sistema distribuido. Diversos objetos coordinan sus actividades y usan sus funcionalidades mediante rutinas explícitas de comunicación. Objetos comunicantes. Un objeto reúne atributos y métodos y cada uno de ellos tiene un estado interno, descrito por los valores de sus atributos. Un objeto puede ser accesado mediante la llamada a sus métodos (mensaje), los cuales pueden representar servicios para clientes o bien para modificar el estado interno del objeto. El modelo OO seguido se usa en el diseño de aplicaciones de granularidad gruesa de gran escala. Objetos distribuidos. Los objetos distribuidos son un modelo para la realización de la arquitectura Cliente/Servidor. Los objetos distribuidos siguen el modelo de memoria distribuida, permiten el paralelismo de tareas y una programación MPMD. 3

4 Cada interacción entre objetos sigue el patrón Cliente/Servidor. Sin embargo, la estructura de los sistemas de objetos distribuidos es peer-to-peer: los papeles de Cliente y Servidor pueden cambiar en el tiempo. Objetos = Unidades de distribución. Los objetos pueden ser de granularidad muy gruesa (productos vendidos por una empresa). Los objetos poderosos de granularidad gruesa son comúnmente conocidos como componentes. Objeto. Término de lenguaje de programación. Enfatiza el encapsulamiento de datos y código. Se usa frecuentemente para entidades en un mismo programa. Componente Término de ingeniería de software. Enfatiza la oportunidad de agrupar entidades en aplicaciones de gran escala. Existe independientemente, no existe un solo programa. Arquitectura de objetos distribuidos. Las aplicaciones a gran escala generalmente de organizan como sistemas de software abiertos: los objetos pueden ser añadidos, modificados o retirados mientras el resto del sistema sigue corriendo. Sistemas como CORBA y DCOM proveen un conjunto de facilidades para el desarrollo de aplicaciones de gran escala (frameworks, dessign patterns, business objects, beans, etc.) 4

5 III CORBA III.I Arquitectura CORBA. CORBA (Common Object Request Broker Architecture) es un estándar establecido por la OMG (Object Management Group: CORBA se diseñó para funcionar sobre ambientes heterogéneos y permite la interoperabilidad entre programas escritos en diferentes lenguajes de programación y entre programas que corren en diferentes máquinas. Existe una clara separación entre interfaz e implementación de servicio. Qué es? CORBA es sólo una especificación para crear y usar objetos distribuidos. Qué no es? CORBA no es un lenguaje de programación. Un sistema basado en CORBA es una colección de objetos que aislan a los solicitantes de servicios (clientes) de los provedores de servicio (servidores) por una interfaz de encapsulamiento bien definida. Los objetos de CORBA pueden correr en cualquier plataforma. Los objetos de CORBA pueden ser localizados en cualquier parte de la red. Los objetos de CORBA pueden ser escritos en cualquier lenguaje que tenga mapeo IDL. La Object Management Architecture (OMA) de OMG define varios servicios de alto nivel para el cómputo distribuido orientado a objetos. El núcleo de OMA es el Object Request Broker (ORB) que es un mecanismo que provee transparencia en la localización de objetos, comunicación y activación. Cualquier programa existente puede ser transformado a un objeto CORBA al describir su interfaz mediante un lenguaje de definición de interfaces (IDL). Transparencia de localización. El propósito del ORB es mediar la comunicación entre los objetos Cliente y Servidor de manera transparente. Un objeto tiene asociado un identificador único (o referencia única de objeto), asignado automática mente por el sistema. Un Cliente no conoce la localización física del Servidor por lo que envía la petición al ORB el cual busca la localización del Servidor y envía la petición del Cliente. 5

6 CORBA (Common Object Request Broker Architecture). Servidor Cliente Operación Resultad o Implementación de objeto DII Stubs Interfaz ORB Interfaz ORB Skeletons DSI Adaptador de objeto Deposito de implement. III.II Lenguaje Java-IDL. Interface description language (también lenguaje de descripción de interfaces). Es un lenguaje de informática utilizado para describir la interfaz de componentes software. Describe una interfaz en un lenguaje neutral, lo cual permite la comunicación entre componentes de software desarrollados en diferentes lenguajes como por ejemplo, entre las componentes escritas Java. Son utilizadas con frecuencia en el software de las llamadas a procedimiento remoto (RPC), lo que permite a los sistemas de computadoras utilizar lenguajes y sistemas operativos diferentes. IDL ofrece un puente entre dos sistemas diferentes. El compilador IDL usa el mapeo del lenguaje IDL-a-Java para convertir las definiciones de interfaz IDL a las correspondientes interfaces, clases y métodos de Java, los cuales pueden ser usados para implementar el código cliente-servidor. 6

7 IV Propuestas de ejercicios básicos usando CORBA: Hola mundo con tecnología Java- IDL. IV.I Aplicación de acceso local. Antes de empezar: Para Windows: Se debe contar previamente con la versión 1.4 de J2SE (Java 2 Standard Edition) que contiene la Interfaz de Programación de Aplicación (API por sus siglas en inglés) y el Intermediario de Petición de Objetos (ORB por sus siglas en inglés) los cuales son necesarios para habilitar la interacción de objetos distribuidos basados en CORBA, así como el compilador IDL. Para Linux: Para poder usar los comandos de conexión remota (orbd) basta con instalar la máquina virtual de Java en el sistema operativo la cual ya cuenta con el compilador IDL y con el protocolo correspondiente que permite habilitar la interacción de objetos distribuidos. Una vez visto esto procederemos a la creación y ejecución del programa. 7

8 Escribiendo el archivo hello.idl. 1. Crear un nuevo directorio llamado Hello para esta aplicación. 2. En un archivo de texto escribir el código: module HelloApp{ interface Hello{ string sayhello(); oneway void shutdown(); ; ; 3. Guardar el archivo como Hello.idl. Entendiendo el archivo idl. El idl para nuestro hola mundo es extremadamente sencillo ya que su interfaz tiene solo dos operaciones. Solo se necesitan tres pasos a realizar: 1. Declaración del modulo CORBA IDL. Un módulo CORBA es un nombre-espacio que actúa como contendor para las interfaces y declaraciones relacionadas. Se asemeja a un paquete Java. Cada declaración de módulo en un archivo IDL es mapeado a un paquete Java. La declaración del módulo luce así: module HelloApp{ // Resto de las líneas del código ; Cuando se compila el IDL, la declaración del módulo generará una declaración de paquete en el código de Java. 2. Declaración de la interfaz. Así como las interfaces Java, las interfaces CORBA declaran la relación que un objeto tiene con otros objetos. Cada declaración de interfaz en IDL mapea la declaración de interfaz de Java. 8

9 Para nuestro archivo Hello.idl, la declaración de interfaz luce así: module HelloApp{ interface Hello{ ; ; Cuando se compila el IDL, esta declaración generará una declaración de interfaz en el código de Java. 3. Declarando las operaciones. Las operaciones de CORBA son el comportamiento que el servidor promete cumplir por los clientes que lo invoquen. Cada declaración de operación en IDL genera una declaración de método correspondiente en el que es generado en la interfaz Java. En nuestro archivohello.idl, la declaración de operaciones luce así: module HelloApp{ interface Hello{ string sayhello(); oneway void shutdown(); ; ; La definición de interfaz para nuestra aplicación hola mundo ahora está completa. Mapeo del archivo Hello.idl a Java. La herramienta idlj lee los archivos IDL y crea los archivos Java requeridos. El compilador idlj genera por defecto solo las obligaciones del lado del cliente. Si se necesitan las obligaciones del lado del cliente y los esqueletos del lado del servidor (como ocurre en este caso), debes usar la opción fall cuando ejecutes el compilador idlj. Dentro del directorio de ubicación del archivo Hello.idl escribir en la línea de comandos: idlj -fall Hello.idl Esto crea un directorio llamado HelloApp que contiene seis archivos *.java. 9

10 Entendiendo la salida del compilador idlj. El compilador idlj genera un cierto número de archivos. Este número depende de las opciones seleccionadas cuando el archivo IDL es compilado. Los archivos generados proveen una funcionalidad estándar, así que pueden ser ignorados hasta el momento en que hay que desplegar y ejecuta el programa. Los archivos generados son: HelloPOA.java. Esta clase abstracta es el esqueleto del servidor de conexión base la cual provee al servidor de la funcionalidad CORBA básica. _HelloStub.java. Esta clase es el talón del cliente, el cual provee al cliente de la funcionalidad CORBA. Hello.java. Esta interfaz contiene la versión Java de nuestra interfaz IDL. HelloHelper.java. Esta clase provee funcionalidad auxiliar, en particular el método narrow() requerido para convertir las referencias de objeto CORBA a los tipos apropiados. HelloHolder.java. Esta clase final posee un miembro de instancia pública del tipo Hello. En el momento en que el tipo IDL es un parámetro out o inout, la clase Poseedor es usada. HelloOperations.java. Esta interfaz contiene los métodos sayhello() y shutdown(). El mapeo IDL-a-Java pone todas las operaciones definidas en la interfaz en este archivo. Cuando se escribe la interfaz IDL, se hace toda la programación requerida para generar todos estos archivos para la aplicación distribuida. 10

11 Desarrollo del servidor. Creación de HelloServer.java. 1. Abrir un editor de texto y crear un archivo llamado HelloServer.java dentro del directorio Hello. 2. Escribe el siguiente código en el archivo: import HelloApp.*; import org.omg.cosnaming.*; import org.omg.cosnaming.namingcontextpackage.*; import org.omg.corba.*; import org.omg.portableserver.*; import org.omg.portableserver.poa; import java.util.properties; class HelloImpl extends HelloPOA{ private ORB orb; public void setorb(orb orb_val){ orb = orb_val; public String sayhello(){ return "\nhello world!!\n"; public void shutdown(){ orb.shutdown(false); public class HelloServer{ public static void main(string args[]) { try{ ORB orb = ORB.init(args, null); POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); rootpoa.the_poamanager().activate(); HelloImpl helloimpl = new HelloImpl(); helloimpl.setorb(orb); org.omg.corba.object ref = rootpoa.servant_to_reference(helloimpl); Hello href = HelloHelper.narrow(ref); org.omg.corba.object objref = orb.resolve_initial_references("nameservice"); NamingContextExt ncref = NamingContextExtHelper.narrow(objRef); String name = "Hello"; 11

12 NameComponent path[] = ncref.to_name( name ); ncref.rebind(path, href); System.out.println("HelloServer ready and waiting..."); orb.run(); catch (Exception e) { System.err.println("ERROR: " + e); e.printstacktrace(system.out); System.out.println("HelloServer Exiting..."); 3. Guarda y cierra HelloServer.java. Entendiendo HelloServer.java. La estructura del programa servidor CORBA es el mismo que el de la mayoría de las aplicaciones Java: se importan paquetes de librerías requeridos, se declara la clase del servidor, se define main() y se manejan las excepciones. Importando los paquetes requeridos: import HelloApp.*; import org.omg.cosnaming.*; import org.omg.cosnaming.namingcontextpackage.*; import org.omg.corba.*; import org.omg.portableserver.*; import org.omg.portableserver.poa; Definiendo la clase servidor: En este ejemplo estamos definiendo la clase para el objeto servidor dentro de HelloServer.java pero fuera de la clase HelloServer. class HelloImpl extends HelloPOA{ // Los métodos sayhello() y shutdown() van aquí El servidor es una subclase de HelloPOA así que hereda la funcionalidad CORBA general generada por el compilador. Ahora, creamos una variable privada orb que es usada en el método setorb(orb). Este en un método privado definido por la aplicación desarrolladora para que el valor ORB pueda ser fijado con el servidor. Este valor ORB es usado para invocar el método shutdown() en respuesta a la invocación del método shutdown() del cliente. 12

13 private ORB orb; public void setorb(orb orb_val){ orb = orb_val; Después declaramos e implementamos el método sayhello() requerido: public String sayhello(){ return "\nhello world!!\n"; Por último, implementamos el método shutdown() de forma similar: public void shutdown(){ orb.shutdown(false); Declarando la clase del servidor: public class HelloServer{ // El método mai() va aquí Definiendo el método main(): Cada aplicación de Java necesita de un método main() y es declarado dentro de la clase HellServer. public static void main(string args[]{ // Aquí va el código try-catch Manejando las excepciones del sistema CORBA. Como todos los programa CORBA pueden arrojar excepciones de sistema CORBA en tiempo de ejecución, toda la funcionalidad de main() es colocada dentro de un bloque trycatch. Los programa CORBA arrojan excepciones en tiempo de ejecución cuando ocurre un problema durante algún proceso envuelto en una invocación. El manejador de excepciones simplemente imprime la excepción y el rastro de su pila en una salida estándar para poder ver que fue lo que ocurrió mal. El bloque try-catch se coloca dentro de main() como se muestra: try{ // El resto del código HelloServer va aquí. catch(exception e){ System.err.println("ERROR: " + e); e.printstacktrace(system.out); 13

14 Compilando el servidor hola mundo. Ahora ya podemos compilar HelloServer.java para corregir cualquier error antes de continuar. 1. Posicionarse en el directorio Hello. 2. Ejecutar el compilador Java sobre HelloServer.java: Javac HelloServer.java HelloApp/*.java 3. Corregir los errores y recompilar si es necesario. 4. Se generan los archivos HelloServer.class y HelloImp.class en el directorio Hello. 14

15 Desarrollo del cliente. Creación de HelloClient.java. 1. Abrir un editor de texto y crear un archivo llamado HelloClient.java dentro del directorio Hello. 2. Escribe el siguiente código en el archivo: import HelloApp.*; import org.omg.cosnaming.*; import org.omg.cosnaming.namingcontextpackage.*; import org.omg.corba.*; public class HelloClient{ static Hello helloimpl; public static void main(string args[]){ try{ ORB orb = ORB.init(args, null); org.omg.corba.object objref = orb.resolve_initial_references("nameservice"); NamingContextExt ncref = NamingContextExtHelper.narrow(objRef); String name = "Hello"; helloimpl = HelloHelper.narrow(ncRef.resolve_str(name)); System.out.println("Obtained a handle on server object: " + helloimpl); System.out.println(helloImpl.sayHello()); helloimpl.shutdown(); catch (Exception e) { System.out.println("ERROR : " + e) ; e.printstacktrace(system.out); 3. Guarda y cierra HelloServer.java. Entendiendo HelloClient.java. El caparazón básico de un cliente CORBA es el mismo que el de muchas de las aplicaciones Java: se importan paquetes de librerías requeridos, se declara la clase del servidor, se define main() y se manejan las excepciones. 15

16 Importando los paquetes requeridos: import HelloApp.*; import org.omg.cosnaming.*; import org.omg.cosnaming.namingcontextpackage.*; import org.omg.corba.*; Definiendo la clase cliente: Lo siguiente es declarar la clase del cliente: public class HelloClient{ // El método main() va aquí Creando el objeto ORB. Un cliente CORBA necesita un objeto ORB local para desempeñar su cálculo de referencias y su trabajo IIOP. La variable ORB es declarada e inicializada dentro del bloque try-catch: ORB orb = ORB.init(args,null); La llamada al método init() de CORBA pasa los argumentos de la línea de comando en la aplicación, permitiendo fijar ciertas propiedades en tiempo de ejecución. Buscando el servidor Hello. Ahora que la aplicación tiene un ORB, puede pedirle que localice el servicio que necesita, en este caso el servidor Hello. Para ello, nuestra aplicación cliente usará el servicio de nombramiento COS. Obteniendo el contexto de nombramiento inicial. El primer paso para usar el servicio de nombramiento es obtener el contexto de nombramiento inicial: org.omg.corba.object objref = orb.resolve_initial_references("nameservice"); Estrechando la referencia del objeto. Como en todas las referencias a objeto CORBA, objref es un objeto CORBA genérico. Para poder usarlo como un objeto NamingContextExt, se debe estrechar al tipo apropiado. NamingContextExt ncref = NamingContextExtHelper.narrow(objRef); 16

17 Aquí vemos el uso de una clase de ayuda generada por idlj, similar a la función HelloHelper. Resolver la referencia a objeto en el nombramiento. Para publicar una referencia en el servicio de nombrado hacia el objeto Hello que implementa la interfaz Hello, necesitas primero una cadena identificadora para el objeto Hello: String name = "Hello"; Finalmente pasamos name al método resolve_str() del servicio de nombrado para obtener una referencia objeto para el servidorhello y estrecharlo al objeto Hello: helloimpl = HelloHelper.narrow(ncRef.resolve-str(name)); System.out.println("Obtained a handle on server object: " + helloimpl); Aquí se ve a la clase de ayuda HelloHelper trabajar. El método resolve_str() regresa un objeto CORBA genérico. Por lo tanto, inmediatamente se estrecha el objeto Hello, el cual es la referencia objeto que se necesita para realizar el resto del trabajo. Invocando la operación sayhello(). Las invocaciones CORBA son una llamada a método sobre un objeto local.finalmente, imprimimos los resultados de la invocación a una salida estándar y se apaga el ORB: System.out.println(helloImpl.sayHello()); helloimpl.shutdown(); Compilando el servidor hola mundo. Ahora ya podemos compilar HelloClient.java para corregir cualquier error antes de continuar. 1. Posicionarse en el directorio Hello. 2. Ejecutar el compilador Java sobre HelloClient.java: Javac HelloClient.java HelloApp/*.java 3. Corregir los errores y recompilar si es necesario. 4. Se genera el archivo HelloClient.class en el directorio Hello. 17

18 Ejecución de la aplicación hola mundo. 1. Iniciar el orbd. Desde terminal Linux: rbd -ORBInitialPort ORBInitialHost localhost& Desde terminal Windows: start orbd -ORBInitialPort ORBInitialHost localhost NOTA: 1050 es el puerto en el cual se quiere ejecutar el servidor. Para poder ejecutar la aplicación en un puerto en un puerto menor a 1024 se debe ser el administrador del sistema, por eso es que se ejecuta en un puerto mayor a Iniciar el servidor Hello: Desde terminal Linux: java HelloServer -ORBInitialPort ORBInitialHost localhost& Desde terminal Windows: start java HelloServer -ORBInitialPort ORBInitialHost localhost 3. Ejecutar la aplicación cliente java HelloClient -ORBInitialPort ORBInitialHost localhost El cliente imprime la cadena desde el servidor en la línea de comandos. Hello world!! 18

19 IV.II Aplicación de acceso remoto. Cliente Implementación del objeto Cliente Implementación del objeto IDL IDL IDL IDL ORB ORB RED Para poder ejecutar la aplicación hola mundo en dos máquinas se debe colocar al cliente, los esbozos y los esqueletos en la máquina del cliente y el servidor en la máquina del servidor. 1. Crear (como se muestro previamente) y compilar el archivo Hello.idl en la máquina del cliente: idlj -fall Hello.idl 2. Crear el archivo HelloClient.java en la máquina del cliente. Compilar los archivos java, incluyendo los esbozos y los esqueletos (que se encuentran en el directorio HelloApp): javac *.java HellApp/*.java 3. Crear el archivo HelloServer.java en la máquina del servidor. Compila los archivos *.java. javac *.java 4. Inicia el demonio intermediario de petición de objets Java (orbd por sus siglas en ingles), el cual incluye el servicio de nombramiento. 19

20 Para hacer esto en Linux: orbd -ORBInitialPort ORBInitialHost direcciónip& Para hacer esto en Windows: start orbd -ORBInitialPort ORBInitialHost direcciónip Los argumentos -ORBInitialPort y -ORBInitialHost son obligatorios para la línea de comando orbd. En este ejemplo se usa el puerto NOTA: La dirección IP del servidor fue generada por medio de un simulador de redes virtuales, Hamachi en este caso, la cual es una es una aplicación configuradora de redes privadas gratuita capaz de establecer vínculos directos entre computadoras que están bajo firewalls de NAT sin requerir reconfiguración alguna (en la mayoría de los casos). En otras palabras, establece una conexión a través de Internet y simula una red de área local formada por ordenadores remotos. 5. Inicia el servidor Hello en la máquina del servidor como se muestra: En la terminal de Linux: java HelloServer -ORBInitialPort 1050& En terminal de Windows: start java HelloServer -ORBInitialPort 1050 Nota: No se necesita especificar el argumento -ORBInitialHost porque el servidor Hello estará ejecutándose en el mismo anfitrión que el servidor en este ejemplo. 6. Ejecuta la aplicación Hello del cliente en la maquina donde se encuentra el cliente: En terminal de Linux: java HelloClient -ORBInitialHost direcciónip -ORBInitialPort 1050& En terminal de Windows: java HelloClient -ORBInitialHost direcciónip orbd -ORBInitialPort 1050 Nota: La direcciónip es el anfitrión en el cual el servidor IDL está ejecutándose. En este caso es la máquina del servidor. 7. Detener el orbd cuando se termine la aplicación, en caso contrario el servidor seguirá esperando invocaciones del cliente. 20

21 V Conclusiones. Java IDL es una tecnología para objetos distribuidos que permite la interacción de estos sobre diferentes plataformas a través de la red. Esta interacción es posible porque Java-IDL está basada en una arquitectura de intermediario de peticiones de objetos comunes (CORBA), un modelo de objetos distribuidos estándar. El compilador IDL es una herramienta poderosa y de gran ayuda para la creación de aplicaciones de objetos distribuidos; una vez que se tiene definida la interface remota se puede de forma relativamente sencilla crear aplicaciones, ya que la conexión entre clienteservidor se realiza de la misma forma en todas las aplicaciones, es decir, no cambia el código de conexión en la aplicación de servidor. Parte del poder de alcance de CORBA se debe al apoyo del compilador IDL, quien es el encargado de la creación de todo el esqueleto de nuestras aplicaciones y al soporte que proporciona Java, comenzando por las clases (que son compatibles con el lenguaje IDL), pasando por los métodos de manipulación hasta el manejo de excepciones. Por ello se propone utilizar esta plataforma para el desarrollo de aplicaciones Java-IDL ya que su manejo es simple (como puede verse en este documento) para la creción de las mismas. VI Referencias. ORBIX de IONA Technologies. VisiBroker de Borland. JacORB is an object request broker written in Java, available under the LGPL. JavaIDL de JavaSoft. Información sobre el compilador IDL. Información sobre Hamachi. 21

22 VII Anexo 1. Otra aplicación para la arquitectura CORBA usando tecnología Java- IDL. Implementador de fechas. Código del archivo IDL: module FechaApp { interface Fecha{ string getfecha(); ; ; Código del servidor: import FechaApp.*; import org.omg.corba.*; import org.omg.portableserver.poahelper; import org.omg.portableserver.poa; import java.util.*; import java.io.*; import org.omg.cosnaming.*; import org.omg.cosnaming.namingcontextpackage.*; import org.omg.corba.*; class FechaImpl extends FechaPOA { public String getfecha() { return (new Date()).toString(); public class FechaServer { public static void main(string args[]) { try { ORB orb = ORB.init(args, null); FechaImpl impl = new FechaImpl(); POA rootpoa=poahelper.narrow(orb.resolve_initial_references("rootpoa")); rootpoa.the_poamanager().activate(); org.omg.corba.object ref = rootpoa.servant_to_reference(impl); 22

23 Fecha href = FechaHelper.narrow(ref); org.omg.corba.object objref = orb.resolve_initial_references("nameservice"); NamingContextExt ncref = NamingContextExtHelper.narrow(objRef); String nombre = "Fecha"; NameComponent path[] = ncref.to_name(nombre); ncref.rebind(path, href); orb.run(); catch (Exception e) { System.err.println("ERROR: " + e); Código del cliente: import FechaApp.*; import org.omg.corba.*; import org.omg.cosnaming.*; import org.omg.cosnaming.namingcontextpackage.*; public class FechaClient { public static void main(string args[]) { try { ORB orb = ORB.init(args, null); org.omg.corba.object objref =orb.resolve_initial_references("nameservice"); NamingContextExt ncref = NamingContextExtHelper.narrow(objRef); String nombre = "Fecha"; Fecha impl = FechaHelper.narrow(ncRef.resolve_str(nombre)); System.out.println("Fecha: " + impl.getfecha()); catch (Exception e) { System.out.println("ERROR : " + e); e.printstacktrace(system.out); 23

24