fix: arraybuffer

Author: astandrik

src/services/api/viewer.ts

@@ -417,26 +417,24 @@ export class ViewerAPI extends BaseYdbAPI {
                 requestConfig: {
                     signal,
                     'axios-retry': {retries: 0}, // No retries for streaming
-                    responseType: 'text',
+                    responseType: 'arraybuffer',
                 },
                 headers: {
                     ...(params.tracingLevel ? {'X-Trace-Verbosity': params.tracingLevel} : {}),
                     Accept: 'multipart/x-mixed-replace',
                 },
                 onDownloadProgress: (progressEvent) => {
-                    const response = progressEvent.event.target as XMLHttpRequest;
+                    const xhr = progressEvent.event.target as XMLHttpRequest;
                     const {chunks, lastProcessedLength: currentLength} = parseMultipart({
-                        responseText: response.responseText,
+                        response: xhr.response,
                         lastProcessedLength,
                     });
                     lastProcessedLength = currentLength;
                     const mergedChunks = new Map<number, StreamDataChunk>();
 
                     for (const chunk of chunks) {
                         if (isSessionChunk(chunk)) {
-                            const traceId = response
-                                .getResponseHeader('traceresponse')
-                                ?.split('-')[1];
+                            const traceId = xhr.getResponseHeader('traceresponse')?.split('-')[1];
 
                             chunk.meta.trace_id = traceId;
                             onChunk(chunk);

src/services/parsers/parseMultipart.ts

@@ -5,74 +5,103 @@ interface MultipartResult {
     lastProcessedLength: number;
 }
 
-const CRLF = '\r\n';
-const HEADER_VALUE_DELIMITER = ': ';
+const CRLF_BYTES = new Uint8Array([13, 10]); // \r\n
+const HEADER_VALUE_DELIMITER_BYTES = new TextEncoder().encode(': ');
+
+function arrayIndexOf(haystack: Uint8Array, needle: Uint8Array, start = 0): number {
+    for (let i = start; i <= haystack.length - needle.length; i++) {
+        let found = true;
+        for (let j = 0; j < needle.length; j++) {
+            if (haystack[i + j] !== needle[j]) {
+                found = false;
+                break;
+            }
+        }
+        if (found) {
+            return i;
+        }
+    }
+    return -1;
+}
 
-// temporary spike for backend problems
-const BACKEND_LAST_CHUNK_BOUNDARY = '--boundary--';
+function arrayStartsWith(array: Uint8Array, prefix: Uint8Array, start = 0): boolean {
+    if (start + prefix.length > array.length) {
+        return false;
+    }
+    for (let i = 0; i < prefix.length; i++) {
+        if (array[start + i] !== prefix[i]) {
+            return false;
+        }
+    }
+    return true;
+}
 
-function getContentHeadersData(data: string, startPos: number): [number, number] {
+function getContentHeadersData(data: Uint8Array, startPos: number): [number, number] {
     let contentLength = 0;
     let pos = startPos;
+    const decoder = new TextDecoder();
 
     while (pos < data.length) {
         // Check for end of headers
-        if (data.startsWith(CRLF, pos)) {
-            return [contentLength, pos + CRLF.length];
+        if (arrayStartsWith(data, CRLF_BYTES, pos)) {
+            return [contentLength, pos + CRLF_BYTES.length];
         }
 
-        const nextCRLF = data.indexOf(CRLF, pos);
+        const nextCRLF = arrayIndexOf(data, CRLF_BYTES, pos);
         if (nextCRLF === -1) {
             // Headers are incomplete
             return [contentLength, startPos];
         }
 
         const line = data.slice(pos, nextCRLF);
-        const colonIndex = line.indexOf(HEADER_VALUE_DELIMITER);
+        const colonIndex = arrayIndexOf(line, HEADER_VALUE_DELIMITER_BYTES);
 
         if (colonIndex !== -1) {
-            const header = line.slice(0, colonIndex).toLowerCase();
-            const value = line.slice(colonIndex + HEADER_VALUE_DELIMITER.length, nextCRLF);
+            const header = decoder.decode(line.slice(0, colonIndex)).toLowerCase();
+            const value = decoder.decode(
+                line.slice(colonIndex + HEADER_VALUE_DELIMITER_BYTES.length),
+            );
 
-            if (header.toLowerCase() === 'content-length') {
+            if (header === 'content-length') {
                 const length = parseInt(value, 10);
                 if (!isNaN(length)) {
                     contentLength = length;
                 }
             }
         }
 
-        pos = nextCRLF + CRLF.length;
+        pos = nextCRLF + CRLF_BYTES.length;
     }
 
     // Headers are incomplete
     return [contentLength, startPos];
 }
 
 export function parseMultipart({
-    responseText,
+    response,
     lastProcessedLength,
     boundary = 'boundary',
 }: {
-    responseText: string;
+    response: ArrayBuffer;
     lastProcessedLength: number;
     boundary?: string;
 }): MultipartResult {
-    const data = responseText;
-    const boundaryStr = `--${boundary}${CRLF}`;
+    const data = new Uint8Array(response);
+    const boundaryBytes = new TextEncoder().encode(`--${boundary}\r\n`);
     let pos = lastProcessedLength;
     let lastProcessedPos = pos;
     const chunks: StreamingChunk[] = [];
+    const decoder = new TextDecoder();
 
     while (pos < data.length) {
         // Look for boundary
-        const boundaryPos = data.indexOf(boundaryStr, pos);
+        const boundaryPos = arrayIndexOf(data, boundaryBytes, pos);
         if (boundaryPos === -1) {
             break;
         }
 
         // Move position past boundary
-        pos = boundaryPos + boundaryStr.length;
+        pos = boundaryPos + boundaryBytes.length;
 
         // Parse headers
         const [contentLength, contentStart] = getContentHeadersData(data, pos);
@@ -83,21 +112,15 @@ export function parseMultipart({
         }
 
         // Check if we have enough data for the content
-        let contentEnd = contentStart + contentLength;
+        const contentEnd = contentStart + contentLength;
         if (contentEnd > data.length) {
-            // last chunk has error with --boundary-- in content length
-            // eslint-disable-next-line no-negated-condition
-            if (data.indexOf(BACKEND_LAST_CHUNK_BOUNDARY, contentStart) !== -1) {
-                contentEnd = data.indexOf(BACKEND_LAST_CHUNK_BOUNDARY, contentStart) - 2;
-            } else {
-                // Content is incomplete
-                pos = lastProcessedLength;
-                break;
-            }
+            // Content is incomplete
+            pos = lastProcessedLength;
+            break;
         }
 
-        // Extract content
-        const content = data.slice(contentStart, contentEnd);
+        // Extract content and decode to string
+        const content = decoder.decode(data.slice(contentStart, contentEnd));
 
         // Try to parse JSON content
         try {