Comunicación en los Sistemas Operativos Distribuidos

1. Comunicación en los Sistemas Operativos Distribuidos M.C. Juan Carlos Olivares Rojas

2. Agenda 2.1 Comunicación 2.2 Sincronización 2.3Nominación

3. 2.1 Comunicación 2.1.1 Comunicación con cliente servidor (sockets). 2.1.2 Comunicación con RPC. 2.1.3 Comunicación en grupo. 2.1.4 Tolerancia a fallos.

4. 2.1 Comunicación Para lograr la distribución de procesos se requiere de mecanismos que permitan coordinar y controlar la ejecución de procesos en ambientes no centralizados, ya sean de manera local y remota. Los primeros protocolos para la distribución de procesos remotos fueron para máquinas homogéneas.

5. Comunicación Otra forma de comunicación fue la estandarización de sistemas heterogéneos con interfaz común UUCP (Unix to Unix Copy Protocol) que dio origen a los comandos R (rcopy, rlogin, rsh). rlogin jcolivar@antares.itmorelia.edu.mx rsh jcolivar@antares.itmorelia.edu.mx

6. Comunicación • La comunicación entre procesos (IPC) es parte fundamental de las primitivas de sincronización de un sistema distribuido. • Los mecanismos de comunicación entre procesos no sólo aplican a aplicaciones distribuidas sino a cualquier tipo.

7. Comunicación • El mecanismo de comunicación entre procesos más famosos es el IPC (Inter Process Comunication) de Unix System V. • El otro punto a tratar es sobre los mecanismos de intercomunicación entre entidades de procesamiento diferentes con diferentes sistemas operativos: POSIX.

8. 2.1.1 Sockets • Los sockets son el mecanismo de sincronización distribuida más importante. • Se les denomina conectores por que pueden unir un proceso cliente y un proceso servidor, de manera semejante a como se puede unir un enchufe de un dispositivo eléctrico con su respectivo zócalo.

9. Sockets • El mecanismo de sockets más conocido es el referente a la API de Berkeley. • Está API está implementado en prácticamente todos los sistemas Unix, por lo que se maneja C, pero también está portado a otras arquitecturas como Windows (WinSock) y a otros lenguajes como Java

10. Sockets Los sockets trabajan sobre capa 4 (Transporte) del modelo OSI, aunque algunos autores la ubican en la capa 5 (Sesión). Para la comunicación de procesos remotos se necesita conocer la dirección de la máquina destino y el puerto donde se va a escuchar.

11. Sockets Los sockets no están casados con ningún tipo de red, por lo que se pueden implementar en diversos protocolos de red como IPX/SPX, NetBEUI, TCP/IP, siendo este último el más importante. Para hacer uso de sockets se necesitan dos cosas: una familia o protocolo a utilizar para la comunicación y un tipo de conexión.

12. Sockets • Se utiliza la biblioteca <sys/socket.> • Se utilizan las siguientes estructuras de datos: struct sockaddr { u_shortsa_family_; /*Familia*/ char sa_data[14]; /*Dirección*/ };

13. Sockets • Para utilizar sockets TCP/IP se debe emplear la familia o protocolo Internet, la cual define sus direcciones en <netinet/in.h> y son: struct in_addr { u_long s_addr; /*32 bits*/ };

14. Sockets struct sockaddr_in { short sin_familiy; /*AF_INET*/ u_short sin_port; /*16 bits*/ struct in_addr sin_addr; /*32 bits*/ char sin_zero[8]; /*8 bytes no usados*/ }; • También existen sockets para sistemas Unix de manera nativa llamados “Unix Domain”

15. Sockets • La biblioteca <sys/un.h> define la siguiente estructura: struct sockaddr_un { short sun_family; /*AF_UNIX*/ char sun_family; /*Ruta*/ }; • Los sockets se basan en la arquitectura cliente/servidor

16. Funciones de un servidor • Abrir el canal de comunicación e informar a la red su dirección y su disposición para aceptar peticiones de servicio. • Esperar a que un cliente pida un servicio • Atender un cliente (servidor interactivo) a la vez o crear un proceso hijo (servidor concurrente) • Volver al punto 2 para esperar nuevas peticiones.

