Systemets syfte
Stöd för fjÀrrÄtkomst till filer pÄ datorer i nÀtverket. Systemet stödjer "virtuellt" alla grundlÀggande filoperationer (skapande, radering, lÀsning, skrivning och sÄ vidare) genom utbyte av transaktioner (meddelanden) via TCP-protokollet.
AnvÀndningsomrÄden
Systemets funktionalitet Àr effektiv i följande fall:
- i inhemska applikationer för mobila och inbyggda enheter (smartphones, styrsystem och sÄ vidare) som krÀver snabb Ätkomst till filer pÄ fjÀrrservrar i situationer med potentiella tillfÀlliga avbrott i anslutningen (nÀr de gÄr offline);
- i belastade databashanteringssystem, om bearbetning av förfrÄgningar utförs pÄ en server, medan datalagring sker pÄ en annan;
- i distribuerade företagsnÀtverk för insamling och bearbetning av information, dÀr hög dataöverföringshastighet, reservkopiering och tillförlitlighet krÀvs;
- i komplexa system med mikrotjÀnstarkitektur, dÀr fördröjningar i informationsutbytet mellan moduler Àr kritiskt viktiga.
Struktur
Cage-systemet (det finns en implementation â beta-version pĂ„ Python 3.7 för Windows) inkluderar tvĂ„ huvuddelar:
- Cageserver â en filserverapplikation (funktionspaket) 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 som förenklar kodning av interaktion med servrar.
AnvÀndning av systemet pÄ klientsidan
Metoderna i Cage-klassen ersÀtter vanliga, "rutinemÀssiga" filsystemoperationer: skapande, öppnande, stÀngning, radering av filer, samt lÀsa/skriva data i binÀrt format (med angivande av position och storlek pÄ data). Konceptuellt Àr dessa metoder nÀra filfunktionerna i C-sprÄket, dÀr öppning/stÀngning av filer sker "pÄ kanaler" för in- och utdata.
Med andra ord arbetar programmören inte med metoder för "fil"-objekt (klassen _io i Python), utan med metoderna frÄn klassen Cage.
NÀr en instans av objektet Cage skapas, upprÀttar det initial förbindelse med servern (eller flera servrar), genomgÄr autentisering med kundens ID och fÄr en bekrÀftelse med numret för den tilldelade porten för att utföra alla filoperationer. NÀr objektet Cage tas bort, kommer det att ge servern ett kommando att avsluta förbindelsen och stÀnga filerna. Förbindelsen kan Àven initieras av servrarna sjÀlva.
Systemet ökar hastigheten pÄ lÀs-/skrivoperationer baserat pÄ buffring av ofta anvÀnda filfragment i klientprogrammens cache (buffert) i RAM-minnet.
Klientprogramvaran kan anvÀnda ett obegrÀnsat antal objekt Cage med olika instÀllningar (buffertstorlek, blockstorlek vid kommunikation med servern, etc.).
Ett objekt Cage kan utbyta data med flera filer pÄ flera servrar. Parametrarna för förbindelsen (IP-adress eller DNS för servern, huvudport för autentisering, filvÀg och namn) anges vid skapandet av objektet.
Eftersom varje objekt Cage kan arbeta med mĂ„nga filer samtidigt, anvĂ€nds ett gemensamt minnesutrymme för buffrande. Cache-storleken â antalet sidor och deras storlek, anges dynamiskt vid skapandet av objektet Cage. Till exempel, en cache pĂ„ 1 GB Ă€r 1000 sidor pĂ„ 1 MB, eller 10 000 sidor pĂ„ 100 KB, eller 1 miljon sidor pĂ„ 1 KB. Valet av storlek och antal sidor Ă€r en specifik uppgift för varje ansökningsfall.
Flera objekt Cage kan anvÀndas samtidigt för att bestÀmma olika buffertinstÀllningar beroende pÄ Ätkomstmönster till information i olika filer. Som grund tillÀmpas den enklaste buffringsalgoritmen: efter att den angivna mÀngden minne har uppnÄtts, ersÀtter nya sidor gamla enligt principen för borttagning med minimiantalet Ätkomster. Buffring Àr sÀrskilt effektiv vid oregelbundet (statistiskt sett) gemensamt tilltrÀde, först och frÀmst till olika filer, och för det andra, till fragment av varje fil.
Klassen Cage stödjer in- och utmatning inte bara per datadress (ange position och lĂ€ngd pĂ„ arrayen, "ersĂ€tter" operationerna i filsystemet), utan ocksĂ„ pĂ„ en lĂ€gre, "fysisk" nivĂ„ â per sidnummer i buffrat minne.
För objekt Cage stöds en originell funktion "dvalande" («sömn») â de kan "minskas" (till exempel vid avbrott i kommunikationen med servrar, eller nĂ€r applikationen stĂ€ngs av, etc.) i en lokal dumpfil pĂ„ klientens sida och snabbt Ă„terstĂ€llas frĂ„n denna fil (efter att kommunikationen Ă„terupptas, vid omstart av applikationen). Detta ger en betydande minskning av trafiken nĂ€r klientprogrammet aktiveras efter en tillfĂ€llig 'offline'-period, eftersom ofta anvĂ€nda delar av filer redan kommer att finnas i cacheminnet.
Cage â det handlar om cirka 3600 rader kod.
Principerna för att bygga servrar
Filsystemet Cageserver kan köras med ett valfritt antal portar, varav en ('huvudporten') enbart anvÀnds för att autentisera alla kunder, medan de övriga anvÀnds för datakommunikation. För Cage-serverprogrammet krÀvs endast Python. Samtidigt kan datorn med filsservern utföra vilket annat arbete som helst.
Servern startas inledningsvis som en samling av tvÄ grundlÀggande processer:
- "Anslutningar" â processen för att utföra operationer för att etablera och avsluta anslutningar med klienterna pĂ„ serverns initiativ;
- "Operationer" â processen för att utföra uppgifter (operationer) frĂ„n klienterna angĂ„ende filhantering, samt för att stĂ€nga anslutningar pĂ„ kunders kommandon.
BÄda processerna Àr inte synkroniserade och organiserade som oÀndliga loopar av meddelandehantering baserat pÄ multiprocessorköer, proxyobjekt, lÄs och sockets.
Processen för "Anslutningar" tilldelar varje klient en port för dataöverföring. Antalet portar anges vid serverstart. Ăverenskommelsen mellan portar och klienter lagras i delat proxyminne mellan processerna.
Processen för "Operationer" stödjer delning av filresurser, vilket gör att flera olika kunder kan gemensamt (nÀraparallellt, eftersom Ätkomsten styrs av lÄs) lÀsa data frÄn en fil, om detta har godkÀnts vid den initiala öppningen av filen av den "första" klienten.
Behandling av kommandon för skapande/fÄ bort/öppning/stÀngning av filer servern utförs i sjÀlva processen för "Operationer" strikt sekventiellt med hjÀlp av operativsystemets filsystem pÄ servern.
För att öka hastigheten för lÀsning/skrivning utförs dessa operationer i trÄdar (threads) som skapas av processen "Operationer". Antalet trÄdar Àr vanligtvis lika med antalet öppna filer. Uppgifter för lÀsning/skrivning frÄn kunder skickas till en gemensam kö och den första lediga trÄden plockar upp uppgiften frÄn köns början. Speciell logik möjliggör att utesluta operationer för överskrivning av data i serverns RAM.
Processen "Operationer" övervakar kundernas aktivitet och avbryter deras tjÀnst bÄde pÄ deras order och nÀr en timeout för inaktivitet överskrids.
För att sÀkerstÀlla tillförlitlighet hÄller Cageserver loggar över alla transaktioner. En gemensam logg innehÄller kopior av meddelanden frÄn kunder med uppgifter för att skapa/öppna/omdöpa/ta bort filer. För varje arbetsfil skapas en separat logg dÀr 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 blev förstörda vid överskrivning (nÀr nya data skrivs "över" gamla).
Dessa loggar ger möjlighet att bÄde ÄterstÀlla nya Àndringar i sÀkerhetskopior och att "ÄtergÄ" frÄn det aktuella innehÄllet till en önskad tidpunkt i det förflutna.
Cageserver bestÄr av cirka 3100 kodrader.
Starta programmet filserver Cageserver
Vid start i dialogen mÄste du ange:
â huvudporten för auktorisation;
â antalet portar för transaktionsutbyte med auktoriserade kunder (frĂ„n 1 och fler, poolen av nummer börjar med nĂ€sta nummer efter huvudportens nummer).
AnvÀnda klassen Cage
klass cage.Cage( cage_name=»», pagesize=0, numpages=0, maxstrlen=0, server_ip={}, wait=0, awake=False, cache_file=»» )
FrÄn denna klass skapas objekt som interagerar med filservrar och innehÄller bufferminnet.
Parametrar
- cage_name(str) â det vill sĂ€ga ett namn för objektet som anvĂ€nds vid identifiering av kunder pĂ„ serverns sida
- pagesize(int) â storleken pĂ„ en sidbuffert (i bytes)
- numpages(int) â antalet sidor i bufferminnet
- maxstrlen(int) â maximal lĂ€ngd pĂ„ byte-strĂ€ngen i lĂ€s- och skrivoperationer
- server_ip(dict) â en ordbok med adresser som anvĂ€nds servrar, dĂ€r nyckeln Ă€r det villkorliga servernamnet (server-ID i applikationen) och vĂ€rdet Ă€r en strĂ€ng med adress: âip address:portâ eller âDNS:portâ (mappning av namn och verkliga adresser Ă€r temporĂ€rt, det kan Ă€ndras)
- vĂ€nta(int) â svarstid frĂ„n servern vid mottagning av portar (i sek.)
- vakna(boolean) â flagga för hur objektet skapas (Falskt â om ett nytt objekt skapas, Sant â om objektet skapas frĂ„n ett tidigare âvilandeâ â genom operationen âhibernationâ, som standard Falskt)
- cache_file(str) â namn pĂ„ filen för hibernation
Metoder
Cage.file_create( server, path ) â skapa en ny fil
Cage.file_rename( server, path, new_name ) â döp om filen
Cage.file_remove( server, path) â ta bort filen
Cage.open( server, path, mod ) â öppna filen
Returnerar fchannel kanalens nummer. Parametern mod â detta Ă€r mod för att öppna filen: 'wm' â monopol (lĂ€sning/skrivning), 'rs' â endast lĂ€sning, och delad endast för lĂ€sning av andra klienter, 'ws' â lĂ€sning/skrivning, och delad endast för lĂ€sning av andra klienter.
Cage.stĂ€ng (fchannel) â stĂ€ng filen
Cage.skriv (fchannel, begin, data ) â skriv en byte-strĂ€ng till filen
Cage.lĂ€s (fchannel, begin, len_data ) â lĂ€s en byte-strĂ€ng frĂ„n filen
Cage.put_pages ( fchannel ) â âskickarâ ut frĂ„n bufferten till servern alla sidor i den angivna kanalen som har modifierats. AnvĂ€nds vid de punkter i algoritmen nĂ€r det Ă€r nödvĂ€ndigt att vara sĂ€ker pĂ„ att alla operationer pĂ„ kanalen fysiskt har sparats i filen pĂ„ servern.
Cage.push_all () â âskickarâ ut frĂ„n bufferten till servern alla sidor i alla kanaler för instansen av klassen Cage som har modifierats. AnvĂ€nds nĂ€r det Ă€r nödvĂ€ndigt att vara sĂ€ker pĂ„ att alla operationer pĂ„ alla kanaler har sparats pĂ„ servern.
KĂ€lla: habr.com
