RMI Sobre IIOP

1
RMI Sobre IIOP
Modelos y Arquitecturas Distribuidas
2
Metas

• La meta principal de los diseñadores de RMI fue
  la de permitir a los programadores el desarrollo
  de programas distribuidos en JAVA, usando la
  misma sintáxis y semántica de los programas no
  distribuidos.
• La arquitectura de RMI define la forma como deben
  interactuar los objetos, cómo y cuándo ocurren
  las excepciones, cómo se administra la memoria y
  cómo pasan y retornan los parámetros a/desde los
  métodos remotos.

3
La Arquitectura de RMI
Client Program
Server Program
Stubs
Stubs
RMI System
Remote Reference Layer
Transport Layer
4
El protocolo IIOP

• IIOP (Internet-Inter ORB Protocol).
• Se deriva del Protocolo GIOP (General Inter ORB
  Protocol).
• Permite la comunicación entre varios ORBs.
• Desde la implementación CORBA 2.0.
• Protocolo sobre TCP/IP.
• Existen otras versiones más genéricas
• GIOP (General Inter-ORB Protocol).
• ESIOPs (Environment-Specific Inter-ORB Protocols).

5
Definición de IIOP en IDL

• module IIOP // IDL extended for version 1.1 and
  1.2
• struct Version
• octet major
• octet minor
• struct ProfileBody_1_0 // renamed from
  ProfileBody
• Version iiop_version
• string host
• unsigned short port
• sequence ltoctetgt object_key
• struct ProfileBody_1_1 // also used for 1.2
• Version iiop_version
• string host
• unsigned short port
• sequence ltoctetgt object_key
• sequence ltIOPTaggedComponentgt components

6
Nivel de Transporte

• Sun e IBM trabajaron en la siguiente versión de
  
• RMI RMI-IIOP o RMI sobre IIOP.
• No usa JRMP, sino IIOP (Internet Inter-ORB
  Protocol) para comunicar clientes y servidores.

7
Diagrama de Bloques de Capas de Protocolos
Modelo OSI
Modelo IIOP
Aplicación
Aplicación
Presentación
ORB
Seción
IIOP
Transporte
TCP
Red
IP
DataLink
IEEE 802
Físico
Físico
8
La interoperabilidad

• Previamente los programadores Java tenían que
  seleccionar entre RMI o CORBA/IIOP (Java IDL)
  para soluciones de programación distribuidas.
• La capa de transporte especificada para el ORB es
  TCP/IP. Derivado de este se define el protocolo
  IIOP, que usa el protocolo TCP/IP para comunicar
  a un ORB con otro. Esto significa que IIOP es un
  protocolo aplicable a la mayoría de redes
  actuales, ya que prácticamente todas ellas
  cuentan con servicios TCP/IP.
• De los protocolos derivados de GIOP el único que
  obligatoriamente ha de implementar un ORB es
  IIOP. Cuando dos ORB quieren comunicarse entre
  sí lo primero que hacen es ponerse de acuerdo en
  cuanto al protocolo que utilizarán.

9
La interoperabilidad (2)
10
Creación de una Aplicación RMI-IIOP

• Cómo compilar y ejecutar un servidor RMI sobre
  IIOP.
• 1. Compilar la implementacin del objeto remoto.
• javac -d . -classpath . HelloImpl.java
• En este ejemplo, el archivo que contiene la
  implementación del objeto remoto es
  HelloImpl.java. Para crear los stub y skeletons,
  primero se debe compilar el archivo
  HelloImpl.java.
• La opción d indica que los archivos generados
  deben ser colocados en el directorio desde el
  cual se está ejecutando el compilador.
• La opción -classpath indica que los archivos de
  los cuales HelloImpl.java es dependiente pueden
  ser encontrados en este directorio.

11
Uso de rmic

• 2. Usar rmic para generar stub y sekeleton.
• rmic -poa -iiop HelloImpl
• Para crear los archivos stub y skeletons CORBA
  compatibles, se debe ejecutar el compilador rmic
  con las opciones poa iiop. El comando rmic poa
  iiop toma una o mas nombres de clases como
  argumento y produce archivos de clases de la
  forma _MyImpl_Tie.class y _MyInterface_Stub.class.
  
• El archivo de implementación remota,
  HelloImpl.class, es la clase a usar en este
  ejemplo.
• El comando anterior crea los siguientes archivos
• _HelloInterface_Stub.class el stub cliente.
• _HelloImpl_Tie.class el skeleton servidor.

12
Compilación de Archivos Fuentes

• Utilizar el comando javac
• javac -d . -classpath . HelloInterface.java
  HelloServer.java HelloClient.java
• Este comando crea los archivos de clases
• HelloInterface.class La interface remota.
• HelloServer.class El Servidor.
• HelloClient.class El cliente.

13
Inicializar el servicio de nombres.

• En este ejemplo se utilizará el Object Request
  Object Request Broker Daemon, orbd, el cual
  incluye Servicio de Nombres Transiente y
  Persistente.
