P2P Los sistemas de archivos distribuidos están creciendo

P2P
Los sistemas de archivos distribuidos están creciendo de tal modo que están dejando a
los sistemas centralizados por debajo.
Estos sistemas de archivos distribuidos cuentan con una alta tolerancia a fallas,
escalabilidad, disponibilidad etc.
En una red P2P los usuarios comparten sus recursos entre los demás nodos, esto va
haciendo que una de sus principales características sea posible, es el caso de la
escalabilidad.
¿Por qué usas una arquitectura P2P para el diseño de un sistema de archivos?
Al hablar de una red P2P nos estamos refiriendo a sistemas y aplicaciones que utilizan
recursos distribuidos, cada uno de los nodos tiene la misma responsabilidad,
compartiendo los ciclos de su CPU.
De los principales objetivos de las P2P es la descentralización, conectividad ad-hoc,
reducir costos de propiedad y anonimato.
Simetría
Los sistemas P2P están caracterizados por la simetría entre los roles de cada uno de los
nodos participantes, esto supone una habilidad, de ser el cliente un servidor y viceversa.
Los sistemas convencionales son asimétricos.
Descentralización
Las redes P2P son descentralizadas por naturaleza, de aquí que los sistemas P2P tienen
mecanismos que soportan almacenamiento, procesando información compartida.
Los elementos del sistema y los nodos de almacenamiento no son manipulados por
alguna autoridad centralizada, he de suponerse que están propensos a fallar y ser
removidos del sistema en cualquier momento, por lo tanto el sistema debe de ser
robusto para subsistir y remover a los nodos que tienen errores en cualquier momento.
En un sistema totalmente descentralizado, como es el caso de una red P2P es que todos
los pares son iguales
Escalabilidad
Un beneficio de la descentralización es la escalabilidad, la cual está limitada por
factores tales como la cantidad de operaciones centralizadas, esto en las redes P2P,
cuantos más nodos estén conectados, mayores serán los recursos, el cual en el modelo
centralizado los recursos solo provenían del servidor.
Anonimato
Permite a los usuarios emplear un sistema sin preocuparse de cuestiones legales, o de
otro tipo.
Seguridad
Seguridad contra ataques, fallas del sistema, los P2P están diseñados de tal modo que
los host están distribuidos geográficamente, en cuanto a la seguridad de la información
se implementa: encriptación, gestión de derechos digitales, reputación e
interoperabilidad con cortafuegos.
Tolerancia a Fallos.
Una de nuestras principales y primordiales características es la tolerancia a fallos, en
los sistemas cliente-servidor suponen una pérdida total del sistema cuando el
servidor falla, algo que evidentemente no ocurre en P2P, es decir un objetivo
básico de diseño de una red P2P es que ésta no pierda su funcionalidad debido a
fallos asociados a desconexiones de nodos o a nodos no alcanzables, caídas de la
red y fallos de nodos.
Buscando un archivo en una red P2P.
Toda la información es identificada mediante una clave alfanumérica que especifica el
usuario que la almacena, no tiene por que tener una estructura en particular, pero
al ser usada por los nodos no solo para acceder a la información, sino también
para tener una indicación de dónde puede estar almacenado un dato en el caso de
no tener ninguna referencia directa a él, es aconsejable que se siga un orden
lógico.
Todos los datos como sus claves son almacenados en los nodos en forma de pila junto a
la dirección IP del servidor donde se ha obtenido dicho dato. Esta pila se
modifica cada vez que un usuario accede a algún bloque de información, en ese
momento el registro de dicho dato se coloca al frente de la pila. Para evitar que
el nodo se sature de información se limita el tamaño máximo de pila.
Cuando un usuario requiere una información y esa información está almacenada en el
nodo, éste se la sirve directamente y pone dicha información al frente de la pila.
Si la información no estuviera almacenada en el nodo, pero sí existiese la clave y
una IP de referencia, se pediría la información al nodo en cuestión y, tras servir
los datos al usuario, pondría al frente de la pila la clave, almacenando la
información. En el caso de que no se tuviera ni siquiera una referencia el nodo
buscaría la información en la referencia con la clave más cercana a la
proporcionada y, si se consigue la información, ésta pasaría al frente de la pila.
SOFTWARE TOLERANTE A FALLOS
Las técnicas del software tolerante a fallos se dividen en 2: uni-versión y multi-versión:
Uni-version.- considera estructura y acciones el programa, detección de errores,
manipulador de excepciones, control y reinicio, procesos pares y diversidad de archivos:
Estructura y acciones del software:
La arquitectura del software provee las bases para la implementación de la
tolerancia a fallas, aquí se trata de dividir el problema en pequeños módulos que sean
fácil de manipular.
Detección de errores.
Para una aplicación efectiva tolerante a fallos en uni-versión requiere que la estructura
de los módulos tenga 2 propiedades básicas: autoprotección y auto chequeo.
La autoprotección se refiere a la propiedad de cada compontenente de ser capaz de
protegerse a si mismo de contaminaciones externas basandose en la detección de errores
en la información obtenida
Autochequeo se refiere a que cada componente debe de ser capaz de detectar errores
eternos y tomar las acciones necesarias para prevenir la propagación de dichos errores
hacia otros componentes.
Manipulación de Excepciones.
Manipulación de excepciones es la interrupción de la operación normal para manipular
sucesos anormales, en el contexto de tolerancia a fallos, las excepciones son señaladas
mediante mecanismos de detección de errores.
Control y Reinicio
Existe otros tipos de errores, en este caso su forma de actuar es: aparecen, hacen el daño
y aparentemente desaparecen.
Así que consiste en detener uno o varios procesos, migrarlos a otro nodo y continuar
con el funcionamiento.
Procesos pares.
Consiste en realizar dos versiones idénticas del software siendo procesados en
procesadores diferentes, se utiliza el mecanismo de checkpoint and restart ( control y
reinicio). Se les asigna a los procesadores un nivel ya sea primario o secundario, el
primario esta procesando activamente la entrada y creando la salida mientras se genera
el control de la información para ser enviada al procesador secundario.
Siendo encontrado un error el procesador secundario carga el último control de la
información y este pasa a ser el procesador primario.
Técnicas de software multi-versión tolerante a fallos
Está basado en el uso de dos o más versiones o variantes de una parte del software,
ejecutándose cada una en paralelo. Las versiones son usadas como alternativas, en pares
o como grandes grupos.
MÓDULO PARA COMPARTIR ARCHIVOS CON RPC's DE LINUX
archivo.x
struct estructura{
char nombre[50];
int entra;
int aux;
int opcion;
};
struct archivo{
char datos[1024];
int tam;
};
program ADD_PROG{
version ADD_VERS{
estructura nombres(estructura) = 1;
archivo leer(estructura)=2;
} = 1;
} = 0x023451111;
archivo_client.c
/*
* This is sample code generated by rpcgen.
* These are only templates and you can use them
* as a guideline for developing your own functions.
*/
#include<stdio.h>
#include <dirent.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "com.h"
estructura
add_prog_1(char *host, estructura regreso1)
{
CLIENT *clnt;
estructura *result_1;
estructura nombres_1_arg;
archivo *result_2;
estructura leer_1_arg;
int fd_destino;
result_1=(estructura*)malloc(sizeof(estructura));
result_2=(archivo*)malloc(sizeof(archivo));
nombres_1_arg.aux= regreso1.aux;
strcpy(nombres_1_arg.nombre,regreso1.nombre);
#ifndef DEBUG
clnt = clnt_create (host, ADD_PROG, ADD_VERS, "udp");
if (clnt == NULL) {
clnt_pcreateerror (host);
exit (1);
}
#endif /* DEBUG */
switch(regreso1.opcion){
case 1:
result_1 = nombres_1(&nombres_1_arg, clnt);
if (result_1 == (estructura *) NULL) {
clnt_perror (clnt, "call failed");
}
return *result_1;
break;
case 2:
printf("estoy en la funcion del case 2\n");
strcpy(leer_1_arg.nombre,regreso1.nombre);
result_2 = leer_1(&leer_1_arg, clnt);
if (result_2 == (archivo *) NULL) {
clnt_perror (clnt, "call failed");
}
if((fd_destino=open(regreso1.nombre,O_WRONLY|O_TRUNC|O_CREAT,
0666))==-1)
{
printf("error");
exit(-1);
}
write(fd_destino, result_2->datos, result_2->tam);
close(fd_destino);
return *result_1;
break;
}
#ifndef DEBUG
clnt_destroy (clnt);
#endif /* DEBUG */
}
int
main (int argc, char *argv[])
{
char *host;
estructura regreso;
char nomArchi[50];
int i=0;
if (argc < 2) {
printf ("usage: %s server_host\n", argv[0]);
exit (1);
}
host = argv[1];
printf("\n*********Bienvenido************\n");
strcpy(regreso.nombre,"mandando");
regreso.aux=0;
regreso.opcion=1;
regreso=add_prog_1 (host, regreso);
for(i=0; i<regreso.entra;i++){
printf("\n%s",regreso.nombre);
regreso.aux=i;
regreso.opcion=1;
regreso=add_prog_1(host, regreso);
}
printf("\n hay %d archivos que compartir\n",regreso.entra);
printf("\n\nEscribe el nombre del archivo que quieras, con todo y su
extension\n\n");
gets(nomArchi);
printf("\n%s",nomArchi);
strcpy(regreso.nombre,nomArchi);
regreso.opcion=2;
regreso=add_prog_1(host, regreso);
exit (0);
}
archivo_server.c
#include<stdio.h>
#include <dirent.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "com.h"
estructura *
nombres_1_svc(estructura *argp, struct svc_req *rqstp)
{
static estructura result;
struct dirent **entradas= NULL;
int numeroEntradas;
int i,j;
printf("\nENTRE\n");
numeroEntradas = scandir ("./", &entradas, NULL, NULL);
result.entra=numeroEntradas;
printf("\naux=%d\n",argp->aux);
while(argp->aux<numeroEntradas)
{
printf("%s\n",entradas[argp->aux]->d_name);
strcpy(result.nombre,entradas[argp->aux]->d_name);
printf("Yo copie\t%s",result.nombre);
return &result;
}
}
archivo *
leer_1_svc(estructura *argp, struct svc_req *rqstp)
{
static archivo result;
result.datos[0]='\0';
struct dirent **entradas= NULL;
int numeroEntradas;
int i,j;
int fd_origen, fd_destino;
int nbytes, y=0;
char path[50]= "/home/victor/prurpc/";
strcat(path,argp->nombre);
printf("\n%s\n", argp->nombre);
if((fd_origen= open (path, O_RDONLY))==-1)
{
printf("ERROR*********");
exit(-1);
}
if((fd_destino=open(path,O_WRONLY|O_TRUNC|O_CREAT, 0666))==-1)
{
printf("error");
exit(-1);
}
while((nbytes=read(fd_origen, result.datos, sizeof result.datos))>0)
result.tam=nbytes;
printf("\n%Se copio el archivo");
close(fd_origen);
return &result;
}