fix: handle zero-length reads to prevent EIO errors during file downloads (#400)

Author: egalvis27

src/backend/features/fuse/on-read/download-cache/download-and-save-block.test.ts

@@ -176,6 +176,31 @@ describe('downloadAndCacheBlock', () => {
     expect(props.onDownloadProgress).not.toHaveBeenCalled();
   });
 
+  it('retries range download and writes once a later attempt succeeds', async () => {
+    const props = createProps();
+    downloadFileRangeMock
+      .mockResolvedValueOnce({ error: new Error('network failed') })
+      .mockResolvedValueOnce({ data: Buffer.from('downloaded') });
+
+    await expect(downloadAndCacheBlock(props)).resolves.toStrictEqual({ data: undefined });
+
+    expect(downloadFileRangeMock).toHaveBeenCalledTimes(2);
+    expect(writeChunkToDiskMock).toHaveBeenCalledWith('/tmp/cache-file', Buffer.from('downloaded'), 100);
+    expect(isRangeHydrated(props.state, { position: props.blockStart, length: props.blockLength })).toBe(true);
+  });
+
+  it('stops retrying after max attempts when download keeps failing', async () => {
+    const props = createProps();
+    downloadFileRangeMock.mockResolvedValue({ error: new Error('network failed') });
+
+    await expect(downloadAndCacheBlock(props)).resolves.toStrictEqual({ error: new Error('network failed') });
+
+    expect(downloadFileRangeMock).toHaveBeenCalledTimes(3);
+    expect(writeChunkToDiskMock).not.toHaveBeenCalled();
+    expect(isRangeHydrated(props.state, { position: props.blockStart, length: props.blockLength })).toBe(false);
+    expect(props.onDownloadProgress).not.toHaveBeenCalled();
+  });
+
   it('does not mark hydrated or emit progress when the disk write fails', async () => {
     const props = createProps();
     writeChunkToDiskMock.mockRejectedValue(new Error('write failed'));

src/backend/features/fuse/on-read/download-cache/download-and-save-block.ts

@@ -4,6 +4,11 @@ import { getHydratedBytes, type FileHydrationState, markBlocksInRangeDownloaded
 import { type File } from '../../../../../context/virtual-drive/files/domain/File';
 import { downloadFileRange } from '../../../../../infra/environment/download-file/download-file';
 import { type Result } from '../../../../../context/shared/domain/Result';
+import { delay } from '../../../../../shared/async/delay';
+
+const MAX_DOWNLOAD_ATTEMPTS = 3;
+const RETRY_BASE_DELAY_MS = 150;
+
 type Props = {
   bucketId: HandleReadDeps['bucketId'];
   mnemonic: HandleReadDeps['mnemonic'];
@@ -33,14 +38,15 @@ export async function downloadAndCacheBlock({
   if (isAborted(state)) return { data: undefined };
 
   try {
-    const download = await downloadFileRange({
+    const download = await downloadBlockWithRetry({
       fileId: virtualFile.contentsId,
       bucketId,
       mnemonic,
       network,
       range: { position: blockStart, length: blockLength },
       signal: state.abortController.signal,
     });
+
     if (isAborted(state)) return { data: undefined };
     if (download.error) return { error: download.error };
 
@@ -60,3 +66,48 @@ export async function downloadAndCacheBlock({
 function isAborted(state: FileHydrationState): boolean {
   return state.abortController.signal.aborted;
 }
+
+type DownloadBlockWithRetryProps = {
+  fileId: string;
+  bucketId: HandleReadDeps['bucketId'];
+  mnemonic: HandleReadDeps['mnemonic'];
+  network: HandleReadDeps['network'];
+  range: { position: number; length: number };
+  signal: AbortSignal;
+};
+
+async function downloadBlockWithRetry({
+  fileId,
+  bucketId,
+  mnemonic,
+  network,
+  range,
+  signal,
+}: DownloadBlockWithRetryProps): Promise<Result<Buffer, Error>> {
+  let lastError: Error | undefined;
+
+  for (let attempt = 1; attempt <= MAX_DOWNLOAD_ATTEMPTS; attempt++) {
+    if (signal.aborted) return { data: Buffer.alloc(0) };
+
+    const download = await downloadFileRange({
+      fileId,
+      bucketId,
+      mnemonic,
+      network,
+      range,
+      signal,
+    });
+
+    if (download.data) {
+      return { data: download.data };
+    }
+
+    lastError = download.error ?? new Error('Unknown error while downloading file range');
+
+    if (attempt < MAX_DOWNLOAD_ATTEMPTS) {
+      await delay(RETRY_BASE_DELAY_MS * attempt);
+    }
+  }
+
+  return { error: lastError ?? new Error('Unable to download file range') };
+}

src/backend/features/fuse/on-read/download-cache/hydration-state.ts

@@ -134,6 +134,7 @@ export function getHydratedBytes(state: FileHydrationState): number {
 }
 
 function blocksWithinRange({ position, length }: ReadRange): Array<number> {
+  if (length <= 0) return [];
   const first = blockIndexForByte(position);
   const last = blockIndexForByte(position + length - 1);
   const blocks: number[] = [];

src/backend/features/virtual-drive/controllers/operations/read.controller.test.ts

@@ -52,6 +52,26 @@ describe('readController', () => {
     expect(readMock).not.toHaveBeenCalled();
   });
 
+  it('should send EINVAL and empty buffer when length is not a number', async () => {
+    req.body = { path: '/file.mp4', length: '10', offset: 0, processName: 'vlc' };
+
+    await readController(req, res, container);
+
+    expect(res.set).toHaveBeenCalledWith('X-Errno', String(FuseCodes.EINVAL));
+    expect(res.send).toHaveBeenCalledWith(Buffer.alloc(0));
+    expect(readMock).not.toHaveBeenCalled();
+  });
+
+  it('should send EINVAL and empty buffer when offset is negative', async () => {
+    req.body = { path: '/file.mp4', length: 10, offset: -1, processName: 'vlc' };
+
+    await readController(req, res, container);
+
+    expect(res.set).toHaveBeenCalledWith('X-Errno', String(FuseCodes.EINVAL));
+    expect(res.send).toHaveBeenCalledWith(Buffer.alloc(0));
+    expect(readMock).not.toHaveBeenCalled();
+  });
+
   it('should normalize path by adding leading slash', async () => {
     req.body = { path: 'file.mp4', length: 10, offset: 0, processName: 'vlc' };
     readMock.mockResolvedValue({ data: Buffer.alloc(0) });

src/backend/features/virtual-drive/controllers/operations/read.controller.ts

@@ -9,8 +9,8 @@ export async function readController(req: Request, res: Response, container: Con
   const { path: rawPath, length, offset } = req.body;
   const processName = typeof req.body.processName === 'string' ? req.body.processName : '';
 
-  if (rawPath === undefined || length === undefined || offset === undefined) {
-    logger.error({ msg: '[FUSE DAEMON] Read: missing required fields', body: req.body });
+  if (!isValidReadPayload(rawPath, length, offset)) {
+    logger.error({ msg: '[FUSE DAEMON] Read: invalid payload', body: req.body });
     res.set('X-Errno', String(FuseCodes.EINVAL));
     res.send(Buffer.alloc(0));
     return;
@@ -34,3 +34,24 @@ export async function readController(req: Request, res: Response, container: Con
   res.set('Content-Type', 'application/octet-stream');
   res.send(result.data);
 }
+
+function isValidReadPayload(path: unknown, length: unknown, offset: unknown): boolean {
+  if (typeof path !== 'string' || path.length === 0) return false;
+  if (!isValidReadLength(length)) return false;
+  if (!isValidReadOffset(offset)) return false;
+  return true;
+}
+
+function isValidReadLength(length: unknown): length is number {
+  if (typeof length !== 'number') return false;
+  if (!Number.isInteger(length)) return false;
+  if (length < 0) return false;
+  return true;
+}
+
+function isValidReadOffset(offset: unknown): offset is number {
+  if (typeof offset !== 'number') return false;
+  if (!Number.isInteger(offset)) return false;
+  if (offset < 0) return false;
+  return true;
+}

src/infra/drive-server/client/interceptors/rate-limiter/wait-for-delay.ts

@@ -1,4 +1,4 @@
-import { delay } from './delay';
+import { delay } from '../../../../../shared/async/delay';
 import { DelayState } from './rate-limiter.types';
 
 export async function waitForDelay(delayState: DelayState, ms: number): Promise<void> {