System syfte
Stöd för fjärråtkomst till filer på datorer i nätverket. Systemet stöder "virtuelt" alla grundläggande filoperationer (skapande, radering, läsning, skrivning, etc.) genom att utbyta transaktioner (meddelanden) med hjälp av TCP-protokollet.
tillämpningar
Systemets funktionalitet är effektiv i följande fall:
- i inbyggda applikationer för mobila och inbyggda enheter (smarttelefoner, inbyggda kontrollsystem, etc.) som kräver snabb åtkomst till filer på fjärrservrar inför eventuella tillfälliga avbrott i kommunikationen (med att gå offline);
- i laddade DBMS:er, om frågebehandling utförs på vissa servrar och datalagring utförs på andra;
- i distribuerade företagsnätverk för insamling och bearbetning av information, som kräver höghastighetsdatautbyte, redundans och tillförlitlighet;
- i komplexa system med mikrotjänstarkitektur, där förseningar i informationsutbytet mellan moduler är kritiska.
Struktur
Cage-systemet (det finns en implementering - betaversion i Python 3.7 på Windows) innehåller två huvuddelar:
- Cageserver — Ett filserverprogram (ett paket med funktioner) som körs på datorer i nätverket vars filer kräver fjärråtkomst.
- klass Cage med ett bibliotek av metoder för klientprogramvara, vilket förenklar kodningen av interaktion med servrar.
Använda systemet på klientsidan
Metoderna i klassen Cage ersätter de vanliga "rutinmässiga" filsystemoperationerna: skapa, öppna, stänga, ta bort filer, samt läsa/skriva data i binärt format (som indikerar informationens position och storlek). Begreppsmässigt ligger dessa metoder nära filfunktionerna i C-språket, där öppning/stängning av filer utförs "på kanaler" för in-/utdata.
Med andra ord, programmeraren fungerar inte med metoder för "fil"-objekt (klass _io i Python), men med metoder i klassen Cage.
När en instans av ett Cage-objekt skapas upprättar det en initial anslutning med en server (eller flera servrar), auktoriseras av klient-ID:t och får bekräftelse med ett dedikerat portnummer för alla filoperationer. När ett Cage-objekt raderas, instruerar det servern att sluta kommunicera och stänga filerna. Avslutning av kommunikation kan också initieras av servrarna själva.
Systemet förbättrar läs-/skrivprestandan genom att buffra ofta använda filfragment av klientprogram i RAM-cachen (bufferten).
Klientprogramvara kan använda valfritt antal Cage-objekt med olika inställningar (buffertminnesstorlek, blockstorlek vid utbyte med servern, etc.).
Ett enda Cage-objekt kan kommunicera med flera filer på flera servrar. Kommunikationsparametrar (IP-adress eller DNS-server, huvudport för behörighet, sökväg och filnamn) anges när objektet skapas.
Eftersom varje Cage-objekt kan arbeta med flera filer samtidigt, används delat minnesutrymme för buffring. Cachestorlek – antalet sidor och deras storlek ställs in dynamiskt när du skapar ett Cage-objekt. Till exempel är en 1 GB cache 1000 sidor på 1 MB vardera, eller 10 tusen sidor på 100 KB vardera, eller 1 miljon sidor på 1 KB vardera. Att välja storlek och antal sidor är en specifik uppgift för varje applikationsfall.
Du kan använda flera Cage-objekt samtidigt för att definiera olika buffertminnesinställningar beroende på hur informationen nås i olika filer. Som en grundläggande sådan används den enklaste buffringsalgoritmen: efter att en viss mängd minne är uttömt, ersätter nya sidor gamla enligt principen om pensionering med ett minsta antal åtkomster. Buffring är särskilt effektiv vid ojämn (i statistisk mening) delad åtkomst, för det första till olika filer, och för det andra till fragment av varje fil.
Cage-klassen stöder I/O inte bara genom dataadresser (som indikerar arrayens position och längd, "ersätter" filsystemoperationer), utan också på en lägre, "fysisk" nivå - med sidnummer i buffertminnet.
Den ursprungliga funktionen stöds för Cage-objekt "dvala" ("sömn") - de kan "kollapseras" (till exempel i händelse av en förlust av anslutningen till servrar, eller när applikationen stoppas, etc.) till en lokal dumpfil på klientsidan och snabbt återställas från denna fil (efter att kommunikationen har återupptagits, när du startar om programmet). Detta gör det möjligt att avsevärt minska trafiken när du aktiverar klientprogrammet efter att tillfälligt gå "offline", eftersom ofta använda filfragment redan finns i cachen.
Cage är cirka 3600 rader kod.
Principer för serverkonstruktion
Cageserver-filservrar kan köras med ett godtyckligt antal portar, varav en ("main") endast används för auktorisering av alla klienter, resten används för datautbyte. Cage-serverprogrammet kräver endast Python. Parallellt kan datorn med filservern utföra vilket annat arbete som helst.
Servern startar initialt som en samling av två huvudprocesser:
- "Anslutningar" – en process för att utföra operationerna att upprätta kommunikation med klienter och avsluta den på initiativ av servern;
- "Operationer" – en process för att utföra uppgifter (operationer) av klienter för att arbeta med filer, samt för att avsluta kommunikationssessioner baserat på klientkommandon.
Båda processerna är inte synkroniserade och är organiserade som ändlösa loopar för att ta emot och skicka meddelanden baserade på multiprocessköer, proxyobjekt, lås och sockets.
Anslutningsprocessen allokerar en port för varje klient för att ta emot och överföra data. Antalet portar ställs in när servern startar. Mappningen mellan portar och klienter lagras i mellanprocessdelat proxyminne.
Operationsprocessen stöder delning av filresurser så att flera olika klienter kan dela (kvasi-parallell, eftersom åtkomst kontrolleras av lås) läser data från en fil om detta var tillåtet när den initialt öppnades av den "första" klienten.
Behandling av kommandon för att skapa/ta bort/öppna/stänga filer på servern utförs i själva "Operations"-processen strikt sekventiellt med hjälp av filundersystemet i serverns operativsystem.
För att generellt påskynda läsning/skrivning utförs dessa operationer i trådar som skapats av "Operations"-processen. Antalet trådar är vanligtvis lika med antalet öppna filer. Läs/skrivuppgifter från klienter skickas till den allmänna kön och den första lediga tråden tar uppgiften från huvudet. Särskild logik gör att du kan eliminera dataomskrivningsoperationer i serverns RAM.
Operationsprocessen övervakar klientaktivitet och slutar att betjäna dem antingen efter deras kommandon eller när inaktivitetstiden överskrids.
För att säkerställa tillförlitligheten håller Cageserver loggar över alla transaktioner. En allmän logg innehåller kopior av meddelanden från klienter med uppgifter att skapa/öppna/byta namn på/ta bort filer. En separat logg skapas för varje arbetsfil, i vilken kopior av meddelanden med uppgifter för läsning och skrivning av data i denna arbetsfil registreras, liksom arrayer av skrivna (nya) data och arrayer av data som förstördes under överskrivning (skrivande) nya data "överst" på gamla). ).
Dessa loggar ger möjlighet att både återställa nya ändringar av säkerhetskopior och återställa aktuellt innehåll till en punkt i det förflutna.
Cageserver är cirka 3100 rader kod.
Startar Cageserver-filserverprogrammet
När du startar, i dialogrutan måste du definiera:
— Huvudhamn för tillstånd.
— Antalet portar för utbyte av transaktioner med auktoriserade klienter (från 1 eller fler, poolen av nummer börjar från den bredvid huvudportnumret).
Använda Cage Class
klass bur.Cage( cage_name="", pagesize=0, numpages=0, maxstrlen=0, server_ip={}, wait=0, awake=False, cache_file="" )
Objekt skapas från denna klass som interagerar med filservrar och innehåller buffertminne.
Parametrar
- burnamn(str) - villkorligt namn på objektet, som används för att identifiera klienter på serversidan
- sidstorlek(int) — storleken på en sida buffertminne (i byte)
- siffror(int) — antal buffertminnessidor
- maxstrlen(int) - den maximala längden på en bytesträng i skriv- och läsoperationer
- server_ip(dict) - en ordbok med adresserna till de servrar som används, där nyckeln är det villkorliga namnet på servern (server-id i applikationen), och värdet är en sträng med adressen: "ip-adress:port" eller "DNS: port” (jämförelsen av namn och riktiga adresser är tillfällig, den kan ändras)
- vänta(int) — väntetid för svar från servern vid mottagning av portar (i sekunder)
- vaken(boolean) — flagga för hur objektet skapas (Falsk - om ett nytt objekt skapas, Sant - om ett objekt skapas från ett tidigare "kollapserat" - med "viloläge", False som standard)
- cache_fil(str) - filnamn för viloläge
metoder
Bur.file_create( server, väg ) – skapa en ny fil
Bur.file_rename( server, sökväg, nytt_namn ) – byt namn på filen
Bur.file_remove( server, väg) - radera en fil
Bur.öppet( server, sökväg, mod ) - öppna fil
Returnerar fkanal kanalnummer. Parameter mod - detta är filöppningsläget: "wm" - exklusiv (läs/skriv), "rs" - skrivskyddad och delas endast för läsning av andra klienter, "ws" - läs/skriv och delas endast för läsning av andra kunder.
Bur.stäng (fkanal) – stäng filen
Bur.skriva (fchannel, börja, data ) – skriv en bytesträng till en fil
Bur.läsa (fchannel, start, len_data ) – läs en bytesträng från en fil
Bur.put_pages ( fkanal ) – "skjuter" från bufferten till servern alla sidor i den angivna kanalen som har modifierats. Den används vid de punkter i algoritmen när du behöver vara säker på att alla operationer på kanalen är fysiskt sparade i en fil på servern.
Bur.push_all () – "skjuter" från bufferten till servern alla sidor i alla kanaler för en instans av Cage-klassen som har modifierats. Används när du behöver vara säker på att alla operationer på alla kanaler är sparade på servern.
Källa: will.com