Nominación

NOMINACIÓN

Es una correspondencia entre objetos de datos lógicos y físicos, es decir los usuarios tratan con objetos de datos lógicos representados por nombres de archivos, mientras que el sistema manipula bloques de datos físicos almacenados en las pistas de los discos.
Usar funciones o llamadas a los servicios de nombrado y ruta de archivos y directorios.

Ejemplo de un programa de nominación.

/* nombre.c */

# include <stdio.h>
#include <windows.h>


   char nombre [20]
   char apellidos [20]
   char nomarch [20]


FILE * datos
   int   i;

    void main ( )

    {
printf ("\n Da el nombre del archivo");
scanf ("%s",& nomarch);
   datos = fopen (nomarch,"w");
   for (i = 1; i < 6; i++)
      {

printf ("\n Da tu nombre");
scanf ("%s", & nombre);
printf ("\n Da tu apellido");
scanf ("%s", & apellido);
fprintf (datos,"%s%s", nombre, apellido);
i ++;
   }
fclose (datos);
}

Sincronización

SINCRONIZACIÓN

La sincronización de procesos en sistemas distribuidos es mas complicada que en entornos centralizados debido a que los procesos no comparten una memoria ni un reloj global comun. esto dificulta la forma de ordenar los cuentos que ocurren en un sistema y la resolicion de problemas de sincronizacion clasicos.

EVENTOS

Ordenacion de eventos en unsistema dostribuido.

*Precedencia

                                                evento 1 ------------------evento 2

                                                                  precedencia a

  

                                         

http://www.alegsa.com.ar/Dic/sincronizacion.php

RPC

RPC

Remote Procedure Call

Es un híbrido que usa el paso de mensajes y el envío de procedimientos externos o remotos.El tubo por donde viaja el mensaje se llama stub o asistente.

RPC es también un protocolo que permite a un programa de ordenador ejecutar código en otra maquina remota sin tener que preocuparse por las comunicaciones entre ambos.
es una interfaz, pues permite la comunicación entre 2 elementos y se llamara cliente-servidor.

Ejemplo Cliente en Base a RPCs (Stream): dirCliente.c


// Envia comandos al servidor para trabajar con archivos
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <sys/errno.h>
#include <netdb.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <rpc/rpc.h>  // RPCs
#include "dir.h" // estructura de los mensajes
direct *pR;
nReg *pNreg;
arrDatos *misDatos;
int i, cuantos=3;
main(int argc,char *argv[])
{
CLIENT *cl;    /* un handle del cliente */
char *valor;
int key=0;
if(argc>=3) key=atol(argv[2]);
if((key==1 && argc!=4) || ((key==2 || key==3) && argc!=3) 
|| key <=0 || (!isdigit(argv[2][0]))) {
printf("USO: %s nombreServidor Servicio [valorBuscado]\n",argv[0]);
printf("\t\tEJEMPLO: dirCliente neumann 1 Maria\n\t\tSERVICIOS\n");
printf("\t\t1. Acceder por Nombre\n");
printf("\t\t2. Acceder varios Registros\n");
printf("\t\t3. Acceder una Cadena de Longitud Variable\n");
exit(1);
}
/* argv[1]: maquina donde esta el servicio.  DIRPROG: Numero del Programa */
/*  DIRVERS: Version.     tcp: Protocolo     */
if (!(cl=clnt_create(argv[1], DIRPROG, DIRVERS, "tcp"))){
clnt_pcreateerror(argv[1]);  exit(1);
}

switch (key = atol(argv[2])) {
case BUSQ_NOMBRE:
pR = busq_nombre_2(&argv[3],cl);
printf("CLIENTE\nNombre\tapPaterno\tapMaterno\tExtensión\tMensaje\n");
printf("%s\t %s\t\t %s\t\t %d\t\t %s\n", pR->nombre,pR->apPaterno,pR->apMaterno,pR-
>extension,pR->mensaje);
break;
case DAME_CADENA:
cuantos=2;
misDatos= dame_cadena_2(&cuantos,cl);
printf("Caracteres Recibidos= %d\n",misDatos->arrDatos_len);
for (i=0; i < misDatos->arrDatos_len; i++)
printf("%c", misDatos->arrDatos_val[i]);
printf("\n");
break;
case BUSQ_VARIOS:
cuantos=3;
pNreg= busq_varios_2(&cuantos,cl);
if(pNreg==NULL) break;
printf("CLIENTE\nNombre\tapPaterno\tapMaterno\tExtensión\tMensaje\n");
for(i=0, pR=pNreg->regs.regs_val; i<pNreg->regs.regs_len;
i++, pR= pNreg->regs.regs_val+i)
printf("%s\t %s\t\t %s\t\t %d\t\t %s\n", pR->nombre,pR->apPaterno,pR-
>apMaterno,pR->extension,pR->mensaje);
printf(" %s MAS DATOS\n", pNreg->hayMas?"HAY":"NO HAY");
break;
default:
printf("CLIENTE: %s: Servicio Desconocido\n",argv[0]);
   }
}

