Das System für den entfernten Dateizugriff Cage.

Systemzweck

Unterstützung des Fernzugriffs auf Dateien auf Computern im Netzwerk. Das System unterstützt "virtuell" alle gängigen Dateioperationen (Erstellen, Löschen, Lesen, Schreiben usw.) durch den Austausch von Transaktionen (Nachrichten) über das TCP-Protokoll.

Anwendungsbereiche

Die Funktionalität des Systems ist in folgenden Fällen effektiv:

• in nativen Anwendungen für mobile und Embedded-Geräte (Smartphones, Bordsteuerungssysteme usw.), die schnellen Zugriff auf Dateien auf entfernten Servern benötigen, auch wenn es zu kurzzeitigen Verbindungsunterbrechungen (Offline-Zeiten) kommen kann;
• in stark belasteten Datenbankmanagementsystemen, wenn die Anfragen auf einem Server bearbeitet und die Daten auf einem anderen gespeichert werden;
• in verteilten Unternehmensnetzwerken für die Sammlung und Verarbeitung von Informationen, die eine hohe Datenübertragungsrate, Redundanz und Zuverlässigkeit erfordern;
• in komplexen Systemen mit mikroserviceorientierter Architektur, in denen Verzögerungen beim Austausch von Informationen zwischen Modulen von entscheidender Bedeutung sind.

Struktur

Das Cage-System (eine Beta-Version ist für Python 3.7 unter Windows verfügbar) umfasst zwei Hauptkomponenten:

1. Cageserver — ein Programm zur Datei-Server-Verwaltung (Funktionspaket), das auf Computern im Netzwerk ausgeführt wird, um den Remote-Zugriff auf Dateien zu ermöglichen;
2. Klasse Cage mit einer Bibliothek von Methoden für Client-Software, die die Interaktion mit Servern vereinfacht.

Verwendung des Systems auf der Clientseite

Die Methoden der Klasse Cage ersetzen die gewöhnlichen, „alltagsmäßigen“ Operationen des Dateisystems: Erstellung, Öffnung, Schließung, Löschung von Dateien sowie das Lesen/Schreiben von Daten im Binärformat (mit Angabe der Position und Größe der Daten). Konzeptuell sind diese Methoden den Dateioperationen der Programmiersprache C ähnlich, bei denen das Öffnen/Schließen von Dateien über Eingabe-/Ausgabe-Kanäle erfolgt.

Mit anderen Worten, der Programmierer arbeitet nicht mit den Methoden der „Datei“-Objekte (der Klasse _io in Python), sondern mit den Methoden der Klasse Cage.

Beim Erstellen einer Cage-Instanz wird eine initiale Verbindung zu einem Server (oder mehreren Servern) hergestellt, die Autorisierung mit der Kunden-ID durchgeführt und eine Bestätigung mit der Nummer des zugewiesenen Ports für alle Dateioperationen erhalten. Beim Löschen des Cage-Objekts wird ein Befehl an den Server gesendet, um die Verbindung zu beenden und Dateien zu schließen. Auch die Server selbst können die Verbindung beenden.

Das System verbessert die Lese-/Schreibgeschwindigkeit durch die Pufferung häufig verwendeter Dateiabschnitte im Cache (Speicher) der Client-Programme.
Die Client-Software kann beliebig viele Cage-Objekte mit unterschiedlichen Einstellungen verwenden (Puffergröße, Blockgröße beim Austausch mit dem Server usw.).

Ein Cage-Objekt kann Daten mit mehreren Dateien auf mehreren Servern austauschen. Die Verbindungsparameter (IP-Adresse oder DNS des Servers, Hauptport zur Autorisierung, Pfad und Name der Datei) werden beim Erstellen des Objekts festgelegt.

Da jedes Cage-Objekt gleichzeitig mit mehreren Dateien arbeiten kann, wird ein gemeinsamer Speicherbereich für das Caching verwendet. Die Cache-Größe - Anzahl der Seiten und deren Größe - wird dynamisch bei der Erstellung des Cage-Objekts festgelegt. Beispielsweise bedeutet ein 1 GB Cache, dass es 1.000 Seiten mit je 1 MB oder 10.000 Seiten mit je 100 KB oder 1 Million Seiten mit je 1 KB gibt. Die Wahl der Größe und Anzahl der Seiten ist eine spezifische Aufgabe für jeden Anwendungsfall.

