core-3nweb-client-lib 0.21.0 → 0.24.0

package/build/lib-client/3nstorage/xsp-fs/node-persistence.js

@@ -0,0 +1,182 @@
+"use strict";
+/*
+ Copyright (C) 2015 - 2020, 2022 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodePersistance = void 0;
+/**
+ * Everything in this module is assumed to be inside of a file system
+ * reliance set.
+ */
+const xsp_files_1 = require("xsp-files");
+const buffer_utils_1 = require("../../../lib-common/buffer-utils");
+const processes_1 = require("../../../lib-common/processes");
+const random = require("../../../lib-common/random-node");
+const pv1 = require("./xsp-payload-v1");
+const pv2 = require("./xsp-payload-v2");
+const SEG_SIZE = 16; // in 256-byte blocks = 4K in bytes
+const EMPTY_BYTE_ARR = new Uint8Array(0);
+/**
+ * This does reading and writing, keeping keys. This and extending objects are
+ * used in file system nodes as thematic place with persistence functionality.
+ */
+class NodePersistance {
+    constructor(zerothHeaderNonce, key, cryptor) {
+        this.zerothHeaderNonce = zerothHeaderNonce;
+        this.key = key;
+        this.cryptor = cryptor;
+        this.reencryptHeader = async (initHeader, newVersion) => {
+            if (!this.key) {
+                throw new Error("Cannot use wiped object.");
+            }
+            const headerContent = await this.cryptor.formatWN.open(initHeader, this.key);
+            const n = xsp_files_1.calculateNonce(this.zerothHeaderNonce, newVersion);
+            return this.cryptor.formatWN.pack(headerContent, n, this.key);
+        };
+    }
+    wipe() {
+        if (this.key) {
+            this.key.fill(0);
+            this.key = undefined;
+            this.zerothHeaderNonce.fill(0);
+            this.zerothHeaderNonce = undefined;
+        }
+    }
+    compareKey(keyB64) {
+        const k = buffer_utils_1.base64.open(keyB64);
+        return xsp_files_1.compareVectors(k, this.key);
+    }
+    fileKeyInBase64() {
+        if (!this.key) {
+            throw new Error("Cannot use wiped object.");
+        }
+        return buffer_utils_1.base64.pack(this.key);
+    }
+    segWriter(version) {
+        if (!this.key) {
+            throw new Error("Cannot use wiped object.");
+        }
+        return xsp_files_1.makeSegmentsWriter(this.key, this.zerothHeaderNonce, version, { type: 'new', segSize: SEG_SIZE, payloadFormat: 2 }, random.bytes, this.cryptor);
+    }
+    async segWriterWithBase(newVersion, base) {
+        if (!this.key) {
+            throw new Error("Cannot use wiped object.");
+        }
+        return xsp_files_1.makeSegmentsWriter(this.key, this.zerothHeaderNonce, newVersion, { type: 'update', base, payloadFormat: 2 }, random.bytes, this.cryptor);
+    }
+    async decryptedByteSrc(src) {
+        if (!this.key) {
+            throw new Error("Cannot use wiped object.");
+        }
+        const version = src.version;
+        const header = await src.readHeader();
+        const segReader = await xsp_files_1.makeSegmentsReader(this.key, this.zerothHeaderNonce, version, header, this.cryptor);
+        return {
+            version,
+            byteSrc: xsp_files_1.makeDecryptedByteSource(src.segSrc, segReader),
+            payloadFormat: segReader.payloadFormat
+        };
+    }
+    async readonlyPayload(src) {
+        const { payloadFormat, byteSrc } = await this.decryptedByteSrc(src);
+        if (payloadFormat === 2) {
+            const payload = await pv2.makeReadonlyPayload(byteSrc);
+            return payload;
+        }
+        else if (payloadFormat === 1) {
+            return await pv1.makeReadonlyPayload(byteSrc);
+        }
+        else {
+            throw new Error(`XSP segments payload format ${payloadFormat} is unknown`);
+        }
+    }
+    async readAll(src) {
+        const payload = await this.readonlyPayload(src);
+        return {
+            content: await payload.readAllContent(),
+            attrs: payload.getAttrs(),
+            xattrs: await payload.getXAttrs(),
+        };
+    }
+    async writablePayload(sink, attrs, base) {
+        if (base) {
+            const { byteSrc, version } = await this.decryptedByteSrc(base);
+            return await pv2.makeWritablePayloadFromBase(sink, version, byteSrc);
+        }
+        else {
+            return await pv2.makeWritablePayload(sink, attrs);
+        }
+    }
+    async writeWhole(content, newVersion, attrs, xattrs) {
+        const bytes = (Array.isArray(content) ? content : [content]);
+        const segWriter = await this.segWriter(newVersion);
+        const { sink, sub } = xsp_files_1.makeEncryptingByteSink(segWriter);
+        return (obs, backpressure) => {
+            // sub must be called before payload creation that uses sink
+            const unsub = sub(obs, backpressure);
+            this.writablePayload(sink, attrs)
+                .then(payload => payload.writeAllContent(bytes, xattrs), err => { var _a; return (_a = obs.error) === null || _a === void 0 ? void 0 : _a.call(obs, err); });
+            return unsub;
+        };
+    }
+    async writeXAttrs(xattrs, newVersion, base) {
+        const segWriter = await this.segWriterWithBase(newVersion, base);
+        const { sink, sub } = xsp_files_1.makeEncryptingByteSink(segWriter);
+        return (obs, backpressure) => {
+            // sub must be called before payload creation that uses sink
+            const unsub = sub(obs, backpressure);
+            this.writablePayload(sink, undefined, base)
+                .then(payload => payload.setXAttrs(xattrs), err => { var _a; return (_a = obs.error) === null || _a === void 0 ? void 0 : _a.call(obs, err); });
+            return unsub;
+        };
+    }
+    async writableSink(newVersion, attrs, xattrs, base) {
+        const segWriter = await (base ?
+            this.segWriterWithBase(newVersion, base) :
+            this.segWriter(newVersion));
+        const { sink, sub } = xsp_files_1.makeEncryptingByteSink(segWriter);
+        const defSink = processes_1.defer();
+        return {
+            sinkPromise: defSink.promise,
+            sub: (obs, backpressure) => {
+                var _a;
+                try {
+                    // sub must be called before payload creation that uses sink
+                    const unsub = sub(obs, backpressure);
+                    this.writablePayload(sink, attrs, base)
+                        .then(payload => payload.makeFileByteSink(xattrs))
+                        .then(sink => defSink.resolve(sink), err => {
+                        if (obs.error) {
+                            obs.error(err);
+                        }
+                        defSink.reject(err);
+                    });
+                    return unsub;
+                }
+                catch (err) {
+                    defSink.reject(err);
+                    (_a = obs.error) === null || _a === void 0 ? void 0 : _a.call(obs, err);
+                    throw err;
+                }
+            }
+        };
+    }
+}
+exports.NodePersistance = NodePersistance;
+Object.freeze(NodePersistance.prototype);
+Object.freeze(NodePersistance);
+function noop() { }
+Object.freeze(exports);

