Comunicación de procesos en sistemas distribuidos

Transcripción

1 Objetivo del tema Comunicación de procesos en sistemas distribuidos Presentar los diferentes esquemas para comunicar procesos en sistemas distribuidos: Servicios básicos de comunicación (colas de mensajes POSIX, mailslots de Win32, sockets) Llamadas a procedimientos remotos Entornos orientados a objetos (CORBA, DCOM, RMI). Presentar el concepto de cliente-servidor Comunicación de grupos. Comunicación de procesos en aplicaciones paralelas (MPI) Sistemas Distribuidos 1 Félix García Carballeira (1999) Contenido Mecanismos de comunicación entre procesos Mecanismos básicos de comunicación entre procesos Modelo cliente/servidor y comunicación en grupos Colas de mensajes POSIX y Mailslots de Win32 Sockets en Unix y Java Llamadas a procedimientos remotos (RPC) Entornos orientados a objetos. CORBA, RMI Comunicación en aplicaciones paralelas. MPI Ficheros Tuberías Sin nombre: pipes Con nombre: FIFOs Memoria Compartida Espacio del sistema operativo Espacio compartido entre los procesos (threads) Paso de mensajes Sistemas Distribuidos 2 Félix García Carballeira (1999) Sistemas Distribuidos 3 Félix García Carballeira (1999) Comunicación en sistemas distribuidos La comunicación de procesos es fundamental en cualquier sistema distribuido Existen diferentes posibilidades todas ellas basadas en el paso de mensajes Mecanismos de bajo nivel, el programador debe preocuparse de establecer los protocolos de comunicación, representación de datos, etc. Colas de mensajes Sockets Mecanismo de alto nivel, ofrecen abstracciones donde el programador no debe preocuparse de establecer protocolos Llamadas a procedimientos remotos Invocación de métodos remotos (entornos orientados a objetos) Paso de mensajes: conceptos básicos Primitivas básicas send(destino, mensaje) receive(origen, mensaje) Tamaño del mensaje Longitud fija o variable Flujo de datos Bidireccional, unidireccional Nombrado Comunicación directa send(p, m): envía un mensaje m al proceso P receive(q, m): recibe un mensaje del proceso Q receive (ANY, m): recibe un mensaje de cualquiera Sistemas Distribuidos 4 Félix García Carballeira (1999) Sistemas Distribuidos 5 Félix García Carballeira (1999)

2 Conceptos básicos Nombrado Comunicación indirecta: los datos se envían a estructuras intermedias Puertos: se asocian a un proceso (un único receptor) Ejemplo: sockets Colas de mensajes: múltiples emisores y receptores Ejemplo: Colas de mensajes POSIX Tipos de comunicación Síncrona o asíncrona Capacidad de almacenamiento (buffering) Fiabilidad Fiables o no fiables Representación de datos, aplanamiento Sistemas Distribuidos 6 Félix García Carballeira (1999) Patrones típicos de comunicación Comunicación cliente-servidor Transmisión de datos y código Comunicación de grupos Útil en servicios replicados Sistemas Distribuidos 7 Félix García Carballeira (1999) Comunicación cliente-sevidor Muy utilizada en entornos distribuidos (más del 90% de los sistemas distribuidos utilizan la arquitectura cliente-servidor) Máquina A cliente NÚCLEO petcición respuesta Máquina B servidor NÚCLEO Comunicación de grupos Utiliza mensajes multicast Útil para: Ofrecer tolerancia a fallos basado en servicios replicados Localizar objetos en sistemas distribuidos Mejor rendimiento mediante datos replicados Actualizaciones múltiples Operaciones colectivas en cálculo paralelo RED Protocolo típico: petición-respuesta Sistemas Distribuidos 8 Félix García Carballeira (1999) Sistemas Distribuidos 9 Félix García Carballeira (1999) Tuberías en POSIX (pipes, FIFOS) Tuberías en POSIX Mecanismo de comunicación y sincronización Servicios POSIX Creación de pipes int pipe(int fildes[2]); Creación de FIFOS int mkfifo(char *name, mode_t mode); int open(char *name, int flag); Lectura de una tubería read(int fd, char *buf, int size); Escritura de una tubería write(int fd, char *buf, int size); Semántica de las lecturas (read(fd[0], buf, n)) Si la tubería está vacía se bloquea al lector Si la tubería tiene p bytes: Si p n devuelve n Si p < n devuelve p Si la tubería está vacía y no hay escritores devuelve 0 Semántica de las escrituras (write(fd[1], buf, n)) Si la tubería está llena se bloquea el escritor Si no hay lectores se recibe la señal SIGPIPE Lecturas y escrituras son atómicas (cuidado con tamaños grandes) Sistemas Distribuidos 10 Félix García Carballeira (1999) Sistemas Distribuidos 11 Félix García Carballeira (1999)

3 Colas de mensajes POSIX Mecanismo de comunicación y sincronización Nombrado indirecto Asignan a las colas nombres de ficheros Sólo pueden utilizar colas de mensajes procesos que comparten un mismo sistema de ficheros Tamaño del mensaje variable Flujo de datos: bidireccional Sincronización: Envío asíncrono Recepción síncrona o asíncrona Los mensajes se pueden etiquetar con prioridades Colas de mensajes POSIX: servicios mqd_t mq_open(char *name, int flag, mode_t mode, struct mq_attr *attr) Crea una cola de mensajes con nombre y atributos Número máximo de mensajes Tamaño del mensaje Recepción bloqueante o no bloqueante int mq_close(mqd_t mqdes) Cierra una cola int mq_unlink(char *name) Borra una cola de mensajes Sistemas Distribuidos 12 Félix García Carballeira (1999) Sistemas Distribuidos 13 Félix García Carballeira (1999) Colas de mensajes POSIX: servicios Ejemplo int mq_send(mqd_t mqdes, char *msg, size_t len, int prio) Envía un mensaje a una cola con prioridad prio Si la cola está llena el servicio bloquea al proceso int mq_receive(mqd_t mqdes, char *msg, size_t len, int prio) Recibe un mensaje de una cola La recepción puede ser bloqueante o no dependiendo de los atributos asociados a las colas. Máquina A cliente NÚCLEO sumar(5,2) Restulado = 7 Máquina B servidor 5+2 NÚCLEO RED Sistemas Distribuidos 14 Félix García Carballeira (1999) Sistemas Distribuidos 15 Félix García Carballeira (1999) #define MAXSIZE 256 Definición de tipos struct peticion int a; /* operando 1 */ int b; /* operando 2 */ char q_name[maxsize]; /* nombre de la cola cliente donde debe enviar la respuesta el servidor */ ; Sistemas Distribuidos 16 Félix García Carballeira (1999) Proceso servidor #include <mqueue.h> void main(void) mqd_t q_servidor; /* cola de mensajes del servidor */ mqd_t q_cliente; /* cola de mensajes del cliente */ struct peticion pet; int res; struct mq_attr attr; attr.mq_maxmsg = 20; attr.mq_msgsize = sizeof(struct peticion); q_servidor = mq_open( SERVIDOR_SUMA, O_CREAT O_READ, 0700, &attr); while(1) mq_receive(q_servidor, &pet, sizeof(pet), 0); res = pet.a + pet.b; /* se responde al cliente abriendo previamente su cola */ q_cliente = mq_open(pet.q_name, O_WRONLY); mq_send(q_cliente, &res, sizeof(int), 0); mq_close(q_cliente); Sistemas Distribuidos 17 Félix García Carballeira (1999)