• Para que el cliente pueda invocar un método
  remoto, éste primero debe obtener la referencia
  al objeto remoto.
• Una vez que el objeto remoto está registrado en
  el servidor, los clientes pueden localizar el
  objeto por el nombre, obtiene una referencia del
  objeto remoto, y luego remotamente invoca al
  método.
• Inciar el Naming Service, ejecutando orbd desde
  la línea de comandos, el cual se ejecutará en
  background o como demonio.
• En Solaris o Linux
• orbd -ORBInitialPort 2070
• en Windows
• cgtstart orbd -ORBInitialPort 2070

14
Ejecutar el Servidor

• El siguiente comando muestra cómo iniciar el
  servidor HelloServer
• java -classpath . Djava.naming.factory.initial
  
• 
  com.sun.jndi.cosnaming.CNCtxFactory -
• 
  Djava.naming.provider.urliiop//localhost2070
  
• HelloServer
• o
• java -classpath . Djava.naming.factory.initial
  
• 
  com.sun.jndi.cosnaming.CNCtxFactory -
• 
  Djava.naming.provider.urliiop//kalku.face.ubiobi
  o.cl2070
• HelloServer

15
Ejecutar el Cliente.

• Una vez que el Naming Service y el servidor están
  corriendo, la aplicación cliente puede ser
  ejecutada.
• Si el servidor corre en la misma máquina, usar
• java -classpath . Djava.naming.factory.initial
  
• 
  com.sun.jndi.cosnaming.CNCtxFactory -
• 
  Djava.naming.provider.urliiop//localhost2070
  HelloClient
• Si el servidor corre en otra máquina, usar
• java -classpath . Djava.naming.factory.initial
  
• 
  com.sun.jndi.cosnaming.CNCtxFactory -
• 
  Djava.naming.provider.urliiop//kalku.face.ubiobi
  o.cl2070
• HelloClient
• Después de ejecutar la aplicación cliente, se
  verá la siguiente salida
• Client Obtained a ref. to Hello server.
• Y en el servidor

16
Otras Opciones de rmic

• Los princiaples flags de rmic son los siguientes
• -iiop que genera los stubs y ties IIOP en vez de
  JRMP.
• -iioop poa que genera los stus y ties que
  trabajan con un POA.
• -idl que genera IDL, útil cuando se tiene un
  cliente escrito en otro lenguaje. Después usar,
  por ejemplo, un compilador IDL-to-C, si el
  cliente está escrito en C.
• La siguientes opciones son utilizadas con la
  opción idl
• -noValueMethods
• -always
• -idlModule
• -idlFile

17
JNDI (Java Naming Directory Interface)

• Constituye una extensión estándar que se integra
  con los applets y aplicaciones de Java.
• Es independiente de todos sercicio de nombres y
  directorios.
• Los servicios de nombres asignan nombres a
  objetos de una red.
• Un contexto es un conjunto de vinculaciones de
  nombres a objetos.
• Los servicios de directorio se construyen y
  amplían en base a los servicios de nombres.
• Organizan los espacios de nombres en forma
  jerárquica.
• Los servicios de directorio de red proporcionan
  información acerca de la red de una organización,
  computadoras, dispositivos (como impresoras),
  servicios y aplicaciones de red, usuarios,
  información de seguridad, etc.

18
Cómo hacer que Programas RMI usen IIOP

• Tanto el cliente como el servidor necesitan crear
  un InitialContext para JNDI (Java Naming
  Directory Interface) usando el siguiente código
• Import javax.naming.
• .....
• Context ic new InitialContext()
• El paquete javax.namig ofrece cinco interfaces y
  diez clases que admiten operaciones básicas con
  nombres
• Context para especificar un contexto de nombres.
• InitialContext Proporciona una implementación
  predeterminada de interfaz Contex y actúa como
  punto de partida para la resolución del nombre.
• Name La implementan nombres y proporciona
  métodos para la manipulación de nombres.
• etc.

19
Modificar el uso de RMI registry

• Modificar el uso de registro RMI lookup() y
  bind() y usar los lookup() y bind() de JNDI. Por
  ejemplo
• Antes
• Import java.rmi.
• ...
• Naming.rebind(NombreObjeto, obj)
• Ahora se debe usar
• Import javax.naming.
• ...
• ic.rebind(NombreObjeto, obj)

20
Cambios Necesarios

• Uso de PortableRemoteObject en vez de
  UnicastRemoteObject.
• Usar el Java Naming Directory Interface (JDNI)
  en vez de rmiregistry.
• Indicarle a rmic que genere el IDL cuando sea
  necesario

21
Ejemplo
22
La Interface HelloInterface.java

• //HelloInterface.java
• import java.rmi.Remote
• public interface HelloInterface extends
  java.rmi.Remote
• public void sayHello() throws
  java.rmi.RemoteException

23
Implementación de la Interface HelloImpl.java

• //HelloImpl.java
• import javax.rmi.PortableRemoteObject
• public class HelloImpl extends PortableRemoteObjec
  t implements
