feat: fs.readFile and tests working with tauri node ws fs

Author: abose

dist/phoenix-fs.js

@@ -6,6 +6,21 @@ const { exec } = require('child_process');
 
 const IS_MACOS = os.platform() === 'darwin';
 
+/**
+ * Converts a buffer to an `ArrayBuffer`.
+ *
+ * @param {Buffer} buf The buffer to convert
+ * @return {ArrayBuffer} Converted buffer
+ * @public
+ */
+function toArrayBuffer(buf) {
+    if (buf.length === buf.buffer.byteLength) {
+        return buf.buffer;
+    }
+
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
+}
+
 function getWindowsDrives(callback) {
     exec('wmic logicaldisk get name', (error, stdout) => {
         if (error) {
@@ -89,7 +104,8 @@ const WS_COMMAND = {
     CONTROL_SOCKET_ANNOUNCE: "controlSock",
     GET_WINDOWS_DRIVES: "getWinDrives",
     READ_DIR: "readDir",
-    STAT: "stat"
+    STAT: "stat",
+    READ_BIN_FILE: "readBinFile"
 };
 
 const LARGE_DATA_THRESHOLD = 2*1024*1024; // 2MB
@@ -196,6 +212,14 @@ function _stat(ws, metadata) {
         }).catch((err)=>_reportError(ws, metadata, err, `Failed to get stat for ${fullPath}`));
 }
 
+function _readBinaryFile(ws, metadata) {
+    const fullPath = metadata.data.path;
+    fs.readFile(fullPath)
+        .then(data => {
+            _sendResponse(ws, metadata, {}, toArrayBuffer(data));
+        }).catch((err)=>_reportError(ws, metadata, err, `Failed to read file at path ${fullPath}`));
+}
+
 function processWSCommand(ws, metadata, dataBuffer) {
     try{
         switch (metadata.commandCode) {
@@ -214,6 +238,9 @@ function processWSCommand(ws, metadata, dataBuffer) {
         case WS_COMMAND.STAT:
             _stat(ws, metadata);
             return;
+        case WS_COMMAND.READ_BIN_FILE:
+            _readBinaryFile(ws, metadata);
+            return;
         case WS_COMMAND.LARGE_DATA_SOCKET_ANNOUNCE:
             console.log("Large Data Transfer Socket established, socket Group: ", metadata.socketGroupID);
             ws.isLargeData = true;

dist/virtualfs.js

@@ -6,6 +6,21 @@ const { exec } = require('child_process');
 
 const IS_MACOS = os.platform() === 'darwin';
 
+/**
+ * Converts a buffer to an `ArrayBuffer`.
+ *
+ * @param {Buffer} buf The buffer to convert
+ * @return {ArrayBuffer} Converted buffer
+ * @public
+ */
+function toArrayBuffer(buf) {
+    if (buf.length === buf.buffer.byteLength) {
+        return buf.buffer;
+    }
+
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
+}
+
 function getWindowsDrives(callback) {
     exec('wmic logicaldisk get name', (error, stdout) => {
         if (error) {
@@ -89,7 +104,8 @@ const WS_COMMAND = {
     CONTROL_SOCKET_ANNOUNCE: "controlSock",
     GET_WINDOWS_DRIVES: "getWinDrives",
     READ_DIR: "readDir",
-    STAT: "stat"
+    STAT: "stat",
+    READ_BIN_FILE: "readBinFile"
 };
 
 const LARGE_DATA_THRESHOLD = 2*1024*1024; // 2MB
@@ -196,6 +212,14 @@ function _stat(ws, metadata) {
         }).catch((err)=>_reportError(ws, metadata, err, `Failed to get stat for ${fullPath}`));
 }
 
+function _readBinaryFile(ws, metadata) {
+    const fullPath = metadata.data.path;
+    fs.readFile(fullPath)
+        .then(data => {
+            _sendResponse(ws, metadata, {}, toArrayBuffer(data));
+        }).catch((err)=>_reportError(ws, metadata, err, `Failed to read file at path ${fullPath}`));
+}
+
 function processWSCommand(ws, metadata, dataBuffer) {
     try{
         switch (metadata.commandCode) {
@@ -214,6 +238,9 @@ function processWSCommand(ws, metadata, dataBuffer) {
         case WS_COMMAND.STAT:
             _stat(ws, metadata);
             return;
+        case WS_COMMAND.READ_BIN_FILE:
+            _readBinaryFile(ws, metadata);
+            return;
         case WS_COMMAND.LARGE_DATA_SOCKET_ANNOUNCE:
             console.log("Large Data Transfer Socket established, socket Group: ", metadata.socketGroupID);
             ws.isLargeData = true;

dist/virtualfs.js.map

@@ -34,7 +34,8 @@ const WS_COMMAND = {
     CONTROL_SOCKET_ANNOUNCE: "controlSock",
     GET_WINDOWS_DRIVES: "getWinDrives",
     READ_DIR: "readDir",
-    STAT: "stat"
+    STAT: "stat",
+    READ_BIN_FILE: "readBinFile"
 };
 
 // each browser context belongs to a single socket group. So multiple websocket connections can be pooled
@@ -352,13 +353,27 @@ function stat(path, callback) {
         });
 }
 
+function readBinaryFile(path) {
+    return new Promise((resolve, reject)=>{
+        const platformPath = Utils.getTauriPlatformPath(path);
+        _execCommand(WS_COMMAND.READ_BIN_FILE, {path: platformPath})
+            .then(({bufferData})=>{
+                resolve(bufferData);
+            })
+            .catch((err)=>{
+                reject(mapNodeTauriErrorMessage(err, path, 'Failed to read file: '));
+            });
+    });
+}
+
 const NodeTauriFS = {
     testNodeWsEndpoint,
     setNodeWSEndpoint,
     stopNodeWSEndpoint,
     getNodeWSEndpoint,
     readdir,
-    stat
+    stat,
+    readBinaryFile
 };
 
 module.exports = {

src-tauri/node-src/phoenix-fs.js

@@ -481,11 +481,21 @@ function _processContents(contents, encoding, callback, path) {
 function readFile(path, options, callback) {
     try {
         path = globalObject.path.normalize(path);
-        const platformPath = Utils.getTauriPlatformPath(path);
 
         callback = arguments[arguments.length - 1];
         options = Utils.validateFileOptions(options, Constants.BINARY_ENCODING, 'r');
 
+        if(!window.__TAURI__ || preferNodeWs) {
+            NodeTauriFS.readBinaryFile(path)
+                .then(contents => {
+                    // contents is Array buffer
+                    _processContents(contents, options.encoding, callback, path);
+                })
+                .catch(callback);
+            return;
+        }
+
+        const platformPath = Utils.getTauriPlatformPath(path);
         __TAURI__.fs.readBinaryFile(platformPath)
             .then(contents => {
                 // contents is Uint8Array

src/fslib_node_ws.js

@@ -493,6 +493,61 @@ function _setupTests(testType) {
         const err = await promise;
         expect(err.code).to.eql(fs.ERR_CODES.ECHARSET);
     });
+
+    function getRandomChar() {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789~!@#$%^&*()_+{}|:"<>?-=[]\\;\',./';
+        return chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+
+    function createRandomString(length) {
+        let str = '';
+        for (let i = 0; i < length; i++) {
+            str += getRandomChar();
+        }
+        return str;
+    }
+
+    async function _testLargeFileRW(filePath, sizeBytes) {
+        console.log("creating random string of size", sizeBytes);
+        const stringWrittenToFile = createRandomString(sizeBytes);
+        console.log("random string created");
+        let resolveP, rejectP;
+        const writePromise = new Promise((resolve, reject) => {resolveP = resolve; rejectP = reject;});
+        fs.writeFile(filePath, stringWrittenToFile, "utf8", (_err)=>{
+            if(_err){
+                rejectP(_err);
+                return;
+            }
+            resolveP();
+        });
+        await writePromise;
+
+        const readPromise = new Promise((resolve, reject) => {resolveP = resolve; rejectP = reject;});
+        fs.readFile(filePath, "utf8", (_err, data)=>{
+            if(_err){
+                rejectP(_err);
+                return;
+            }
+            resolveP(data);
+        });
+        const strReadFromFile = await readPromise;
+        expect(strReadFromFile).to.eql(stringWrittenToFile);
+    }
+
+    let sizeMBs = [1, 2, 4, 8, 16];
+    if(location.href.startsWith("http://localhost:8081/test/")){
+        // during development, large data transfer seems to get the developer tools stuck. so we only run small tests
+        sizeMBs = [1, 2, 4];
+        it(`Should phoenix ${testType} read and write a large text file with 8, 16 MB disabled in dev builds due to possible dev tools crash`, async function () {
+            expect(1).to.eql(1);
+        });
+    }
+    for(let sizeMB of sizeMBs) {
+        it(`Should phoenix ${testType} read and write a large text file of size ${sizeMB} MB`, async function () {
+            const filePath = `${testPath}/browserWrite.txt`;
+            await _testLargeFileRW(filePath, sizeMB * 1024 * 1024); // Roughly 4MB considering 1 byte per char
+        }).timeout(60000);
+    }
 }
 
 describe(`File: Browser virtual fs tests: filer paths`, function () {