17. Funciones de un cliente • Abrir el canal de comunicaciones y conectarse a la dirección del servidor. • Enviar al servidor un mensaje de petición de servicio y esperar hasta recibir la respuesta. • Cerrar el canal de comunicaciones y terminar la ejecución.

18. Primitivas de sockets en el servidor • Las primitivas son para comunicación orientada a conexión (Stream) socket(); bind(); listen(); accept(); read(); write();

19. Primitivas de sockets en el cliente • Las primitivas de sockets pueden ser bloqueantes y no bloqueantes socket(); connect(); write(); read(); close();

20. Diagrama de Sockets Stream

21. Primitivas de sockets en el servidor • Las primitivas son para comunicación entre procesos no orientada a conexión (Datagramas). socket(); bind(); recvfrom(); sendto();

22. Primitivas de sockets en el cliente socket(); bind(); sendto(); recvfrom(); shutdown(); Socket(int af, int type, int protocol) • Tipos: SOCK_STREAM, SOCK_DGRAM

23. Sockets bind(int sfd, const void *addr, int addrlen); listen(int sfd, int backlog); connect(int sfd, void *addr, int addrlen); Ns =accept(int sfd, void *addr, int *addrlen); Todas las funciones regresan -1 para error

24. Sockets Para establecer una comunicación a través de sockets se necesitan 5 requerimientos: Dirección del servidor Puerto del servidor Dirección del cliente Puerto del cliente Canal de comunicación abierto

25. Sockets Para leer datos de un socket se pueden utilizar las siguientes primitivas: read, readv, recv, recvfrom y recvmsg; siendo las más utilizadas read y recv(sfd, buf, len, flags). Para escribir datos en un socket se utilizan las siguientes primitivas: write, writev, send, sendto y sendmsg, siendo las más utilizadas write y send(sfd, buf, len, flags).

26. Sockets • Se necesitan funciones de conversión para poder homogenizar las diferencias existentes entre las diversas arquitecturas de cómputo. #include <arpa/inet.h> • inet_addr(char *) convierte una dirección IP en formato de cadena a su representación en bytes.

27. Sockets • char *inet_ntoa(struct in_addr) convierte una dirección IP a cadena. unsigned long htonl(unsigned long hostlong); unsigned short htons(unsigned short hshort); unsigned long ntohl(unsigned long netlong); unsgined long ntohs(unsigned short netsho); • h:host n:network l:long s:short

28. Servidor stream int sfd, nsfd, pid; struct sockaddr_in ser, cli; int tam_clie; if((sd = socket(AF_INET, SOCK_STREAM, 0)) == -1) /*Error al crear el socket*/ /*Dirección del servidor*/ ser.sin_family = AF_INET;

29. Servidor stream ser.sin_addr.s_addr = inet_addr( “148.208.209.25”); ser.sin_port = htons(24400); if(bind(sfd, &ser, sizeof(ser)) == -1) /*Error al publicar dirección*/ listen(sfd, 5);

30. Servidor stream for(;;){ /*Un servidor siempre está activo*/ tam_clie = sizeof(clie); if((nsfd = accept(sfd, &clie, &tam_clie)) == -1) /*Error al aceptar peticiones*/ if((pid = fork()) ==-1) /*Error al crear subproceso*/ else if(pid ==0) /*Hijo atiende peticiones*/ /*Código padre*/ close(sfd); }

31. Cliente stream int sfd; struct sockaddr_in ser; if((sfd = socket(AF_INET, SOCK_STREAM, 0)) ==-1) /*Error al crear el socket*/ /*Dirección del servidor*/ ser.sin_family = AF_INET;

32. Cliente stream ser.sin_addr.s_addr = inet_addr( “148.208.209.25”); ser.sin_port = htons(24400); if(connect(sfd, &ser, sizeof(ser)) ==-1) /*Error al conectar*/ send(); read(); …. close(sfd);

