Cage bestands toegangssysteem

Doel van het systeem

Ondersteuning voor externe toegang tot bestanden op computers in het netwerk. Het systeem ondersteunt ‘virtueel’ alle belangrijke bestandsoperaties (aanmaken, verwijderen, lezen, schrijven, enz.) door transacties (berichten) uit te wisselen via het TCP-protocol.

Toepassingsgebieden

De functionaliteit van het systeem is effectief in de volgende gevallen:

• in native applicaties voor mobiele en embedded apparaten (smartphones, boordbeheersystemen, enz.), die snelle toegang tot bestanden op externe servers vereisen onder omstandigheden van mogelijke tijdelijke verbindingsonderbrekingen (offline gaan);
• in zwaarbelaste databasebeheersystemen, wanneer de verwerking van verzoeken op de ene server plaatsvindt en de opslag van gegevens op een andere;
• in gedistribueerde bedrijfsnetwerken voor het verzamelen en verwerken van informatie, die hoge dataverkeer snelheid, redundantie en betrouwbaarheid vereisen;
• in complexe systemen met microservices-architectuur, waar vertragingen in de informatie-uitwisseling tussen modules van cruciaal belang zijn.

Structuur

Het Cage-systeem (er is een implementatie — beta-versie op Python 3.7 in Windows OS) omvat twee hoofdcomponenten:

1. Cageserver — een bestandserverprogramma (functionaliteitspakket), dat op computers in het netwerk wordt uitgevoerd waarvan de bestanden externe toegang vereisen;
2. klasse Cage met een bibliotheek van methoden voor clientsoftware die de codering van interactie met servers vereenvoudigt.

Gebruik van het systeem aan de klantzijde

De methoden van de Cage-klasse vervangen de gebruikelijke, ‘routine’ bestandsoperaties: aanmaken, openen, afsluiten, verwijderen van bestanden, evenals lezen/schrijven van gegevens in binaire vorm (met vermelding van positie en grootte van de gegevens). Conceptueel zijn deze methoden vergelijkbaar met de bestandsfuncties van de C-taal, waar bestanden ‘over kanalen’ van invoer-uitvoer worden geopend/afgesloten.

Met andere woorden, de programmeur werkt niet met de methoden van ‘bestands’-objecten (klasse _io in Python), maar met de methoden van de Cage-klasse.

Bij het maken van een instantie van een Cage-object wordt een initiële verbinding met de server (of meerdere servers) tot stand gebracht, wordt authenticatie op basis van klant-ID doorlopen en wordt een bevestiging ontvangen met het nummer van de toegewezen poort voor het uitvoeren van alle bestandsoperaties. Bij het verwijderen van een Cage-object geeft het een commando aan de server om de verbinding te beëindigen en de bestanden te sluiten. De verbinding kan ook worden beëindigd door de servers zelf.

Het systeem verbetert de lees- en schrijfsnelheid door vaak gebruikte bestandsgedeelten in het cache-geheugen (buffer) van de clienttoepassingen te bufferen.
De clientsoftware kan een onbeperkt aantal Cage-objecten gebruiken met verschillende instellingen (buffergeheugen, blokgrootte bij communicatie met de server, enz.).

Één Cage-object kan gegevens uitwisselen met meerdere bestanden op verschillende servers. De parameters voor de verbinding (IP-adres of DNS van de server, hoofdpoort voor autorisatie, pad en bestandsnaam) worden ingesteld bij het aanmaken van het object.

Aangezien elk Cage-object gelijktijdig met meerdere bestanden kan werken, wordt er gebruikgemaakt van een gedeelde geheugenspace voor buffering. De grootte van de cache – het aantal pagina's en hun grootte – wordt dynamisch vastgesteld bij het aanmaken van het Cage-object. Bijvoorbeeld, een cache van 1 GB bestaat uit 1000 pagina's van 1 MB, of 10.000 pagina's van 100 KB, of 1 miljoen pagina's van 1 KB. De keuze van de grootte en het aantal pagina's is een specifieke taak voor elke toepassingscasus.

