Download V. Ingeniería del dominio. Análisis.

INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE CÓMPUTO
Trabajo Terminal
“Desarrollo de un Sistema de Archivos Distribuido
Orientado a Objetos”
Integrantes:
Carlos Artemio Paz Linares
Juárez Pérez Oscar
Galicia Duran Mario
dry_azor@hotmail.com
ojupez@hotmail.com
mgaliciad@prodigy.net.mx
Director:
Ricardo Felipe Díaz Santiago
53991861
53969820
56041915
Sistema de Archivos Orientado a Objetos
TT908
Índice.
I. Introducción. ................................................................................................................. 3
II. Estudio preliminar. ....................................................................................................... 4
2.1. Objeto de estudio. .................................................................................................. 4
2.1.1. Problema ......................................................................................................... 4
2.1.1.1. Definición del problema. ............................................................................. 4
2.1.1.2. Dificultades actuales en el objeto de estudio. .............................................. 4
2.1.1.3. Restricciones impuestas por el usuario. ....................................................... 4
2.1.2. Objetivo general. ............................................................................................ 4
2.2. Software propuesto. ............................................................................................... 4
2.2.1. Controles necesarios para garantizar la confiabilidad del sistema. ................ 5
2.2.2. Ambiente de software y hardware. ................................................................. 5
III. Metodología. ............................................................................................................... 7
3.1. Definición y justificación de la metodología. ........................................................ 7
IV. Ingeniería del dominio................................................................................................ 8
4.1. Estado del arte. ...................................................................................................... 8
4.2. CODA File System. ............................................................................................... 9
4.3. Distributed File System. ...................................................................................... 10
4.4. Network File System. .......................................................................................... 11
4.5. Componentes reutilizables................................................................................... 11
V. Ingeniería del dominio. Análisis. ............................................................................... 13
5.1. Responsabilidades del sistema............................................................................. 13
5.1.1. Requisitos del sistema. ................................................................................. 13
5.1.2. Metas del diseño ........................................................................................... 14
5.2. Casos de uso. ....................................................................................................... 14
5.2.1 Definición de escenarios. ............................................................................... 14
5.2.2 Diagrama de Casos de Uso. ........................................................................... 15
5.3. Definición de componentes. ................................................................................ 16
5.4. Definición de clases. ............................................................................................ 16
5.4.1. Nivel de aplicación. ...................................................................................... 16
5.4.2. Nivel de comunicación distribuida. .............................................................. 18
5.4.3. Manejo local de archivos. ............................................................................. 21
5.5. Definición de asociaciones. ................................................................................. 24
5.5.1. Diagrama de objetos. .................................................................................... 24
VI. Ingeniería del dominio. Diseño. ............................................................................... 25
6.1 Arquitectura del sistema. ...................................................................................... 25
6.1.1. Modelo de capas. .......................................................................................... 25
6.2. Diseño funcional. ................................................................................................. 25
6.3. Diseño del comportamiento. ................................................................................ 26
6.3.1. Diagramas de secuencia. Global. .................................................................. 26
6.3.2. Diagramas de secuencia. Aplicación. ........................................................... 28
6.3.3. Diagramas de secuencia. Sistema distribuido............................................... 30
6.3.4. Diagramas de secuencia. Manejador local de archivos. ............................... 33
VII. Trabajos futuros. ..................................................................................................... 36
7.1. Puntos deseables a implementar. ......................................................................... 36
VIII. Referencias. ........................................................................................................... 37
8.1.1. Bibliográficas. .............................................................................................. 37
8.1.2. Electrónicas. ................................................................................................. 37
-2-
Sistema de Archivos Orientado a Objetos
TT908
I. Introducción.
En el ámbito del multiprocesamiento se encuentran los sistemas fuertemente acoplados
(una maquina con múltiples procesadores) y débilmente acoplados (varias entidades y
cada una con su procesador).
Los sistemas débilmente acoplados se comunican por medio de una red, estos sistemas
idealmente deberían estar soportados por un Sistema Operativo Distribuido para poder
ofrecer procesamiento paralelo y otro conjunto de servicios como es la compartición de
recursos.
Un Sistema Operativo Distribuido esta compuesto por distintos módulos, y uno de los
más importantes es el Sistema de Archivos el cual se encarga de darle transparencia de
ubicación al usuario en cuanto a recursos de almacenamiento secundario se refiere. El
sistema de archivos de uno de estos sistemas también le ofrece ventajas a un
programador, la más importante es la transparencia para el desarrollo de aplicaciones
que necesiten del uso de archivos en una ubicación remota.
Este documento aborda el proceso formal para el desarrollo de un Sistema de Archivos
Distribuido a través de un paradigma Orientado a Objetos.
-3-
Sistema de Archivos Orientado a Objetos
TT908
II. Estudio preliminar.
2.1. Objeto de estudio.
El objeto de estudio son los sistemas de archivos distribuidos.
2.1.1. Problema
2.1.1.1. Definición del problema.
El problema que atacaremos es la necesidad de compartir archivos dentro de una red.
2.1.1.2. Dificultades actuales en el objeto de estudio.
El desarrollo de un sistema de archivos local implica un gran trabajo para el control de
bloques y del manejo de los mapas de archivos. Generar una estructura de bloques que a
su vez controlen un árbol de listas con la información y datos de los archivos involucra
la implementación de algoritmos de estructuras de datos eficientes con bajas
probabilidades de fallos.
Además de la lógica para el manejo del almacenamiento físico de los archivos
usualmente es un problema que implica programación de bajo nivel.
Remotamente y tomando en cuenta el uso de una red de comunicación, se presenta el
problema de la sincronización y el control de peticiones.
2.1.1.3. Restricciones impuestas por el usuario.
En el caso de este sistema las restricciones que podría imponer un usuario se limitan al
control de acceso, es decir, manejar una serie de permisos que él mismo establezca a
cada archivo.
Por otra parte más que atender a un usuario, este sistema proporciona un servicio al
Sistema Operativo LINUX. Dado lo anterior podemos considerar a Linux como nuestro
usuario, requiere la programación en C++ para tener una comunicación directa con el
Kernel.
2.1.2. Objetivo general.
Desarrollar un Sistema de Archivos Distribuidos Orientado a Objetos que cumpla con
funciones básicas como lectura, escritura y apertura de archivos, el cual permita en un
futuro integrar más servicios de los que será capaz de ofrecer al finalizar en este
proyecto.
2.2. Software propuesto.
SADOO es el nombre de nuestro Sistema de Archivos Distribuido sobre LINUX,
construido con programación orientada a objetos en C++ y utilizando la especificación
de CORBA para la reutilización de componentes de comunicación entre entidades.
El sistema denomina como “servicio” al hecho de que uno o varios archivos (como uno
o varios) sean vistos como un objeto que contiene atributos como: fecha de
modificación, usuario propietarios, tamaño e identificador global. Estos servicios serán
-4-
Sistema de Archivos Orientado a Objetos
TT908
manipulados por el SADOO en el momento en que un usuario desee disponer de él sin
importar en que equipo o entidad se encuentre, siempre y cuando este disponible.
2.2.1. Controles necesarios para garantizar la confiabilidad del
sistema.
- Servidor distribuido de hora global mediante algoritmos de sincronización.
- Servidor de nombres para el manejo de servicios.
- Manejo de marcas de tiempo para la duplicación de servicios (servicio de
nombres).
- Bloqueo de servicios al realizar cualquier clase de operación sobre alguno de los
archivos.
- Notificación de cambios en cualquier servicio.
- Implementación de un esquema de carga/descarga.
- Uso del middleware Corba Orbit para garantizar una completa y fiable
implementación de la comunicación en red.
- Indexación de archivos tanto local como globalmente.
- La autenticación del usuario se realiza mediante procesos nativos de LINUX.
2.2.2. Ambiente de software y hardware.
Maquina objetivo.
Los requerimientos mínimos de nuestro sistema son:
- Procesador Pentium II o superior (o equivalente).
- 128 Mb de memoria RAM.
- Espacio en disco duro requerido por la distribución de LINUX.
NOTA: en cualquier otra versión de LINUX con un hardware distinto al x86, puede
existir la posibilidad de que funcione gracias a la portabilidad de C++ a nivel código
fuente.
Sistema operativo.
Será necesario disponer de un sistema operativo LINUX con un Kernel versión 2.5.x o
superior, y un servidor de ventanas Xwindow sobre el cual se administre con un gestor
como KDE 2.x o Gnome 2.x.
Entorno de desarrollo.
Sparxs System, Enterprise Architect 5
Herramienta CASE para la generación de diagramas y documentos en alguna de las
fases del desarrollo.
OpenOffice 1.0(Linux) ó Microsoft Word XP(Windows)
Procesador de texto para la generación de documentos.
GNU gcc-3.4.3
Conjunto de compiladores para C++.
Make
Utilidad para ejecución y compilación de proyectos.
-5-
Sistema de Archivos Orientado a Objetos
TT908
Gtk2
API para la creación de interfaces graficas.
Corba Orbit.
Object Device Broker, middleware para soportar el sistema distribuido.
-6-
Sistema de Archivos Orientado a Objetos
TT908
III. Metodología.
3.1. Definición y justificación de la metodología.
Desarrollo Basado en Componentes.
Esta metodología está orientada a objetos y contempla la reutilización de componentes
(clases orientadas a objetos). Otra de las ventajas de esta metodología es el hecho de ser
evolutiva, es decir nos permite realizar múltiples versiones del software, implementando
en cada una de ellas nuevas funcionalidades así como corregir errores.
Esta metodología, al igual que la mayoría de las metodologías para desarrollo de
software, está propuesta para trabajar con un cliente. En nuestro caso al no contar con
un cliente, las fases propuestas para la comunicación con el cliente serán sustituidas por
investigación, para determinar los requerimientos que debe cubrir nuestro sistema.
En cuanto a la utilización de múltiples ciclos para la creación de varias versiones, solo
podremos utilizar una iteración del modelo, debido a la complejidad del proyecto así
como por el corto tiempo para realizar este trabajo.
Esta metodología analiza un sistema desde dos actividades principales:
Ingeniería del dominio:
En principio nos recomienda analizar sistemas muy similares para obtener los
componentes o módulos que puedan ser reutilizados. Esencialmente es documentar el
estado del arte para localizar componentes o módulos que puedan ser reutilizados y
posiblemente implementados para nuestro sistema. La mayoría de nuestros módulos
fueron obtenidos a partir de un análisis del CODA, NFS, AFS y DFS.
Desarrollo basado en componentes:
Esta actividad incluye la fase de análisis y diseño. Nos recomienda identificar
los componentes candidatos a reutilizar para ser adaptados a nuestro sistema así como el
diseño de nuevos módulos. De esta manera muchos de los componentes de más bajo
nivel serán reutilizados gracias al uso de CORBA (para la comunicación en red).
Las actividades que se realizarán se dividirán en las siguientes regiones de tareas:
-7-
Sistema de Archivos Orientado a Objetos
TT908
IV. Ingeniería del dominio.
4.1. Estado del arte.
Sistemas de Archivos Distribuidos
Estos Sistemas de Archivos se pueden ver como parte de un Sistema Operativo
Realmente Distribuido. En la actualidad este concepto se utiliza principalmente fuera de
los antes mencionados Sistemas Operativos, y más bien están diseñados, la mayoría de
ellos, para trabajar dentro de un Sistema Operativo de Red, conviviendo con el Sistema
de Archivos propio del Sistema Operativo.
Ofrecen dos servicios básicos, de directorios y de archivos. El primero sirve para crea o
eliminar directorios así como renombrar, cambiar o mover un archivo, el segundo
permite crear o eliminar directorios así como sus atributos.
Estos sistemas los podemos considerar no solo proyectos, sino que ya son la mayoría de
ellos productos de software terminados.
De los principales Sistemas de Archivos destacan:
AFS. Este sistema propone un concepto llamado “celda” (cell), la cual es considerada
como un espacio independiente de espacio de archivos. Estas celdas se conectan para
formar un gran Sistema de Archivos de UNIX.
RFS (1986). Este Sistema de Archivos ofrece acceso a cualquier tipo de archivo
incluyendo dispositivos especiales, así como “Names Pipes”. También permite el
bloqueo de archivos remotos. La meta principal de RFS es proporcionar tanto a usuarios
como a aplicaciones un verdadero acceso a archivos remotos.
DFS (1980). Este sistema proporciona al usuario la posibilidad de acceder a un archivo
solo con el nombre de este, sin necesidad de conocer la ubicación física.
CODA (1990). Coda es surge a partir de AFS, con mejoras en lo que se refiere a las
fallas de los servidores. Coda ofrece una disponibilidad constante de la información,
permitiendo que el sistema siga funcionando sin importar donde se genere una falla.
Otra de sus funcionalidades, es el hecho de dar acceso a todos los recursos locales, a
pesar que estos sean parcial o totalmente inaccesibles
NFS. Este sistema de archivos fue creado inicialmente para ser soportado bajo UNIX,
pero actualmente puede soportar sistemas heterogéneos. Este Sistema de Archivos es
soportado tanto en redes de área local como en redes de área amplia. Utiliza la
arquitectura Cliente – Servidor, y cada estación es tanto cliente como servidor para
poder compartir archivos.
Muchos de estos sistemas de archivos están basan su funcionamiento en una capa de
abstracta que permite la comunicación entre estos sistemas y el kernel, es el Virtual
File-System, el cual se distribuye en Linux/Unix y esta descrito en el kernel de Linux
2.3.29
-8-
Sistema de Archivos Orientado a Objetos
TT908
4.2. CODA File System.
Sistema de archivos distribuido desarrollado por M. Satyanarayanan en la Universidad
de Carnegie Mellon. Y basado en el Adrew File System.
Características:
- Ancho de banda adaptable
- Reintegración de datos de clientes desconectados.
- Replicación de servidores de escritura/lectura
- Resolución de errores entre servidores.
- Cache de los archivos y directorios en el cliente.
Funciona bajo una arquitectura cliente/servidor mediante Sun RPC2. Trabaja sobre
Linux y se monta bajo el sistema de archivos “Coda” en /coda. Cuando se hace la
petición de algún servicio el cliente hace una llamada al VFS para saber si se encuentra
en el mismo sistema, de no ser así, recurre al uso del proceso Venus (parte de el cliente
de Coda), el cual lleva una lista y un cache de la mayoría de las respuestas a peticiones
mas comunes y verifica si se encuentran o no localmente (Venus lleva un archivo
temporal con los servicios o archivos mas comúnmente utilizados). De no existir alguno
de los archivos del cache, envía la petición al sistema Vice (parte del servidor de Coda)
mediante RPC2.
Todas las acciones de cortar, pegar, copiar, modificar, etc. Son propagadas hacia todos
los servidores mediante notificaciones de los clientes.
Servidores y servidor de replicas.
La estructura de archivos de Coda se encuentra en particionada en volúmenes que son
más pequeños que un sistema de archivos tradicional pero más grande que un simple
directorio, es una unidad lógica de archivos, en el cual se lleva una estructura similar a
la de un árbol.
Los volúmenes se encuentran en particiones RAW. El acceso a los archivos se hace a
través de una bitácora en una memoria virtual recuperable, denominada RVM, que
permite el acceso rápido y confiable.
Coda identifica a los archivos con un entero de 32-bits llamado Fid: consiste de un
VolumeId, VnodeId y un identificador. El VolumeId indica el volumen en el cual se
encuentra el archivo, VnodeId es el numero Inode del archivo y el identificador se
utiliza para la resolución del archivo. El Fid es único en el arreglo de clusters de Coda.
Los servidores de replicación de archivos otorgan permisos de lectura/escritura y se
encargan de enviar datos a los clientes así como las actualizaciones y modificaciones a
los demás servidores. Los volúmenes son guardados en un grupo de servidores llamados
VSG, estos servidores mantiene una replica de los volúmenes.
Cuando Venus necesita acceder a un archivo, primero necesita encontrar el VolumenId
que contiene el archivo. Esta información es una lista Id de servidores y del volumen
local de cada servidor.
-9-
Sistema de Archivos Orientado a Objetos
TT908
4.3. Distributed File System.
Un recurso compartido de DFS utiliza una estructura de árbol. Para crear un recurso
compartido DFS, primero debe crear una raíz DFS. La raíz en si es un recurso
compartido que se encuentra en lo más alto del árbol DFS y que sirve de punto de inicio
para alojar:
-
Carpetas compartidas.
Vínculos a recursos compartidos, que se trata de una referencia a una carpeta
compartida SMB, NetWare, NFS, NCP u otra raíz DFS. Se componen de una
etiqueta, que es el nombre visible en el árbol DFS y la referencia al recurso de
red vinculado.
Dentro de un árbol DFS, el administrador organiza los recursos compartidos, vínculos a
recursos compartidos en los distintos servidores y vínculos a vínculos en otros árboles
DFS. Por tanto, podemos crear estructuras más complejas que nos permiten organizar
todos nuestros recursos en un mismo espacio de nombres uniforme, independizando la
forma de acceder a los recursos de la forma en que hemos distribuido estos entre los
servidores.
Toda la información de recursos definida a partir de la raíz de un sistema DFS comparte
el espacio de nombres DFS, que es lo que verán los usuarios. Este espacio de nombres
tiene una limitación en el tamaño de ruta hacia cualquier archivo en 260 caracteres y
otra en el número máximo de carpetas compartidas y vínculos DFS que se pueden crear
por raíz, que es de 1000.
Cuando el árbol DFS es de dominio, puede tener varias replicas de la raíz, aunque en un
servidor solo puede haber una replica de la misma raíz. Windows 2000 acepta hasta 256
miembros de una replica del árbol DFS. El conjunto de raíces del árbol DFS contienen
la misma información, pero dotan al sistema de tolerancia a fallos y de reparto de carga
equilibrado entre los servidores integrantes. Toda la información de la topología se
almacena en el directorio y los mecanismos de replicación de este se encargan de
mantener replicada la topología en todos los servidores raíz de DFS.
Los cambios en la topología son visibles en el momento de aplicar sin necesidad de
detener el servicio.
El acceso a los servicios del DFS se hace mediante un espacio de nombres, definido
por: \\servidor\recurso. Este recurso es compartido como en cualquier equipo con
Windows y un servidor de nombres se encarga de asociar un nombre a este recurso. Con
información de ubicación e IP el sistema puede localizar fácilmente un servicio y,
además, el sistema operativo se encarga del manejo de réplicas y el acceso se realizará a
la réplica más accesible.
La réplica de la topología se realiza cada cierto tiempo en cada uno de los equipos
manteniendo cada equipo una replica constante de los archivos. La réplica de los
contenidos se puede o no realizar de forma automática, incluso da la posibilidad de
hacerlo manualmente.
- 10 -
Sistema de Archivos Orientado a Objetos
TT908
4.4. Network File System.
Sistema de archivos de red desarrollado por Sun Microsystems teniendo como meta la
independencia del sistema operativo. Proporciona acceso transparente a los archivos
mediante cliente ejecutándose sobre Unix.
La comunicación se realiza mediante RPC y utilizando “credenciales” para validación
del usuario.
Se integra mediante VFS para que el núcleo realice una diferencia entre archivos locales
y remotos. Ademas integra un volumen montable virtual (filesystem volumen) que se
genera cuando NFS lo monta y es único en la red, esto permite que cuando se haga una
llamada a un archivo que contenga una descripción de vnodo (una descripción completa
del árbol de archivos y directorios) remota, implica que el inodo del archivo es remoto y
no se encuentra localmente.
A pesar de tener un punto único de fallos, con los servidores de NFS, realiza un manejo
eficaz de esta falla ya que, al caerse el cliente se mantiene en espera de que el servidor
sea levantado nuevamente, continuando su operación desde el momento en que se
bloqueo.
Nos soporta replicación, solo de bases de datos y/o archivos pequeños en los servidores.
4.5. Componentes reutilizables.
Analizar sistemas muy similares es una de las actividades de la Metodología orientada a
componentes. Definir componentes comunes que puedan ser utilizados en nuestro
sistema es la siguiente actividad.
Espacio de Nombres.
Esta parte permite asignar un nombre que debe ser global en cualquier clase de sistema
distribuido. En nuestro caso los archivos deben ser nombrados de una forma específica
para su localización.
Manejo local de archivos.
Realiza una búsqueda local y “publica” los archivos locales en el Sistema Distribuido.
Servidores de búsqueda.
Módulos que realizan peticiones para obtener información acerca de un archivo o
incluso de localizar servicios y darlos de alta localmente.
Clientes.
Realizan la petición directa de algún servicio como tal. Estas peticiones son distintas a
las realizadas como cliente/servidor y se atienden por algún otro proceso que regresa el
servicio o la denegación del mismo.
Transparencia de localización.
Este modulo es muy curiosos ya que “engaña” al Kernel al mostrarle archivos que
realmente no existen.
- 11 -
Sistema de Archivos Orientado a Objetos
TT908
Replica de archivos.
Mediante algoritmos y el uso de una cache, realizan copias de archivos para hacerlo
tolerante a fallas.
- 12 -
Sistema de Archivos Orientado a Objetos
TT908
V. Ingeniería del dominio. Análisis.
5.1. Responsabilidades del sistema.