33. Servidor datagrama int sfd; struct sockaddr_in ser, clie; if((sfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) /*Error al crear socket datagrama*/ /*Dirección del servidor*/ ser.sin_family = AF_INET; ser.sin_port = htons(21100);

34. Servidor datagrama ser.sin_addr.s_addr = inet_addr( “142.208.209.25”); if(bind(sfd, &ser, sizeof(ser)) ==-1) /*Error al ligar el socket*/ recvfrom(); sendto(); close(sfd);

35. Cliente datagrama int sfd; struct sockaddr_in ser, clie; if((sfd = socket(AF_INET, SOCK_DGRAM, 0)) ==-1) /*Error al crear el socket*/ /*Dirección del servidor*/ ser.sin_family = AF_INET; ser.sin_port = htons(21100);

36. Cliente datagrama ser.sin_addr.s_addr = inet_addr( “148.208.209.25”); /*Dirección del cliente*/ cli.sin_family = AF_INET cli.sin_addr.s_addr = inet_addr(INADDR_ANY); cli.sin_port = htons(0);

37. Cliente datagrama if(bind(sfd, &cli, & sizeof(cli)) ==-1) /*Error*/ sento(); recvfrom(); … close(sfd); • Existen otras funciones auxiliares de socket: • gethostname(char *nombre, size_t tipo);

38. Otras funciones de sockets • shutdown(int sfd, int how) cierra la comunicación del socket. Los socket por naturaleza son bidireccionales. Si how es 0 se deshabilita la recepción de datos, si es 1 se deshabilita el envío y si es 2, se cierra todo (similar a close()). • Para utilizar nombres de dominio se utilizan: struct hosent *gethostent();

39. Otras funciones de sockets • struct hostent *gethostbyname(char *nom); • struct hostent *gethostbyaddr(const char *addr, int len, int type); • Para utilizar estas funciones se debe incluir la biblioteca: #include <netdb.h>

40. Otras funciones de sockets struct hostent{ char *h_name; char **h_aliasses; char h_addrtype; int h_length; char **h_addr_list; };

41. Otras funciones de sockets struct hostent *host; if((host = gethostbyname(argv[1])) ==-1) /*Error al resolver nombre a IP*/ ser.sin_familiy =AF_INET; ser.sin_addr.s_addr = *(long *) host-> h_addr_list; ser.sin_port = htons(1000);

42. Sockets • Algunas funciones trabajan en forma bloqueante como accept(), recv(), revfrom(), etc. Para cambiar el modo de trabajo se utiliza la función: int fcntl(int fd, int cmd, long arg) fd = socket(AF_INET, SOCKET_STREAM, 0); fcntl(fd, F_SETFL, O_NONBLOCK);

43. Sockets Java Java es un lenguaje multiplataforma que al igual que otros lenguajes de programación tiene APIs para la comunicación de procesos remotos. La ventaja de utilizar sockets en Java con respecto a su contraparte en C, radica en que Java enmascara la complejidad de los procesos en clases más simples.

44. Sockets Java • Para utilizar sockets y clases similares se necesita utilizar el paquete java.net.*; • Se pueden utilizar clases específicas para conectarse a servicios de red determinados como http, ftp, entre otros. //Servidor usando sockets stream ServerSocket ss = new ServerSocket(5000, 100);

45. Servidor Stream Socket con = ss.accept(); OutputStream sal = con.getOutputStream(); String s = new String(“ITMorelia\n”); for(int i=0; i < s.length(); i++) sal.write((int) s.charAt(i)); Conection.close();

46. Cliente stream Socket c = new Socket(InetAddress.getLocalHost(), 5000); InputStream entrada = c.getInputStream(); char c; while((c = (char) entrada.read()) != ‘\n’) System.out.println(String.valueOf(c));

47. Servidor datagramas try { DatagramSocket sS = new DatagramSocket(); DatagramSocket rS = new DatagramSocket( 5000); } catch(SocketException SE) { SE.printStackTrace(); System.exit(1); }

48. Servidor datagramas byte a = new byte [100]; DatagramPacket rP = new DatagramPacket( a, a.length); rS.receive(rP); System.out.println(“Dirección:” + rP.getAddress() + “ Puerto” + rP.getPort + “ longitud:” +rP.getLength());

49. Servidor datagramas byte d[] = rP.getData(); sP = new DatagramPacket(d, d.length, rP.getAddress(), 5001); sS.send(sendPacket); InetAddress comp = InetAddress.getByName(“www.itc.edu.mx”);

50. Sockets Java • Otras excepciones que se pueden capturar: • UnknownHostException • EOFException • ConnectException