Er kunnen tegelijkertijd meerdere Cage-objecten worden gebruikt om verschillende instellingen voor het buffergeheugen te bepalen, afhankelijk van de kenmerken van de toegang tot informatie in verschillende bestanden. Als basis wordt een eenvoudig bufferingsalgoritme gebruikt: nadat de opgegeven geheugengrootte is bereikt, verdringen nieuwe pagina's oude op basis van de regel van eliminatie met het minste aantal toegangspunten. Buffering is bijzonder effectief bij ongelijkmatige (statistisch gezien) gelijktijdige toegang tot verschillende bestanden, en, ten tweede, tot fragmenten van elk bestand.

De Cage-klasse ondersteunt I/O niet alleen op gegevensadressen (met vermelding van positie en lengte van de array, 'vervangend' voor bestandsfuncties), maar ook op een lager, 'fysiek' niveau – op basis van paginanummers in het buffergeheugen.

Voor Cage-objecten wordt de originele functie ondersteund ‘hibernatie’ («snu») – deze kunnen worden «ingevouwen» (bijvoorbeeld in het geval van een onderbreking van de verbinding met de servers, of bij het stoppen van de applicatie, enz.) in een lokale dump-bestand aan de zijde van de klant en snel worden hersteld uit dit bestand (na het herstellen van de verbinding, bij het opnieuw starten van de applicatie). Dit stelt ons in staat om de traffic aanzienlijk te verminderen wanneer de client-applicatie weer actief wordt na een tijdelijke «offline» periode, aangezien vaak gebruikte bestandfragmenten zich al in de cache bevinden.

Cage — dit is ongeveer 3600 regels code.

Principes voor het bouwen van servers

Cageserver-bestandservers kunnen worden gestart met een willekeurig aantal poorten, waarvan één (‘hoofd’) alleen wordt gebruikt voor de autorisatie van alle klanten, en de andere voor gegevensuitwisseling. Voor het Cage-serverprogramma is alleen Python vereist. Tegelijkertijd kan de computer met de bestandserver elke andere taak uitvoeren.

De server wordt aanvankelijk opgestart als een combinatie van twee hoofprocessen:

1. «Verbindingen» – het proces voor het uitvoeren van verbindingsoprichtingsoperaties met klanten en hun beëindiging op initiatief van de server;
2. «Operaties» – het proces voor het uitvoeren van taken (operaties) van klanten met bestanden, evenals voor het afsluiten van verbindingssessies op verzoek van klanten.

Beide processen zijn niet gesynchroniseerd en zijn georganiseerd als eindeloze lussen voor het ontvangen en verzenden van berichten op basis van multiprocess-queues, proxy-objecten, locks en sockets.
Het «Verbindings»-proces wijst elke klant een poort toe voor gegevensoverdracht. Het aantal poorten wordt ingesteld bij het starten van de server. De overeenkomst tussen poorten en klanten wordt opgeslagen in gedeeld proxy-geheugen.

Het «Operaties»-proces ondersteunt de deling van bestandsresources, waarbij meerdere verschillende klanten samen (quasi-parallel, omdat de toegang wordt beheerd door locks) gegevens uit één bestand kunnen lezen, als dit was toegestaan bij de eerste opening door de ‘eerste’ klant.

Het verwerken van commando's voor het aanmaken/verwijderen/openen/sluiten van bestanden op de server gebeurt in het «Operaties»-proces strikt sequentieel met behulp van het besturingssysteem van de server.

Om het algemene lezen/schrijven te versnellen, worden deze bewerkingen uitgevoerd in threads die door het proces 'Operaties' worden gegenereerd. Het aantal threads is meestal gelijk aan het aantal geopende bestanden. Lezen/schrijven opdrachten van klanten worden in een gezamenlijke wachtrij geplaatst en de eerste vrijgegeven thread pakt de opdracht van de kop. Speciale logica maakt het mogelijk om data-hersoverwriting in het RAM van de server uit te sluiten.

Het proces 'Operaties' houdt toezicht op de activiteit van klanten en stopt hun dienstverlening zowel op hun commando als bij het overschrijden van de inactiviteitstimer.

