Das System für den Remote-Dateizugriff Cage

Zweck des Systems

Unterstützung des Remote-Zugriffs auf Dateien auf Computern im Netzwerk. Das System unterstützt „virtuell“ alle wichtigen Dateioperationen (Erstellung, Löschung, 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 eingebettete Geräte (Smartphones, Bordsteuerungssysteme usw.), die schnellen Zugriff auf Dateien auf entfernten Servern erfordern, insbesondere unter Bedingungen, die vorübergehende Unterbrechungen der Verbindung (Offline-Nutzung) nach sich ziehen;
• in stark belasteten DBMS, wenn die Verarbeitung von Anfragen auf einem Server erfolgt, während die Datenspeicherung auf einem anderen stattfindet;
• in verteilten Unternehmensnetzwerken zur Erfassung und Verarbeitung von Informationen, die eine hohe Datenaustauschgeschwindigkeit, Redundanz und Zuverlässigkeit erfordern;
• in komplexen Systemen mit Mikrodiensten, wo Verzögerungen im Austausch von Informationen zwischen Modulen von entscheidender Bedeutung sind.

Struktur

Das Cage-System (eine Implementierung – Beta-Version auf Python 3.7 unter Windows) umfasst zwei Hauptteile:

1. Cageserver – ein Programm für Datei-Server (Funktionspaket), das auf Computern im Netzwerk ausgeführt wird, auf deren Dateien ein Remote-Zugriff erforderlich ist;
2. Klasse Cage mit einer Bibliothek von Methoden für Client-Software, die die Kodierung der Interaktion mit Servern vereinfacht.

Verwendung des Systems auf der Client-Seite

Die Methoden der Klasse Cage ersetzen die gewöhnlichen, „routinehaften“ Operationen des Dateisystems: Erstellung, Öffnen, Schließen, Löschen von Dateien sowie lesen/schreiben von Daten im binären Format (unter Angabe der Position und Größe der Daten). Konzeptuell sind diese Methoden den Datei-Funktionen der Programmiersprache C ähnlich, wo das Öffnen/Schließen von Dateien „über Kanäle“ für Ein- und Ausgabe erfolgt.

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

Bei der Erstellung einer Instanz des Objekts Cage wird eine initiale Verbindung zum Server (oder mehreren Servern) hergestellt, die Autorisierung mittels Client-ID durchgeführt und eine Bestätigung mit der Nummer des reservierten Ports für alle Dateioperationen empfangen. Beim Löschen des Cage-Objekts gibt es dem Server den Befehl, die Verbindung zu beenden und die Dateien zu schließen. Die Beendigung der Verbindung kann auch von den Servern selbst initiiert werden.

Das System erhöht die Lese-/Schreibgeschwindigkeit durch das Caching häufig verwendeter Dateiabschnitte in den Client-Programmen im Arbeitsspeicher (Puffer).
Die Client-Software kann beliebig viele Cage-Objekte mit unterschiedlichen Einstellungen (Speichervolumen, Blockgröße beim Austausch mit dem Server usw.) verwenden.

Ein Cage-Objekt kann Daten mit mehreren Dateien auf mehreren Servern austauschen. Die Parameter für die Verbindung (IP-Adresse oder DNS-Server, Hauptport für die Autorisierung, Pfad und Dateiname) werden bei der Erstellung des Objekts festgelegt.

Da jedes Cage-Objekt gleichzeitig mit mehreren Dateien arbeiten kann, wird dafür ein gemeinsamer Speicherbereich für das Caching verwendet. Die Größe des Caches – die Anzahl der Seiten und deren Größe – wird dynamisch bei der Erstellung des Cage-Objekts festgelegt. Zum Beispiel ist ein 1 GB Cache 1000 Seiten zu 1 MB, oder 10.000 Seiten zu 100 KB, oder 1 Million Seiten zu 1 KB. Die Auswahl 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 unterschiedliche Pufferungseinstellungen je nach Zugriffsmerkmalen auf Informationen in verschiedenen Dateien festzulegen. Als Basis wird ein einfachster Pufferungsalgorithmus verwendet: Nach Erschöpfung des festgelegten Speichervolumens verdrängen neue Seiten die alten nach dem Prinzip der minimalen Zugriffsanzahl. Die Pufferung ist besonders effektiv bei ungleichmäßigem (statistisch gesehen) gleichzeitigen Zugriff, erstens auf verschiedene Dateien und zweitens auf Abschnitte jeder Datei.

Die Klasse Cage unterstützt Ein- und Ausgabe nicht nur anhand von Datenadressen (mit Angabe der Position und Länge des Arrays, wodurch sie die Dateioperationssysteme "ersetzt"), sondern auch auf einer niedrigeren, "physikalischen" Ebene – anhand von Seitennummern im Arbeitsspeicher.

Für Cage-Objekte wird die originale Funktion unterstützt "Hibernate" („Schlaf“) – sie können „zusammengefasst“ werden (zum Beispiel im Falle eines Verbindungsabbruchs zu den Servern oder beim Stoppen der Anwendung usw.) in eine lokale Dump-Datei auf der Client-Seite und schnell aus dieser Datei wiederhergestellt werden (nach Wiederherstellung der Verbindung, beim erneuten Start der Anwendung). Dies ermöglicht eine erhebliche Reduzierung des Datenverkehrs, wenn das Client-Programm nach einer temporären „Offline“-Phase wieder aktiviert wird, da häufig verwendete Dateifragemente bereits im Cache vorhanden sein werden.

Cage ist ungefähr 3600 Zeilen Code.

Prinzipien des Serveraufbaus

Cageserver-Dateiserver können mit einer beliebigen Anzahl von Ports gestartet werden, von denen einer („hauptsächlich“) nur für die Authentifizierung aller Clients verwendet wird, während die anderen für den Datenaustausch dienen. Die Cage-Serveranwendung benötigt nur Python. Gleichzeitig kann der Computer mit dem Datei-Server jede andere Arbeit ausführen.

Der Server wird zunächst als Kombination aus zwei Hauptprozessen gestartet:

1. „Verbindungen“ – ein Prozess zur Durchführung von Verbindungsherstellungen mit Clients und deren Beendigung auf Initiative des Servers;
2. „Operationen“ – ein Prozess zur Durchführung von Aufträgen (Operationen) der Clients im Umgang mit Dateien sowie zum Schließen von Verbindungssitzungen auf Anweisung der Clients.

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

Der Prozess „Operationen“ unterstützt die Teilung der Dateiresourcen, wobei mehrere verschiedene Clients gleichzeitig (quasi-parallel, da der Zugriff über Sperren gesteuert wird) Daten aus einer Datei lesen können, sofern dies beim anfänglichen Öffnen durch den „ersten“ Client genehmigt 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 die allgemeine Geschwindigkeit von Lese-/Schreibvorgängen zu erhöhen, werden diese Operationen in Threads durchgeführt, die vom Prozess „Operationen“ erzeugt werden. Die Anzahl der Threads entspricht in der Regel der Anzahl der geöffneten Dateien. Lese-/Schreibaufträge von Kunden werden in eine gemeinsame Warteschlange eingereicht, und der erste verfügbare Thread nimmt den Auftrag vom Kopf der Warteschlange an. Eine spezielle Logik ermöglicht es, Datenüberschreibungen im Arbeitsspeicher des Servers auszuschließen.

Der Prozess „Operationen“ überwacht die Aktivität der Kunden und stellt deren Bedienung sowohl auf deren Anforderung als auch bei Überschreitung des Zeitlimits für Inaktivität ein.

Um die Zuverlässigkeit sicherzustellen, führt Cageserver Protokolle über alle Transaktionen. Ein allgemeines Protokoll enthält Kopien der Nachrichten von Kunden mit Aufträgen zum Erstellen, Öffnen, Umbenennen und Löschen von Dateien. Für jede Arbeitsdatei wird ein separates Protokoll erstellt, in dem Kopien von Nachrichten mit Aufträgen zum Lesen und Schreiben von Daten in dieser Arbeitsdatei sowie Arrays der geschriebenen (neuen) Daten und Arrays von Daten, die beim Überschreiben (Speichern neuer Daten „über“ alten) gelöscht wurden, aufgezeichnet werden.

Diese Protokolle ermöglichen sowohl die Wiederherstellung neuer Änderungen aus Sicherungskopien als auch das „Rollback“ des aktuellen Inhalts zu einem gewünschten Zeitpunkt in der Vergangenheit.

Cageserver besteht aus etwa 3100 Zeilen Code.

Starten des Datei-Servers Cageserver

Beim Starten im Dialog muss Folgendes festgelegt werden:
— der Hauptport für die Autorisierung;
— die Anzahl der Ports für den Austausch von Transaktionen mit autorisierten Kunden (ab mindestens einem, der Pool von Nummern 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 die Interaktion mit Datei-Servern ermöglichen und über Pufferspeicher verfügen.

Parameter

• cage_name(str) — der bedingte Name des Objekts, der bei der Identifizierung von Kunden auf der Serverseite verwendet wird
• pagesize(int) — die Größe einer Seite im Pufferspeicher (in Bytes)
• numpages(int) — die Anzahl der Seiten im Pufferspeicher
• maxstrlen(int) — die maximale Länge der Byte-Zeichenfolge bei Lese- und Schreiboperationen
• server_ip(dict) — ein Wörterbuch mit den verwendeten Adressen Server, wo 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 und realen Adressen ist vorübergehend und kann geändert werden)
• warte(int) — die Wartezeit auf eine Antwort vom Server beim Empfang der Ports (in Sek.)
• wach(boolean) — das Flag für die Art und Weise, wie das Objekt erstellt wird (Falsch — wenn ein neues Objekt erstellt wird, Wahr — wenn das Objekt aus einem zuvor «reduzierten» Zustand erstellt wird — durch Anwendung der Operation «Hibernation», standardmäßig Falsch)
• cache_file(str) — der Name der Datei für die Hibernation

Methoden

Cage.file_create( server, pfad ) – eine neue Datei erstellen

Cage.file_rename( server, pfad, neuer_name ) – die Datei umbenennen

Cage.file_remove( server, pfad) – die Datei löschen

Cage.öffnen( server, pfad, mod ) – die Datei öffnen

Gibt zurück fchannel die Kanalnummer. Der Parameter mod — ist der Modus zum Öffnen der Datei: „wm“ — monopol (lesen/schreiben), „rs“ — nur lesen, und von anderen Clients nur zum Lesen freigegeben, „ws“ — lesen/schreiben, und von anderen Clients nur zum Lesen freigegeben.

Cage.schließen (fchannel) – die Datei schließen

Cage.schreiben (fchannel, beginn, daten ) – eine Byte-Zeichenfolge in die Datei schreiben

Cage.lesen (fchannel, beginn, len_daten ) – eine Byte-Zeichenfolge aus der Datei lesen

Cage.put_pages ( fchannel ) – „schiebt“ alle modifizierten Seiten des angegebenen Kanals aus dem Puffer auf den Server. Wird an den Stellen des Algorithmus verwendet, an denen sichergestellt werden muss, dass alle Vorgänge auf dem Kanal physisch in der Datei auf dem Server gespeichert sind.

Cage.push_all () – „schiebt“ alle modifizierten Seiten aller Kanäle für die Instanz der Klasse Cage aus dem Puffer auf den Server. Wird verwendet, wenn sichergestellt werden muss, dass alle Vorgänge auf allen Kanälen auf dem Server gespeichert sind.

Quelle: habr.com