Es können mehrere Cage-Objekte gleichzeitig verwendet werden, um verschiedene Einstellungen des Pufferspeichers zu bestimmen, je nach den Zugriffsmerkmalen auf Informationen in unterschiedlichen Dateien. Als Basis wird ein einfachster Pufferalgorithmus angewendet: Nach Erschöpfung des zugewiesenen Speicherplatzes verdrängen neue Seiten alte in der Reihenfolge der geringsten Zugriffe. Die Pufferung ist besonders effektiv bei ungleichmäßigem (im statistischen Sinne) gemeinsamen Zugriff, erstens auf verschiedenen Dateien und zweitens auf Fragmenten jeder Datei.

Die Cage-Klasse unterstützt Ein- und Ausgaben nicht nur über Datenadressen (unter Angabe der Position und Länge des Arrays, wodurch Dateisystemoperationen "ersetzt" werden), sondern auch auf einer tieferen, "physischen" Ebene – über die Seitenzahlen im Pufferspeicher.

Für Cage-Objekte wird die Originalfunktion „Hibernation“ („Schlaf“) unterstützt – sie können in eine lokale Dump-Datei auf der Client-Seite "eingefroren" werden (zum Beispiel im Falle eines Verbindungsabbruchs zu Servern oder beim Stoppen einer Anwendung usw.) und schnell aus dieser Datei wiederhergestellt werden (nach Wiederherstellung der Verbindung, bei erneutem Starten der Anwendung). Dies ermöglicht eine signifikante Reduzierung des Datenverkehrs, wenn das Client-Programm nach einem temporären "Offline-Gang" wieder aktiviert wird, da häufig verwendete Dateifragmente bereits im Cache vorhanden sind.

Cage umfasst etwa 3600 Zeilen Code.

Prinzipien des Serveraufbaus

Cageserver-Dateiserver können mit einer beliebigen Anzahl von Ports betrieben werden, wobei einer davon (der „Hauptport“) ausschließlich für die Authentifizierung aller Clients verwendet wird, während die anderen für den Datenaustausch zuständig sind. Für das Cage-Server-Programm wird lediglich Python benötigt. Gleichzeitig kann der Computer mit dem Dateiserver auch jede andere Aufgabe ausführen.

Der Server wird zunächst als Kombination zweier Hauptprozesse gestartet:

1. „Verbindungen“ – ein Prozess zur Durchführung von Verbindungsaufbau und -abbruch mit den Clients auf Initiative des Servers;
2. „Operationen“ – ein Prozess zur Ausführung von Aufgaben (Operationen) der Clients im Umgang mit Dateien sowie zur Beendigung von Verbindungen auf Anforderung der Clients.

Beide Prozesse sind nicht synchronisiert und organisiert als unendliche Schleifen für den Empfang und Versand von Nachrichten basierend auf multiplen Warteschlangen, Proxy-Objekten, Locks und Sockets.
Der Prozess „Verbindungen“ weist jedem Client einen Port für den Datenempfang und -versand zu. Die Anzahl der Ports wird beim Start des Servers festgelegt. Die Zuordnung zwischen Ports und Clients wird im zwischen den Prozessen geteilten Proxy-Speicher gespeichert.

Der Prozess „Operationen“ unterstützt die Trennung von Dateiressourcen, sodass mehrere unterschiedliche Clients gleichzeitig (quasi parallel, da der Zugriff durch Sperren geregelt wird) Daten aus einer Datei lesen können, wenn dies beim ursprünglichen Öffnen durch den „ersten“ Client erlaubt wurde.

Die Verarbeitung von Befehlen zum Erstellen/Löschen/Öffnen/Schließen von Dateien Server erfolgt im Prozess „Operationen“ streng sequenziell unter Verwendung des Dateisystems des Server-Betriebssystems.

Um das Lesen/Schreiben zu beschleunigen, werden diese Operationen in Threads ausgeführt, die durch den Prozess „Operationen“ erzeugt werden. Die Anzahl der Threads entspricht in der Regel der Anzahl der geöffneten Dateien. Lese-/Schreibaufträge von Clients werden in eine gemeinsame Warteschlange eingegeben, und der erste freigewordene Thread nimmt den Auftrag von deren Kopf auf. Eine spezielle Logik ermöglicht es, Schreiboperationen im Arbeitsspeicher des Servers auszuschließen.

Der Prozess „Operationen“ überwacht die Aktivität der Clients und beendet deren Bedienung sowohl auf ihre Befehle hin als auch bei Überschreitung der Inaktivitätstimeout.