Om de betrouwbaarheid te waarborgen, houdt Cageserver logs van alle transacties bij. Een gezamenlijke log bevat kopieën van berichten van klanten met opdrachten voor het aanmaken/openen/hernoemen/verwijderen van bestanden. Voor elk werkend bestand wordt een aparte log aangemaakt waarin kopieën van berichten met opdrachten voor het lezen en schrijven van gegevens in dat werkbestand worden bijgehouden, evenals arrays van geschreven (nieuwe) gegevens en arrays van gegevens die verloren zijn gegaan bij heroverschrijving (schrijven van nieuwe gegevens 'over' oude).

Deze logs bieden de mogelijkheid om zowel nieuwe wijzigingen in back-ups te herstellen als om terug te rollen van de huidige inhoud naar een gewenst moment in het verleden.

Cageserver bestaat uit ongeveer 3100 regels code.

Het starten van het Cageserver bestandserverprogramma

Bij de start moet het volgende worden bepaald:
— de hoofdpoort voor autorisatie;
— het aantal poorten voor transactiewisseling met geautoriseerde klanten (vanaf 1 of meer, de pool van nummers begint met het volgende nummer na het hoofpoortnummer).

Gebruik van de Cage-klasse

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

Uit deze klasse worden objecten gecreëerd die interactie hebben met bestandservers en geheugenbuffers bevatten.

Instellingen

• cage_name(str) — de voorwaardelijke naam van het object, die wordt gebruikt bij de identificatie van klanten aan de serverzijde
• pagesize(int) — de grootte van één pagina in de geheugenbuffer (in bytes)
• numpages(int) — het aantal pagina's in de geheugenbuffer
• maxstrlen(int) — de maximale lengte van een byte-string in lees- en schrijfoperaties
• server_ip(dict) — een woordenboek met de gebruikte adressen servers, waarbij de sleutel de voorwaardelijke naam van de server is (server-id binnen de applicatie), en de waarde een string met het adres: “ip-adres:poort” of “DNS:poort” (de mapping van namen en werkelijke adressen is tijdelijk en kan worden gewijzigd)
• wachten(int) – de wachttijd voor een antwoord van de server bij het ontvangen van poorten (in sec.)
• wakker(boolean) – een vlag voor de methode van objectcreatie (False – als er een nieuw object wordt aangemaakt, Waar – als het object wordt aangemaakt vanuit een eerder ‘ingevroren’ — door het toepassen van de ‘hibernatie’-bewerking, standaard is Onwaar)
• cache_bestand(str) – de naam van het bestand voor hibernatie

Methoden

Cage.bestand_aangemaakt( server, pad ) – een nieuw bestand aanmaken

Cage.bestand_hernoemen( server, pad, nieuwe_naam ) – bestand hernoemen

Cage.bestand_verwijderen( server, pad) – bestand verwijderen

Cage.open( server, pad, mod ) – bestand openen

Geeft terug fchannel kanaalnummer. De parameter mod – dit is de modus voor het openen van het bestand: «wm» — exclusief (lezen/schrijven), «rs» — alleen lezen, en gedeeld alleen voor lezen door andere clients, «ws» — lezen/schrijven, en gedeeld alleen voor lezen door andere clients.

Cage.sluiten (fchannel) – bestand sluiten

Cage.write (fchannel, begin, data ) – schrijf een byte-string naar het bestand

Cage.read (fchannel, begin, len_data ) – lees een byte-string uit het bestand

Cage.zet_paginas ( fchannel ) – ‘stoot’ alle pagina’s van de opgegeven kanaal uit de buffer naar de server die zijn gewijzigd. Wordt op die punten in het algoritme gebruikt waar je zeker wilt zijn dat alle operaties op het kanaal fysiek zijn opgeslagen in het bestand op de server.

Cage.duwen_alles () – ‘stoot’ alle pagina’s van alle kanalen voor een instantie van de klasse Cage uit de buffer naar de server die zijn gewijzigd. Wordt gebruikt wanneer je zeker wilt zijn dat alle operaties op alle kanalen zijn opgeslagen op de server.

Bron: habr.com