webkitFileSystem.backend.js

import {Reader, Writer} from '../shared-channel';

let FS;
let rootEntry;
let openFiles = new Map();

function openFile(filename) {
  let opened = openFiles.get(filename);
  if (opened) {
    return opened;
  }

  return new Promise((resolve, reject) => {
    rootEntry.getFile(
      filename,
      {create: true},
      (entry) => {
        openFiles.set(filename, entry);
        resolve(entry);
      },
      (err) => reject(err),
    );
  });
}

async function handleWrites(writer, name, writes) {
  let entry = await openFile(name);

  for (let w of writes) {
    await new Promise((resolve, reject) => {
      entry.createWriter((writer) => {
        writer.onwrite = resolve;
        writer.onerror = reject;

        writer.seek(w.pos);
        writer.write(new Blob([w.data], {type: 'octet/stream'}));
      });
    });
  }

  writer.int32(0);
  writer.finalize();
}

async function handleRead(writer, name, pos, length) {
  let entry = await openFile(name);
  let file = await new Promise((resolve, reject) =>
    entry.file(resolve, reject),
  );

  let bytes = await new Promise((resolve, reject) => {
    let reader = new FileReader();
    reader.onload = (e) => resolve(e.target.result);
    reader.onerror = reject;

    reader.readAsArrayBuffer(file.slice(pos, pos + length));
  });

  writer.bytes(bytes);
  writer.finalize();
}

async function handleReadMeta(writer, name) {
  let entry = await openFile(name);
  let file = await new Promise((resolve, reject) => {
    entry.file(resolve, reject);
  });

  let meta = {size: file.size, blockSize: 4096};
  writer.int32(meta ? meta.size : -1);
  writer.int32(meta ? meta.blockSize : -1);
  writer.finalize();
}

async function handleWriteMeta(writer, name, meta) {
  let entry = await openFile(name);

  try {
    await new Promise((resolve, reject) => {
      entry.createWriter((writer) => {
        writer.onwrite = resolve;
        writer.onerror = reject;
        writer.truncate(meta.size);
      });
    });

    writer.int32(0);
    writer.finalize();
  } catch (err) {
    console.log('handleWriteMeta err:', err);
    writer.int32(-1);
    writer.finalize();
  }
}

async function listen(reader, writer) {
  while (1) {
    let method = reader.string();

    switch (method) {
      case 'writeBlocks': {
        let name = reader.string();
        let writes = [];
        while (!reader.done()) {
          let pos = reader.int32();
          let data = reader.bytes();
          writes.push({pos, data});
        }

        await handleWrites(writer, name, writes);
        break;
      }

      case 'readBlock': {
        let name = reader.string();
        let pos = reader.int32();
        let length = reader.int32();
        reader.done();

        await handleRead(writer, name, pos, length);
        break;
      }

      case 'readMeta': {
        let name = reader.string();
        reader.done();
        await handleReadMeta(writer, name);
        break;
      }

      case 'writeMeta': {
        let name = reader.string();
        let size = reader.int32();
        let blockSize = reader.int32();
        reader.done();
        await handleWriteMeta(writer, name, {size, blockSize});
        break;
      }
    }
  }
}

self.onmessage = async (msg) => {
  switch (msg.data.type) {
    case 'init': {
      let quota = msg.data.quota;

      if (quota === 0) {
        postMessage({type: 'no-filesystem'});
        return;
      }

      FS = await new Promise((resolve, reject) => {
        self.webkitRequestFileSystem(
          self.PERSISTENT,
          quota,
          (fs) => {
            resolve(fs);
          },
          (err) => {
            postMessage({type: 'no-filesystem'});
            reject(err);
          },
        );
      });

      rootEntry = await new Promise((resolve, reject) => {
        FS.root.getDirectory(
          'dbs',
          {create: true},
          (entry) => {
            resolve(entry);
          },
          (err) => {
            postMessage({type: 'no-filesystem'});
            reject(err);
          },
        );
      });

      postMessage({type: 'worker-ready'});
      let [argBuffer, resultBuffer] = msg.data.buffers;
      let reader = new Reader(argBuffer, {name: 'args', debug: false});
      let writer = new Writer(resultBuffer, {name: 'results', debug: false});

      listen(reader, writer);
      break;
    }
  }
};