4 Proceso cliente #include <mqueue.h> void main(void) mqd_t q_servidor; /* cola de mensajes del proceso servidor */ mqd_t q_cliente; /* cola de mensajes para el proceso cliente */ struct peticion pet; int res; struct mq_attr attr; attr.mq_maxmsg = 1; attr.mq_msgsize = sizeof(int); q_cliente = mq_open( CLIENTE_UNO, O_CREAT O_RDONLY, 0700, &attr); q_servidor = mq_open( SERVIDOR_SUMA, O_WRONLY); /* se rellena la petición */ pet.a = 5; pet.b = 2; strcpy(pet.q_name, CLIENTE_UNO ); mq_send(q_servidor, &pet, sizeof(struct petiticion), 0); mq_receive(q_cliente, &res, sizeof(int), 0); mq_close(q_servidor); mq_close(q_cliente); mq_unlink( CLIENTE_UNO ); Sistemas Distribuidos 18 Félix García Carballeira (1999) Mailslots de Win32 Similares a las colas de mensajes de POSIX Tamaño máximo de los mensajes es de 64 KB Pueden utilizarse entre procesos que ejecuten en máquinas de un mismo dominio. El nombre de un mailslots sigue el formato: \\.\mailslot\nombre Para abrir un mailslot debe utilizarse: \\.\mailslot\nombre para un mailslot local \\.\maquina\mailslot\nombre para una máquina remota \\.\dominio\mailslot\nombre para un mailslot creado en un dominio Sistemas Distribuidos 19 Félix García Carballeira (1999) Mailslots: servicios Mailslots: servicios HANDLE Creat slot(LPCTSTR name, DWORD MaxMessSize, DWORD lreadtimeout, LPSECURITY_ATTRIBUTES lpsa): Tamaño máximo del mensaje de mensajes Tiempo de bloqueo de una operación de lectura (INFINITE) Atributos de seguridad HANDLE CreateFile(LPCSTR name, DWORD Access, DWORD ShareMode, LPVOID lpsecurityattributes, DWORD CreationDisposition, DWORD FlagsAndAttributes, Handle TemplateFile); Abre un mailslot existente. Sistemas Distribuidos 20 Félix García Carballeira (1999) BOOL ReadFile(HANDLE hm, LPVOID lpbuffer DWORD nbytes, LPDWORD lpnbytes, LPOVERLAPPED lpoverlapped); Lee datos de un mailslot BOOL WriteFile(HANDLE hm, LPVOID lpbuffer DWORD nbytes, LPDWORD lpnbytes, LPOVERLAPPED lpoverlapped); Escribe datos a un mailslot BOOL CloseHandle(HANDLE hm); Cierra un mailslot Sistemas Distribuidos 21 Félix García Carballeira (1999) #include <windows.h> void main(void) HANDLE mhs, mhc; struct peticion pet; int res, nrw; Proceso servidor Proceso cliente #include <windows.h> void main(void) HANDLE mhs; /* mailslot del proceso servidor */ HANDLE mhc; /* mailslot para el proceso cliente */ struct peticion pet; int res, nrw; mhs = Creat slot( \\.\mailslot\servidor_suma, sizeof(struct peticion), INFINITE, NULL); while(1) ReadFile(mhs, (char *)&pet, sizeof(struct peticion), &nrw, NULL); res = pet.a + pet.b; /* se responde al cliente abriendo previamente su mailslot */ mhc = CreateFile(pet.q_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, NULL); WriteFile(mhc, &res, sizeof(int), &nrw, NULL); CloseHandle(mhc); mhc = Creat slot( \\.\mailslot\cliente_uno, sizeof(struct peticion), INFINITE, NULL); mhs = CreateFile ( \\.\mailslot\servidor_suma, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, NULL); /* se rellena la petición */ pet.a = 5; pet.b = 2; strcpy(pet.q_name, \\.\mailslot\cliente_uno ); WriteFile(mhs, (char *)&pet, sizeof(struct peticion),&nrw, NULL); ReadFile(mhc, &res, sizeof(int),&nrw, NULL); CloseHandle(mhc); CloseHandle(mhs); Sistemas Distribuidos 22 Félix García Carballeira (1999) Sistemas Distribuidos 23 Félix García Carballeira (1999)

5 Sockets: introducción Aparecieron en 1981 en UNIX BSD 4.2 Intento de incluir TCP/IP en UNIX Diseño independiente del protocolo de comunicación Un socket es punto final de comunicación (dirección IP y puerto) Abstracción que: Ofrece interfaz de acceso a los servicios de red en el nivel de transporte Protocolo TCP Protocolo UDP Representa un extremo de una comunicación bidireccional con una dirección asociada Sockets: introducción Sujetos a proceso de estandarización dentro de POSIX (POSIX g) Actualmente Disponibles en casi todos los sistemas UNIX En prácticamente todos los sistemas operativos WinSock: API de sockets de Windows En Java como clase nativa Sistemas Distribuidos 24 Félix García Carballeira (1999) Sistemas Distribuidos 25 Félix García Carballeira (1999) Sockets UNIX Dominios de comunicación Dominios de comunicación Tipos de sockets Direcciones de sockets Creación de un socket Asignación de direcciones Solicitud de conexión Preparar para aceptar conexiones Aceptar una conexión Transferencia de datos Un dominio representa una familia de protocolos Un socket está asociado a un dominio desde su creación Sólo se pueden comunicar sockets del mismo dominio Algunos ejemplos: PF_UNIX (o PF_LOCAL): comunicación dentro de una máquina PF_INET: comunicación usando protocolos TCP/IP Los servicios de sockets son independientes del dominio Sistemas Distribuidos 26 Félix García Carballeira (1999) Sistemas Distribuidos 27 Félix García Carballeira (1999) Tipos de sockets Stream (SOCK_STREAM) Orientado a conexión Fiable, se asegura el orden de entrega de mensajes No mantiene separación entre mensajes Si PF_INET se corresponde con el protocolo TCP Datagrama (SOCK_DGRAM) Sin conexión No fiable, no se asegura el orden en la entrega Mantiene la separación entre mensajes Si PF_INET se corresponde con el protocolo UDP Raw (SOCK_RAW) Permite el acceso a los protocolos internos como IP Sistemas Distribuidos 28 Félix García Carballeira (1999) Direcciones de sockets Cada socket debe tener asignada una dirección única Las direcciones se usan para: Asignar una dirección local a un socket (bind) Especificar una dirección remota (connect o sendto) Dependientes del dominio Se utiliza la estructura struct sockaddr Cada dominio usa una estructura específica Uso de cast en las llamadas Direcciones en PF_UNIX (struct sockaddr_un) Nombre de fichero Sistemas Distribuidos 29 Félix García Carballeira (1999)

