Deze pagina is vertaald door de Cloud Translation API.

Hoogwaardige opslag voor uw app: de Storage Foundation API

Thomas Steiner

Het webplatform biedt ontwikkelaars steeds meer de tools die ze nodig hebben om nauwkeurig afgestemde, krachtige applicaties voor het web te bouwen. Het meest opvallend is dat WebAssembly (Wasm) de deur heeft geopend voor snelle en krachtige webapplicaties, terwijl technologieën als Emscripten ontwikkelaars nu in staat stellen beproefde code op internet te hergebruiken. Om dit potentieel echt te benutten, moeten ontwikkelaars over dezelfde kracht en flexibiliteit beschikken als het om opslag gaat.

Dit is waar de Storage Foundation API in beeld komt. De Storage Foundation API is een nieuwe, snelle en ongecompliceerde opslag-API die nieuwe en veelgevraagde gebruiksscenario's voor het web ontsluit, zoals het implementeren van performante databases en het op een elegante manier beheren van grote tijdelijke bestanden. Met deze nieuwe interface kunnen ontwikkelaars "hun eigen opslag" naar het web brengen, waardoor de kloof tussen web- en platformspecifieke code wordt verkleind.

De Storage Foundation API is ontworpen om op een heel eenvoudig bestandssysteem te lijken en geeft ontwikkelaars dus flexibiliteit door generieke, eenvoudige en performante primitieven te bieden waarop ze componenten van een hoger niveau kunnen bouwen. Applicaties kunnen profiteren van de beste tool voor hun behoeften en de juiste balans vinden tussen bruikbaarheid, prestaties en betrouwbaarheid.

Waarom heeft het web nog een opslag-API nodig?

Het webplatform biedt een aantal opslagopties voor ontwikkelaars, die allemaal zijn gebouwd met specifieke gebruiksscenario's in gedachten.

Sommige van deze opties overlappen duidelijk niet met dit voorstel, omdat ze slechts zeer kleine hoeveelheden gegevens toestaan, zoals cookies of de Web Storage API bestaande uit de sessionStorage en de localStorage -mechanismen.
Andere opties zijn om verschillende redenen al verouderd, zoals de File and Directory Entries API of WebSQL .
De File System Access API heeft een soortgelijk API-oppervlak, maar het gebruik ervan is om te communiceren met het bestandssysteem van de client en toegang te bieden tot gegevens die mogelijk buiten het eigendom van de oorsprong of zelfs van de browser vallen. Deze andere focus gaat gepaard met strengere veiligheidsoverwegingen en hogere prestatiekosten.
De IndexedDB API kan worden gebruikt als backend voor een aantal gebruiksscenario's van de Storage Foundation API. Emscripten bevat bijvoorbeeld IDBFS , een op IndexedDB gebaseerd persistent bestandssysteem. Omdat IndexedDB echter in wezen een sleutel-waarde-opslag is, kent het aanzienlijke prestatiebeperkingen. Bovendien is directe toegang tot subsecties van een bestand zelfs nog moeilijker en langzamer onder IndexedDB.
Ten slotte wordt de CacheStorage-interface breed ondersteund en afgestemd op het opslaan van grote gegevens, zoals webapplicatiebronnen, maar de waarden zijn onveranderlijk.

De Storage Foundation API is een poging om alle gaten in de eerdere opslagopties te dichten door de performante opslag mogelijk te maken van veranderlijke grote bestanden die zijn gedefinieerd in de oorsprong van de applicatie.

Voorgestelde gebruiksscenario's voor de Storage Foundation API

Voorbeelden van sites die deze API kunnen gebruiken zijn:

Productiviteits- of creativiteitsapps die werken met grote hoeveelheden video-, audio- of afbeeldingsgegevens. Dergelijke apps kunnen segmenten naar schijf overbrengen in plaats van ze in het geheugen vast te houden.
Apps die afhankelijk zijn van een persistent bestandssysteem dat toegankelijk is vanuit Wasm en die meer prestaties nodig hebben dan wat IDBFS kan garanderen.

Wat is de Storage Foundation-API?

De API bestaat uit twee hoofdonderdelen:

Bestandssysteemaanroepen , die basisfunctionaliteit bieden voor interactie met bestanden en bestandspaden.
Bestandshandles , die lees- en schrijftoegang tot een bestaand bestand bieden.

Aanroepen van bestandssysteem

De Storage Foundation API introduceert een nieuw object, storageFoundation , dat op het window leeft en een aantal functies bevat:

storageFoundation.open(name) : Opent het bestand met de opgegeven naam als dit bestaat en maakt anders een nieuw bestand. Retourneert een belofte die wordt opgelost met het geopende bestand.

Waarschuwing: bestandsnamen zijn beperkt tot alfanumerieke kleine letters en onderstrepingstekens ( az , 0-9 , _ ).

storageFoundation.delete(name) : Verwijdert het bestand met de opgegeven naam. Retourneert een belofte die wordt opgelost wanneer het bestand wordt verwijderd.
storageFoundation.rename(oldName, newName) : Hernoemt het bestand atomair van de oude naam naar de nieuwe naam. Retourneert een belofte die wordt opgelost wanneer de naam van het bestand wordt gewijzigd.
storageFoundation.getAll() : Retourneert een belofte die wordt opgelost met een array van alle bestaande bestandsnamen.
storageFoundation.requestCapacity(requestedCapacity) : Vraagt nieuwe capaciteit aan (in bytes) voor gebruik door de huidige uitvoeringscontext. Retourneert een belofte die is opgelost met de resterende hoeveelheid beschikbare capaciteit.

storageFoundation.releaseCapacity(toBeReleasedCapacity) : Geeft het opgegeven aantal bytes vrij uit de huidige uitvoeringscontext en retourneert een belofte die wordt opgelost met de resterende capaciteit.
storageFoundation.getRemainingCapacity() : Retourneert een belofte die wordt opgelost met de beschikbare capaciteit voor de huidige uitvoeringscontext.

Bestandshandvatten

Het werken met bestanden gebeurt via de volgende functies:

NativeIOFile.close() : Sluit een bestand en retourneert een belofte die wordt opgelost wanneer de bewerking is voltooid.
NativeIOFile.flush() : Synchroniseert (dat wil zeggen, leegt) de geheugenstatus van een bestand met het opslagapparaat en retourneert een belofte die wordt opgelost wanneer de bewerking is voltooid.

Opmerking: het is een bekend probleem dat flush() langzaam kan zijn en we onderzoeken of het aanbieden van een snellere, minder betrouwbare variant nuttig zou zijn.

NativeIOFile.getLength() : Retourneert een belofte die wordt opgelost met de lengte van het bestand in bytes.
NativeIOFile.setLength(length) : Stelt de lengte van het bestand in bytes in en retourneert een belofte die wordt opgelost wanneer de bewerking is voltooid. Als de nieuwe lengte kleiner is dan de huidige lengte, worden bytes verwijderd vanaf het einde van het bestand. Anders wordt het bestand uitgebreid met bytes met een nulwaarde.
NativeIOFile.read(buffer, offset) : Leest de inhoud van het bestand op de opgegeven offset via een buffer die het resultaat is van het overbrengen van de gegeven buffer, die vervolgens losgelaten wordt. Retourneert een NativeIOReadResult met de overgedragen buffer en het aantal bytes dat met succes is gelezen.
Een NativeIOReadResult is een object dat uit twee vermeldingen bestaat:
- buffer : Een ArrayBufferView , die het resultaat is van het overbrengen van de buffer die is doorgegeven aan read() . Het is van hetzelfde type en dezelfde lengte als de bronbuffer.
- readBytes : Het aantal bytes dat met succes in buffer is ingelezen. Dit kan kleiner zijn dan de buffergrootte als er een fout optreedt of als het leesbereik voorbij het einde van het bestand reikt. Het wordt op nul gezet als het leesbereik voorbij het einde van het bestand ligt.
NativeIOFile.write(buffer, offset) : Schrijft de inhoud van de opgegeven buffer naar het bestand met de opgegeven offset. De buffer wordt overgedragen voordat er gegevens worden geschreven en blijft daarom los. Retourneert een NativeIOWriteResult met de overgedragen buffer en het aantal bytes dat met succes is geschreven. Het bestand wordt uitgebreid als het schrijfbereik de lengte ervan overschrijdt.
Een NativeIOWriteResult is een object dat uit twee vermeldingen bestaat:
- buffer : Een ArrayBufferView die het resultaat is van het overbrengen van de buffer die is doorgegeven aan write() . Het is van hetzelfde type en dezelfde lengte als de bronbuffer.
- writtenBytes : Het aantal bytes dat met succes naar buffer is geschreven. Dit kan kleiner zijn dan de buffergrootte als er een fout optreedt.

