Tema 2: Introducción a CORBA

Tema 2: Introducción a CORBA
¿ Qué es CORBA ? (1)
n
n
Permite invocar métodos de objetos remotos sin que
importe el lenguaje en el que estén escritos el
llamador y el llamado, ni las plataformas (s.o. y hw.)
y redes de comunicación intermedias
Incluye un buen número de servicios
n
n
n
n
n
n
n
Nombres
Trading
Seguridad
Transacciones
Persistencia
Notificaciones
Etc.
¿ Qué es CORBA ? (2)
n
Está estandarizado por el OMG (Object Management
Group)
n
n
n
n
n
El mayor consorcio de la industria del software
Sólo emite especificaciones (no existe implementación de
referencia)
Las especificaciones se desarrollan por consenso y son
públicas y gratuitas
Existen muchos fabricantes que implementan las
especificaciones más importantes para las plataformas más
usuales
También estandariza UML (Unified Modeling Language)
¿ Qué es CORBA ? (y 3)
n
Ventajas (con respecto a otras tecnologías similares)
n
Software COTS (Commercial Off The Shelf)
n
n
n
n
n
Estandarizado, múltiples implementaciones (no se depende de
un fabricante)
Las especificaciones se adoptan por consenso
Buena infraestructura para construir aplicaciones distribuidas
Permite integrar aplicaciones heterogéneas
Desventajas
n
n
No es la tecnología más sencilla de utilizar ...
Las especificaciones tardan en desarrollarse, y en
consecuencia las implementaciones tardan en salir al
mercado
La arquitectura de gestión de objetos (OMA)
Interfaces de
aplicación
Interfaces del
dominio
Facilidades
comunes
Object Request Broker (ORB)
Servicios
ORB
n
n
Permite realizar invocaciones de métodos de objetos
remotos en un entorno heterogéneo
El documento estándar se llama CORBA (Common
Object Request Broker Architecture)
n
n
n
En la práctica, el nombre CORBA realmente se aplica para
referirse al conjunto de especificaciones
Las especificaciones de interfaces remotos se hacen
en IDL (Interface Definition Language)
Se han estandarizado los mappings de IDL a los
lenguajes más comunes (C, C++, Java, COBOL,
Smalltalk, Ada, etc.)
Servicios
n
Interfaces de servicios útiles para aplicaciones de
cualquier dominio
n
n
n
n
n
n
n
n
Nombres
Trading
Seguridad
Transacciones
Persistencia
Eventos
Notificaciones
Etc.
Facilidades comunes
n
Interfaces de servicios útiles para muchas
aplicaciones, pero no tan fundamentales como los
“servicios CORBA”
n
n
Internacionalización y Tiempo
Agentes móbiles
Interfaces del dominio
n
Interfaces útiles para dominios específicos
n
n
n
n
n
n
Negocios
Finanzas
Manufacturación
Salud
Telecomunicaciones
Transporte
Interfaces de aplicación
n
n
Interfaces desarrollados específicamente para una
aplicación
Lógicamente, no están estandarizados por el OMG,
pero si se repiten en muchas aplicaciones diferentes,
se convertirán en candidatos para estandarización
(servicios, facilidades comunes o interfaces del
dominio)
Componentes de un ORB
Aplicación cliente
DII
Stubs
IDL
estáticos
Aplicación servidora
Interfaz
ORB
Skeletons
IDL
estáticos
DSI
Adaptador
de Objetos
Núcleo ORB
Interfaz igual para
todos los ORBs
Un stub y un skeleton
específico para cada objeto
Puede haber múltiples
adaptadores de objetos
Interfaz privado del ORB
Clock.idl
/*
* Clock example.
*/
module es { module udc { module fbellas {
module corba { module clock { module idl {
struct TimeOfDay {
short hour; // 0-23
short minute; // 0-59
short second; // 0-59
};
interface Clock {
TimeOfDay getTimeOfDay();
};
}; }; }; }; }; };
El compilador de IDL
Clock.idl
Compilador
IDL-a-Java
Compilador
IDL-a-C++
Ficheros
.java
Ficheros
.cpp
Stubs y skeletons
n
Stubs IDL estáticos o SII (Static Invocation Interface)
n
n
n
n
n
Las operaciones locales que usan los clientes como sustitutas de las
remotas
Generadas por el compilador de IDL
Envían y reciben mensajes (haciendo “marshalling” /
“unmarshalling”).
En lenguajes OO se genera una clase “proxy” por cada interfaz
remoto (patrón de diseño “Proxy”)
Skeletons IDL estáticos o SSI (Static Skeleton Interface)
n
n
n
n
Las operaciones en el servidor que invocan las correspondientes
implementaciones proporcionadas por el programador
Generadas por el compilador de IDL
Reciben y envían mensajes (haciendo “unmarshalling” /
“marshalling”)
En lenguajes OO se genera una clase “skeleton” por cada interfaz
remoto
Algunos conceptos
n
Objeto CORBA
n
n
Referencia a un objeto CORBA
n
n
n
Entidad virtual sobre la que se pueden realizar invocaciones
remotas
Estructura de datos (puntero) que identifica a un objeto
CORBA
Son opacas
Servant
n
Entidad del lenguaje de programación que implementa uno
o más objetos CORBA. En lenguajes OO, un servant es una
instancia de una clase que implementa las operaciones del
interfaz remoto
Adaptador de objetos
n
n
n
En el servidor: recibe una petición y la dirige al
servant correspondiente
Corresponde al patrón de diseño “Adapter”
Hasta CORBA 2.1 (inclusive), la especificación CORBA
estandarizaba el BOA (Basic Object Adapter)
n
n
n
Especificación ambigua y poco potente
Los fabricantes añadieron sus propias extensiones =>
problemas de portabilidad importantes
A partir de CORBA 2.2 (inclusive), la especifiación
CORBA estandarizó el POA (Portable Object Adapter)
n
n
Potente, pero complejo ...
El BOA ya no forma parte de CORBA
Interfaz del ORB, DII y DSI
n
Interfaz del ORB
n
n
Dynamic Invocation Interface (DII)
n
n
Proporciona operaciones para inicializarlo, convertir
referencias a objetos remotos a cadenas de caracteres y
viceversa, etc.
Permite realizar invocaciones de métodos de objetos
remotos sin utilizar los stubs correspondientes
Dynamic Skeleton Interface (DSI)
n
Permite recibir invocaciones de métodos de objetos remotos
sin disponer de los skeletons correspondientes
Repositorios de interfaces e implementaciones
n
Repositorio de interfaces
n
n
n
Repositorio que contiene descripciones de las definiciones de
tipos en IDL
El programador dispone de un API para consultar el
repositorio
Repositorio de implementaciones
n
Mantiene un registro de servidores de manera que puede
proporcionar características como: arranque automático de
servidores, balanceo de carga, etc.
Interoperabilidad
n
Interoperabilidad entre distintos ORBs de distintos fabricantes
n
GIOP (General Inter-ORB Protocol)
n
n
IIOP (Internet Inter-ORB Protocol)
n
n
Formato estándar de una referencia a un objeto remoto (es opaco para
el programador)
ESIOPs (Environment-Specific Inter-ORB Protocols)
n
n
n
GIOP sobre TCP/IP
IOR (Interoperable Object Reference)
n
n
Protocolo abstracto que especifica el formato de transferencia de tipos
IDL y un conjunto de formatos de mensajes para permitir que ORBs de
distintos fabricantes pueden interoperar sobre un protocolo de
transporte orientado a la conexión
No siguen GIOP (porque hay una infraestructura subyacente que
quieren aprovechar)
DCE CIOP (DCE Common Inter-ORB Protocol)
También está estandarizada la interoperabilidad COM/DCOM
Un sencillo ejemplo con CORBA/Java
Definición de un interfaz remoto
/*
* Clock example.
*/
module es { module udc { module fbellas {
module corba { module clock { module idl {
struct TimeOfDay {
short hour; // 0-23
short minute; // 0-59
short second; // 0-59
};
interface Clock {
TimeOfDay getTimeOfDay();
};
}; }; }; }; }; };
Compilación del interfaz IDL
Clock.idl
Compilador
IDL-a-Java
Ficheros
.java
-
Clock.java
ClockHelper.java
TimeOfDay.java
La clase proxy que
implementa Clock
- ClockPOA.java
- etc.
Servidor – Implementación del objeto remoto
package es.udc.fbellas.corba.clock.server;
import java.util.Calendar;
import es.udc.fbellas.corba.clock.idl.TimeOfDay;
import es.udc.fbellas.corba.clock.idl.ClockPOA;
class ClockImpl extends ClockPOA {
public TimeOfDay getTimeOfDay() {
short hour =
(short) Calendar.getInstance().get(Calendar.HOUR);
short minute =
(short) Calendar.getInstance().get(Calendar.MINUTE);
short second =
(short) Calendar.getInstance().get(Calendar.SECOND);
return new TimeOfDay(hour, minute, second);
}
}
Servidor – main (1)
package es.udc.fbellas.corba.clock.server;
import
import
import
import
import
import
org.omg.CORBA.ORB;
org.omg.PortableServer.POA;
org.omg.PortableServer.POAHelper;
org.omg.PortableServer.POAManager;
java.io.PrintWriter;
java.io.FileOutputStream;
import es.udc.fbellas.corba.clock.idl.Clock;
class Server {
public static void main(String args[]) {
ORB orb = null;
Servidor – main (2)
try {
/* Initialize ORB. */
orb = ORB.init(args, null);
/* Get a reference to the Root POA. */
org.omg.CORBA.Object rootPOAObject =
orb.resolve_initial_references("RootPOA");
POA rootPOA = POAHelper.narrow(rootPOAObject);
/* Activate the Root POA's manager. */
POAManager rootPOAManager = rootPOA.the_POAManager();
rootPOAManager.activate();
/*
* Create servant, register it on the Root POA and
* obtain a reference to it.
*/
ClockImpl clockImpl = new ClockImpl();
Clock clock = clockImpl._this(orb);
Servidor – main (3)
/* Write the reference in file "Clock.ref". */
String stringifiedReference =
orb.object_to_string(clock);
FileOutputStream fileOutputStream = null;
PrintWriter printWriter = null;
try {
fileOutputStream =
new FileOutputStream("Clock.ref");
printWriter = new PrintWriter(fileOutputStream);
printWriter.println(stringifiedReference);
} finally {
if (printWriter != null) {
printWriter.close();
}
if (fileOutputStream != null) {
fileOutputStream.close();
}
}
Servidor – main (y 4)
/* Allow the ORB to start processing requests. */
System.out.println("Server running");
orb.run();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (orb != null) {
orb.destroy();
}
} catch (org.omg.CORBA.SystemException e) {
e.printStackTrace();
}
}
} // main
} // class
Cliente (1)
package es.udc.fbellas.corba.clock.client;
import org.omg.CORBA.ORB;
import java.io.BufferedReader;
import java.io.FileReader;
import es.udc.fbellas.corba.clock.idl.Clock;
import es.udc.fbellas.corba.clock.idl.ClockHelper;
import es.udc.fbellas.corba.clock.idl.TimeOfDay;
class Client {
public static void main(String args[]) {
ORB orb = null;
try {
/* Initialize ORB. */
orb = ORB.init(args, null);
Cliente (2)
/* Read stringified reference from "Clock.ref". */
FileReader fileReader = null;
BufferedReader bufferedReader = null;
String stringifiedReference;
try {
fileReader = new FileReader("Clock.ref");
bufferedReader = new BufferedReader(fileReader);
stringifiedReference = bufferedReader.readLine();
} finally {
if (bufferedReader != null) {
bufferedReader.close();
}
if (fileReader != null) {
fileReader.close();
}
}
Cliente (3)
/*
* Convert stringified reference into a Clock object
* reference.
*/
org.omg.CORBA.Object clockObject =
orb.string_to_object(stringifiedReference);
if (clockObject == null) {
throw new Exception("stringified reference is nil");
}
Clock clock = ClockHelper.narrow(clockObject);
/* Obtain the time of day and print it. */
TimeOfDay timeOfDay = clock.getTimeOfDay();
System.out.println("Hour: " + timeOfDay.hour);
System.out.println("Minute: " + timeOfDay.minute);
System.out.println("Second: " + timeOfDay.second);
Cliente (y 4)
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (orb != null) {
orb.destroy();
}
} catch (org.omg.CORBA.SystemException e) {
e.printStackTrace();
}
}
} // main
} // class
Flujo de una invocación remota
n
Cliente
n
n
TimeOfDay timeOfDay = clock.getTimeOfDay();
Flujo de la invocación
n
n
n
n
El cliente invoca la operación sobre un proxy
La operación getTimeOfDay del proxy envía un mensaje
por la red utilizando el ORB
El ORB del servidor recibe el mensaje y se lo entrega al
gestor del POA (rootPOAManager) y éste al POA
(rootPOA)
El adaptador de objetos envía la invocación al servant
(clockImpl)
n
n
Se llama a una operación de ClockPOA, que realiza el
unmarshalling e invoca a la operación abstracta
getTimeOfDay, definida en ClockImpl.
Cuando el servant termina de ejecutar la operación, la
respuesta se envía al cliente
Ejecución del ejemplo Clock
* cd $CORBA_JAVA_EXAMPLES_HOME/Subsystems/Clock/Scripts
* Ejecutar ClockServer.sh
* Ejecutar ClockClient.sh
Implementaciones
n
Existe un buen número de implementaciones,
comerciales y gratuitas, del ORB de CORBA (para
distintos lenguajes y plataformas) y de los servicios
más comunes
n
n
n
n
n
http://www.cs.wustl.edu/~schmidt/corba-products.html
Iona (http://www.iona.com). Orbix
Inprise (http://www.inprise.com). Visibroker
Object Oriented Concepts (http://www.ooc.com). ORBacus
http://www.cs.wustl.edu/~schmidt/TAO.html. TAO