Systemformål
Støtte for ekstern tilgang til filer på datamaskiner på nettverket. Systemet støtter "virtuelt" alle grunnleggende filoperasjoner (oppretting, sletting, lesing, skriving, etc.) ved å utveksle transaksjoner (meldinger) ved hjelp av TCP-protokollen.
søknader
Funksjonaliteten til systemet er effektiv i følgende tilfeller:
- i native applikasjoner for mobile og innebygde enheter (smarttelefoner, innebygde kontrollsystemer, etc.) som krever rask tilgang til filer på eksterne servere i møte med mulige midlertidige avbrudd i kommunikasjonen (med å gå offline);
- i lastede DBMS-er, hvis spørringsbehandling utføres på noen servere, og datalagring utføres på andre;
- i distribuerte bedriftsnettverk for innsamling og behandling av informasjon, som krever høyhastighets datautveksling, redundans og pålitelighet;
- i komplekse systemer med mikrotjenestearkitektur, hvor forsinkelser i utveksling av informasjon mellom moduler er kritiske.
Struktur
Cage-systemet (det er en implementering - betaversjon i Python 3.7 på Windows) inkluderer to hoveddeler:
- Cageserver — et filserverprogram (en pakke med funksjoner) som kjører på datamaskiner på nettverket hvis filer krever ekstern tilgang;
- klasse Cage med et bibliotek med metoder for klientprogramvare, som forenkler kodingen av interaksjon med servere.
Bruk av systemet på klientsiden
Metodene til Cage-klassen erstatter de vanlige, "rutinemessige" filsystemoperasjonene: opprette, åpne, lukke, slette filer, så vel som lese/skrive data i binært format (som indikerer posisjon og størrelse på dataene). Konseptuelt er disse metodene nær filfunksjonene til C-språket, der åpning/lukking av filer utføres "på kanaler" for input/output.
Med andre ord, programmereren fungerer ikke med metoder for "fil"-objekter (class _io i Python), men med metoder i Cage-klassen.
Når en forekomst av et Cage-objekt opprettes, etablerer det en innledende forbindelse med en server (eller flere servere), er autorisert av klient-ID, og mottar bekreftelse med et dedikert portnummer for alle filoperasjoner. Når et Cage-objekt slettes, instruerer det serveren om å slutte å kommunisere og lukke filene. Avslutning av kommunikasjon kan også initieres av serverne selv.
Systemet forbedrer lese-/skriveytelsen ved å bufre ofte brukte filfragmenter av klientprogrammer i RAM-cachen (bufferen).
Klientprogramvare kan bruke et hvilket som helst antall Cage-objekter med forskjellige innstillinger (bufferminnestørrelse, blokkstørrelse ved utveksling med serveren osv.).
Et enkelt Cage-objekt kan kommunisere med flere filer på flere servere. Kommunikasjonsparametere (IP-adresse eller DNS-server, hovedport for autorisasjon, bane og filnavn) spesifiseres når objektet opprettes.
Siden hvert Cage-objekt kan arbeide med flere filer samtidig, brukes delt minneplass til buffering. Bufferstørrelse – antall sider og størrelsen på dem, angis dynamisk når du oppretter et Cage-objekt. For eksempel er en 1 GB cache 1000 sider på 1 MB hver, eller 10 tusen sider på 100 KB hver, eller 1 million sider på 1 KB hver. Å velge størrelse og antall sider er en spesifikk oppgave for hver søknadssak.
Du kan bruke flere Cage-objekter samtidig for å definere forskjellige bufferminneinnstillinger avhengig av hvordan informasjonen er tilgjengelig i forskjellige filer. Som en grunnleggende, brukes den enkleste bufferalgoritmen: etter at en gitt mengde minne er oppbrukt, erstatter nye sider gamle i henhold til prinsippet om pensjonering med et minimum antall tilganger. Bufring er spesielt effektivt ved ujevn (i statistisk forstand) delt tilgang, for det første til forskjellige filer, og for det andre til fragmenter av hver fil.
Cage-klassen støtter I/O ikke bare av dataadresser (som indikerer posisjonen og lengden på arrayet, "erstatter" filsystemoperasjoner), men også på et lavere, "fysisk" nivå - etter sidetall i bufferminnet.
Den opprinnelige funksjonen støttes for Cage-objekter "dvale" ("sleep") - de kan "kollapses" (for eksempel ved tap av forbindelse med servere, eller når applikasjonen stoppes osv.) til en lokal dumpfil på klientsiden og raskt gjenopprettet fra denne filen (etter at kommunikasjonen er gjenopptatt, når du starter programmet på nytt). Dette gjør det mulig å redusere trafikken betraktelig ved aktivering av klientprogrammet etter midlertidig å være "offline", siden ofte brukte filfragmenter allerede vil være i hurtigbufferen.
Cage er omtrent 3600 linjer med kode.
Prinsipper for serverkonstruksjon
Cageserver-filservere kan kjøres med et vilkårlig antall porter, hvorav en ("main") kun brukes for autorisasjon av alle klienter, resten brukes til datautveksling. Cage-serverprogrammet krever bare Python. Parallelt kan datamaskinen med filserveren utføre alt annet arbeid.
Serveren starter i utgangspunktet som en samling av to hovedprosesser:
- "Tilkoblinger" – en prosess for å utføre operasjonene med å etablere kommunikasjon med klienter og avslutte den på initiativ fra serveren;
- "Operasjoner" – en prosess for å utføre oppgaver (operasjoner) av klienter for å jobbe med filer, samt for å lukke kommunikasjonsøkter basert på klientkommandoer.
Begge prosessene er ikke synkronisert og er organisert som endeløse løkker for mottak og sending av meldinger basert på multiprosesskøer, proxy-objekter, låser og sockets.
Tilkoblingsprosessen tildeler en port for hver klient for å motta og overføre data. Antall porter angis når serveren starter. Kartleggingen mellom porter og klienter lagres i delt proxy-minne mellom prosesser.
Driftsprosessen støtter deling av filressurser slik at flere forskjellige klienter kan dele (kvasi-parallell, siden tilgang er kontrollert av låser) les data fra én fil hvis dette var tillatt da den opprinnelig ble åpnet av den "første" klienten.
Behandling av kommandoer for å opprette/slette/åpne/lukke filer på serveren utføres i selve "Operations"-prosessen strengt tatt sekvensielt ved å bruke filundersystemet til server-OS.
For generelt å øke hastigheten på lesing/skriving, utføres disse operasjonene i tråder skapt av "Operations"-prosessen. Antall tråder er vanligvis lik antall åpne filer. Lese-/skriveoppgaver fra klienter sendes til den generelle køen og den første ledige tråden tar oppgaven fra hodet. Spesiell logikk lar deg eliminere dataomskrivingsoperasjoner i serverens RAM.
Driftsprosessen overvåker klientaktivitet og slutter å betjene dem enten etter deres kommandoer eller når tidsavbruddet for inaktivitet overskrides.
For å sikre pålitelighet fører Cageserver logger over alle transaksjoner. Én generell logg inneholder kopier av meldinger fra klienter med oppgaver for å opprette/åpne/gi nytt navn/slette filer. Det opprettes en egen logg for hver arbeidsfil, der kopier av meldinger med oppgaver for lesing og skriving av data i denne arbeidsfilen registreres, samt arrays av skrevne (nye) data og arrays av data som ble ødelagt under overskriving (skriving). nye data «på toppen» av gamle). ).
Disse loggene gir muligheten til både å gjenopprette nye endringer i sikkerhetskopier og rulle tilbake gjeldende innhold til et punkt i fortiden.
Cageserver er omtrent 3100 linjer med kode.
Starter Cageserver-filserverprogrammet
Når du starter, i dialogen må du definere:
— hovedhavn for autorisasjon;
— antall porter for utveksling av transaksjoner med autoriserte klienter (fra 1 eller flere starter tallutvalget fra den ved siden av hovedportnummeret).
Bruke Cage Class
klasse bur.Cage( cage_name="", pagesize=0, numpages=0, maxstrlen=0, server_ip={}, wait=0, awake=False, cache_file="" )
Objekter er opprettet fra denne klassen som samhandler med filservere og inneholder bufferminne.
Parametere
- bur_navn(str) - betinget navn på objektet, som brukes til å identifisere klienter på serversiden
- sidestørrelse(int) — størrelsen på én side med bufferminne (i byte)
- tall(int) — antall bufferminnesider
- maxstrlen(int) - maksimal lengde på en bytestreng i skrive- og leseoperasjoner
- server_ip(diktere) - en ordbok med adressene til serverne som brukes, der nøkkelen er det betingede navnet på serveren (server-ID inne i applikasjonen), og verdien er en streng med adressen: "ip-adresse:port" eller "DNS: port" (sammenligningen av navn og ekte adresser er midlertidig, den kan endres)
- vente(int) — ventetid på svar fra serveren ved mottak av porter (i sekunder)
- våken(boolean) — flagg for hvordan objektet er opprettet (Falsk - hvis et nytt objekt opprettes, ekte - hvis et objekt er opprettet fra et tidligere "kollapset" - ved å bruke "dvalemodus"-operasjonen, False som standard)
- cache_file(str) - filnavn for dvalemodus
fremgangsmåter
Bur.file_create( server, bane ) – opprett en ny fil
Bur.file_rename( server, bane, nytt_navn ) – gi nytt navn til filen
Bur.file_remove( server, bane) - slett en fil
Bur.åpen( server, bane, mod ) - åpen fil
Returnerer fkanal kanalnummer. Parameter mod - dette er filåpningsmodusen: "wm" - eksklusiv (lese/skrive), "rs" - skrivebeskyttet, og deles kun for lesing av andre klienter, "ws" - les/skriv, og deles kun for lesing av andre kunder.
Bur.nær (fkanal) – lukk filen
Bur.skrive (fchannel, start, data ) – skriv en bytestreng til en fil
Bur.lese (fchannel, start, len_data ) – les en bytestreng fra en fil
Bur.put_pages ( fkanal ) – "skyver" fra bufferen til serveren alle sidene i den spesifiserte kanalen som har blitt endret. Den brukes på de punktene i algoritmen når du skal være sikker på at alle operasjoner på kanalen er fysisk lagret i en fil på serveren.
Bur.push_all () – "skyver" fra bufferen til serveren alle sider i alle kanaler for en forekomst av Cage-klassen som har blitt endret. Brukes når du skal være sikker på at alle operasjoner på alle kanaler er lagret på serveren.
Kilde: www.habr.com