Capacidad de ser montado por el sistema operativo (LINUX) y ser manejado por
este como cualquier otro.
Facilitar las primitivas mínimas necesarias para la manipulación de archivos
(para usuarios, sistema operativo y programadores)
La comunicación de los objetos distribuidos se hará mediante mensajes (para
estos mensajes se especificará un protocolo propietario).
Proporcionar un servicio de nombres que contendrá la información de los nodos
activos así como su ubicación (dirección IP).
Construir una jerarquía de tablas de archivos mediante un servicio de
indexación. Esto proveerá la transparencia de ubicación.
Generar automáticamente una carpeta a cada usuario, esta carpeta contendrá
todos los archivos creados por este sin importar en que nodo del sistema en que
reside.
5.1.1. Requisitos del sistema.




Transparencia en la ubicación. Este requisito se refiere a ocultar la localización
física de un archivo.
Tolerancia a Fallas. El sistema debe ser capaz de reponerse a fallas en la
comunicación de red, de existir fallas a nivel de software rehabilitara los
servicios de archivos (siempre y cuando no muera el proceso principal del
sistema), y en cuanto a fallas a hardware solo rehabilitará el servicio de
nombres.
Consistencia. El sistema deberá restringir el uso de un archivo a un solo usuario
a la vez.
Seguridad. El sistema debe ser capaz identificar al usuario del sistema operativo
y restringirle el uso de los archivos conforme a los permisos otorgados para el
uso de los mismos (lectura, escritura).
Las aplicaciones que hacen uso de un sistema de archivos se comunican con este
mediante llamadas al sistema operativo, este a su vez se comunica con el sistema de
archivos. De lo anterior se puede concluir que nuestro sistema tendrá la posibilidad de
atender a las operaciones open, close, write, read, stat y unlink que ofrece Linux para
manejo de archivos. La Tabla 5.1.1.a presenta las operaciones que ofrece Linux.
Operación
desarchivo = open (nombre, modo)
Desarchivo = creat (nombre, modo)
Estado = close (desarchivo)
Recuento = read (desarchivo, búfer, n)
Recuento = write (desarchivo, búfer, n)
Pos = Iseek (desarchivo, despl., desde)
Descripción
Abre un archivo existente con un nombre
determinado.
Crea un archivo nuevo con un nombre
determinado.
Cierra el archivo abierto desarchivo.
Transfiere n bytes del archivo referenciado
por desarchivo sobre búfer.
Transfiere n bytes al archivo referenciado
por desarchivo desde búfer.
Desplaza el puntero de lectura – escritura
hasta despl..
- 13 -
Sistema de Archivos Orientado a Objetos
TT908
Estado = unlink (nombre)
Elimina el nombre de archivo de la
estructura de directorios. Y si el archivo no
tuviera otros nombres también es eliminado.
Añade un nuevo nombre a un archivo.
Obtiene los atributos del archivo nombre
sobre búfer.
Estado = link (nombre1, nombre2)
Estado = stat (nombre, búfer)
Tabla 5.1.1.a
5.1.2. Metas del diseño
Comunicación
Para la comunicación en red se utilizará, como ya se mencionó, ORBIT. Esta
herramienta utiliza como protocolo de transporte TCP, lo cual significa que se manejará
una comunicación sincronía. El uso de este protocolo nos garantiza una comunicación
segura en una red de área amplia (WAN).
Forma de nombrar
Para la ubicación física de los archivos se utilizará el siguiente formato:
a:ruta/fisica/del/archivo
De dónde a es el nombre de la máquina en la cual se encuentra el archivo requerido,
mientras que la ruta es la localización del archivo en la máquina a.
Estructura del software
La estructura de este Software pretende agregar tres capas por debajo de las
aplicaciones que corren sobre Linux y hace uso de los sistemas de archivos montados
sobre este Sistema Operativo.
Asignación del trabajo
El trabajo se asignará de igual forma a todos los nodos del sistema, es decir, todos
tendrán disponible un Servicio de Archivos, y de igual forma todos estarán habilitados
para acceder a estos servicios.
Mantenimiento de la consistencia
Para ofrecer consistencia de actualizaciones se va a restringir el uso de un archivo a un
único usuario a la vez, es decir, no ofreceremos actualizaciones concurrentes.
Desempeño
Para garantizar un buen desempeño se mantendrá un servidor de nombres que resolverá
la ubicación de los recursos, así como una tabla con los últimos servicios solicitados en
cada nodo.
Otro aspecto con el que se pretende ofrecer un mayor desempeño es implementando el
modelo carga y descarga, el cual evitará que exista excesivo tráfico en la red.
5.2. Casos de uso.
5.2.1 Definición de escenarios.
La necesidad de intercambiar información en una organización es muy importante y
más aun cuando está es vital.
- 14 -
Sistema de Archivos Orientado a Objetos
TT908
En una empresa existen muchos usuarios que no poseen los conocimientos para el uso
de un equipo de cómputo. Es molesto para estos usuarios utilizar alguna aplicación
externa con la cual compartan información (como el correo electrónico) o que incluso
cuando escuchan el concepto de red se comporten renuentes a aceptar este concepto y lo
consideren complicado.
En una universidad existe una amplia variedad de usuarios que pueden ser usuarios
expertos o inexpertos que intercambian archivos mediante redes de computo o correo
electrónico sin problema alguno pero mucho tiene la inquietud de realizar esto de una
manera mas simple y tomando la idea de que exista un repositorio de datos común
independientemente de su ubicación.
Un profesor proporciona material a sus alumnos proporcionando como ubicación una
carpeta de datos o simplemente un archivo que, sin importar en que equipo lo busque el
alumno, lo encuentre sin problema alguno (muy similar a utilizar una página de
Internet).
Estos son solo algunos escenarios en los cuales pueda ser necesitado el SADOO pero en
todos existe algo en común: información que puede ser obtenida sin importar en donde
esté. Esto no solo implica visualizar información también realizar cambios, eliminar e
incluso moverla a algún otro lugar del mismo equipo o del Sistema de Archivos
Distribuido.
5.2.2 Diagrama de Casos de Uso.
Tomando como base los escenarios se identificó cuales son los casos de uso que tendrá
el SADOO, esto es, definir las operaciones básicas que un usuario desearía tener o,
desde un punto de vista técnico, las primitivas mínimas necesarias que requiera una
aplicación para manipular archivos.
ud Escenario
Genera Tabla de
resultados
«extend»
Registra archiv os
globalmente
Nav ega
Tabla
«use»
«use»
Bloquear
Archiv o
Mov er a
entidad
peticionaria
Inicia sistema
«use»
Borrar copia
Usuario
«use»
«use»
Leer
Operacion con
archiv o
«include»
«include»
«include»
Indexacion de
archiv o
«use»
Crear
Eliminar
«include»
Escribir
«use»
Cambio de
nombre global
5.2.2.a Casos de uso
- 15 -
Sistema de Archivos Orientado a Objetos
TT908
5.3. Definición de componentes.
Previamente se realizo un análisis de los componentes de los cuales hacen uso sistemas
con una funcionalidad similar. Elegir los componentes útiles para el SADOO son los
siguientes:
Espacio de Nombres.
Permitirá nombrar globalmente los archivos y asignarles un identificador único.
Manejo local de archivos.
El manejo de archivos se debe hacer respaldándose con algún medio de almacenamiento
local, en algunos sistemas redefinen las llamadas a sistema del sistema operativo o
utilizan una clase de buscador de archivos sobre el sistema local.
Servidores de búsqueda.
A partir de la idea de NFS y CODA se elegirá una entidad como servidor de nombres y
un espejo del mismo. Esta configuración es la más óptima ya que no satura la red con
broadcast de entidades que se agreguen al SADOO.
Clientes.
Estos clientes realizarán peticiones directas a los servidores de nombres para localizar
servicios.
5.4. Definición de clases.
5.4.1. Nivel de aplicación.
Objetos que actúan como una interfaz entre las aplicaciones y los archivos. También se
define un objeto como interfaz de usuario, que en realidad es una aplicación sencilla que
hace uso del SADOO.
InterfazUsuario
Aplicación sencilla que hace uso del SADOO.
cd CapaAplicacion
InterfazUsuario
-
componentesGraficos: gtkGraf[]
+
+
+
+
creaComponentes() : bool
bandejaSistema() : bool
ubicarComponentes() : bool
asociarEventos() : bool
5.4.1.a Clases de aplicación. Interfaz Usuario
Atributos:
Nombre
Descripción
componetesGraficos Arreglo de objetos gráficos (botones, campos de textos,
etiquetas, etc.).
Métodos
Nombre
Bool
Descripción
Instancia cada uno de los componentes gráficos del arreglo.
- 16 -
Sistema de Archivos Orientado a Objetos
creaComponentes(void)
Bool
bandejaSistema(void)
Bool
ubicarComponentes(void)
Bool
asociarEventos(void)
TT908
Crea un controla una objeto grafico en la bandeja del sistema.
Coloca en una región de la ventana cada uno de los
componentes gráficos.
Conecta un objeto grafico con algún evento específico.
ServiciosAplicacion
Interfase entre las aplicaciones y el SADOO que permite notificar la notificación de
archivos, provee llamadas a sistema básicas y la comunicación con capas inferiores.
cd Capa de aplicacion
Serv iciosAplicacion
-
listaArchivos: Tabla
tiposArchivos: TipoArchivos
+
+
+
+
noitificaLiberacion() : bool
peticionInfoArchivo() : bool[]
peticionTabla() : TablaResultados
filtraTabla() : char[]
5.4.1.b Clases de aplicación. ServiciosAplicacin
Atributos:
Nombre
listaArchivos
tiposArchivos
Descripción
Tabla que contiene una lista de archivos.
Listado de extensiones de archivos.
Métodos
Nombre
Bool
notificaLiberación(void)
Bool
peticionInfoArchivo(void)
TablaResultados
peticionTabla(void)
char filtraTabla(void)
Descripción
Envía la señal de cerrado o de que un objeto ya no va a ser
utilizado para eliminar el bloqueo.
Pide datos del archivo como permisos o tamaño.
Obtiene la lista de archivos del directorio actual
Filtra los datos de la tabla recibida por el metodo
peticionTabla(), eso es, filtra por letra o tamaño los
resultados.
TipoArchivos.
Verifica el tipo de archivo que desea el usuario abrir así como su aplicación asociada.
cd CapaAplicacion
TipoArchiv os
-
listaAplicaciones: char
listaExtenciones: char
+
+
+
agregaAsosiacion() : bool
cambiaAsosiacion() : bool
obtenerListaAplicaciones() : char
5.4.1.c Clases de aplicación. TipoArchivos
- 17 -
Sistema de Archivos Orientado a Objetos
Atributos:
Nombre
listaAplicaciones
tlistaExtenciones
TT908
Descripción
Contiene un listado de aplicaciones de Unix.
Listado de extensiones de archivo soportadas por las
aplicaciones.
Métodos
Nombre
Bool agregaAsosiacion(void)
Descripción
Cuando un tipo de archivo no se reconoce se busca y
asocia una aplicación a este.
Modifica la aplicación asociada a un archivo.
Bool cambiaAsosiacion(void)
Consulta una base de datos de aplicaciones y tipos de
Bool
obtenerListaAplicaciones(void) archivos soportados.
5.4.2. Nivel de comunicación distribuida.
NodoSD
La función principal de esta clase es comunicarse con las demás capas del sistema. Es
decir, este objeto será el punto de acceso a la capa.
cd Clases capa SD
NodoSD
-
nombre: char*
servicioArchivos: Servicio
dirSvrNom1: char*
dirSvrNom2: char*
usuario: char*
+
+
tabla(char*) : TablaResultados
opArchivo(char, int) : ArchivoSD
5.4.2.a Clases de comunicación distribuida. NodoSD.
Atributos:
Nombre
Nombre
servicioArchivos
dirSvrNom1
dirSvrNom2
Usuario
Descripción
Es una cadena que contiene el identificador del nodo en el sistema.
Es una referencia al servicio de archivos del nodo.
Es una cadena que contiene la dirección IP del servidor de nombres
principal.
Cadena que contiene la dirección IP del servidor de nombres de
respaldo.
Cadena que guarda el nombre del usuario de LINUX que esta
haciendo uso del sistema.
Métodos
Nombre
TablaResultados
tabla(char *ruta)
opArchivo(char
*nombreArchivo,int
tipo)
Descripción
Método que proporciona una tabla de archivos de una ruta
solicitada.
Envía una petición a la capa mas baja del tipo de operación que
se realizara con un archivo (abrir, escribir, mover, etc.)
- 18 -
Sistema de Archivos Orientado a Objetos
TT908
Servicio
Esta clase se encargará de procesar peticiones de nodos dentro del sistema.
cd Clases capa SD
Serv icio
-
nombre: char*
+
+
+
rechaza() : void
aceptaPeticiones() : void
procesaPeticion(Mensaje) : void
5.4.2.b Clases de comunicación distribuida. Servicio.
Atributos
Nombre
nombre
enviaRespuesta
Descripción
Cadena que almacena el identificador del servicio.
Métodos
Nombre
Void rechaza(void)
Void
aceptaPeticiones(void)
Void
procesaPeticion(void)
Descripción
Envía un mensaje de rechazo de la petición.
Cambia el estado del objeto a la espera de peticiones de los
demás nodos.
Toma una petición para darle respuesta.
Peticion
Esta clase hace la función de un cliente, con la diferencia que solo hace una operación y
es destruido al finalizarla.
cd Clases capa SD
Peticion
-
nombreServicio: int
+
+
peticionRemota(Mensaje) : bool
recibe(int, void*) : bool
5.4.2.c Clases de comunicación distribuida. Petición.
Atributos
Nombre
nombreServicio
Descripción
Guarda el nombre del servicio al que quiere llamar.
Métodos
Nombre
bool
peticionRemota(Mensaje)
Bool recibe(int tamano,
void *buffer)
Descripción
Envía un mensaje al servicio que se quiere acceder.
Especifica el espacio de memoria en el que se guardará una
respuesta.
- 19 -
Sistema de Archivos Orientado a Objetos
TT908
Mensaje
Esta clase proporciona un medio de comunicación entre la clase servicio y petición.
cd Clases capa SD
Mensaj e
-
tipo: int
datos: char
5.4.2.d Clases de comunicación distribuida. Mensaje.
Atributos
Nombre
tipo
datos
Descripción
Especifica que tipo de mensaje.
Almacena los datos que maneja el mensaje.
ServicioNombres
Esta clase es la encargada de mantener la información de la ubicación de los servicios
así como del nombrado de los mismos.
cd Clases capa SD
Serv icioNombres
-
tablaN: TablaNodos
tablaA: TablaArchivos
respaldo: char = 127.0.0.1
+
+
+
+
+
+
+
nombraNodo(char*) : char*
resuelveArchivo(char*) : char*
nombraArchivo(char*, char*) : char*
respalda() : bool
guardaDD() : bool
guardaTablaNodo() : bool
proporcionaTabla(char*) : TablaResultados
5.4.2.e Clases de comunicación distribuida. ServicioNombres.
Atributos
Nombre
tablaN
tablaA
respaldo
Descripción
Guarda una relación de los nodos del sistema en una tabla.
Esta tabla se mantiene la jerarquía actual de los archivos.
Contiene la dirección del servicio de nombres secundario.
Métodos
Nombre
char*
nombraNodo(char* dir)
char
*resuelveArchivo(char
*nombreArchivo)
char
*nombraArchivo(char
*nombreArchivo,char
*nombreNodo):
bool respalda(void)
Descripción
Proporciona un nombre al nodo que los invoque, además si no
esta dentro de la tabla de nodos lo agrega, de otra forma
simplemente cambiará su estatus dentro de la tabla.
Regresa una dirección IP teniendo como parámetro el nombre
global del archivo.
Asigna un nombre a un archivo para su localización global.
Envía información al Servicio de Nombres secundario para su
- 20 -
Sistema de Archivos Orientado a Objetos
bool guardaDD(void)
bool
guardaTablaNodo(void):
tablaResultados
proporcionaTabla(char
*ruta)
TT908
actualización, retorna TRUE si tiene exito
Guarda la información de las tablas de archivos en disco duro,
retorna TRUE si tiene éxito.
Almacena en disco duro la información de la tabla de nodos,
retorna TRUE si tiene éxito.
Proporciona la tabla correspondiente a la ruta.
5.4.3. Manejo local de archivos.
Estas clases definen la manera en la cual se realizará el manejo de los archivos
localmente.
ManServ.
Este objeto estará encargado de proporcionar una interfaz para la comunicación con la
capa inmediata superior (capa distribuida), es decir, recibirá peticiones de dicha capa
que luego traducirá y posteriormente notificar a la capa distribuida del éxito o fracaso de
la operación.
cd CapaManej olocal
ManServ
+
+
+
+
recvPet() : void
TradPet() : void
SendTabla() : void
SendMsg() : void
5.4.3.a Clases de manejo local. ManServ,
Atributos
Nombre
void recvPet(void)
void tradPet(void)
void sendTabla(void)
void sendMsg(void)
Descripción
Recibe alguna petición en forma de mensaje de la capa
distribuida, como por ejemplo la petición de una tabla local
regresando la tabla solicitada.
Se encargará de traducir la petición recibida en recvPet() es
decir verificar que tipo de petición se ha hecho a la capa local.
Mandará la tabla en caso de que la petición haya sido
precisamente una tabla local.
Útil para el control, ya que se encargará principalmente de
enviar mensajes de error en caso de haberlos
Jerarquía.
Este objeto se encargará de la organización de los archivos y directorios que conforman
el sistema, permitiendo además seleccionar diversas opciones a realizar con los nodos
correspondientes a la jerarquía como por ejemplo crear nuevos nodos (agregar nodo),
eliminar algún nodo (borrarNodo), etc.
- 21 -
Sistema de Archivos Orientado a Objetos
TT908
cd CapaManej olocal
Jerarquia
-
jerarquia: AB+ Nodo
EliminarNodo: int
+
+
+
+
+
+
+
crearJerarquia() : void
agregaNodo() : void
borrarJerarquia() : void
buscarNodo() : void
modificarNodo() : void
EliminarNodo() : void
visitarNodo() : void
5.4.3.b Clases de manejo local. Jerarquia,
Atributos
Nombre
jerarquia
Descripción
Es una estructura del tipo árbol b+ que se utilizará para la organización
jerárquica de los archivos y directorios del sistema de archivos.
Métodos
Nombre
void
crearJerarquia(void)
void buscarNodo(void)
void
borrarJerarquia(void)
void eliminarNodo(void)
void visitarNodo(void)
void
modificarNodo(void)
Descripción
Se utiliza para crear una “jerarquia”, es decir inicializar un
árbol b+ para su utilización, esta operación solo se utilizará en
instalación del sistema de archivos.
Busca algún nodo en la jerarquía para operar en este nodo
según convenga (borrar, eliminar, etc.)
Elimina la jerarquía dejando la partición libre.
Elimina un nodo de la jerarquía.
Se utiliza para la operación de lectura de un archivo.
Se utiliza para la operación de escritura de un nodo.
Nodo.
El objeto nodo es del que se compone la jerarquía, son los que permiten la formación de
objetos del tipo NodoFile y NodoDir los cuales son propiamente dichos los archivos y
directorios del sistema.
cd CapaManej olocal
Nodo
-
ruta: String
nombre: String
+
inicNodo() : void
5.4.3.c Clases de manejo local. Nodo,
Atributos
Nombre
ruta
nombre
Descripción
Es el nombre de la ruta donde se creará el archivo o directorio.
Es el nombre que tendrá el archivo o fichero.
- 22 -
Sistema de Archivos Orientado a Objetos
Métodos
Nombre
void inocNodo(void)
TT908
Descripción
Método que incluye los atributos antes mencionados al nodo.
Tabla.
Este objeto es una lista de archivos y directorios locales del sistema SADOO la cual se
comparte con los demás nodos que pertenecen al sistema permitiendo al usuario ver en
su máquina toda la información contenida en el sistema.
cd CapaManej olocal
Tabla
-
tabLocal: byte
+
creaTabla() : void
5.4.3.d Clases de manejo local. Tabla,
Atributos
Nombre
tabLocal
Descripción
Contiene la información de la tabla.
Métodos
Nombre
void creaTabla(void)
Descripción
Genera la tabla de archivos y directorios.
NodoDir
Objeto que, como en un sistema de archivos local, contiene una lista de los archivos
contenidos en su estructura, es decir, funcionan como una carpeta.
cd CapaManej olocal
NodoDir
-
listaFiles: NodoFile
5.4.3.e Clases de manejo local. NodoDir,
Atributos
Nombre
listaFiles
Descripción
Listado de objetos nodoFile.
NodoFile
Tal y como existen los archivos pero encapsulados en un objeto manipulable por el
sistema, este tipo de objetos son los mas importantes.
- 23 -
Sistema de Archivos Orientado a Objetos
TT908
cd CapaManej olocal
NodoFile
-
tamano: byte
permisos: String
fechaUltMod: int
info: byte
5.4.3.f Clases de manejo local. NodoFile,
Atributos
Nombre
Tamano
permisos
fechaUltMod
Info
Descripción
Tamaño del archivo en bytes.
Permisos de los usuarios par la manipulación del archivo.
Fecha en que se modificó por última vez el archivo.
Lugar físico donde se encuentra la información de dicho archivo.
5.5. Definición de asociaciones.
5.5.1. Diagrama de objetos.
Muestra la interacción entre cada objeto.
cd DiagObj Grn
intefaz :InterfazUsuario
operaciones
tipoArch :TipoArchiv os
tablaAsociasion
serv Aplic :Serv iciosAplicacion
operacion sobre archivo
serv idorPrincipal:
Serv icioNombres
nodoN:NodoSD
Actualiza
petición de nombre
serv idorSecundario:
Serv icioNombres
peticionRemota:
Petición
petición de
operacion
serv icioRemoto:
Serv ico
realiza operación
manserv icio:
ManServ
PetTabla
tabloc:Tabla
nodof:NodoFile
CreaJerarquia
j er:Jerarquia
NuevoNodo
inicNodo
nodo:Nodo
NuevoNodo
nodod:NodoDir
5.5.1.a Diagrama de Objetos global.
- 24 -
Sistema de Archivos Orientado a Objetos
TT908
VI. Ingeniería del dominio. Diseño.
6.1 Arquitectura del sistema.
6.1.1. Modelo de capas.
El SADOO (sistema distribuido de archivos) contará con tres capas en su arquitectura,
capa de aplicación, la capa distribuida y la capa del manejo local, de las cuales en la
siguiente figura se muestra su estructura y funcionamiento básico.
Figura 6.1.1.a estructura básica.
La capa de aplicación se encargará funda mentalmente de brindar una interfaz al usuario
similar a un buscador de Internet, la cual le permitirá realizar la búsqueda del archivo
requerido o de una serie de archivos con características comunes como por ejemplo
todos los archivos que comiencen con la letra a, además de permitir un ordenamiento de
archivos mediante diversos criterios, como por ejemplo por fecha, por tipo, etc.
La capa distribuida se encargara entre otras cosas de manejar el servicio de indexado, es
decir de encontrar la ubicación lógica del archivo en cuestión, para esto se ayudará de
un sistema de nombrado (servidor de nombres).
La capa de servicios locales se encargará prácticamente de la manipulación de archivos
(objetos del tipo archivo), como por ejemplo apertura, eliminación de archivos y de la
modificación de archivos, además se encargará de la notificación a la capa distribuida
de los cambios en los archivos locales para que esta realice los cambios en los índices y
nombres globales. La capa de manejo local utilizará una carpeta a compartir (carpeta
SADOO), la cual contendrá la información que se podrá compartir con otros nodos
ayudándose para esto del sistema nativo de Linux para su organización.
6.2. Diseño funcional.
Por otra parte hay que tomar en cuenta que el SADOO (prototipo y versión final)
utilizará una variación del modelo de carga/descarga para el servicio de archivos, es
decir cuando un archivo necesite ser consultado en la máquina a y este se encuentra en
la máquina b el archivo se transferirá a la máquina a, una vez terminada la modificación
al archivo este no regresará a la máquina origen, en lugar de esto la tabla de indexado y
el servidor de nombres realizará la modificación pertinente. Otra de las situaciones que
hay que tomar en cuenta es que el tamaño de los archivos estará limitado a 5 Mb
brindando mayor rapidez al SADOO.
- 25 -
Sistema de Archivos Orientado a Objetos
TT908
6.3. Diseño del comportamiento.
La comunicación entre los objetos muestra y modela el que y a quien se enviarán los
mensajes.
6.3.1. Diagramas de secuencia. Global.
Estos diagramas nos permiten reconocer los mensajes enviado e información requerida
por cada una de las capas.
sd GlobalBusqueda
aplicacion
:Serv iciosAplicacion
remoto
Llamada del sistema
exploraTabla(ruta)
tabla(ruta)
Tabla
Visualizacion de la tabla
6.3.1.a Navega tabla
sd GlobalCrear
aplicacion
:Serv iciosAplicacion
remoto
local :ManServ
Llamada del sistema
open(nombreArchivo,"w")
crear(nombreArchivo)
agregar(nombreArchivo,usuario,permisos)
refArchivo
refArchivo
refArchivo
6.3.1.b Crea archivo
- 26 -
Sistema de Archivos Orientado a Objetos
TT908
sd GlobalSecEliminar
aplicacion
:Serv iciosAplicacion
remoto
local :ManServ
Llamada del sistema
unlink(nombreArchivo)
eliminar(nombreArchivo)
elimina(nombreArchivo,usuario)
OK
OK
OK
6.3.1.c Elimina archivo
sd GlobalEscribir
aplicacion
:Serv iciosAplicacion
remoto
local :ManServ
Llamada del sistema
write(refArchivo,bufer,bytes)
escribir(refArchivo,bufer,bytes)
escribir(nombreArchivo,bufer,bytes,usuario)
OK
OK
bytesEscritos
6.3.1.d Escribir archivo
- 27 -
Sistema de Archivos Orientado a Objetos
TT908
sd GlobalLeer
aplicacion
:Serv iciosAplicacion
remoto
local :ManServ
Llamada del sistema
read(desArchivo,bufer,bytes)
leer(desArchivo,bufer,bytes)
leer(nombreArchivo,bufer,bytes,usuario)
OK
OK
bytes leidos
6.3.1.e Leer archivo
6.3.2. Diagramas de secuencia. Aplicación.
sd Abrir
:InterfazUsuario
:Serv iciosAplicacion
:NodoSD
:TipoArchiv os
aplicacionAsociada:= verificaTipo(nombreArchivo)
Aplicacion
bool:= peticionApertura(nombreArchivo)
bool:= abrir(nombreArchivo)
Ok
Ok
6.3.2.a Abrir archivo
- 28 -
Sistema de Archivos Orientado a Objetos
TT908
sd Crear
:InterfazUsuario
:Serv iciosAplicacion
:NodoSD
:TipoArchiv os
bool:= peticionNuevo(nombreArchivo)
bool:= nuevo(nombreArchivo)
Ok
bool:= verificaAsociacion(nombreArchivo)
Ok
Ok
6.3.2.b Crear archivo
sd Eliminar
:InterfazUsuario
:Serv iciosAplicacion
:NodoSD
bool:= peticionBorrado(nombreArchivo)
bool:= eliminar(nombreArchivo)
Ok
Ok
6.3.2.c Eliminar archivo
sd Escribir
:Serv iciosAplicacion
:NodoSD
bool:= notificaModificacion
Ok
6.3.2.d Escribir archivo
- 29 -
Sistema de Archivos Orientado a Objetos
TT908
sd Nav egaTabla
:InterfazUsuario
:Serv iciosAplicacion
:NodoSD
char[]:= busqueda
TablaResultados:= peticionTabla
Tabla de resultados
char[]:= filtraTabla()
Tabla filtrada
6.3.2.e Navega tabla
6.3.3. Diagramas de secuencia. Sistema distribuido.
sd SDCrear
:Serv iciosAplicacion
:local
:serv icioLocal
:peticionNodo
:serv idorPrincipal
bool:= crea(nombreArchivo,permisos)
agregar(nombreArchivo,usuario,permisos)
peticion(agregaTabla,nombreArchivo,usuario)
agregar(nombreTabla,usuario,permisos)
OK
OK
OK
Ok
6.3.3.a Crea archivo
- 30 -
Sistema de Archivos Orientado a Objetos
TT908
sd SDEliminar
:Serv iciosAplicacion
:local
:peticionNodo
:serv icioRemoto
eliminar(nombreArchivo)
peticion(Eliminar,nombreArchivo)
eliminar(nombreArchivo,usuario)
OK
OK
Ok
6.3.3.b Eliminar archivo
sd SDEscribir
:Serv iciosAplicacion
:local
:peticionNodo
:serv icioRemoto
:serv idorPrincipal
escribir(nombreArchivo,datos)
peticion(Localizacion,nombreArchivo)
localizacion(nombreArchivo)
Localizacion
Localizacion
peticion(Escribir,nombreArchivo)
escribir(nombreArchivo,usuario)
Archivo
refArchivo
escribe
nuevoArchivo
OK
Ok
6.3.3.c Escribir archivo
- 31 -
Sistema de Archivos Orientado a Objetos
TT908
sd SDInicia
:local
:peticionNodo
:serv icioLocal
:serv idorPrincipal
char*:= peticion(NombraNodo)
nombraNodo
peticionTabla
Tabla
NombreNodo
6.3.3.c Inicia sistema
sd SDLeer
:Serv iciosAplicacion
:local
:peticionNodo
:serv icioRemoto
:serv idorPrincipal
refArchivo:= leer(nombreArchivo,Usuario)
peticion(Localizacion,nombreArchivo)
localizacion(NombreArchivo)
Localizacion
Localizacion
peticion(leer,nombreArchivo)
leer(nombreArchivo,Usuario)
Archivo
refArchivo
referencia del archivo
6.3.3.d Lee archivo
- 32 -
Sistema de Archivos Orientado a Objetos
TT908
6.3.4. Diagramas de secuencia. Manejador local de archivos.
sd NNodoFile
NodoSD:nodosd
ManServ :manser
Jerarquia:j er
Nodo
NodoFile:nodof
int CrearFile(Nombre,Usr,Parametros)
int AgregarNodo(Nombre,Usr,Permisos)
int CrearNodo(Nombre,Usr,Permisos)
int CrearNodo(Nombre,Usr,Permisos)
Ok
Ok
Ok
Ok
6.3.4.a Crea archivo
sd LocLeerNodoFile
NodoSD:nodosd
ManServ :manser
Jerarquia:j er
int visitarNodo(Nombre,Ust,Permisos)
buscarNodo
referencia
referencia
6.3.4.b Leer archivo
- 33 -
Sistema de Archivos Orientado a Objetos
TT908
sd LocModNodoFile
NodoSD:nodosd
ManServ :manser
Jerarquia:j er
Nodo:nodo
int escribir(Nombre,Usr,Permisos)
int escribir(Nombre,Usr,Permisos)
modificarNodo
Ok
Ok
Ok
6.3.4.c Escribir archivo
sd manLocBorrNodo
NodoSD:nodosd
ManServ :manser
Jerarquia:j er
int BorrarNodo(Nombre,Usr,Permisos)
int EliminarNodo(Nombre,Usr,Permisos)
Ok
Ok
6.3.4.d Elimina archivo
sd manLocSecTab
NodoSD:nodosd
ManServ :manser
Tabla:tab
peticionTabla
int:= Creatabla(void)
Ok
Ok
6.3.4.e Generar tabla de resultados
- 34 -
Sistema de Archivos Orientado a Objetos
TT908
sd secManLocNDir
NodoSD:nodosd
ManServ :mserv
Jerarquia:j er
Nodo:nodo
NodoDir:Dir
int:= nuevoNodo(Nombre,Usr,Permisos)
int:= agregarNodo(Nombre,Usr,Permisos)
crearNodo
creaDir
Ok
Ok
Ok
Ok
6.3.4.f Inicia sistema, crea directorio.
- 35 -
Sistema de Archivos Orientado a Objetos
TT908
VII. Trabajos futuros.
7.1. Puntos deseables a implementar.
Como parte del diseño del SADOO se tomaron en cuenta muchos aspectos que no
podían ser cubiertos en el tiempo considerado, este apartado contiene puntos que
podrían ser desarrollados en algún futuro:






Manejo de réplicas de archivos.
Implementación de un esquema de seguridad mediante firmas digitales o tickets
(como Kerberos).
Eliminación de la tradicional jerarquía de archivos.
Actualizaciones concurrentes.
Búsqueda automática de servicios.
Computación móvil.
- 36 -
Sistema de Archivos Orientado a Objetos
TT908
VIII. Referencias.
8.1.1. Bibliográficas.
“Sistemas distribuidos, conceptos y diseño”, George Colouris, Jean Dollimore, Tim
Kindberg, tercera edición, editorial Addison Wesley, Reino Unido, 1998.
“Sistemas Operativos Distribuidos”, Andrew S. Tanenbaum, editorial Prentice Hall,
Holanda, 1995.
“Sistemas Operativos”, Abraham. Silberschatz, J.Peterson, sexta edición, editorial
Addison-Wesley 1999.
“Ingenieria de software, Un enfoque practico”, Roger S. Presuman, quinta edición,
editorial Mc Graw Hill, España.
8.1.2. Electrónicas.
Distributed File System
http://www.cs.washington.edu/lab/sw/uwcsentdfs.html
http://fferrer.dsic.upv.es/cursos/Windows/Avanzado/ch07s03.html
Network File System
http://www.ucbcba.edu.bo/carreras/ingsis/cursos/web/SistemasOperativos/tema10.htm
http://docs.sun.com/app/docs/doc/806-2195-10?l=es
CODA File System
http://www.coda.cs.cmu.edu/
CORBA
http://www.omg.org/technology/documents/corba_spec_catalog.htm
Virtual File System (VFS)
http://www.tldp.org/LDP/tlk/fs/filesystem.html
http://www.tldp.org/LDP/khg/HyperNews/get/fs/vfstour.html
http://www.faqs.org/docs/kernel_2_4/lki-3.html
- 37 -