6 Direcciones de sockets en PF_INET Host (32 bits) + puerto (16 bits) Estructura struct sockaddr_in Debe iniciarse a 0 sin_family: dominio (AF_INET) sin_port: puerto sin_addr: dirección del host Funciones para transformar formato: htonl: de host a red ntohl: de red a host Obtención de la dirección de host Usuarios manejan direcciones en forma de texto: decimal-punto: dominio-punto: laurel.datsi.fi.upm.es Conversión a binario desde decimal-punto: int inet_aton(char *str, struct in_addr *dir) str: contiene la cadena a convertir dir: resultado de la conversión en formato de red Conversión a binario desde dominio-punto: struct hostent *gethostbyname(char *str) str: cadena a convertir Devuelve la estructura que describe el host Sistemas Distribuidos 30 Félix García Carballeira (1999) Sistemas Distribuidos 31 Félix García Carballeira (1999) Creación de un socket int socket(int dominio, int tipo, int protocolo) Crea un socket devolviendo un descriptor de fichero dominio: PF_XXX tipo: SOCK_XXX protocolo: dependiente del dominio y tipo 0 elige el más adeucado Especificados en /etc/protocols El socket creado no tiene dirección asignada Sistemas Distribuidos 32 Félix García Carballeira (1999) Asignación de direcciones int bind(int sd, struct sockaddr *dir, int long) sd: descriptor devuelto por socket dir: dirección a asignar long: longitud de la dirección Si no se asigna dirección (típico en clientes) Se le asigna automáticamente (puerto efímero) en la su primera utilización (connect o sendto) Direcciones en dominio PF_INET Puertos en rango Reservados: Si 0, el sistema elige uno Host: una dirección local IP INNADDR_ANY: elige cualquiera de la máquina El espacio de puertos para streams y datagramas es indendiente Sistemas Distribuidos 33 Félix García Carballeira (1999) Solicitud de conexión Preparar para aceptar conexiones Realizada en el cliente int connect(int sd, struct sockaddr *dir, int long) sd: descriptor devuelto por socket dir: dirección del socket remoto long: longitud de la dirección Si el socket no tiene dirección asignada, se le asigna una automáticamente Normalmente se usa con streams Realizada en el servidor stream después de socket y bind int listen(int sd, int baklog) sd: descriptor devuelto por socket backlog: Número máximo de peticiones pendientes de aceptar que se encolarán (algunos manuales recomiendan 5) Hace que el socket quede preparado para aceptar conexiones. Sistemas Distribuidos 34 Félix García Carballeira (1999) Sistemas Distribuidos 35 Félix García Carballeira (1999)

7 Aceptar una conexión Aceptar una conexión Realizada en el servidor stream después de socket, bind y listen Cuando se produce la conexión, el servidor obtiene: La dirección del socket del cliente Un nuevo descriptor que queda conectado al socket del cliente Después de la conexión quedan activos dos sockets en el servidor: El original para aceptar nuevas conexiones El nuevo para enviar/recibir datos por la conexión int accept(int sd, struct sockaddr *dir, int *long) sd: descriptor devuelto por socket dir: dirección del socket del cliente devuelta long: parámetor valor-resultado Antes de la llamada: tamaño de dir Después de la llamada: tamaño de la dirección del cliente que se devuelve. Sistemas Distribuidos 36 Félix García Carballeira (1999) Sistemas Distribuidos 37 Félix García Carballeira (1999) Obtener la dirección de un socket Obtener la dirección a partir del descriptor int getsockname(int sd, struct sockaddr *dir, int *long) sd: descriptor devuelto por socket dir: dirección del socket devuelta long: parámetro valor-resultado (igual que en accept) Obtener la dirección del socket en el toro extremo de la conexión: int gerpeername(int sd, struct sockaddr *dir, int *long) sd: descriptor devuelto por socket dir: dirección del socket remoto long: parámetro valor-resultado Transferencia de datos con streams Una vez realizada la conexión, ambos extremos puede transferir datos. Envío: Puede usarse el servicio write sobre el descriptor de socket int send(int sd, char *mem, int long, int flags) Devuelve el nº de bytes enviados Recepción: Puede usarse el servicio read sobre el descriptor de socket int recv(int sd, char *mem, int long, int flags) Devuelve el nº de bytes recibidos Los flags implican aspectos avanzado como enviar o recibir datos urgentes (out-of-band) Sistemas Distribuidos 38 Félix García Carballeira (1999) Sistemas Distribuidos 39 Félix García Carballeira (1999) Transferencia de datos con datagramas No hay conexión real Para usar un socket para transferir basta con: Crearlo: socket Asignarle una dirección: bind (si no, lo hará el sistema) Envío: int sendto(int sd, char *men, int long, int flags, struct sockaddr *dir, int long) Devuelve el nº de bytes enviados dir: dirección del socket remoto y long la longitud Rccepción: int recvfrom(int sd, char *men, int long, int flags, struct sockaddr *dir, int long) Devuelve el nº de bytes enviados dir: dirección del socket remoto y long la longitud Sistemas Distribuidos 40 Félix García Carballeira (1999) Cerrar un socket Se usa close para cerrar ambos tipos de sockets Si el socket es de tipo stream, close cierra la conexión en ambos sentidos Se puede cerrar un único extremo: int shutdown(int st, int modo) sd: descriptor devuelto por socket modo: SHUT_RD, SHUT_RW o SHUT_RDWR Sistemas Distribuidos 41 Félix García Carballeira (1999)