package/build/lib-client/3nstorage/xsp-fs/xsp-payload-v1.d.ts

@@ -0,0 +1,3 @@
+import { ByteSource } from "xsp-files";
+import { ReadonlyPayload } from "./node-persistence";
+export declare function makeReadonlyPayload(src: ByteSource): Promise<ReadonlyPayload>;

package/build/lib-client/3nstorage/xsp-fs/xsp-payload-v1.js

@@ -0,0 +1,87 @@
+"use strict";
+/*
+ Copyright (C) 2022 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeReadonlyPayload = void 0;
+const assert_1 = require("../../../lib-common/assert");
+const file_1 = require("../../../lib-common/exceptions/file");
+const processes_1 = require("../../../lib-common/processes");
+const attrs_1 = require("./attrs");
+async function makeReadonlyPayload(src) {
+    const payload = await ReadonlyPayloadV1.makeFor(src);
+    return payload;
+}
+exports.makeReadonlyPayload = makeReadonlyPayload;
+class ReadonlyPayloadV1 {
+    constructor(src, size, isEndless = false) {
+        this.src = src;
+        this.size = size;
+        this.isEndless = isEndless;
+        this.syncProc = new processes_1.SingleProc();
+        this.xattrs = undefined;
+        this.isEndless = (this.size === undefined);
+        Object.seal(this);
+    }
+    static async makeFor(src) {
+        let { size, isEndless } = await src.getSize();
+        return new ReadonlyPayloadV1(src, size, isEndless);
+    }
+    getAttrs() {
+        return {
+            ctime: 0, mtime: 0, size: this.size, isEndless: this.isEndless
+        };
+    }
+    async getXAttrs() {
+        if (!this.xattrs) {
+            this.xattrs = attrs_1.XAttrs.makeEmpty();
+        }
+        return this.xattrs;
+    }
+    readAllContent() {
+        if (this.isEndless) {
+            throw makeEndlessException();
+        }
+        return this.readSomeContentBytes(0, this.size);
+    }
+    async readSomeContentBytes(start, end) {
+        if (this.isEndless) {
+            throw makeEndlessException();
+        }
+        assert_1.assert(Number.isInteger(start) && (start >= 0) && (start <= this.size));
+        assert_1.assert(Number.isInteger(end) && (end >= start) && (end <= this.size));
+        if (end === start) {
+            return;
+        }
+        return await this.syncProc.startOrChain(async () => {
+            await this.src.seek(start);
+            return await this.src.read(end - start);
+        });
+    }
+    makeFileByteSource() {
+        const { getPosition, seek, read } = this.src;
+        return {
+            seek, getPosition, read,
+            getSize: async () => this.size,
+        };
+    }
+}
+Object.freeze(ReadonlyPayloadV1.prototype);
+Object.freeze(ReadonlyPayloadV1);
+function makeEndlessException() {
+    return file_1.makeFileException(file_1.Code.isEndless, '');
+}
+Object.freeze(exports);

package/build/lib-client/3nstorage/xsp-fs/xsp-payload-v2.d.ts

@@ -0,0 +1,6 @@
+import { ByteSink, ByteSource } from "xsp-files";
+import { CommonAttrs } from "./attrs";
+import { ReadonlyPayload, WritablePayload } from "./node-persistence";
+export declare function makeReadonlyPayload(src: ByteSource): Promise<ReadonlyPayload>;
+export declare function makeWritablePayload(sink: ByteSink, attrs?: CommonAttrs): Promise<WritablePayload>;
+export declare function makeWritablePayloadFromBase(sink: ByteSink, base: number, baseSrc: ByteSource): Promise<WritablePayload>;