TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para...

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

Transcript of TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para...

Page 1: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

����������

��� ����������������������������������������������������������� �����!��"�������# !�$��������%�!��%������&������ ���� '(

'�')��* (+,(�

-���./0�����%1�'���������������� �������2�%%1�/../� -�� 3��%�450-(�.40�(�%�1�6������� ����������� ������������� ������� 2�%%1�/../��

-�� 3��%�/.0-2�%..0�2�%���������%�������������� ������� �����������7��-8�9:0�8����1����������� ��� ����� !�����"�����������������

!���;��1��%��<51�=�/1�+������>1�499:�

TEMA 4: PROGRAMACIÓN DISTRIBUIDA

?�(�������������������������������������������������������������>������������

Page 2: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

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

������������� ������������������������������� ������������������

?�(�������������������������������������������������������������>������������

Page 3: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

� 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

Modelos de Programación DistribuidaModelos de Programación Distribuida

?�(�������������������������������������������������������������>������������

Page 4: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

� 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 de Paso de MensajesModelo de Paso de Mensajes

?�(�������������������������������������������������������������>������������

Page 5: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

NUCLEO NUCLEO

CLIENTE SERVIDOR

SOLICITUD

RESPUESTA

RED

Modelo General

?�(�������������������������������������������������������������>������������

Page 6: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��������������������

� �%� ���%�����#>������@�A��$����%�;��%�� ������ ����"�����%%�����%��������������������� �����������B�������&������������CB���

SERVIDOR

PUERTO

CLIENTE

TCP/UDP

?�(�������������������������������������������������������������>������������

Page 7: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

PROTOCOLO TCP/UDP

Port xxx Port yyy Port zzz Port kkk

App A App B App C

0010111001100010101 Port yyy

Page 8: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

SERVIDOR

PUERTO

CLIENTE

Solicitud de conexión

SERVIDOR

PUERTO

CLIENTE

PUERTO

PUERTO

?�(�������������������������������������������������������������>������������

Page 9: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

������� ������

� ������� ��������D�������� ������ A����;������%����1� ��������%���������������7�����������������%�������������

� �%����������%�;������ ������� ��������%����%��%����%���������7������%��� %����������������������%������

?�(�������������������������������������������������������������>������������

Socket()Accept()

Socket creado y activo

Page 10: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

�������ServerSocket

� �����"���%���������������������������� �����%������&������%���%����Socket�

� ���������"������%�ServerSocket L = newServerSocket (num_puerto)

� '%B����� ������%������L.accept();

� )%��������������������%������ �����������%B���� �%�����������������C%�����������

?�(�������������������������������������������������������������>������������

Page 11: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

�������Socket

� �� %��������������������%�%�����%��%����

� ������������������������%��������� ���������"������%�Socket (dirección_IP, puerto);

?�(�������������������������������������������������������������>������������

Page 12: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

4� ���������&���ServerSocket/� ���������&���Socket<� ��������InputStream ����%�����������%��%����

E� ��������OutputStream �����������7��������%��%����

5� 2������F����������������G� ��������%������

���������������������

?�(�������������������������������������������������������������>������������

Page 13: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

Page 14: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

4� ���������&���Socket/� ��������InputStream ����%�����������%��%����

<� ��������OutputStream �����������7��������%��%����

E� 2������F����������������5� ��������%������

���������������������

?�(�������������������������������������������������������������>������������

Page 15: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

� ��������!���������������

Page 16: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

���������������"�������������socket

� A����;��������%����D��1���������>��%�������� ��������&���socket�

� !@�������%���%����socket� getInputStream() ������������� getOutputStream() ����������

� ��%���%�������������� !��&��%�����7%�&������F�� (�3�����&�����%���%����SocketChannel

?�(�������������������������������������������������������������>������������

Page 17: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

������������ #$���� "�� ������#��%&�����������'()***+

� �����������%����%����"�%���������� �%� ���� ��������������3������

� 8�����%����� ����������read-only

� 8�����%������7����%�����%��%�����%�� ������� ��"�>������������������

� ��������������� ����������%���������������� ��&������������ ���������3�F��������7��������������%%��� !�>�� �����%�����B���"�%��#������8!$�

¡SE ELIMINA LA MEMORIA COMÚN!

?�(�������������������������������������������������������������>������������

Page 18: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

� 2�%����@���wait(), notify(), notifyAll()� A�����

� �����>����%��"�%��� ��7������������3��������������(synchronized).� �����%����%�������;�������7�����D %3�����

� ���%���� ���� ����%�rendezvous� �������������%�������;������ ������������%��������������� ������������%���3��������&���� ��������>����%�� ������

Emisor Listo Receptor ListoCanal

?�(�������������������������������������������������������������>������������

Page 19: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

���������������,����

send (B, mensaje)

receive (A, mensaje)

rendezvous

tiempo

Proceso A

Proceso B

?�(�������������������������������������������������������������>������������

Page 20: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

� ����������&���������������� ������������������%��� ����7�;������ ��������

� !@���run()

� �&���������%������������� �&���������%��������%���

public void run()

{ //codigo ejec.

}

Canal de Salida

Canal de Entrada

Page 21: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

�����������������#�-�����"�,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 procesopublic mi_proceso(channels y parametros){//codigo del constructor

}public void run() //sobreescritura de run{//código del proceso}}

?�(�������������������������������������������������������������>������������

Page 22: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

�������"�,��������#�

� ����7�;����@����read >�write

� ��� ��%��� ������������ ������&���� ����������������������@������%%��� �%���������������������� �����������#����H7��$��3���# ��

����;��;$� ���� � ������%������H7��� ����������������3�����

?�(�������������������������������������������������������������>������������

Page 23: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

}

}?�(�������������������������������������������������������������>������������

Page 24: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

}

}?�(�������������������������������������������������������������>������������

Page 25: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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?�(�������������������������������������������������������������>������������

Page 26: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

#���������������#�

� '%��(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

?�(�������������������������������������������������������������>������������

Page 27: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

�����������������������#�

� Sequential (Process[] procesos)

� Parallel (Process[] procesos)

� PriParallel (Process[] procesos)

� Con guardas:� Alternative

� PriAlternative

?�(�������������������������������������������������������������>������������

Page 28: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

./���������01

� csp.io.linkdrivers.TCPIP (ó UDP)

� �����������%���������public TCPIP(remotehost, remoteport, TCPIP.tipo)

� ���� �� REALTIME �������������������#���� ASYNCHRONOUS �������������

� ��%�����%��%�����������%���%��� ��������

?�(�������������������������������������������������������������>������������

Page 29: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

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

Page 30: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

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������

http://www.ce.utwente.nl/javapp/

Page 31: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

� 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

2����3�����2����3��������������������� ���������3����3���

?�(�������������������������������������������������������������>������������

Page 32: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

2��%��%

�� ������%�������

���������%����

�� ������%�������

���������������

func() func(void){//codigo………….}

2������

����������������������������

�'����8���4��7�������%��%%�����������������������C�����%��%/������������� �������%������������������<�KL�����%����%MN

Page 33: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

������������������������

� �7���H���%����������� $������������ ��� ��C������

� '%B�����%��%�������%���� ������%�����%����

� ���� �����������&������������� ����7������%����%��������

� ���� A��

?�(�������������������������������������������������������������>������������

Page 34: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

������������ ��

���������%����

������%��%����

�������%����

callrpcrpcreturn

������������ ��

������%��������

+�������������

�������������

llamadanormal

return

RED

��B����� ��������%�

�H�%���%���� �H�%���������

Page 35: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

./���� ��������������1

� ���7���������%� ���7��������C����

��� ���7�������7���%��������7�;��7�O������ ��37��� rpcgen #�P��D$Frmic #����$

?�(�������������������������������������������������������������>������������

Page 36: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

Especificación FormalInterface

Precompiladorrpcgen o rmic

ResguardoStub

ResguardoSkeleton

Ficheros compartidos

Representaciónde datosCliente Servidor

COMPILAR

COMPILAR

ClienteEjecutable

ServidorEjecutable

4��������������5����������

?�(�������������������������������������������������������������>������������

Page 37: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

Especificación FormalInterface

Generadorde

Resguardos

Res. Del Servidor Res. Del Cliente

SERVIDOR CLIENTECONECTOR

Interfaz delservidor+asacreate, readdelete, write

Petición de asa del servidor Envío de asa

Read(f,d)

d

�������������� ����� �����

?�(�������������������������������������������������������������>������������

Page 38: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

�����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;

}=0x3111111;

� *�������������C������������������$rpcgen rand.x

� �����������>��� �%���7��"���������%����CB������� %������� ������������%�;����� ����������Q� ��'��%������xdr.h

?�(�������������������������������������������������������������>������������

Page 39: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

32��3�����32��3�����2��$�2��$� ����������������������������������

ObjetoCliente

JVM

ObjetoServidor

JVM

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

?�(�������������������������������������������������������������>������������

Page 40: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

3��������32�

El código es móvil, mediante el uso de bytecodes.

NO hay movilidad de código

El uso de referencias a objetos locales y remotos es automático

El uso de punteros requiere el manejo explícito de los mismos

Utiliza la serialización de objetos en Java

Utiliza la representación externa de datos XDR

Es dependiente del lenguajeEs dependiente del lenguaje

Carácter y Estructura de diseño orientada a objetos

Carácter y Estructura de diseño procedimental

RMIRPC

?�(�������������������������������������������������������������>������������

Page 41: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

����������������'��������������

� 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);

Page 42: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

7�!���������32�

Cliente Servidor

Stub Skeleton

ReferenciaRemota

ReferenciaRemota

TransporteTransporte

� 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ónRemoteException

� El método main del servidor debe lanzarun 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.

?�(�������������������������������������������������������������>������������

Page 43: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

?�(�������������������������������������������������������������>������������

Page 44: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

K����%����%Npublic interfazextends Remote

{signaturas métodos}

Implementaciónde la interfaz

Cliente

SERVIDOR

implements

new

��"��������

3�"�������6�����

bind ó rebindlookup

referencia a interfaz

ref.metodo(param)

resultado

?�(�������������������������������������������������������������>������������

Page 45: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

Definir Interfaz Remotaimplements

Implementar InterfazRemota

$ rmic .class

SkeletonStub

JVM

Implementar Cliente

JVM

Implementar Servidor

Page 46: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

?�(�������������������������������������������������������������>������������

Page 47: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

���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 rmiimport java.rmi.*;

//toda interface remota debe extender la clase Remotepublic interface IEjemploRMI1 extends Remote{//todo metodo de la interfaz remota debe lanzrar la //excepcion RemoteExceptionint 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;

}?�(�������������������������������������������������������������>������������

Page 48: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

87���������9:32��)<�2���2�6#7��>6�

?�(�������������������������������������������������������������>������������

Page 49: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

���2��:��2���2�6#7��>6���6#�387=/��3?��:3�

/**Ejemplo de implementacion del interfaz remoto para un RMI* @author Antonio Tomeu*/

//se importan los paquetes necesariosimport 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 EjemploRMI1extends UnicastRemoteObjectimplements IEjemploRMI1

{

Page 50: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

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

Page 51: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

//es necesario que haya un constructor (nulo) como minimo, ya //que debe lanzar RemoteExceptionpublic 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");}}

Page 52: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

87���������9:32��@< 4��������#A�/�B���#:6�

Compilador de RMI$ rmic imp

Fichero de implementación

de Interfaz compilado

(Imp.class)

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énlos 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 &

?�(�������������������������������������������������������������>������������

Page 53: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

?�(�������������������������������������������������������������>������������

Page 54: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

87���������9:32��D<����6#��

?�(�������������������������������������������������������������>������������

Page 55: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

/**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));}}

���2��:�����6#��

Page 56: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

�������"�,Serializable

� �����%�;�����&�������������%�������������������1� �������������������������%��&��������%� ���H��%� �����������&������ %�&���� !�� �� �� �����������������%�;���������������� �%�������������������@� ��&������ %�&��������� %�������%������7�;��Serializable #�����7%��$� ���� �������������%�;���

?�(�������������������������������������������������������������>������������

Page 57: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

� ���������������,����� ���������

import java.io.*;import java.util.*;

public class cuentabancaimplements Serializable{ int ccc; float saldo; String Titular;

public cuentabanca(int codigo, float deposito, Stringnombre)

{ccc = codigo; saldo = deposito; Titular = nombre;}

public String toString(){return("codigo = "+ccc+" saldo= "+saldo+" titular=

"+Titular);}}

Page 58: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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) throwsRemoteException;

String nomtit(int codigo) throws RemoteException;

int codtit(String nom) throws RemoteException;/aquí la serializacion es necesaria*/cuentabanca [] listado() throws RemoteException;

}

�����"�,

Page 59: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

4������������� ����-policytool

� ������������������%�����������System.setSecurityManager(new RMISecurityManager());

� ����&�����%������������� �����>������&���SecurityManager� )%������%��@���setSecurityManager (clase System)

� �%����RMISecurityManager� �����������&�����%��������������������%���%����Policy� Policy.getPolicy() ������������%�����������������%�� Policy.setPolicy() �������7�&�������� %3�����

� �������������������7��"����� ��37���

� ����/���� ������"���������������%��policytool

?�(�������������������������������������������������������������>������������

Page 60: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

� (&��������%�� %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 ������%��&���������

Page 61: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

� 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

2������:� ���������������2������:� ���������������

?�(�������������������������������������������������������������>������������

Page 62: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

�:3�7��:3�7������������� :� ���:� ��� 3�!����3�!���� ������������7��$��������7��$����������

?�(�������������������������������������������������������������>������������

Page 63: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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)?�(�������������������������������������������������������������>������������

Page 64: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

� 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

?�(�������������������������������������������������������������>������������

Page 65: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

OBJECT REQUEST BROKER

APPLICATIONINTERFACES

COMMONFACILITIES

DOMAININTERFACES

SERVICIOS A OBJETOS

NamingPersistenceTransactionsConcurrency

SecurityTimePropertiesExternalization

BussinesHealthcareFinanceTelecom

CompoundObject LinkingHelpMOF

No estandarizados

Por OMG

Modelo de Referencia OMA

Page 66: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

ORB

Cliente Implementación del objeto

?�(�������������������������������������������������������������>������������

Page 67: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

Estructura del ORB

Page 68: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

ORB Core

IDLStub

Cliente

Interface dependiente del ORB

Stub para cada tipo de objeto

ObjectAdapter

IDLSkeleton

Servidor

rebObjeto.metodo(param)

marshallingunmarshalling

metodo(param)

Invocación Estática

Page 69: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

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/

?�(�������������������������������������������������������������>������������

Page 70: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

� 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

JavaIDL

?�(�������������������������������������������������������������>������������

Page 71: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

Herramientas JavaIDL

?�(�������������������������������������������������������������>������������

Page 72: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

� org.omg.CORBA

� org.omg.CosNaming

� org.omg.PortableServer

� org.omg.CORBA.ORB

� org.omg.PortableInterceptor

� org.omg.DynamicAny

API JavaIDL Básica

?�(�������������������������������������������������������������>������������

Page 73: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

InterfazIDL

Compilador de IDL($idltojava)

($idlj) en J2SE

StubsCliente

AplicaciónCliente

SkeletonsServidor

Implemen.Servidor

AplicaciónServidor

Compilando IDL

-fclient

-fserver

-fall

POAServidor

-fserver

A partir de J2SE v1.4

Page 74: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

Portable Object Adapter (POA)

?�(�������������������������������������������������������������>������������

Page 75: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

ORB

POA Manager

POA

Servants

Page 76: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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

Page 77: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

Jeraquía de Nombres

x

Servidor

bind(x, ref)x

Clienteresolve(A)

ref

NamingContext ncRef = NamingContextHelper.narrow(refObj);NameComponent nc = newNameComponent("Impresor Remoto", "");NameComponent [] ruta = { nc };ncRef.rebind(ruta, IRem);

NamingContext ncRef = NamingContextHelper.narrow(refObj);NameComponent nc = newNameComponent("Impresor Remoto", "");NameComponent [] ruta ={nc};HolaMundoDistribuido ObjImpresor = HolaMundoDistribuidoHelper.narrow(ncRef.resolve(ruta));

Page 78: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

Interacción Cliente/Servidor-Servicio de Nombres

� '�����

Page 79: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

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 porcompatiblidad hacia atrás.

Page 80: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

Hola Mundo Distribuido Con CORBAServidor

/**Ejemplo de fichero que implanta un servidor via CORBA* @author Antonio Tomeu*/

//CosNaming contiene aspectos relacionados con el servicio de nombre de JavaIDLimport 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 idljclass 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

Page 81: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

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 javaImpresorRemoto 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 servidorNameComponent nc = new NameComponent("Impresor Remoto", "");NameComponent [] ruta = { nc };//Se vincula la referencia pasada a String con la referencia a objetoncRef.rebind(ruta, IRem);//Se esperan peticiones de clientes.java.lang.Object sinc = new java.lang.Object();synchronized (sinc){sinc.wait();}}

}

Page 82: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

Hola Mundo Distribuido Con CORBACliente/**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");}

}

Page 83: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

Hola Mundo Distribuido Con CORBAEjecutando el Servicio de Nombres

?�(�������������������������������������������������������������>������������

Page 84: TEMA 4: PROGRAMACIÓN DISTRIBUIDA - Indicetic217.uca.es/ficheros/cap_4.pdf · Mecanismo para comunicar y sincronizar entidades concurrentes que no pueden o no quieren compartir memoria

��

Hola Mundo Distribuido Con CORBA2

Especificación IDL

2Utilizando el servicio de nombres persistente orbd. Es el estándar de Java IDL a partirde J2SE y versiones del jdk 1.4 o superiores.