Opmerking: Aanroepen van NativeIOFile.write() garanderen alleen dat de gegevens naar het bestand zijn geschreven, maar garanderen niet dat de gegevens in de onderliggende opslag zijn bewaard. Om ervoor te zorgen dat er geen gegevensverlies optreedt bij een systeemcrash, moet u NativeIOFile.flush() aanroepen en wachten tot het succesvol terugkeert.

Volledige voorbeelden

Om de hierboven geïntroduceerde concepten duidelijker te maken, volgen hier twee volledige voorbeelden die u door de verschillende fasen in de levenscyclus van Storage Foundation-bestanden leiden.

Openen, schrijven, lezen, sluiten

// Open a file (creating it if needed).
const file = await storageFoundation.open('test_file');
try {
  // Request 100 bytes of capacity for this context.
  await storageFoundation.requestCapacity(100);

  const writeBuffer = new Uint8Array([64, 65, 66]);
  // Write the buffer at offset 0. After this operation, `result.buffer`
  // contains the transferred buffer and `result.writtenBytes` is 3,
  // the number of bytes written. `writeBuffer` is left detached.
  let result = await file.write(writeBuffer, 0);

  const readBuffer = new Uint8Array(3);
  // Read at offset 1. `result.buffer` contains the transferred buffer,
  // `result.readBytes` is 2, the number of bytes read. `readBuffer` is left
  // detached.
  result = await file.read(readBuffer, 1);
  // `Uint8Array(3) [65, 66, 0]`
  console.log(result.buffer);
} finally {
  file.close();
}

Openen, vermelden, verwijderen

// Open three different files (creating them if needed).
await storageFoundation.open('sunrise');
await storageFoundation.open('noon');
await storageFoundation.open('sunset');
// List all existing files.
// `["sunset", "sunrise", "noon"]`
await storageFoundation.getAll();
// Delete one of the three files.
await storageFoundation.delete('noon');
// List all remaining existing files.
// `["sunrise", "noon"]`
await storageFoundation.getAll();

Demo

Je kunt spelen met de Storage Foundation API-demo in de onderstaande insluiting. Maak, hernoem, schrijf en lees bestanden, en bekijk de beschikbare capaciteit die u hebt aangevraagd bij het bijwerken terwijl u wijzigingen aanbrengt. Je kunt de broncode van de demo vinden op Glitch.

Beveiliging en machtigingen

Het Chromium-team heeft de Storage Foundation API ontworpen en geïmplementeerd met behulp van de kernprincipes die zijn gedefinieerd in Toegangscontrole tot krachtige webplatformfuncties , waaronder gebruikerscontrole, transparantie en ergonomie.

Volgens hetzelfde patroon als andere moderne opslag-API's op internet is de toegang tot de Storage Foundation API oorspronggebonden, wat betekent dat een oorsprong alleen toegang heeft tot zelf gemaakte gegevens. Het is ook beperkt tot beveiligde contexten.

Gebruikerscontrole

Opslagquota zullen worden gebruikt om de toegang tot schijfruimte te verdelen en misbruik te voorkomen. Geheugen dat u wilt gebruiken, moet eerst worden aangevraagd. Net als andere opslag-API's kunnen gebruikers via hun browser de ruimte vrijmaken die door de Storage Foundation API wordt ingenomen.

Handige links

Dankbetuigingen

De Storage Foundation API is gespecificeerd en geïmplementeerd door Emanuel Krivoy en Richard Stotz . Dit artikel is beoordeeld door Pete LePage en Joe Medley .

Hero-afbeelding via Markus Spiske op Unsplash .