Um die Zuverlässigkeit zu gewährleisten, protokolliert Cageserver alle Transaktionen. Ein gemeinsames Protokoll enthält Kopien der Nachrichten von Kunden mit Aufträgen zum Erstellen, Öffnen, Umbenennen oder Löschen von Dateien. Für jede Arbeitsdatei wird ein separates Protokoll erstellt, in dem Kopien der Nachrichten zu Lese- und Schreibaufträgen in dieser Arbeitsdatei sowie Arrays der geschriebenen (neuen) Daten und Arrays der Daten, die beim Überschreiben (Neuschreiben von Daten "über" alte) verloren gingen, aufgezeichnet werden.

Diese Protokolle ermöglichen sowohl die Wiederherstellung neuer Änderungen in Backups als auch das "Rollback" vom aktuellen Inhalt zu einem gewünschten Zeitpunkt in der Vergangenheit.

Cageserver besteht aus etwa 3100 Zeilen Code.

Starten des Cageserver-Datei-Server-Programms.

Beim Starten im Dialog müssen Sie Folgendes festlegen:
— den Hauptport zur Authentifizierung;
— die Anzahl der Ports für den Austausch von Transaktionen mit autorisierten Kunden (mindestens 1, der Pool beginnt mit der Nummer nach dem Hauptport).

Verwendung der Klasse Cage

class cage.Cage( cage_name=»», pagesize=0, numpages=0, maxstrlen=0, server_ip={}, wait=0, awake=False, cache_file=»» )

Aus dieser Klasse werden Objekte erstellt, die mit Datei-Servern interagieren und über einen Zwischenspeicher verfügen.

Einstellungen

• cage_name(str) - der bedingte Name des Objekts, der zur Identifizierung von Clients auf der Serverseite verwendet wird.
• pagesize(int) - die Größe einer Seite im Zwischenspeicher (in Bytes).
• numpages(int) - die Anzahl der Seiten im Zwischenspeicher.
• maxstrlen(int) - die maximale Länge der Byte-Zeichenfolge bei Schreib- und Lesevorgängen.
• server_ip(dict) - ein Wörterbuch mit den verwendeten Adressen, wobei der Schlüssel der bedingte Name des Servers (Server-ID innerhalb der Anwendung) ist und der Wert die Zeichenfolge mit der Adresse: „IP-Adresse:Port“ oder „DNS:Port“ (die Zuordnung von Namen und tatsächlichen Adressen ist temporär und kann geändert werden). Server, wobei der Schlüssel der bedingte Name des Servers (Server-ID innerhalb der Anwendung) ist und der Wert eine Zeichenfolge mit der Adresse ist: "IP-Adresse:Port" oder "DNS:Port" (die Zuordnung von Namen zu tatsächlichen Adressen ist temporär und kann geändert werden)
• wait(int) - die Wartezeit auf eine Antwort vom Server bei der Abfrage der Ports (in Sekunden).
• awake(boolean) - ein Flag, das die Art der Erstellung des Objekts angibt (False - wenn ein neues Objekt erstellt wird, True - wenn das Objekt aus einem zuvor "eingefrorenen" Zustand erstellt wird - durch die Anwendung der Operation „Hibernate“, per Voreinstellung False).
• cache_file(str) - der Name der Datei für das Hibernate.

Methoden

Cage.file_create( server, path ) - eine neue Datei erstellen.

Cage.file_rename( server, path, new_name ) - eine Datei umbenennen.

Cage.file_remove( server, path) - eine Datei löschen.

Cage.öffnen( server, path, mod ) - eine Datei öffnen.

Gibt zurück fchannel Kanalnummer. Parameter mod — ist der Modus zum Öffnen einer Datei: „wm“ — monopol (lesen/schreiben), „rs“ — nur lesen und für andere Benutzer nur lesbar, „ws“ — lesen/schreiben und für andere Benutzer nur lesbar.

Cage.close (fchannel) – Datei schließen

Cage.write (fchannel, begin, data ) – eine Byte-Zeichenkette in die Datei schreiben

Cage.read (fchannel, begin, len_data ) – eine Byte-Zeichenkette aus der Datei lesen

Cage.put_pages ( fchannel ) – „stößt“ alle Seiten des angegebenen Kanals aus dem Puffer auf den Server, die modifiziert wurden. Wird an den Stellen des Algorithmus verwendet, an denen sichergestellt werden muss, dass alle Operationen auf dem Kanal physisch in der Datei auf dem Server gespeichert sind.

Cage.push_all () – „stößt“ alle Seiten aller Kanäle für die Instanz der Klasse Cage aus dem Puffer auf den Server, die modifiziert wurden. Wird verwendet, wenn sichergestellt werden muss, dass alle Operationen auf allen Kanälen auf dem Server gespeichert sind.

Quelle: habr.com