8 Configuración de opciones Escenario típico con sockets streams Existen varios niveles dependiendo del protocolo afectado como parámetro SOL_SOCKET: opciones independientes del protocolo IPPROTO_TCP: nivel de protocolo TCP IPPTOTO_IP: nivel de protocolo IP Consultar opciones asociadas a un socket int getsockopt(int sd, int nivel, int opc, char *val, int *long) Modificar las opciones asociadas a un socket int setsockopt(int sd, int nivel, int opc, char *val, int long) Ejemplos (nivel SOL_SOCKET): SO_REUSEADDR: permite reutilizar direcciones Proceso cliente socket() Abrir conexión connect() Petición write() Respuesta read() close() Proceso servidor socket() bind() listen() accept() Crear thread accept() read() write() close() Sistemas Distribuidos 42 Félix García Carballeira (1999) Sistemas Distribuidos 43 Félix García Carballeira (1999) Ejemplo (TCP) Servidor (TCP) Máquina A cliente sumar(5,2) Máquina B servidor 5+2 void main(int argc, char *argv[]) struct sockaddr_in server_addr, client_addr; int sd, sc; int size, val; int size; int num[2], res; NÚCLEO Restulado = 7 NÚCLEO sd = socket(af_inet, SOCK_STREAM, IPPROTO_TCP); val = 1; setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char *) &val, sizeof(int)); RED bzero((char *)&server_addr, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = INADDR_ANY; server_addr.sin_port = 4200; bind(sd, &server_addr, sizeof(server_addr)); Sistemas Distribuidos 44 Félix García Carballeira (1999) Sistemas Distribuidos 45 Félix García Carballeira (1999) Servidor (TCP) listen(sd, 5); size = sizeof(client_addr); while (1) printf("esperando conexion\n"); sc = accept(sd, (struct sockaddr *)&client_addr,&size); Cliente (TCP) void main(void) int sd; struct sockaddr_in server_addr; struct hostent *hp; int num[2], res; read(sc, (char *) num, 2 *sizeof(int)); // recibe la petición sd = socket(af_inet, SOCK_STREAM, IPPROTO_TCP); res = num[0] + num[1]; write(sc, &res, sizeof(int)); // se envía el resultado bzero((char *)&server_addr, sizeof(server_addr)); hp = gethostbyname ("arlo.datsi.fi.upm.es"); close(sc); close (sd); exit(0); memcpy (&(server_addr.sin_addr), hp->h_addr, hp->h_length); server_addr.sin_family = AF_INET; server_addr.sin_port = 4200; Sistemas Distribuidos 46 Félix García Carballeira (1999) Sistemas Distribuidos 47 Félix García Carballeira (1999)

9 Cliente (TCP) Servidor (datagramas) // se establece la conexión connect(sd, (struct sockaddr *) &server_addr, sizeof(server_addr)); num[0]=5; num[1]=2; write(sd, (char *) num, 2 *sizeof(int)); read(sd, &res, sizeof(int)); printf("resultado es %d \n", res); close (sd); exit(0); // envía la petición // recibe la respuesta void main(void) int num[2]; int s, res, clilen; struct sockaddr_in server_addr, client_addr; s = socket(af_inet, SOCK_DGRAM, 0); bzero((char *)&server_addr, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = INADDR_ANY; server_addr.sin_port = 7200; bind(s, (struct sockaddr *)&server_addr, sizeof(server_addr)); Sistemas Distribuidos 48 Félix García Carballeira (1999) Sistemas Distribuidos 49 Félix García Carballeira (1999) Servidor (datagramas) clilen = sizeof(client_addr); while (1) recvfrom(s, (char *) num, 2* sizeof(int), 0, (struct sockaddr *)&client_addr, &clilen); res = num[0] + num[1]; sendto(s, (char *)&res, sizeof(int), 0, (struct sockaddr *)&client_addr, clilen); Cliente (datagramas) void main(int argc, char *argv[]) struct sockaddr_in server_addr, client_addr; struct hostent *hp; int s, num[2], res; if (argc!= 2) printf("uso: client <direccion_servidor> \n"); exit(0); s = socket(af_inet, SOCK_DGRAM, 0); hp = gethostbyname (argv[1]); bzero((char *)&server_addr, sizeof(server_addr)); server_addr.sin_family = AF_INET; memcpy (&(server_addr.sin_addr), hp->h_addr, hp->h_length); server_addr.sin_port = 7200; Sistemas Distribuidos 50 Félix García Carballeira (1999) Sistemas Distribuidos 51 Félix García Carballeira (1999) Cliente (datagramas) bzero((char *)&client_addr, sizeof(client_addr)); client_addr.sin_family = AF_INET; client_addr.sin_addr.s_addr = INADDR_ANY; client_addr.sin_port = htons(0); bind (s, (struct sockaddr *)&client_addr, sizeof(client_addr)); num[0] = 2; num[1] = 5; Rendimiento I Tiempo en realizar una suma utilizando datagramas y streams. Incluye todas las operaciones (creación de sockets, conexión, etc.) Biprocesador Pentiun II 266 MHZ con Linux. UDP TCP sendto(s, (char *)num, 2 * sizeof(int), 0, (struct sockaddr *) &server_addr, sizeof(server_addr)); Local 2,2 ms 2,74 ms recvfrom(s, (char *)&res, sizeof(int), 0, NULL, NULL); printf("2 + 5 = %d\n", res); close(s); Remoto 6,8 ms 7,35 ms Sistemas Distribuidos 52 Félix García Carballeira (1999) Sistemas Distribuidos 53 Félix García Carballeira (1999)

10 Rendimiento II Sockets de Java Tiempo en realizar únicamente el envío y la recepción de datos (sendto, recvfrom, read, write). Sin conexiones Local Remoto UDP 0,21 ms 0,29 ms TCP 0,34 ms 0,44 ms El paquete java.net de Java permite crear sockets TCP/IP. Clases para sockets datagrama DatagramSocket DatagramPacket Clases para sokcets stream ServerSocket Socket Sistemas Distribuidos 54 Félix García Carballeira (1999) Sistemas Distribuidos 55 Félix García Carballeira (1999) Sockets datagrama Sockets stream DatagramPacket: implementa un objeto que permite enviar o recibir paquetes: Constructor: DatagramPackect Métodos: getaddres, getport, setdata,... DatagramSocket: implementa un socket que se puede utilizar para enviar o recibir datagramas. Constructor: DatagramSocket Métodos: send, receive, close, setsotimetout, getsotimetout,... La clase socket implementa un socket stream La clase ServerSocket implementa un socket a utilizar en los servidores para esperar la conexiones de los clientes Alunas clases abstractas para trabajar con streams: OutputStream close, flush, write InputStream close, read DataOutputStream writebyte, writeint, writedouble,... DataInputStream readbye, readint, readdouble,... Sistemas Distribuidos 56 Félix García Carballeira (1999) Sistemas Distribuidos 57 Félix García Carballeira (1999) Cliente-servidor con sockets streams de Java Cliente-servidor con sockets streams de Java Servidor Proceso servidor Cliente ServerSocket(puerto); ServerSocket() Proceso cliente socket(host, puerto) accept(); Socket() Abrir conexión Accept() Crear Thread OutoputStream InputStream Obtener streams Accept() Obtener streams Petición InputStream OutoputStream write() read() Respuesta read() write() close() close() close() close() Sistemas Distribuidos 58 Félix García Carballeira (1999) Sistemas Distribuidos 59 Félix García Carballeira (1999)

11 Ejemplo Servidor (streams) Máquina A cliente NÚCLEO sumar(5,2) Restulado = 7 Máquina B servidor 5+2 NÚCLEO RED import java.lang.* ; import java.io.* ; import java.net.* ; import java.util.* ; public class servidor public static void main ( String [] args) ServerSocket serveraddr = null; Socket sc = null; int num[] ; // petición int res; try serveraddr = new ServerSocket(2500); catch (Exception e) System.err.println("Error creando socket"); Sistemas Distribuidos 60 Félix García Carballeira (1999) Sistemas Distribuidos 61 Félix García Carballeira (1999) Servidor (streams) while (true) try sc = serveraddr.accept(); // esperando conexión InputStream istream = sc.getinputstream(); ObjectInput in = new ObjectInputStream(istream); num = (int[]) in.readobject(); res = num[0] + num[1]; DataOutputStream ostream = new DataOutputStream(sc.getOutputStream()); ostream.writeint(res); ostream.flush(); sc.close(); catch(exception e) System.err.println("excepcion " + e.tostring() ); e.printstacktrace() ; Sistemas Distribuidos 62 Félix García Carballeira (1999) import java.lang.* ; import java.io.* ; import java.net.* ; import java.util.* ; Cliente (streams) public class client public static void main ( String [] args) int res; int num[] = new int[2]; if (args.length!= 1) System.out.println("Uso: cliente <host>"); System.exit(0); try // se crea la conexión String host = args[0]; Socket sc = new Socket(host, 2500); // conexión Sistemas Distribuidos 63 Félix García Carballeira (1999) Cliente (streams) OutputStream ostream = sc.getoutputstream(); ObjectOutput s = new ObjectOutputStream(ostream); DataInputStream istream = new DataInputStream(sc.getInputStream()); import java.lang.* ; import java.io.* ; import java.net.* ; import java.util.* ; Servidor (datagramas) num[0] = 5; num[1] = 2; //prepara la petición s.writeobject(num); s.flush(); res = istream.readint(); sc.close(); System.out.println("La suma es " + res); catch (Exception e) System.err.println("excepcion " + e.tostring() ); e.printstacktrace() ; public class servidor public static void main ( String [] args) DatagramSocket s = null; DatagramPacket in, out; InetAddress client_addr = null; int client_port; byte brecv[] = new byte[100]; byte bsend[] = new byte[100]; int num[], res; try s = new DatagramSocket(2500); in = new DatagramPacket(brecv, 100); // paquete para recibir la // solicitud Sistemas Distribuidos 64 Félix García Carballeira (1999) Sistemas Distribuidos 65 Félix García Carballeira (1999)

12 Servidor (datagramas) Servidor (datagramas) while (true) s.receive(in); // esperamos a recibir los paquetes brecv = in.getdata(); // obtener datos client_addr = in.getaddress(); client_port = in.getport(); // desempaquetar los datos. ByteArrayInputStream bais = new ByteArrayInputStream(brecv) ; ObjectInputStream dis = new ObjectInputStream(bais); num = (int[])dis.readobject(); res = num[0] + num[1]; bsend = baos.tobytearray(); out = new DatagramPacket(bsend, bsend.length, client_addr, client_port); s.send(out); catch(exception e) System.err.println("excepcion " + e.tostring() ); e.printstacktrace() ; ByteArrayOutputStream baos = new ByteArrayOutputStream() ; DataOutputStream dos = new DataOutputStream(baos); dos.writeint(res); Sistemas Distribuidos 66 Félix García Carballeira (1999) Sistemas Distribuidos 67 Félix García Carballeira (1999) import java.lang.* ; import java.io.* ; import java.net.* ; import java.util.* ; Cliente (datagramas) public class client public static void main ( String [] args) byte bsend[] = new byte[100]; byte brecv[] = new byte[100]; InetAddress server_addr = null; DatagramSocket s = null; DatagramPacket in = null; DatagramPacket out = null; int res; int num[] = new int[2]; if (args.length!= 1) System.out.println("Uso: cliente <host>"); System.exit(0); Sistemas Distribuidos 68 Félix García Carballeira (1999) try Cliente (datagramas) // se crea el socket del cliente s = new DatagramSocket(); // en el puerto que quiera // direción del servidor server_addr = InetAddress.getByName(args[0]); num[0] = 2; num[1] = 5; // empaquetar los datos. ByteArrayOutputStream baos = new ByteArrayOutputStream() ; ObjectOutputStream dos = new ObjectOutputStream(baos); dos.writeobject(num) ; bsend = baos.tobytearray() ; // se obtiene el buffer (datagrama) // un único envio out = new DatagramPacket(bsend, bsend.length, server_addr, 2500); s.send(out); Sistemas Distribuidos 69 Félix García Carballeira (1999) Cliente (datagramas) // se recibe el datagrama de respuesta in = new DatagramPacket(brecv, 100); s.receive(in); // se obtiene el buffer brecv = in.getdata(); // se desempaqueta ByteArrayInputStream bais = new ByteArrayInputStream(brecv) ; DataInputStream dis = new DataInputStream(bais); res = dis.readint(); System.out.println("Datos recibidos " + res); catch (Exception e) System.err.println("<<<<<excepcion " + e.tostring() ); e.printstacktrace() ; Sistemas Distribuidos 70 Félix García Carballeira (1999) Rendimiento I Tiempo en realizar una suma utilizando datagramas y streams. Incluye todas las operaciones (creación de sockets, conexión, etc.) Biprocesador Pentiun II 266 MHZ con Linux. Local Remoto UDP 211 ms 217 ms TCP 235,6 ms 286 ms Sistemas Distribuidos 71 Félix García Carballeira (1999)

13 Local Remoto Rendimiento II Tiempo en realizar únicamente el envío y la recepción de datos (sin conexiones) UDP 6,25 ms 4,95 ms TCP 152 ms 139 ms Rendimiento: sockets Unix contra Java Streams con conexión (en ms) local remoto Java 235,6 286 Sokcets Unix 2,74 7,35 Datagramas con conexión (en ms) local remoto Java Sokcets Unix 2,2 6,8 Sistemas Distribuidos 72 Félix García Carballeira (1999) Sistemas Distribuidos 73 Félix García Carballeira (1999) Rendimiento: sockets Unix contra Java Streams sin conexión (en ms) local remoto Java Sokcets Unix 0,34 0,44 Datagramas sin conexión (en ms) local remoto Java 6,25 4,95 Sokcets Unix 0,21 0,29 RPC RPC (remote procedure call): llamadas a procedimiento remoto (Birrel y Nelson 1985) Híbrido entre llamadas a procedimientos y paso de mensajes Las RPC constituyen el núcleo de muchos sistemas distribuidos Llegaron a su culminación con DCE (Distributed Computing Environment) Han evolucionado hacia orientación a objetos Invocación de métodos remotos (CORBA, RMI) Sistemas Distribuidos 74 Félix García Carballeira (1999) Sistemas Distribuidos 75 Félix García Carballeira (1999) Funcionamiento de las RPC Llamadas y mensajes en una RPC El proceso que realiza la llamada empaqueta los argumentos en un mensaje, se los envía a otro proceso y espera el resultado El proceso que ejecuta el procedimiento extrae los argumentos del mensaje, realiza la llamada de forma local, obtiene el resultado y se lo envía de vuelta al proceso que realizó la llamada Objetivo: acercar la semántica de las llamadas a procedimiento convencional a un entorno distribuido (transparencia). SISTEMA CLIENTE CÓDIGO DE LA APLICACIÓN INICIO LLAMADA FIN LLAMADA RESGUARDO PREPARA CLIENTE 1 ENTRADA CONVIERTE SALIDA BIBLIOT. EJECUCIÓN RPC 9 ENVÍA 2 ENTRADA RECIBE 8 SALIDA SISTEMA SERVIDOR PROCEDIMIENTOS 5 EJECUTA PROCEDIMIENTO REMOTO RESGUARDO CONVIERTE 4 SERVIDOR ENTRADA 6 BIBLIOT. EJECUCIÓN RPC 7 PREPARA SALIDA RECIBE Y PASA TRANSMITE SALIDA 3 Sistemas Distribuidos 76 Félix García Carballeira (1999) Sistemas Distribuidos 77 Félix García Carballeira (1999)

14 Resguardos (stubs) RPC: protocolo básico Se generan automáticamente por el software de RPC En el cliente: Localizan al servidor Empaquetan los parámetros y construyen los mensajes Envían el mensaje al servidor Espera la recepción del mensaje y devuelven los resultados En el servidor Realizan tareas similares Los resguardos son independientes de la implementación que se haga del cliente y del servidor. Sólo dependen de la interfaz. enlaza con el servidor prepara parámetros, envía petición Desempaqueta la respuesta cliente servidor Se registra con un servicio de nombres recibe petición Ejecuta el procedimiento envía petición Sistemas Distribuidos 78 Félix García Carballeira (1999) Sistemas Distribuidos 79 Félix García Carballeira (1999) Problemas de diseño de las RPC Lenguaje de definición de interfaces Lenguaje de definición de interfaces. Generador de resguardos. Transferencia de parámetros Enlace dinámico (binding) Semántica de las RPC en presencia de fallos Una interfaz especifica un nombre de servicio que utilizan los clientes y servidores Nombres de procedimientos y parámetros (entrada y salida). Los compiladores pueden diseñarse para que los clientes y servidores se escriban en lenguajes diferentes. Tipos de RPC Integrado con un lenguaje de programación (Cedar, Argus) Lenguaje de definición de interfaces específico para describir las interfaces entre los clientes y los servidores (RPC de Sun y RPC de DCE) Sistemas Distribuidos 80 Félix García Carballeira (1999) Sistemas Distribuidos 81 Félix García Carballeira (1999) Transferencia de parámetros Una de las funciones de los resguardos es empaquetar los parámetros en un mensaje: aplanamiento (marshalling) Problemas en la representación de los datos Servidor y cliente pueden ejecutar en máquinas con arqutecturas distintas XDR (external data representation) es un estándar que define la representación de tipos de datos Problemas con los punteros Una dirección sólo tiene sentido en un espacio de direcciones Enlace dinámico (Binding) Enlace dinámico: permite localizar objetos con nombre en un sistema distribuido, en concreto, servidores que ejecutan las RPC. Tipos de enlace: Enlace no persistente: la conexión entre el cliente y el servidor se establece en cada RPC. Enlace persistente: la conexión se mantiene después de la primera RPC. Útil en aplicaciones con muchas RPC repetidas Problemas si lo servidores cambian de lugar Sistemas Distribuidos 82 Félix García Carballeira (1999) Sistemas Distribuidos 83 Félix García Carballeira (1999)

15 Enlazador dinámico Semántica de las RPC en presencia de fallos Enlazador dinámico (binder): Es el servicio que mantiene una tabla de traducciones entre nombres de servicio y direcciones. Incluye funciones para: Registrar un nombre de servicio Eliminar un nombre de servicio Buscar la dirección correspondiente a un nombre de servicio Como localizar al enlazador dinámico: Ejecuta en una dirección fija de un computador fijo. El sistema operativo se encarga de indicar su dirección Difundiendo un mensaje (broadcast) cuando los procesos comienzan su ejecución. Problemas que pueden plantear las RPC El cliente no es capaz de localizar al servidor Se pierde el mensaje de petición del cliente al servidor Se pierde el mensaje de respuesta del servidor al cliente El servidor falla después de recibir una petición El cliente falla después de enviar una petición Sistemas Distribuidos 84 Félix García Carballeira (1999) Sistemas Distribuidos 85 Félix García Carballeira (1999) Cliente no puede localizar al servidor El servidor puede estar caído El cliente puede estar usando una versión antigua del servidor La versión ayuda a detectar accesos a copias obsoletas Cómo indicar el error al cliente Devolviendo un código de error (-1) No es transparente Ejemplo: sumar(a,b) Elevando una excepción Necesita un lenguaje que tenga excepciones Pérdida de mensajes del cliente Es la más fácil de tratar Se activa una alarma (timeout) después de enviar el mensaje Si no se recibe una respuesta se retransmite Sistemas Distribuidos 86 Félix García Carballeira (1999) Sistemas Distribuidos 87 Félix García Carballeira (1999) Pérdidas en los mensajes de respuesta Más difícil de tratar Se pueden emplear alarmas y retransmisiones, pero: Se perdió la petición? Se perdió la respuesta? El servidor va lento? Algunas operaciones pueden repetirse sin problemas (operaciones idempotentes) Una transferencia bancaria no es idempotente Solución con operaciones no idempotentes es descartar peticiones ya ejecutadas Un nº de secuencia en el cliente Un campo en el mensaje que indique si es una petición original o una retransmisión Sistemas Distribuidos 88 Félix García Carballeira (1999) Fallos en los servidores El servidor no ha llegado a ejecutar la operación Se podría retransmitir El servidor ha llegado a ejecutar la operación El cliente no puede distinguir los dos Qué hacer? No garantizar nada Semántica al menos una vez Reintentar y garantizar que la RPC se realiza al menos una vez No vale para operaciones no idempotentes Semántica a lo más una vez No reintentar, puede que no se realice ni una sola vez Semántica de exactamente una Sería lo deseable Sistemas Distribuidos 89 Félix García Carballeira (1999)

16 Fallos en los clientes Aspectos de implementación La computación está activa pero ningún cliente espera los resultados (computación huérfana) Gasto de ciclos de CPU Si cliente rearranca y ejecuta de nuevo la RPC se pueden crear confusiones Protocolos RPC Orientados a conexión Fiabilidad se resuelve a bajo nivel, peor rendimiento No orientados a conexión Uso de un protocolo estándar o un específico Algunos utilizan TCP o UDP como protocolos básicos Sistemas Distribuidos 90 Félix García Carballeira (1999) Sistemas Distribuidos 91 Félix García Carballeira (1999) Programación con un paquete de RPC El programador debe proporcionar: La definición de la interfaz (idl) Nombres de las funciones Parámetros que el cliente pasa al servidor Resultados que devuelve el servidor al cliente El código del cliente El código del servidor El compilador de idl proporciona: El resguardo del cliente El resguardo del servidor DESARROLLO DE LA INTERFAZ RESGUARDO EN CLIENTE COMPILADOR C OBJETO RESGUARDO EN CLIENTE Programación con RPC FICHEROS FUENTE DEL CLIENTE COMPILADOR C FICHEROS OBJETO DEL CLIENTE CABECERA BIBLIOT. RPC FICHERO DE DEFINICIÓN DE INTERFAZ COMPILADOR IDL CABECERA CABECERA BIBLIOT. RPC FICHEROS FUENTE DEL SERVIDOR COMPILADOR C COMPILADOR C FICHEROS OBJETO DEL SERVIDOR RESGUARDO EN SERVIDOR OBJETO RESGUARDO EN SERVIDOR DESARROLLO DEL CLIENTE MONTADOR EJECUTABLE DEL CLIENTE MONTADOR EJECUTABLE DEL DESARROLLO SERVIDOR DEL SERVIDOR Sistemas Distribuidos 92 Félix García Carballeira (1999) Sistemas Distribuidos 93 Félix García Carballeira (1999) Ejemplos de paquetes de RPC RPC de Sun RPC de Sun (1990) utilizado en NFS RPC del proyecto ANSA (1989) desarrollado por Architecture Project Management Ltd. (Cambridge, Inglaterra) RPC de DCE (1990), estándar desarrollado por Open Software Foundation Utiliza como lenguaje de definición de interfaz XDR: Una interfaz contiene un nº de programa y un nº de versión. Cada procedimiento específica un nombre y un nº de procedimiento Los procedimientos sólo aceptan un parámetro. Los parámetros de salida se devuelven mediante un único resultado El lenguaje ofrece una notación para definir: constantes definición de tipos estructuras, uniones programas Sistemas Distribuidos 94 Félix García Carballeira (1999) Sistemas Distribuidos 95 Félix García Carballeira (1999)

17 RPC de Sun Ejemplo rpcgen es el compilador de interfaces que genera: Resguardo del cliente Resguardo del servidor y procedimiento principal del servidor. Procedimientos para el aplanamiento (marshalling) Fichero de cabecera (.h) con los tipos y declaración de prototipos. Enlace dinámico El cliente debe especificar el host donde ejecuta el servidor El servidor se registra (nº de programa, nº de versión y nº de puerto) en el port mapper local El cliente envía una petición al port mapper del host donde ejecuta el servidor Máquina A cliente NÚCLEO sumar(5,2) Restulado = 7 Máquina B servidor 5+2 NÚCLEO RED Sistemas Distribuidos 96 Félix García Carballeira (1999) Sistemas Distribuidos 97 Félix García Carballeira (1999) Esquema de la aplicación suma.x cliente.c suma_clnt.c Archivos para el cliente struct peticion int a; int b; ; suma.x repcgen suma_xdr.c suma.h suma_svc.c servidor.c Archivos comunes Archivos para el servidor program SUMAR version SUMAVER int SUMA(peticion) = 1; = 1; = 99; Sistemas Distribuidos 98 Félix García Carballeira (1999) Sistemas Distribuidos 99 Félix García Carballeira (1999) suma.h servidor.c #ifndef _SUMA_H_RPCGEN #define _SUMA_H_RPCGEN #include <rpc/rpc.h> struct peticion int a; int b; ; #define SUMAVER ((u_long)99) #define SUMA ((u_long)1) extern int * suma_1(peticion *, CLIENT *); extern int * suma_1_svc(peticion *, struct svc_req *); #include "suma.h" int *suma_1_svc(peticion *argp, struct svc_req *rqstp) static int result; result = argp->a + argp->b; return(&result); #endif /*!_SUMA_H_RPCGEN */ Sistemas Distribuidos 100 Félix García Carballeira (1999) Sistemas Distribuidos 101 Félix García Carballeira (1999)

18 cliente.c cliente.c #include "suma.h" main( int argc, char* argv[] ) CLIENT *clnt; int *res; peticion suma_1_arg; char *host; if(argc < 2) printf("usage: %s server_host\n", argv[0]); exit(1); host = argv[1]; Sistemas Distribuidos 102 Félix García Carballeira (1999) /* localiza al servidor */ clnt = clnt_create(host, SUMAR, SUMAVER, "udp"); if (clnt == NULL) clnt_pcreateerror(host); exit(1); suma_1_arg.a = 5; suma_1_arg.b = 2; res = suma_1(&suma_1_arg, clnt); if (res == NULL) clnt_perror(clnt, "call failed:"); printf("la suma es %d\n", *res); clnt_destroy( clnt ); Sistemas Distribuidos 103 Félix García Carballeira (1999) Rendimiento I Rendimiento de sockets y RPC. Incluye todo el tiempo. Enlace, conexión en sockets, etc. Rendimiento II Sólo incluye el tiempo en realiza la operación. Envío/recepción en sockets. Ejecución de suma_l en RPC Sockets RPC Sockets RPC UDP TCP UDP TCP UDP TCP UDP TCP Local 2,2 ms 2,74 ms 4,61 ms 5,43 ms Local 0,21 ms 0,34 ms 0,28 ms 0,43 ms Remoto 6,8 ms 7,35 ms 8,21 ms 8,77 ms Remoto 0,29 ms 0,44 ms 0,36 ms 0,55 ms Sistemas Distribuidos 104 Félix García Carballeira (1999) Sistemas Distribuidos 105 Félix García Carballeira (1999) Entornos orientados a objetos Modelo de objetos Tendencia actual hacia sistemas compuestos por un conjunto de objetos que interactúan entre sí. Un programa solicita servicios invocando los métodos que ofrece un objeto La invocación de métodos se ve como un paso de mensajes ANSA ( ) fue el primer proyecto que intentó desarrollar una tecnología para modelizar sistemas distribuidos complejos Utilizaba un diseño orientado a objetos Estándares: RMI: invocación de métodos remotos de Java CORBA: expande DCE con servicios orientados a objetos DCOM: versión CORBA de Microsoft Sistemas Distribuidos 106 Félix García Carballeira (1999) Sistemas Distribuidos 107 Félix García Carballeira (1999)

19 Modelo de objetos en sistemas distribuidos Invocación de métodos remotos en Java Máquina A Máquina B Máquina C RMI (Remote method invocation) El soporte para RMI en Java está basado en las interfaces y clases definidas en los paquetes java.rmi y java.rmi.server RMI ofrece Mecanismos para crear servidores y objetos cuyos métodos se puedan invocar remotamente Mecanismos que permiten a los clientes localizar los objetos remotos Sistemas Distribuidos 108 Félix García Carballeira (1999) Sistemas Distribuidos 109 Félix García Carballeira (1999) Arquitectura de RMI Nivel de transporte: se encarga de las comunicaciones y de establecer las conexiones necesarias Nivel de gestión de referencias remotas: trata los aspectos relacionados con el comportamiento esperado de las referencias remotas (mecanismos de recuperación, etc.) Nivel de resguardo/esqueleto (proxy/skeleton) que se encarga del aplanamiento de los parámetros proxy: resguardo local. Cuando un cliente realiza una invocación remota, en realidad hace una invocación de un método del resguardo local. Esqueleto (skeleton): recibe las peticiones de los clientes, realiza la invocación del método y devuelve los resultados. Sistemas Distribuidos 110 Félix García Carballeira (1999) Cómo escribir aplicaciones con RMI? 8 usa Cliente (.java) 9 javac (.class) 10 Ejectuar Cliente 1 Definición de la interfaz remota 2 Implementación de la interfaz remota (.java) 3 javac (.class) 4 rmic Servidor (.class) Esqueleto (.class) Esqueleto (.class) Arrancar RMIRegistry Crear los objetos Registrar los objetos CLIENTE SERVIDOR Sistemas Distribuidos 111 Félix García Carballeira (1999) Invocación remota Ejemplo 0iTXLQD 0iTXLQD 50, UPLUHJLVWU\ &OLHQWH 50, 50, 6HUYLGRU Sistemas Distribuidos 112 Félix García Carballeira (1999) Sistemas Distribuidos 113 Félix García Carballeira (1999)

20 Modelización de la interfaz remota (Sumador) public interface Sumador extends java.rmi.remote public int sumar(int a, int b) throws java.rmi.remoteexception; Sistemas Distribuidos 114 Félix García Carballeira (1999) Clase que implementa la interfaz (SumadorImpl) import java.rmi.*; import java.rmi.server.unicastremoteobject; public class SumadorImpl extends UnicastRemoteObject implements Sumador public SumadorImpl(String name) throws RemoteException super(); try System.out.println("Rebind Object " + name); Naming.rebind(name, this); catch (Exception e) System.out.println("Exception: " + e.getmessage()); e.printstacktrace(); public int sumar (int a, int b) throws RemoteException return a + b; Sistemas Distribuidos 115 Félix García Carballeira (1999) Código del servidor (SumadorServer) Registro del servicio import java.rmi.*; import java.rmi.server.*; public class SumadorServer public static void main (String args[]) int res = 0; System.out.println("Setting Security Manager"); if (System.getSecurityManager() == null) System.setSecurityManager(new RMISecurityManager()); System.out.println("Security Manager Installed"); try SumadorImpl misuma = new SumadorImpl("MiSumador"); catch(exception e) System.err.println("System exception" + e); Sistemas Distribuidos 116 Félix García Carballeira (1999) Cualquier programa que quiera instanciar un objeto de esta clase debe realizar el registro con el servicio de nombrado de la siguiente forma: Sumador misuma = (Sumador)Naming.lookup("rmi://" + args[0] + "/" +"MiSumador"); Antes de arrancar el cliente y el servidor, se debe arrancar el programa rmiregistry en el servidor para el servicio de nombres Sistemas Distribuidos 117 Félix García Carballeira (1999) Código en el cliente (SumadorCliente) import java.rmi.registry.*; import java.rmi.server.*; public class SumadorClient public static void main(string args[]) int res = 0; try System.out.println("Buscando Objeto "); Sumador misuma = (Sumador)Naming.lookup("rmi://" + args[0] + "/" +"MiSumador"); res = misuma.sumar(5, 2); System.out.println("5 + 2 = " + res); catch(exception e) System.err.println(" System exception"); System.exit(0); Sistemas Distribuidos 118 Félix García Carballeira (1999) Cómo se ejecuta? Compilación javac Sumador.java javac SumadorImpl.java javac SumadorClient.java javac Sumador Server.java Generación de los esqueletos rmic SumadorImpl Ejecución del programa de registro de RMI rmiregistry Ejecución del servidor java SumadorServer Ejecución del cliente java SumadorCliente <host-del-servidor> Sistemas Distribuidos 119 Félix García Carballeira (1999)

21 Rendimiento Comparando el rendimiento Tiempo en realizar una suma con RMI Biprocesador Pentiun II 266 MHZ con Linux. Local Remoto Con lookup 684 ms 652 ms Sin lookup 17,5 ms 15 ms Local Con conexión Remoto Con conexión Local Sin conexión Remoto Sin conexión Sockes Unix TCP 2,74 7,35 0,34 0,44 Sockets Unix UDP 2,2 6,8 0,29 0,21 Sockets Java TCP 235, Sockets Java UDP ,25 4,95 RPC-TCP 5,43 8,77 0,43 0,55 RPC-UDP 4,61 8,21 0,44 0,34 RMI-Java ,5 15 Sistemas Distribuidos 120 Félix García Carballeira (1999) Sistemas Distribuidos 121 Félix García Carballeira (1999) CORBA RPC contra ORB CORBA (common object request broker architecure) Estándar desarrollado por ONG (Object management group) a principios de los 90 El modelo de referencia CORBA incluye el conjunto de componentes y servicios que debería ofrecer una plataforma distribuida CORBA especifica: Una arquitectura de componentes cliente-servidor cooperantes. Un conjunto de funcionalidades Un lenguaje de descripción de interfaces para definir objetos La interfaz es independiente del lenguaje y se puede utilizar desde diferentes lenguajes de programación (C, C++, Java,...) Cliente Servidor Código Llamar a f() Datos Mecanismo de RPC Cliente Servidor Objeto X Objeto Y Invoca el Invoca el método método f del f del objetox objeto Y f f Object Request Broker Sistemas Distribuidos 122 Félix García Carballeira (1999) Sistemas Distribuidos 123 Félix García Carballeira (1999) Repositorio de interfaces Invocación dinámica Estructura de CORBA Cliente Resguardo del cliente Interfaz ORB Object Request Broker Implementación de objetos Esqueletos estáticos Invocación dinámica de Invocación esqueletos Adaptador dinámica de de objetos esqueletos Repositorio de implmentación Sistemas Distribuidos 124 Félix García Carballeira (1999) Componentes de CORBA Lenguaje de definición de interfaces (IDL). Especifica objetos, métodos, excepciones, herencia. Compilador del IDL. Genera los resguardos y esqueletos. ORB (Object Request Broker). Se ocupa de las comunicaciones, enlaces (bindings) y gestionar la invocación de métodos. Toda implementación CORBA debe ofrecer al menos un ORB. Resguardos del cliente. Define la forma en la que los clientes invocan los servicios correspondientes del servidor. Generado por el compilador de IDL. Interfaz de invocación dinámica. Permite a los clientes descubrir e invocar nuevas interfaces en tiempo de ejecución. No necesitan un resguardo precompilado. Repositorio de interfaces. Base de datos distribuida que contiene las versiones de las interfaces definidas. Sistemas Distribuidos 125 Félix García Carballeira (1999)

22 Componentes de CORBA Ejemplo El interfaz ORB. API de los servicios que ofrece ORB (pe: convertir referencias a objetos en cadenas de caracteres y viceversa) Adaptador de objetos básico. Componente de ORB que soporta la activación de objetos en los servidores. Esqueletos estáticos. Proporcionan las interfaces estáticas para cada servicio exportado por un servidor. Generados por el compilador de IDL. Interfaz para la invocación dinámica de esqueletos. Interfaz para manejar la invocación de métodos dinámicos (no están en los esqueletos). Repositorio de implementación. Repositorio con las clases que soporta un servidor. Máquina A cliente NÚCLEO sumar(5,2) Restulado = 7 Máquina B servidor 5+2 NÚCLEO RED Sistemas Distribuidos 126 Félix García Carballeira (1999) Sistemas Distribuidos 127 Félix García Carballeira (1999) Programación con invocación estática sumar.idl 1 Escribir la interfaz (IDL) 2 // sumar.idl 8 3 Precompilar Resguardo del cliente 4 Implementar el cliente Esqueleto del servidor Implementar el servidor Repositorio de interfaces Adaptador de objetos module Sumador interface sumar long suma(in long a, in long b); ; ; 9 Compilar 5 Compilar 7 6 Repositorio de implementación Cliente Servidor Sistemas Distribuidos 128 Félix García Carballeira (1999) Sistemas Distribuidos 129 Félix García Carballeira (1999) Servidor Implementación del servidor // SumarServer.java: The Sumador Server main program class SumarServer static public void main(string[] args) try // Initialize the ORB org.omg.corba.orb orb = org.omg.corba.orb.init(args, null); // Initialize the BOA org.omg.corba.boa boa = orb.boa_init(); // Create the Sumador object SumarImpl sumador = new SumarImpl("My Sumador"); // Export to the ORB the newly created object boa.obj_is_ready(sumador); // Ready to service requests boa.impl_is_ready(); catch(org.omg.corba.systemexception e) System.err.println(e); Sistemas Distribuidos 130 Félix García Carballeira (1999) // SumarImpl.java: The Sumador Implementation class SumarImpl extends Sumador._sumarImplBase private int sum; // Constructors SumarImpl(String name) super(name); System.out.println("Creado objeto Sumador "); public int suma(int a, int b) int res = a+b; return res; Sistemas Distribuidos 131 Félix García Carballeira (1999)