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 vaker de tools die ze nodig hebben om verfijnde, krachtige webapplicaties te bouwen. WebAssembly (Wasm) heeft met name de deur geopend naar snelle en krachtige webapplicaties, terwijl technologieën zoals Emscripten ontwikkelaars nu in staat stellen om beproefde code op het web te hergebruiken. Om dit potentieel optimaal te benutten, moeten ontwikkelaars dezelfde kracht en flexibiliteit hebben als het gaat om opslag.

Hier komt de Storage Foundation API om de hoek kijken. De Storage Foundation API is een nieuwe, snelle en onafhankelijke opslag-API die nieuwe en veelgevraagde use cases voor het web ontsluit, zoals het implementeren van performante databases en het soepel 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 kleiner wordt.

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

Waarom heeft het web nog een opslag-API nodig?

Het webplatform biedt ontwikkelaars verschillende opslagopties, die elk zijn ontworpen met specifieke use-cases in gedachten.

Sommige van deze opties overlappen duidelijk niet met dit voorstel, aangezien ze alleen de opslag van zeer kleine hoeveelheden gegevens toestaan, zoals cookies of de Web Storage API die bestaat uit de mechanismen sessionStorage en localStorage .
Andere opties zijn om verschillende redenen al verouderd, zoals de File and Directory Entries API of WebSQL .
De File System Access API heeft een vergelijkbaar API-oppervlak, maar dient om te communiceren met het bestandssysteem van de client en toegang te bieden tot gegevens die mogelijk niet eigendom zijn van de bron of zelfs van de browser. Deze andere focus gaat gepaard met strengere beveiligingsoverwegingen en hogere prestatiekosten.
De IndexedDB API kan worden gebruikt als backend voor enkele use-cases van de Storage Foundation API. Emscripten bevat bijvoorbeeld IDBFS , een op IndexedDB gebaseerd persistent bestandssysteem. Omdat IndexedDB echter in principe een sleutel-waardeopslag is, kent het aanzienlijke prestatiebeperkingen. Bovendien is directe toegang tot subsecties van een bestand nog lastiger en trager onder IndexedDB.
Ten slotte wordt de CacheStorage-interface breed ondersteund en is deze afgestemd op de opslag van grote hoeveelheden gegevens, zoals webtoepassingsbronnen. De waarden zijn echter onveranderlijk.

De Storage Foundation API is een poging om alle hiaten van de voorgaande opslagopties te dichten door de snelle opslag van veranderlijke grote bestanden die in de oorsprong van de toepassing zijn gedefinieerd, mogelijk te maken.

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 beelddata. Dergelijke apps kunnen segmenten naar schijf verplaatsen in plaats van ze in het geheugen op te slaan.
Apps die afhankelijk zijn van een persistent bestandssysteem dat toegankelijk is via 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.
Bestandsingangen , die lees- en schrijftoegang bieden tot een bestaand bestand.

Bestandssysteemoproepen

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

storageFoundation.open(name) : Opent het bestand met de opgegeven naam (indien aanwezig) en maakt anders een nieuw bestand aan. Retourneert een promise die resulteert in het geopende bestand.

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

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

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

Bestandsgrepen

Werken met bestanden gebeurt via de volgende functies:

NativeIOFile.close() : Sluit een bestand en retourneert een promise die wordt opgelost wanneer de bewerking is voltooid.
NativeIOFile.flush() : synchroniseert (dat wil zeggen, spoelt) de status van een bestand in het geheugen met het opslagapparaat en retourneert een promise die wordt opgelost wanneer de bewerking is voltooid.

Let op: het is een bekend probleem dat flush() traag kan zijn. We onderzoeken of het zinvol zou zijn om een snellere, minder betrouwbare variant aan te bieden.

NativeIOFile.getLength() : Retourneert een promise die wordt omgezet in de lengte van het bestand in bytes.
NativeIOFile.setLength(length) : Stelt de lengte van het bestand in bytes in en retourneert een promise die wordt verwerkt 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 waarde van nul.
NativeIOFile.read(buffer, offset) : Leest de inhoud van het bestand op de opgegeven offset via een buffer die het resultaat is van het overdragen van de opgegeven buffer, die vervolgens losgekoppeld blijft. Retourneert een NativeIOReadResult met de overgedragen buffer en het aantal bytes dat succesvol is gelezen.
Een NativeIOReadResult is een object dat uit twee vermeldingen bestaat:
- buffer : Een ArrayBufferView , die het resultaat is van het overdragen van de buffer die aan read() is doorgegeven. Deze is van hetzelfde type en dezelfde lengte als de bronbuffer.
- readBytes : Het aantal bytes dat succesvol in buffer is gelezen. Dit kan minder zijn dan de buffergrootte, als er een fout optreedt of als het leesbereik verder reikt dan het einde van het bestand. Het wordt op nul gezet als het leesbereik verder reikt dan het einde van het bestand.
NativeIOFile.write(buffer, offset) : Schrijft de inhoud van de opgegeven buffer naar het bestand op de opgegeven offset. De buffer wordt overgedragen voordat er gegevens worden geschreven en blijft daarom losgekoppeld. Retourneert een NativeIOWriteResult met de overgedragen buffer en het aantal bytes dat succesvol is geschreven. Het bestand wordt verlengd 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 overdragen van de buffer die aan write() is doorgegeven. Deze is van hetzelfde type en dezelfde lengte als de bronbuffer.
- writtenBytes : Het aantal bytes dat succesvol naar buffer is geschreven. Dit kan minder 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 opgeslagen. Om te voorkomen dat er gegevens verloren gaan bij een systeemcrash, moet u NativeIOFile.flush() aanroepen en wachten tot de retourzending succesvol is.

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, weergeven, 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();

Demonstratie

Je kunt de demo van de Storage Foundation API uitproberen in de onderstaande embed. Maak, hernoem, schrijf naar en lees bestanden, en bekijk de beschikbare capaciteit die je hebt aangevraagd terwijl je wijzigingen aanbrengt. Je vindt de broncode van de demo op Glitch.

Beveiliging en machtigingen

Het Chromium-team heeft de Storage Foundation API ontworpen en geïmplementeerd op basis van de kernprincipes die zijn gedefinieerd in Controlling Access to Powerful Web Platform Features , waaronder gebruikerscontrole, transparantie en ergonomie.

De Storage Foundation API volgt hetzelfde patroon als andere moderne opslag-API's op het web en is daarom oorsprongsgebonden. Dit betekent dat een oorsprong alleen toegang heeft tot zelfgegenereerde data. De toegang is ook beperkt tot beveiligde contexten.

Gebruikerscontrole

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

Nuttige 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 .