Stefan Hacker
812 lines
38 KiB
JavaScript
812 lines
38 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.Nfsv4FsClient = void 0;
|
|
const tslib_1 = require("tslib");
|
|
const builder_1 = require("../builder");
|
|
const structs = tslib_1.__importStar(require("../structs"));
|
|
const Writer_1 = require("@jsonjoy.com/buffers/lib/Writer");
|
|
const Reader_1 = require("@jsonjoy.com/buffers/lib/Reader");
|
|
const XdrEncoder_1 = require("../../../xdr/XdrEncoder");
|
|
const XdrDecoder_1 = require("../../../xdr/XdrDecoder");
|
|
const NfsFsStats_1 = require("./NfsFsStats");
|
|
const NfsFsDir_1 = require("./NfsFsDir");
|
|
const NfsFsDirent_1 = require("./NfsFsDirent");
|
|
const NfsFsFileHandle_1 = require("./NfsFsFileHandle");
|
|
class Nfsv4FsClient {
|
|
constructor(fs) {
|
|
this.fs = fs;
|
|
this.openOwnerSeqids = new Map();
|
|
this.defaultOpenOwnerId = new Uint8Array([1, 2, 3, 4]);
|
|
this.closeStateid = async (openOwner, stateid) => {
|
|
const key = this.makeOpenOwnerKey(openOwner);
|
|
const previousSeqid = this.openOwnerSeqids.get(key);
|
|
const seqid = this.nextOpenOwnerSeqid(openOwner);
|
|
const response = await this.fs.compound([builder_1.nfs.CLOSE(seqid, stateid)]);
|
|
if (response.status !== 0) {
|
|
if (previousSeqid !== undefined) {
|
|
this.openOwnerSeqids.set(key, previousSeqid);
|
|
}
|
|
else {
|
|
this.openOwnerSeqids.delete(key);
|
|
}
|
|
throw new Error(`Failed to close file: ${response.status}`);
|
|
}
|
|
};
|
|
this.readFile = async (id, options) => {
|
|
const encoding = typeof options === 'string' ? options : options?.encoding;
|
|
const path = typeof id === 'string' ? id : id.toString();
|
|
const parts = this.parsePath(path);
|
|
const operations = this.navigateToParent(parts);
|
|
const filename = parts[parts.length - 1];
|
|
const openOwner = this.createDefaultOpenOwner();
|
|
const claim = builder_1.nfs.OpenClaimNull(filename);
|
|
const openSeqid = this.nextOpenOwnerSeqid(openOwner);
|
|
operations.push(builder_1.nfs.OPEN(openSeqid, 1, 0, openOwner, builder_1.nfs.OpenHowNoCreate(), claim));
|
|
const openResponse = await this.fs.compound(operations);
|
|
if (openResponse.status !== 0) {
|
|
throw new Error(`Failed to open file: ${openResponse.status}`);
|
|
}
|
|
const openRes = openResponse.resarray[openResponse.resarray.length - 1];
|
|
if (openRes.status !== 0 || !openRes.resok) {
|
|
throw new Error(`Failed to open file: ${openRes.status}`);
|
|
}
|
|
const stateid = openRes.resok.stateid;
|
|
const chunks = [];
|
|
let offset = BigInt(0);
|
|
const chunkSize = 65536;
|
|
try {
|
|
while (true) {
|
|
const readResponse = await this.fs.compound([builder_1.nfs.READ(offset, chunkSize, stateid)]);
|
|
if (readResponse.status !== 0) {
|
|
throw new Error(`Failed to read file: ${readResponse.status}`);
|
|
}
|
|
const readRes = readResponse.resarray[0];
|
|
if (readRes.status !== 0 || !readRes.resok) {
|
|
throw new Error(`Failed to read file: ${readRes.status}`);
|
|
}
|
|
if (readRes.resok.data.length > 0) {
|
|
chunks.push(readRes.resok.data);
|
|
offset += BigInt(readRes.resok.data.length);
|
|
}
|
|
if (readRes.resok.eof)
|
|
break;
|
|
}
|
|
}
|
|
finally {
|
|
await this.closeStateid(openOwner, stateid);
|
|
}
|
|
const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
|
|
const result = new Uint8Array(totalLength);
|
|
let position = 0;
|
|
for (const chunk of chunks) {
|
|
result.set(chunk, position);
|
|
position += chunk.length;
|
|
}
|
|
return this.decodeData(result, encoding);
|
|
};
|
|
this.writeFile = async (id, data, options) => {
|
|
const path = typeof id === 'string' ? id : id.toString();
|
|
const parts = this.parsePath(path);
|
|
const operations = this.navigateToParent(parts);
|
|
const filename = parts[parts.length - 1];
|
|
const openOwner = this.createDefaultOpenOwner();
|
|
const claim = builder_1.nfs.OpenClaimNull(filename);
|
|
const openSeqid = this.nextOpenOwnerSeqid(openOwner);
|
|
operations.push(builder_1.nfs.OPEN(openSeqid, 2, 0, openOwner, builder_1.nfs.OpenHowCreateUnchecked(), claim));
|
|
const writer = new Writer_1.Writer(16);
|
|
const xdr = new XdrEncoder_1.XdrEncoder(writer);
|
|
xdr.writeUnsignedHyper(BigInt(0));
|
|
const attrVals = writer.flush();
|
|
const truncateAttrs = builder_1.nfs.Fattr([4], attrVals);
|
|
const stateid = builder_1.nfs.Stateid(0, new Uint8Array(12));
|
|
operations.push(builder_1.nfs.SETATTR(stateid, truncateAttrs));
|
|
const openResponse = await this.fs.compound(operations);
|
|
if (openResponse.status !== 0) {
|
|
throw new Error(`Failed to open file: ${openResponse.status}`);
|
|
}
|
|
const openRes = openResponse.resarray[openResponse.resarray.length - 2];
|
|
if (openRes.status !== 0 || !openRes.resok) {
|
|
throw new Error(`Failed to open file: ${openRes.status}`);
|
|
}
|
|
const openStateid = openRes.resok.stateid;
|
|
const buffer = this.encodeData(data);
|
|
const chunkSize = 65536;
|
|
try {
|
|
let offset = BigInt(0);
|
|
for (let i = 0; i < buffer.length; i += chunkSize) {
|
|
const chunk = buffer.slice(i, Math.min(i + chunkSize, buffer.length));
|
|
const writeResponse = await this.fs.compound([
|
|
builder_1.nfs.WRITE(openStateid, offset, 2, chunk),
|
|
]);
|
|
if (writeResponse.status !== 0) {
|
|
throw new Error(`Failed to write file: ${writeResponse.status}`);
|
|
}
|
|
const writeRes = writeResponse.resarray[0];
|
|
if (writeRes.status !== 0 || !writeRes.resok) {
|
|
throw new Error(`Failed to write file: ${writeRes.status}`);
|
|
}
|
|
offset += BigInt(writeRes.resok.count);
|
|
}
|
|
}
|
|
finally {
|
|
await this.closeStateid(openOwner, openStateid);
|
|
}
|
|
};
|
|
this.stat = async (path, options) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
const operations = this.navigateToPath(parts);
|
|
const attrNums = [
|
|
1,
|
|
4,
|
|
20,
|
|
33,
|
|
35,
|
|
45,
|
|
47,
|
|
53,
|
|
52,
|
|
];
|
|
const attrMask = this.attrNumsToBitmap(attrNums);
|
|
operations.push(builder_1.nfs.GETATTR(attrMask));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to stat file: ${response.status}`);
|
|
}
|
|
const getattrRes = response.resarray[response.resarray.length - 1];
|
|
if (getattrRes.status !== 0 || !getattrRes.resok) {
|
|
throw new Error(`Failed to get attributes: ${getattrRes.status}`);
|
|
}
|
|
const fattr = getattrRes.resok.objAttributes;
|
|
const reader = new Reader_1.Reader();
|
|
reader.reset(fattr.attrVals);
|
|
const xdr = new XdrDecoder_1.XdrDecoder(reader);
|
|
let fileType = 1;
|
|
let size = 0;
|
|
let fileid = 0;
|
|
let mode = 0;
|
|
let nlink = 1;
|
|
let spaceUsed = 0;
|
|
let atime = new Date(0);
|
|
let mtime = new Date(0);
|
|
let ctime = new Date(0);
|
|
const returnedMask = fattr.attrmask.mask;
|
|
for (let i = 0; i < returnedMask.length; i++) {
|
|
const word = returnedMask[i];
|
|
if (!word)
|
|
continue;
|
|
for (let bit = 0; bit < 32; bit++) {
|
|
if (!(word & (1 << bit)))
|
|
continue;
|
|
const attrNum = i * 32 + bit;
|
|
switch (attrNum) {
|
|
case 1:
|
|
fileType = xdr.readUnsignedInt();
|
|
break;
|
|
case 4:
|
|
size = Number(xdr.readUnsignedHyper());
|
|
break;
|
|
case 20:
|
|
fileid = Number(xdr.readUnsignedHyper());
|
|
break;
|
|
case 33:
|
|
mode = xdr.readUnsignedInt();
|
|
break;
|
|
case 35:
|
|
nlink = xdr.readUnsignedInt();
|
|
break;
|
|
case 45:
|
|
spaceUsed = Number(xdr.readUnsignedHyper());
|
|
break;
|
|
case 47: {
|
|
const seconds = Number(xdr.readHyper());
|
|
const nseconds = xdr.readUnsignedInt();
|
|
atime = new Date(seconds * 1000 + nseconds / 1000000);
|
|
break;
|
|
}
|
|
case 53: {
|
|
const seconds = Number(xdr.readHyper());
|
|
const nseconds = xdr.readUnsignedInt();
|
|
mtime = new Date(seconds * 1000 + nseconds / 1000000);
|
|
break;
|
|
}
|
|
case 52: {
|
|
const seconds = Number(xdr.readHyper());
|
|
const nseconds = xdr.readUnsignedInt();
|
|
ctime = new Date(seconds * 1000 + nseconds / 1000000);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const blocks = Math.ceil(spaceUsed / 512);
|
|
return new NfsFsStats_1.NfsFsStats(0, 0, 0, 4096, fileid, size, blocks, atime, mtime, ctime, mtime, atime.getTime(), mtime.getTime(), ctime.getTime(), mtime.getTime(), 0, mode, nlink, fileType);
|
|
};
|
|
this.lstat = async (path, options) => {
|
|
return this.stat(path, options);
|
|
};
|
|
this.mkdir = async (path, options) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
if (parts.length === 0) {
|
|
throw new Error('Cannot create root directory');
|
|
}
|
|
const operations = this.navigateToParent(parts);
|
|
const dirname = parts[parts.length - 1];
|
|
const createType = builder_1.nfs.CreateTypeDir();
|
|
const emptyAttrs = builder_1.nfs.Fattr([], new Uint8Array(0));
|
|
operations.push(builder_1.nfs.CREATE(createType, dirname, emptyAttrs));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to create directory: ${response.status}`);
|
|
}
|
|
const createRes = response.resarray[response.resarray.length - 1];
|
|
if (createRes.status !== 0) {
|
|
throw new Error(`Failed to create directory: ${createRes.status}`);
|
|
}
|
|
return undefined;
|
|
};
|
|
this.readdir = async (path, options) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const withFileTypes = typeof options === 'object' && options?.withFileTypes;
|
|
const encoding = typeof options === 'string' ? options : options?.encoding;
|
|
const parts = this.parsePath(pathStr);
|
|
const operations = this.navigateToPath(parts);
|
|
const attrNums = withFileTypes ? [1] : [];
|
|
const attrMask = this.attrNumsToBitmap(attrNums);
|
|
operations.push(builder_1.nfs.READDIR(attrMask));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to read directory: ${response.status}`);
|
|
}
|
|
const readdirRes = response.resarray[response.resarray.length - 1];
|
|
if (readdirRes.status !== 0 || !readdirRes.resok) {
|
|
throw new Error(`Failed to read directory: ${readdirRes.status}`);
|
|
}
|
|
const entries = [];
|
|
const dirents = [];
|
|
const entryList = readdirRes.resok.entries;
|
|
for (let i = 0; i < entryList.length; i++) {
|
|
const entry = entryList[i];
|
|
const name = entry.name;
|
|
if (withFileTypes) {
|
|
const fattr = entry.attrs;
|
|
const reader = new Reader_1.Reader();
|
|
reader.reset(fattr.attrVals);
|
|
const xdr = new XdrDecoder_1.XdrDecoder(reader);
|
|
let fileType = 1;
|
|
const returnedMask = fattr.attrmask.mask;
|
|
for (let i = 0; i < returnedMask.length; i++) {
|
|
const word = returnedMask[i];
|
|
if (!word)
|
|
continue;
|
|
for (let bit = 0; bit < 32; bit++) {
|
|
if (!(word & (1 << bit)))
|
|
continue;
|
|
const attrNum = i * 32 + bit;
|
|
if (attrNum === 1) {
|
|
fileType = xdr.readUnsignedInt();
|
|
}
|
|
}
|
|
}
|
|
dirents.push(new NfsFsDirent_1.NfsFsDirent(name, fileType));
|
|
}
|
|
else {
|
|
entries.push(name);
|
|
}
|
|
}
|
|
if (withFileTypes) {
|
|
return dirents;
|
|
}
|
|
if (encoding && encoding !== 'utf8') {
|
|
return entries.map((name) => Buffer.from(name, 'utf8'));
|
|
}
|
|
return entries;
|
|
};
|
|
this.appendFile = async (path, data, options) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
const operations = this.navigateToParent(parts);
|
|
const filename = parts[parts.length - 1];
|
|
const openOwner = this.createDefaultOpenOwner();
|
|
const claim = builder_1.nfs.OpenClaimNull(filename);
|
|
const openSeqid = this.nextOpenOwnerSeqid(openOwner);
|
|
operations.push(builder_1.nfs.OPEN(openSeqid, 2, 0, openOwner, builder_1.nfs.OpenHowNoCreate(), claim));
|
|
const attrNums = [4];
|
|
const attrMask = this.attrNumsToBitmap(attrNums);
|
|
operations.push(builder_1.nfs.GETATTR(attrMask));
|
|
const openResponse = await this.fs.compound(operations);
|
|
if (openResponse.status !== 0) {
|
|
throw new Error(`Failed to open file: ${openResponse.status}`);
|
|
}
|
|
const openRes = openResponse.resarray[openResponse.resarray.length - 2];
|
|
if (openRes.status !== 0 || !openRes.resok) {
|
|
throw new Error(`Failed to open file: ${openRes.status}`);
|
|
}
|
|
const getattrRes = openResponse.resarray[openResponse.resarray.length - 1];
|
|
if (getattrRes.status !== 0 || !getattrRes.resok) {
|
|
throw new Error(`Failed to get attributes: ${getattrRes.status}`);
|
|
}
|
|
const fattr = getattrRes.resok.objAttributes;
|
|
const reader = new Reader_1.Reader();
|
|
reader.reset(fattr.attrVals);
|
|
const xdr = new XdrDecoder_1.XdrDecoder(reader);
|
|
const currentSize = Number(xdr.readUnsignedHyper());
|
|
const openStateid = openRes.resok.stateid;
|
|
const buffer = this.encodeData(data);
|
|
const chunkSize = 65536;
|
|
try {
|
|
let offset = BigInt(currentSize);
|
|
for (let i = 0; i < buffer.length; i += chunkSize) {
|
|
const chunk = buffer.slice(i, Math.min(i + chunkSize, buffer.length));
|
|
const writeResponse = await this.fs.compound([
|
|
builder_1.nfs.WRITE(openStateid, offset, 2, chunk),
|
|
]);
|
|
if (writeResponse.status !== 0) {
|
|
throw new Error(`Failed to write file: ${writeResponse.status}`);
|
|
}
|
|
const writeRes = writeResponse.resarray[0];
|
|
if (writeRes.status !== 0 || !writeRes.resok) {
|
|
throw new Error(`Failed to write file: ${writeRes.status}`);
|
|
}
|
|
offset += BigInt(writeRes.resok.count);
|
|
}
|
|
}
|
|
finally {
|
|
await this.closeStateid(openOwner, openStateid);
|
|
}
|
|
};
|
|
this.truncate = async (path, len = 0) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
const operations = this.navigateToPath(parts);
|
|
const writer = new Writer_1.Writer(16);
|
|
const xdr = new XdrEncoder_1.XdrEncoder(writer);
|
|
xdr.writeUnsignedHyper(BigInt(len));
|
|
const attrVals = writer.flush();
|
|
const sizeAttrs = builder_1.nfs.Fattr([4], attrVals);
|
|
const stateid = builder_1.nfs.Stateid(0, new Uint8Array(12));
|
|
operations.push(builder_1.nfs.SETATTR(stateid, sizeAttrs));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to truncate file: ${response.status}`);
|
|
}
|
|
const setattrRes = response.resarray[response.resarray.length - 1];
|
|
if (setattrRes.status !== 0) {
|
|
throw new Error(`Failed to truncate file: ${setattrRes.status}`);
|
|
}
|
|
};
|
|
this.unlink = async (path) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
if (parts.length === 0) {
|
|
throw new Error('Cannot unlink root directory');
|
|
}
|
|
const operations = this.navigateToParent(parts);
|
|
const filename = parts[parts.length - 1];
|
|
operations.push(builder_1.nfs.REMOVE(filename));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to unlink file: ${response.status}`);
|
|
}
|
|
const removeRes = response.resarray[response.resarray.length - 1];
|
|
if (removeRes.status !== 0) {
|
|
throw new Error(`Failed to unlink file: ${removeRes.status}`);
|
|
}
|
|
};
|
|
this.rmdir = async (path, options) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
if (parts.length === 0) {
|
|
throw new Error('Cannot remove root directory');
|
|
}
|
|
const operations = this.navigateToParent(parts);
|
|
const dirname = parts[parts.length - 1];
|
|
operations.push(builder_1.nfs.REMOVE(dirname));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to remove directory: ${response.status}`);
|
|
}
|
|
const removeRes = response.resarray[response.resarray.length - 1];
|
|
if (removeRes.status !== 0) {
|
|
throw new Error(`Failed to remove directory: ${removeRes.status}`);
|
|
}
|
|
};
|
|
this.rm = async (path, options) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
if (parts.length === 0) {
|
|
throw new Error('Cannot remove root directory');
|
|
}
|
|
const force = options?.force ?? false;
|
|
const recursive = options?.recursive ?? false;
|
|
if (recursive) {
|
|
try {
|
|
const stats = await this.stat(path);
|
|
if (stats.isDirectory()) {
|
|
const entries = await this.readdir(path);
|
|
for (const entry of entries) {
|
|
const entryPath = pathStr + '/' + entry;
|
|
await this.rm(entryPath, options);
|
|
}
|
|
}
|
|
}
|
|
catch (err) {
|
|
if (!force)
|
|
throw err;
|
|
return;
|
|
}
|
|
}
|
|
try {
|
|
const operations = this.navigateToParent(parts);
|
|
const name = parts[parts.length - 1];
|
|
operations.push(builder_1.nfs.REMOVE(name));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
if (!force)
|
|
throw new Error(`Failed to remove: ${response.status}`);
|
|
return;
|
|
}
|
|
const removeRes = response.resarray[response.resarray.length - 1];
|
|
if (removeRes.status !== 0) {
|
|
if (!force)
|
|
throw new Error(`Failed to remove: ${removeRes.status}`);
|
|
}
|
|
}
|
|
catch (err) {
|
|
if (!force)
|
|
throw err;
|
|
}
|
|
};
|
|
this.access = async (path, mode = 0) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
const operations = this.navigateToPath(parts);
|
|
let accessMask = 0;
|
|
if (mode === 0) {
|
|
accessMask = 1;
|
|
}
|
|
else {
|
|
if (mode & 4)
|
|
accessMask |= 1;
|
|
if (mode & 2)
|
|
accessMask |= 4;
|
|
if (mode & 1)
|
|
accessMask |= 32;
|
|
}
|
|
operations.push(builder_1.nfs.ACCESS(accessMask));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Access denied: ${response.status}`);
|
|
}
|
|
const accessRes = response.resarray[response.resarray.length - 1];
|
|
if (accessRes.status !== 0) {
|
|
throw new Error(`Access denied: ${accessRes.status}`);
|
|
}
|
|
};
|
|
this.rename = async (oldPath, newPath) => {
|
|
const oldPathStr = typeof oldPath === 'string' ? oldPath : oldPath.toString();
|
|
const newPathStr = typeof newPath === 'string' ? newPath : newPath.toString();
|
|
const oldParts = this.parsePath(oldPathStr);
|
|
const newParts = this.parsePath(newPathStr);
|
|
if (oldParts.length === 0 || newParts.length === 0) {
|
|
throw new Error('Cannot rename root directory');
|
|
}
|
|
const operations = [];
|
|
operations.push(builder_1.nfs.PUTROOTFH());
|
|
for (const part of oldParts.slice(0, -1)) {
|
|
operations.push(builder_1.nfs.LOOKUP(part));
|
|
}
|
|
operations.push(builder_1.nfs.SAVEFH());
|
|
operations.push(builder_1.nfs.PUTROOTFH());
|
|
for (const part of newParts.slice(0, -1)) {
|
|
operations.push(builder_1.nfs.LOOKUP(part));
|
|
}
|
|
const oldname = oldParts[oldParts.length - 1];
|
|
const newname = newParts[newParts.length - 1];
|
|
operations.push(builder_1.nfs.RENAME(oldname, newname));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to rename: ${response.status}`);
|
|
}
|
|
const renameRes = response.resarray[response.resarray.length - 1];
|
|
if (renameRes.status !== 0) {
|
|
throw new Error(`Failed to rename: ${renameRes.status}`);
|
|
}
|
|
};
|
|
this.copyFile = async (src, dest, flags) => {
|
|
const data = await this.readFile(src);
|
|
await this.writeFile(dest, data);
|
|
};
|
|
this.realpath = async (path, options) => {
|
|
const encoding = typeof options === 'string' ? options : options?.encoding;
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const normalized = '/' + this.parsePath(pathStr).join('/');
|
|
if (!encoding || encoding === 'utf8') {
|
|
return normalized;
|
|
}
|
|
return Buffer.from(normalized, 'utf8');
|
|
};
|
|
this.link = async (existingPath, newPath) => {
|
|
const existingPathStr = typeof existingPath === 'string' ? existingPath : existingPath.toString();
|
|
const newPathStr = typeof newPath === 'string' ? newPath : newPath.toString();
|
|
const existingParts = this.parsePath(existingPathStr);
|
|
const newParts = this.parsePath(newPathStr);
|
|
if (newParts.length === 0) {
|
|
throw new Error('Cannot create link at root');
|
|
}
|
|
const operations = this.navigateToPath(existingParts);
|
|
operations.push(builder_1.nfs.SAVEFH());
|
|
operations.push(builder_1.nfs.PUTROOTFH());
|
|
for (const part of newParts.slice(0, -1)) {
|
|
operations.push(builder_1.nfs.LOOKUP(part));
|
|
}
|
|
const newname = newParts[newParts.length - 1];
|
|
operations.push(builder_1.nfs.LINK(newname));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to create link: ${response.status}`);
|
|
}
|
|
const linkRes = response.resarray[response.resarray.length - 1];
|
|
if (linkRes.status !== 0) {
|
|
throw new Error(`Failed to create link: ${linkRes.status}`);
|
|
}
|
|
};
|
|
this.symlink = async (target, path, type) => {
|
|
const targetStr = typeof target === 'string' ? target : target.toString();
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
if (parts.length === 0) {
|
|
throw new Error('Cannot create symlink at root');
|
|
}
|
|
const operations = this.navigateToParent(parts);
|
|
const linkname = parts[parts.length - 1];
|
|
const createType = new structs.Nfsv4CreateType(5, new structs.Nfsv4CreateTypeLink(targetStr));
|
|
const emptyAttrs = builder_1.nfs.Fattr([], new Uint8Array(0));
|
|
operations.push(builder_1.nfs.CREATE(createType, linkname, emptyAttrs));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to create symlink: ${response.status}`);
|
|
}
|
|
const createRes = response.resarray[response.resarray.length - 1];
|
|
if (createRes.status !== 0) {
|
|
throw new Error(`Failed to create symlink: ${createRes.status}`);
|
|
}
|
|
};
|
|
this.utimes = async (path, atime, mtime) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
const operations = this.navigateToPath(parts);
|
|
const atimeMs = typeof atime === 'number' ? atime : atime instanceof Date ? atime.getTime() : Date.now();
|
|
const mtimeMs = typeof mtime === 'number' ? mtime : mtime instanceof Date ? mtime.getTime() : Date.now();
|
|
const writer = new Writer_1.Writer(64);
|
|
const xdr = new XdrEncoder_1.XdrEncoder(writer);
|
|
xdr.writeUnsignedInt(1);
|
|
xdr.writeHyper(BigInt(Math.floor(atimeMs / 1000)));
|
|
xdr.writeUnsignedInt((atimeMs % 1000) * 1000000);
|
|
xdr.writeUnsignedInt(1);
|
|
xdr.writeHyper(BigInt(Math.floor(mtimeMs / 1000)));
|
|
xdr.writeUnsignedInt((mtimeMs % 1000) * 1000000);
|
|
const attrVals = writer.flush();
|
|
const timeAttrs = builder_1.nfs.Fattr([48, 54], attrVals);
|
|
const stateid = builder_1.nfs.Stateid(0, new Uint8Array(12));
|
|
operations.push(builder_1.nfs.SETATTR(stateid, timeAttrs));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to set times: ${response.status}`);
|
|
}
|
|
const setattrRes = response.resarray[response.resarray.length - 1];
|
|
if (setattrRes.status !== 0) {
|
|
throw new Error(`Failed to set times: ${setattrRes.status}`);
|
|
}
|
|
};
|
|
this.readlink = async (path, options) => {
|
|
const encoding = typeof options === 'string' ? options : options?.encoding;
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
const operations = this.navigateToPath(parts);
|
|
operations.push(builder_1.nfs.READLINK());
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to read link: ${response.status}`);
|
|
}
|
|
const readlinkRes = response.resarray[response.resarray.length - 1];
|
|
if (readlinkRes.status !== 0 || !readlinkRes.resok) {
|
|
throw new Error(`Failed to read link: ${readlinkRes.status}`);
|
|
}
|
|
if (!encoding || encoding === 'utf8') {
|
|
return readlinkRes.resok.link;
|
|
}
|
|
return Buffer.from(readlinkRes.resok.link, 'utf8');
|
|
};
|
|
this.opendir = async (path, options) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
const operations = this.navigateToPath(parts);
|
|
return new NfsFsDir_1.NfsFsDir(pathStr, this.fs, operations);
|
|
};
|
|
this.mkdtemp = async (prefix, options) => {
|
|
const encoding = typeof options === 'string' ? options : options?.encoding;
|
|
const randomSuffix = Math.random().toString(36).substring(2, 8);
|
|
const dirName = prefix + randomSuffix;
|
|
await this.mkdir(dirName);
|
|
if (!encoding || encoding === 'utf8')
|
|
return dirName;
|
|
return Buffer.from(dirName, 'utf8');
|
|
};
|
|
this.chmod = async (path, mode) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
const operations = this.navigateToPath(parts);
|
|
const modeValue = typeof mode === 'number' ? mode : parseInt(mode.toString(), 8);
|
|
const writer = new Writer_1.Writer(8);
|
|
const xdr = new XdrEncoder_1.XdrEncoder(writer);
|
|
xdr.writeUnsignedInt(modeValue);
|
|
const attrVals = writer.flush();
|
|
const attrs = builder_1.nfs.Fattr([33], attrVals);
|
|
const stateid = builder_1.nfs.Stateid(0, new Uint8Array(12));
|
|
operations.push(builder_1.nfs.SETATTR(stateid, attrs));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to chmod: ${response.status}`);
|
|
}
|
|
const setattrRes = response.resarray[response.resarray.length - 1];
|
|
if (setattrRes.status !== 0) {
|
|
throw new Error(`Failed to chmod: ${setattrRes.status}`);
|
|
}
|
|
};
|
|
this.chown = async (path, uid, gid) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
const operations = this.navigateToPath(parts);
|
|
const writer = new Writer_1.Writer(64);
|
|
const xdr = new XdrEncoder_1.XdrEncoder(writer);
|
|
xdr.writeStr(uid.toString());
|
|
xdr.writeStr(gid.toString());
|
|
const attrVals = writer.flush();
|
|
const attrs = builder_1.nfs.Fattr([36, 37], attrVals);
|
|
const stateid = builder_1.nfs.Stateid(0, new Uint8Array(12));
|
|
operations.push(builder_1.nfs.SETATTR(stateid, attrs));
|
|
const response = await this.fs.compound(operations);
|
|
if (response.status !== 0) {
|
|
throw new Error(`Failed to chown: ${response.status}`);
|
|
}
|
|
const setattrRes = response.resarray[response.resarray.length - 1];
|
|
if (setattrRes.status !== 0) {
|
|
throw new Error(`Failed to chown: ${setattrRes.status}`);
|
|
}
|
|
};
|
|
this.lchmod = async (path, mode) => {
|
|
return this.chmod(path, mode);
|
|
};
|
|
this.lchown = async (path, uid, gid) => {
|
|
return this.chown(path, uid, gid);
|
|
};
|
|
this.lutimes = async (path, atime, mtime) => {
|
|
return this.utimes(path, atime, mtime);
|
|
};
|
|
this.open = async (path, flags, mode) => {
|
|
const pathStr = typeof path === 'string' ? path : path.toString();
|
|
const parts = this.parsePath(pathStr);
|
|
const operations = this.navigateToParent(parts);
|
|
const filename = parts[parts.length - 1];
|
|
const openOwner = this.createDefaultOpenOwner();
|
|
const claim = builder_1.nfs.OpenClaimNull(filename);
|
|
let access = 1;
|
|
const openSeqid = this.nextOpenOwnerSeqid(openOwner);
|
|
if (typeof flags === 'string') {
|
|
if (flags.includes('r') && flags.includes('+')) {
|
|
access = 3;
|
|
}
|
|
else if (flags.includes('w') || flags.includes('a')) {
|
|
access = 2;
|
|
if (flags.includes('+')) {
|
|
access = 3;
|
|
}
|
|
}
|
|
}
|
|
else if (typeof flags === 'number') {
|
|
const O_RDONLY = 0;
|
|
const O_WRONLY = 1;
|
|
const O_RDWR = 2;
|
|
const O_ACCMODE = 3;
|
|
const accessMode = flags & O_ACCMODE;
|
|
switch (accessMode) {
|
|
case O_RDONLY:
|
|
access = 1;
|
|
break;
|
|
case O_WRONLY:
|
|
access = 2;
|
|
break;
|
|
case O_RDWR:
|
|
access = 3;
|
|
break;
|
|
}
|
|
}
|
|
operations.push(builder_1.nfs.OPEN(openSeqid, access, 0, openOwner, builder_1.nfs.OpenHowNoCreate(), claim));
|
|
const openResponse = await this.fs.compound(operations);
|
|
if (openResponse.status !== 0) {
|
|
throw new Error(`Failed to open file: ${openResponse.status}`);
|
|
}
|
|
const openRes = openResponse.resarray[openResponse.resarray.length - 1];
|
|
if (openRes.status !== 0 || !openRes.resok) {
|
|
throw new Error(`Failed to open file: ${openRes.status}`);
|
|
}
|
|
const stateid = openRes.resok.stateid;
|
|
const fd = Math.floor(Math.random() * 1000000);
|
|
return new NfsFsFileHandle_1.NfsFsFileHandle(fd, pathStr, this, stateid, openOwner);
|
|
};
|
|
this.statfs = (path, options) => {
|
|
throw new Error('Not implemented.');
|
|
};
|
|
this.watch = (filename, options) => {
|
|
throw new Error('Not implemented.');
|
|
};
|
|
this.glob = (pattern, options) => {
|
|
throw new Error('Not implemented.');
|
|
};
|
|
}
|
|
makeOpenOwnerKey(owner) {
|
|
return `${owner.clientid}:${Buffer.from(owner.owner).toString('hex')}`;
|
|
}
|
|
nextOpenOwnerSeqid(owner) {
|
|
const key = this.makeOpenOwnerKey(owner);
|
|
const last = this.openOwnerSeqids.get(key);
|
|
const next = last === undefined ? 0 : last === 0xffffffff ? 1 : (last + 1) >>> 0;
|
|
this.openOwnerSeqids.set(key, next);
|
|
return next;
|
|
}
|
|
createDefaultOpenOwner() {
|
|
return builder_1.nfs.OpenOwner(BigInt(1), new Uint8Array(this.defaultOpenOwnerId));
|
|
}
|
|
attrNumsToBitmap(attrNums) {
|
|
const bitmap = [];
|
|
for (const attrNum of attrNums) {
|
|
const wordIndex = Math.floor(attrNum / 32);
|
|
const bitIndex = attrNum % 32;
|
|
while (bitmap.length <= wordIndex) {
|
|
bitmap.push(0);
|
|
}
|
|
bitmap[wordIndex] |= 1 << bitIndex;
|
|
}
|
|
return bitmap;
|
|
}
|
|
parsePath(path) {
|
|
const normalized = path.replace(/^\/+/, '').replace(/\/+$/, '');
|
|
if (!normalized)
|
|
return [];
|
|
return normalized.split('/').filter((part) => part.length > 0);
|
|
}
|
|
navigateToParent(parts) {
|
|
const operations = [builder_1.nfs.PUTROOTFH()];
|
|
for (const part of parts.slice(0, -1)) {
|
|
operations.push(builder_1.nfs.LOOKUP(part));
|
|
}
|
|
return operations;
|
|
}
|
|
navigateToPath(parts) {
|
|
const operations = [builder_1.nfs.PUTROOTFH()];
|
|
for (const part of parts) {
|
|
operations.push(builder_1.nfs.LOOKUP(part));
|
|
}
|
|
return operations;
|
|
}
|
|
encodeData(data) {
|
|
if (data instanceof Uint8Array)
|
|
return data;
|
|
if (data instanceof ArrayBuffer)
|
|
return new Uint8Array(data);
|
|
if (typeof data === 'string')
|
|
return new TextEncoder().encode(data);
|
|
if (Buffer.isBuffer(data))
|
|
return new Uint8Array(data);
|
|
throw new Error('Unsupported data type');
|
|
}
|
|
decodeData(data, encoding) {
|
|
if (!encoding || encoding === 'buffer')
|
|
return Buffer.from(data);
|
|
return new TextDecoder(encoding).decode(data);
|
|
}
|
|
}
|
|
exports.Nfsv4FsClient = Nfsv4FsClient;
|
|
//# sourceMappingURL=Nfsv4FsClient.js.map
|