Propósito do sistema
Soporte para o acceso remoto a ficheiros en ordenadores da rede. O sistema admite "virtualmente" todas as operacións básicas de ficheiros (creación, eliminación, lectura, escritura, etc.) intercambiando transaccións (mensaxes) mediante o protocolo TCP.
Áreas de aplicación
A funcionalidade do sistema é efectiva nos seguintes casos:
- en aplicacións nativas para dispositivos móbiles e embebidos (teléfonos intelixentes, sistemas de control a bordo, etc.) que requiren un acceso rápido a ficheiros en servidores remotos ante posibles interrupcións temporais na comunicación (con saída de liña);
- nos DBMS cargados, se nalgúns servidores se realiza o procesamento de consultas e noutros se realiza o almacenamento de datos;
- en redes corporativas distribuídas para recoller e procesar información, que requiren intercambio de datos de alta velocidade, redundancia e fiabilidade;
- en sistemas complexos con arquitectura de microservizos, onde os atrasos no intercambio de información entre módulos son críticos.
Estrutura
Sistema Cage (hai unha implementación - versión beta en Python 3.7 no sistema operativo) Windows) inclúe dúas partes principais:
- Cageserver — un programa de servidor de ficheiros (un paquete de funcións) que se executa en ordenadores da rede cuxos ficheiros requiren acceso remoto;
- clase Cage cunha biblioteca de métodos para software cliente, simplificando a codificación da interacción cos servidores.
Usando o sistema no lado do cliente
Os métodos da clase Cage substitúen as operacións habituais do sistema de ficheiros "rutinarias": creación, apertura, peche, eliminación arquivos, así como lectura/escritura de datos en formato binario (indicando a posición e tamaño dos datos). Conceptualmente, estes métodos están próximos ás funcións de ficheiros da linguaxe C, onde a apertura/pechadura de ficheiros realízase "en canles" de entrada/saída.
Noutras palabras, o programador non traballa con métodos de obxectos "ficheiro" (clase _io en Python), pero con métodos da clase Cage.
Cando se crea unha instancia dun obxecto Cage, establece unha conexión inicial cun servidor (ou varios servidores), é autorizada polo ID de cliente e recibe a confirmación cun número de porto dedicado para todas as operacións de ficheiro. Cando se elimina un obxecto Cage, indícase ao servidor que deixe de comunicarse e peche os ficheiros. A terminación da comunicación tamén pode ser iniciada polos propios servidores.
O sistema aumenta o rendemento de lectura/escritura almacenando fragmentos de ficheiros usados con frecuencia dos programas cliente na caché RAM (búfer).
O software cliente pode usar calquera número de obxectos Cage con diferentes configuracións (tamaño da memoria intermedia, tamaño do bloque ao intercambiar co servidor, etc.).
Un único obxecto Cage pode comunicarse con varios ficheiros en varios servidores. Os parámetros de comunicación (enderezo IP ou servidor DNS, porto principal para a autorización, camiño e nome do ficheiro) especifícanse ao crear o obxecto.
Dado que cada obxecto Cage pode funcionar con varios ficheiros ao mesmo tempo, utilízase espazo de memoria compartida para almacenar no búfer. Tamaño da caché: o número de páxinas e o seu tamaño, establécese de forma dinámica ao crear un obxecto Cage. Por exemplo, unha caché de 1 GB son 1000 páxinas de 1 MB cada unha, ou 10 mil páxinas de 100 KB cada unha, ou 1 millón de páxinas de 1 KB cada unha. Seleccionar o tamaño e o número de páxinas é unha tarefa específica para cada caso de aplicación.
Podes usar varios obxectos Cage ao mesmo tempo para definir diferentes configuracións de memoria intermedia dependendo de como se accede á información en diferentes ficheiros. Como básico, utilízase o algoritmo de buffering máis sinxelo: despois de esgotar unha determinada cantidade de memoria, as páxinas novas desprazan ás antigas segundo o principio de retirada cun mínimo de accesos. O almacenamento en búfer é especialmente eficaz no caso de acceso compartido desigual (nun sentido estatístico), en primeiro lugar, a diferentes ficheiros e, en segundo lugar, a fragmentos de cada ficheiro.
A clase Cage admite E/S non só mediante enderezos de datos (indicando a posición e lonxitude da matriz, "substituíndo" as operacións do sistema de ficheiros), senón tamén a un nivel "físico" inferior: por números de páxina na memoria intermedia.
A función orixinal é compatible con obxectos Cage "hibernación" ("sleep") - poden ser "contraídos" (por exemplo, en caso de perda de conexión cos servidores, ou cando a aplicación se detén, etc.) nun ficheiro de volcado local no lado do cliente e restauralos rapidamente desde este ficheiro (despois de retomar a comunicación, cando reinicie a aplicación). Isto fai posible reducir significativamente o tráfico ao activar o programa cliente despois de estar temporalmente "sen conexión", xa que os fragmentos de ficheiros de uso frecuente xa estarán na caché.
Cage ten unhas 3600 liñas de código.
Principios de construción de servidores
Os servidores de ficheiros Cageserver pódense executar cun número arbitrario de portos, un dos cales ("principal") só se utiliza para a autorización de todos os clientes, o resto utilízase para o intercambio de datos. O programa do servidor Cage só require Python. Paralelamente, o ordenador co servidor de ficheiros pode realizar calquera outro traballo.
O servidor comeza inicialmente como unha colección de dous procesos principais:
- "Conexións" – un proceso para realizar as operacións de establecer comunicación cos clientes e finalizala por iniciativa do servidor;
- "Operacións" – un proceso para realizar tarefas (operacións) dos clientes para traballar con ficheiros, así como para pechar sesións de comunicación baseadas nos comandos do cliente.
Ambos os procesos non están sincronizados e organízanse como bucles infinitos de recepción e envío de mensaxes baseados en colas multiproceso, obxectos proxy, bloqueos e sockets.
O proceso de conexión asigna un porto para que cada cliente reciba e transmita datos. O número de portos establécese cando se inicia o servidor. A asignación entre portos e clientes gárdase na memoria proxy compartida entre procesos.
O proceso de operacións admite compartir recursos de ficheiros para que varios clientes diferentes poidan compartir (case paralelo, xa que o acceso está controlado por bloqueos) len datos dun ficheiro se iso estaba permitido cando o abriu inicialmente o "primeiro" cliente.
Comandos de procesamento para crear/eliminar/abrir/pechar ficheiros en servidor lévase a cabo no propio proceso de "Operación", de forma estritamente secuencial utilizando o subsistema de ficheiros do sistema operativo do servidor.
Para acelerar xeralmente a lectura/escritura, estas operacións realízanse en fíos xerados polo proceso "Operacións". O número de fíos adoita ser igual ao número de ficheiros abertos. As tarefas de lectura/escritura dos clientes envíanse á cola xeral e o primeiro fío libre toma a tarefa da súa cabeza. A lóxica especial permítelle eliminar as operacións de reescritura de datos na memoria RAM do servidor.
O proceso de operacións supervisa a actividade do cliente e deixa de prestarlle servizo cando se lles ordene ou cando se supere o tempo de espera de inactividade.
Para garantir a fiabilidade, Cageserver mantén rexistros de todas as transaccións. Un rexistro xeral contén copias de mensaxes dos clientes con tarefas para crear/abrir/renomear/eliminar ficheiros. Créase un rexistro separado para cada ficheiro de traballo, no que se rexistran copias de mensaxes con tarefas para ler e escribir datos neste ficheiro de traballo, así como matrices de datos escritos (novos) e matrices de datos que foron destruídos durante a sobreescritura (escritura). novos datos "enriba" dos antigos). ).
Estes rexistros ofrecen a posibilidade de restaurar novos cambios nas copias de seguranza e retrotraer o contido actual a un punto no pasado.
Cageserver ten unhas 3100 liñas de código.
Iniciando o programa do servidor de ficheiros Cageserver
Ao comezar, no diálogo cómpre definir:
— Porto principal para a autorización;
— o número de portos para intercambiar transaccións con clientes autorizados (a partir de 1 ou máis, o conxunto de números comeza a partir do próximo ao número de porto principal).
Usando a clase Cage
clase gaiola.Cage( cage_name="", pagesize=0, numpages=0, maxstrlen=0, server_ip={}, wait=0, awake=False, cache_file="" )
A partir desta clase créanse obxectos que interactúan cos servidores de ficheiros e conteñen memoria intermedia.
Parámetros
- nome_gaiola(str) - nome condicional do obxecto, que se usa para identificar clientes no lado do servidor
- tamaño de páxina(int) — tamaño dunha páxina de memoria intermedia (en bytes)
- números(int) — número de páxinas de memoria intermedia
- maxstrlen(int) - a lonxitude máxima dunha cadea de bytes nas operacións de escritura e lectura
- ip_servidor(dict) - un dicionario con enderezos de usados servidores, onde a clave é o nome condicional do servidor (o ID do servidor dentro da aplicación) e o valor é unha cadea de caracteres co enderezo: "enderezo ip:porto" ou "DNS:porto" (a correspondencia de nomes e enderezos reais é temporal e pódese modificar)
- esperar(int) — tempo de espera para unha resposta do servidor ao recibir portos (en segundos)
- acordado(booleano) — bandeira de como se crea o obxecto (Falso - se se crea un novo obxecto, Certo - se se crea un obxecto a partir dun previamente "contraído" - usando a operación "hibernación", False por defecto)
- ficheiro_caché(str) - nome do ficheiro para a hibernación
Métodos
Gaiola.ficheiro_crear( servidor, camiño ) – crea un novo ficheiro
Gaiola.file_rename( servidor, ruta, nome_novo ) – renomear o ficheiro
Gaiola.ficheiro_eliminar( servidor, camiño) - eliminar un ficheiro
Gaiola.abrir( servidor, ruta, mod ) - Arquivo aberto
Devolucións fcanle número de canle. Parámetro mod - este é o modo de apertura do ficheiro: "wm" - exclusivo (lectura/escritura), "rs" - só lectura e compartido só para a súa lectura por outros clientes, "ws" - lectura/escritura e compartido só para lectura por parte outros clientes.
Gaiola.pechar (fcanle) – pecha o ficheiro
Gaiola.escribir (fcanle, comezar, datos ): escribe unha cadea de bytes nun ficheiro
Gaiola.ler (fchannel, begin, len_data ) – le unha cadea de bytes dun ficheiro
Gaiola.poñer_páxinas ( fcanle ) – "empuxa" desde o búfer ao servidor todas as páxinas da canle especificada que foron modificadas. Utilízase neses puntos do algoritmo cando se precisa asegurarse de que todas as operacións da canle se gardan fisicamente nun ficheiro do servidor.
Gaiola.push_all () – "empuxa" desde o búfer ao servidor todas as páxinas de todas as canles para unha instancia da clase Cage que foi modificada. Utilízase cando precisas estar seguro de que todas as operacións de todas as canles están gardadas no servidor.
Fonte: www.habr.com