COMUNICACIÓN GRUPAL

Es una técnica,interfaz,objeto o sistema de comunicación para sistemas distribuidos en una técnica de una a muchas bajo un sistema de ciente.servidor.
Este sistema permite el radiado de mensajes (multicast o broadcast).Se trata de una comunicación de 1 a muchos, en la que los procesos envían un mismo mensaje a un grupo de procesos.

TIPOS:

 1. Envió multicast, el emisor  envía un mensaje a un subconjunto de todos los procesos del grupo.

2. Broadcast, el mensaje se envía a todos los procesos.





http://www.alegsa.com.ar/Dic/rpc.php

Sockets

SOCKETS

Un socket (enchufe), es un método para la comunicación entre un programa del cliente y un programa del servidor en una red.Es también una dirección de Internet, combinando una dirección IP y un número de puerto.

TIPOS DE SOCKETS

1. Stream o de flijo: (SOCK_STREAM)

Con este tipo de socket la comunicación que existe es orientada a conexión, es decir, envía informacion si los datos llegaron desordenados o incompletos en un sistema cliente-servidor, similar al protocolo TCP por lo tanto es un intercambio de datos fiable.

2. Datagrama: (SOCK_DGRAM)

 Este tipo de socket pertenece a una comunicación orientada a no conexión y no se asegura su fiabilidad. 

*arquitectura del socket

EJEMPLO EN LENGUAJE C DE SOCKETS

/* Estos son los ficheros de cabecera usuales */
#include <stdio.h>          
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 3550 /* El puerto que será abierto */
#define BACKLOG 2 /* El número de conexiones permitidas */

main()
{

   int fd, fd2; /* los ficheros descriptores */

   struct sockaddr_in server; 
   /* para la información de la dirección del servidor */

   struct sockaddr_in client; 
   /* para la información de la dirección del cliente */

   int sin_size;

   /* A continuación la llamada a socket() */
   if ((fd=socket(AF_INET, SOCK_STREAM, 0)) == -1 ) {  
      printf("error en socket()\n");
      exit(-1);
   }

   server.sin_family = AF_INET;         

   server.sin_port = htons(PORT); 
   /* ¿Recuerdas a htons() de la sección "Conversiones"? =) */

   server.sin_addr.s_addr = INADDR_ANY; 
   /* INADDR_ANY coloca nuestra dirección IP automáticamente */

   bzero(&(server.sin_zero),8); 
   /* escribimos ceros en el reto de la estructura */


   /* A continuación la llamada a bind() */
   if(bind(fd,(struct sockaddr*)&server,
           sizeof(struct sockaddr))==-1) {
      printf("error en bind() \n");
      exit(-1);
   }     

   if(listen(fd,BACKLOG) == -1) {  /* llamada a listen() */
      printf("error en listen()\n");
      exit(-1);
   }

   while(1) {
      sin_size=sizeof(struct sockaddr_in);
      /* A continuación la llamada a accept() */
      if ((fd2 = accept(fd,(struct sockaddr *)&client,
                        &sin_size))==-1) {
         printf("error en accept()\n");
         exit(-1);
      }

      printf("Se obtuvo una conexión desde %s\n",
             inet_ntoa(client.sin_addr) ); 
      /* que mostrará la IP del cliente */

      send(fd2,"Bienvenido a mi servidor.\n",22,0); 
      /* que enviará el mensaje de bienvenida al cliente */

      close(fd2); /* cierra fd2 */
   }
}

http://www.areatecnologia.com/tipos-sockets.htm

UNIDAD 2. COMUNICACIÓN EN LOS SISTEMAS OPERATIVOS DISTRIBUIDOS

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

2.2 Sincronización
      2.2.1 Relojes físicos
      2.2.2 Relojes lógicos
      2.2.3 Uso de la sincronización (manejo de caché,comunicación en grupo, exclusión mutua e interbloqueo)

2.3 Nominación
      2.3.1 Características y estructuras
      2.3.2 Tipos de nombres (de usuario y sistema)
      2.3.3 Resolución y distribución
      2.3.4 Servidores y agentes de nombres
      2.3.5 Mapeo de direcciones
      2.3.6 Mapeo de rutas
      2.3.7 Modelo de Terry