• 
  
  HelloInterface
• public HelloImpl() throws java.rmi.RemoteExcepti
  on
• super() // invoca a rmi para enlace e
  inicialización del objeto remoto.
• public void sayHello() throws
  java.rmi.RemoteException
• System.out.println( "It works! Hello
  World!!" )

24
La clase HelloServer (1)

• //HelloServer.java
• import javax.naming.InitialContext
• import javax.naming.Context
• import javax.rmi.PortableRemoteObject
• import com.sun.corba.se.internal.POA.POAORB
• import org.omg.PortableServer.
• import java.util.
• import org.omg.CORBA.
• import javax.rmi.CORBA.Stub
• import javax.rmi.CORBA.Util

25
La clase HelloServer (2)

• public class HelloServer
• public HelloServer(String args)
• try
• Properties p System.getProperties()
• // add runtime properties here
• p.put("org.omg.CORBA.ORBClass",
  "com.sun.corba.se.internal.POA.POAORB")
• p.put("org.omg.CORBA.ORBSingletonClass","com
  .sun.corba.se.internal.corba.ORBSingleton")
• ORB orb ORB.init( args, p )
• POA rootPOA (POA)orb.resolve_initial_refer
  ences("RootPOA")
• // Etapa 1 Crear un POA las políticas
  apropiadas.
• Policy tpolicy new Policy3
• tpolicy0 rootPOA.create_lifespan_policy(
  LifespanPolicyValue.TRANSIENT )
• tpolicy1 rootPOA.create_request_processi
  ng_policy(
• RequestProcessingPolicyValue.USE_ACTIVE_OB
  JECT_MAP_ONLY )
• tpolicy2 rootPOA.create_servant_retentio
  n_policy(ServantRetentionPolicyValue.RETAIN)
• POA tPOA rootPOA.create_POA("MyTransientPO
  A", null, tpolicy)

26
La clase HelloServer (3)

• // Etapa 2 Activar el POA Manager, de lo
  contrario todas las llamadas al sirviente
  quedarán colgadas, porque por
• defecto, el POA Manager se activa con el
  estado HOLD.
• tPOA.the_POAManager().activate()
• // Etapa 3 Instanciar el Servant y activar
  el Tie. Si la política del POA es
  USE_ACTIVE_OBJECT_MAP_ONLY
• HelloImpl helloImpl new HelloImpl()
• _HelloImpl_Tie tie (_HelloImpl_Tie)Util.ge
  tTie( helloImpl )
• String helloId "hello"
• byte id helloId.getBytes()
• tPOA.activate_object_with_id( id, tie )
• // Etapa 4 Publicar la referencia del
  objeto usando el mismo id de objeto usado para
  activar el objeto Tie.
• Context initialNamingContext new
  InitialContext()
• initialNamingContext.rebind("HelloService",t
  POA.create_reference_with_id(id,
  tie._all_interfaces(tPOA,id)0))
• System.out.println("Hello Server
  Ready...")
• orb.run() // Etapa 5 Preparse para
  aceptar requeriomientos desde cualquier cliente.
• catch (Exception e)
• System.out.println("Problem running
  HelloServer " e)

27
La clase HelloClient (1)

• import java.rmi.RemoteException
• import java.net.MalformedURLException
• import java.rmi.NotBoundException
• import javax.rmi.
• import java.util.Vector
• import javax.naming.NamingException
• import javax.naming.InitialContext
• import javax.naming.Context
• public class HelloClient
• public static void main( String args )
• Context ic
• Object objref
• HelloInterface hi
• try
• ic new InitialContext()
• catch (NamingException e)
• System.out.println("failed to obtain
  context" e)
• e.printStackTrace()

28
La clase HelloClient (2)

• // Etapa 1 Obtener la referencia del objeto
  desde Servicio de Nombres usando llamadas al
  JNDI.
• try
• objref ic.lookup("HelloService")
• System.out.println("Client Obtained a
  ref. to Hello server.")
• catch (NamingException e)
• System.out.println("failed to lookup
  object reference")
• e.printStackTrace()
• return
• // Etapa 2 Usar Narrow a la referencia del
  objetopara obtener el tipo concreto y llamar al
  método.
• try
• hi (HelloInterface) PortableRemoteObject
  .narrow(objref, HelloInterface.class)
• hi.sayHello()
• catch (ClassCastException e)
• System.out.println("narrow failed")
• e.printStackTrace()
• return
• catch( Exception e )
• System.err.println( "Exception " e
  "Caught" )

29
Cómo obtener el IDL si el cliente es CORBA

• rmic idl HelloInterface
• / HelloInterface.idl
• Generated by rmic -idl. Do not edit
• viernes 13 de junio de 2003 14H11' GMT /
• include "orb.idl"
• ifndef __HelloInterface__
• define __HelloInterface__
• interface HelloInterface
• void sayHello( )
• pragma ID HelloInterface "RMIHelloInterface0000
  000000000000"
• endif

30
Como Tarea

• Implementar el Cliente C con CORBA.