@aztec/p2p 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.75.0

package/src/services/reqresp/reqresp.ts

@@ -22,8 +22,7 @@ import { ConnectionSampler } from './connection-sampler/connection_sampler.js';
 import {
   DEFAULT_SUB_PROTOCOL_HANDLERS,
   DEFAULT_SUB_PROTOCOL_VALIDATORS,
-  type ReqRespResponse,
-  ReqRespSubProtocol,
+  type ReqRespSubProtocol,
   type ReqRespSubProtocolHandlers,
   type ReqRespSubProtocolValidators,
   type SubProtocolMap,
@@ -31,7 +30,6 @@ import {
 } from './interface.js';
 import { ReqRespMetrics } from './metrics.js';
 import { RequestResponseRateLimiter } from './rate-limiter/rate_limiter.js';
-import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqRespStatus } from './status.js';
 
 /**
  * The Request Response Service
@@ -192,17 +190,10 @@ export class ReqResp {
         this.logger.trace(`Sending request to peer: ${peer.toString()}`);
         const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffer);
 
-        if (response && response.status !== ReqRespStatus.SUCCESS) {
-          this.logger.debug(
-            `Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(response.status)}`,
-          );
-          continue;
-        }
-
         // If we get a response, return it, otherwise we iterate onto the next peer
         // We do not consider it a success if we have an empty buffer
-        if (response && response.data.length > 0) {
-          const object = subProtocolMap[subProtocol].response.fromBuffer(response.data);
+        if (response && response.length > 0) {
+          const object = subProtocolMap[subProtocol].response.fromBuffer(response);
           // The response validator handles peer punishment within
           const isValid = await responseValidator(request, object, peer);
           if (!isValid) {
@@ -320,22 +311,8 @@ export class ReqResp {
               for (const index of indices) {
                 const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffers[index]);
 
-                // Check the status of the response buffer
-                if (response && response.status !== ReqRespStatus.SUCCESS) {
-                  this.logger.debug(
-                    `Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(
-                      response.status,
-                    )}`,
-                  );
-
-                  // If we hit a rate limit or some failure, we remove the peer and return the results,
-                  // they will be split among remaining peers and the new sampled peer
-                  batchSampler.removePeerAndReplace(peer);
-                  return { peer, results: peerResults };
-                }
-
-                if (response && response.data.length > 0) {
-                  const object = subProtocolMap[subProtocol].response.fromBuffer(response.data);
+                if (response && response.length > 0) {
+                  const object = subProtocolMap[subProtocol].response.fromBuffer(response);
                   const isValid = await responseValidator(requests[index], object, peer);
 
                   if (isValid) {
@@ -417,7 +394,7 @@ export class ReqResp {
     peerId: PeerId,
     subProtocol: ReqRespSubProtocol,
     payload: Buffer,
-  ): Promise<ReqRespResponse | undefined> {
+  ): Promise<Buffer | undefined> {
     let stream: Stream | undefined;
     try {
       this.metrics.recordRequestSent(subProtocol);
@@ -425,8 +402,8 @@ export class ReqResp {
       stream = await this.connectionSampler.dialProtocol(peerId, subProtocol);
 
       // Open the stream with a timeout
-      const result = await executeTimeout<ReqRespResponse>(
-        (): Promise<ReqRespResponse> => pipe([payload], stream!, this.readMessage.bind(this)),
+      const result = await executeTimeout<Buffer>(
+        (): Promise<Buffer> => pipe([payload], stream!, this.readMessage.bind(this)),
         this.individualRequestTimeoutMs,
         () => new IndividualReqRespTimeoutError(),
       );
@@ -470,15 +447,7 @@ export class ReqResp {
    * Categorize the error and log it.
    */
   private categorizeError(e: any, peerId: PeerId, subProtocol: ReqRespSubProtocol): PeerErrorSeverity | undefined {
-    // Non punishable errors - we do not expect a response for goodbye messages
-    if (subProtocol === ReqRespSubProtocol.GOODBYE) {
-      this.logger.debug('Error encountered on goodbye sub protocol, no penalty', {
-        peerId: peerId.toString(),
-        subProtocol,
-      });
-      return undefined;
-    }
-
+    // Non pubishable errors
     // We do not punish a collective timeout, as the node triggers this interupt, independent of the peer's behaviour
     const logTags = {
       peerId: peerId.toString(),
@@ -523,45 +492,14 @@ export class ReqResp {
 
   /**
    * Read a message returned from a stream into a single buffer
-   *
-   * The message is split into two components
-   * - The first chunk should contain a control byte, indicating the status of the response see `ReqRespStatus`
-   * - The second chunk should contain the response data
    */
-  private async readMessage(source: AsyncIterable<Uint8ArrayList>): Promise<ReqRespResponse> {
-    let statusBuffer: ReqRespStatus | undefined;
+  private async readMessage(source: AsyncIterable<Uint8ArrayList>): Promise<Buffer> {
     const chunks: Uint8Array[] = [];
-
-    try {
-      for await (const chunk of source) {
-        if (statusBuffer === undefined) {
-          const firstChunkBuffer = chunk.subarray();
-          statusBuffer = parseStatusChunk(firstChunkBuffer);
-        } else {
-          chunks.push(chunk.subarray());
-        }
-      }
-
-      const messageData = Buffer.concat(chunks);
-      const message: Buffer = this.snappyTransform.inboundTransformNoTopic(messageData);
-
-      return {
-        status: statusBuffer ?? ReqRespStatus.UNKNOWN,
-        data: message,
-      };
-    } catch (e: any) {
-      this.logger.debug(`Reading message failed: ${e.message}`);
-
-      let status = ReqRespStatus.UNKNOWN;
-      if (e instanceof ReqRespStatusError) {
-        status = e.status;
-      }
-
-      return {
-        status,
-        data: Buffer.from([]),
-      };
+    for await (const chunk of source) {
+      chunks.push(chunk.subarray());
     }
+    const messageData = Buffer.concat(chunks);
+    return this.snappyTransform.inboundTransformNoTopic(messageData);
   }
 
   /**
@@ -587,28 +525,25 @@ export class ReqResp {
   private async streamHandler(protocol: ReqRespSubProtocol, { stream, connection }: IncomingStreamData) {
     this.metrics.recordRequestReceived(protocol);
 
-    try {
-      // Store a reference to from this for the async generator
-      if (!this.rateLimiter.allow(protocol, connection.remotePeer)) {
-        this.logger.warn(`Rate limit exceeded for ${protocol} from ${connection.remotePeer}`);
+    // Store a reference to from this for the async generator
+    if (!this.rateLimiter.allow(protocol, connection.remotePeer)) {
+      this.logger.warn(`Rate limit exceeded for ${protocol} from ${connection.remotePeer}`);
 
-        throw new ReqRespStatusError(ReqRespStatus.RATE_LIMIT_EXCEEDED);
-      }
+      // TODO(#8483): handle changing peer scoring for failed rate limit, maybe differentiate between global and peer limits here when punishing
+      await stream.close();
+      return;
+    }
 
-      const handler = this.subProtocolHandlers[protocol];
-      const transform = this.snappyTransform;
+    const handler = this.subProtocolHandlers[protocol];
+    const transform = this.snappyTransform;
 
+    try {
       await pipe(
         stream,
         async function* (source: any) {
           for await (const chunkList of source) {
             const msg = Buffer.from(chunkList.subarray());
             const response = await handler(connection.remotePeer, msg);
-
-            // Send success code first, then the response
-            const successChunk = Buffer.from([ReqRespStatus.SUCCESS]);
-            yield new Uint8Array(successChunk);
-
             yield new Uint8Array(transform.outboundTransformNoTopic(response));
           }
         },
@@ -617,30 +552,8 @@ export class ReqResp {
     } catch (e: any) {
       this.logger.warn(e);
       this.metrics.recordResponseError(protocol);
-
-      // If we receive a known error, we use the error status in the response chunk, otherwise we categorize as unknown
-      let errorStatus = ReqRespStatus.UNKNOWN;
-      if (e instanceof ReqRespStatusError) {
-        errorStatus = e.status;
-      }
-
-      const sendErrorChunk = this.sendErrorChunk(errorStatus);
-
-      // Return and yield the response chunk
-      await pipe(
-        stream,
-        async function* (_source: any) {
-          yield* sendErrorChunk;
-        },
-        stream,
-      );
     } finally {
       await stream.close();
     }
   }
-
-  private async *sendErrorChunk(error: ReqRespStatus): AsyncIterable<Uint8Array> {
-    const errorChunk = Buffer.from([error]);
-    yield new Uint8Array(errorChunk);
-  }
 }

package/dest/services/reqresp/status.js

@@ -1,51 +0,0 @@
-/**
- * The error codes for the ReqResp protocol
- */ export var ReqRespStatus = /*#__PURE__*/ function(ReqRespStatus) {
-    ReqRespStatus[ReqRespStatus["SUCCESS"] = 0] = "SUCCESS";
-    ReqRespStatus[ReqRespStatus["RATE_LIMIT_EXCEEDED"] = 1] = "RATE_LIMIT_EXCEEDED";
-    ReqRespStatus[ReqRespStatus["BADLY_FORMED_REQUEST"] = 2] = "BADLY_FORMED_REQUEST";
-    ReqRespStatus[ReqRespStatus["UNKNOWN"] = 127] = "UNKNOWN";
-    return ReqRespStatus;
-}({});
-export class ReqRespStatusError extends Error {
-    /**
-   * The status code
-   */ status;
-    constructor(status){
-        super(`ReqResp Error: ${prettyPrintReqRespStatus(status)}`);
-        this.status = status;
-    }
-}
-/**
- * Parse the status chunk
- * @param chunk
- * @returns
- *
- * @throws ReqRespStatusError if the chunk is not valid
- */ export function parseStatusChunk(chunk) {
-    if (chunk.length !== 1) {
-        throw new ReqRespStatusError(127);
-    }
-    const status = chunk[0];
-    // Check if status is a valid ReqRespStatus value
-    if (!(status in ReqRespStatus)) {
-        throw new ReqRespStatusError(127);
-    }
-    return status;
-}
-/**
- * Pretty print the ReqResp status
- * @param status
- * @returns
- */ export function prettyPrintReqRespStatus(status) {
-    switch(status){
-        case 0:
-            return 'SUCCESS';
-        case 1:
-            return 'RATE_LIMIT_EXCEEDED';
-        case 2:
-            return 'BADLY_FORMED_REQUEST';
-        case 127:
-            return 'UNKNOWN';
-    }
-}

package/src/services/reqresp/status.ts

@@ -1,59 +0,0 @@
-/**
- * The error codes for the ReqResp protocol
- */
-export enum ReqRespStatus {
-  SUCCESS = 0,
-  RATE_LIMIT_EXCEEDED = 1,
-  BADLY_FORMED_REQUEST = 2,
-  UNKNOWN = 127,
-}
-
-export class ReqRespStatusError extends Error {
-  /**
-   * The status code
-   */
-  status: ReqRespStatus;
-
-  constructor(status: ReqRespStatus) {
-    super(`ReqResp Error: ${prettyPrintReqRespStatus(status)}`);
-    this.status = status;
-  }
-}
-
-/**
- * Parse the status chunk
- * @param chunk
- * @returns
- *
- * @throws ReqRespStatusError if the chunk is not valid
- */
-export function parseStatusChunk(chunk: Uint8Array): ReqRespStatus {
-  if (chunk.length !== 1) {
-    throw new ReqRespStatusError(ReqRespStatus.UNKNOWN);
-  }
-
-  const status = chunk[0];
-  // Check if status is a valid ReqRespStatus value
-  if (!(status in ReqRespStatus)) {
-    throw new ReqRespStatusError(ReqRespStatus.UNKNOWN);
-  }
-  return status as ReqRespStatus;
-}
-
-/**
- * Pretty print the ReqResp status
- * @param status
- * @returns
- */
-export function prettyPrintReqRespStatus(status: ReqRespStatus) {
-  switch (status) {
-    case ReqRespStatus.SUCCESS:
-      return 'SUCCESS';
-    case ReqRespStatus.RATE_LIMIT_EXCEEDED:
-      return 'RATE_LIMIT_EXCEEDED';
-    case ReqRespStatus.BADLY_FORMED_REQUEST:
-      return 'BADLY_FORMED_REQUEST';
-    case ReqRespStatus.UNKNOWN:
-      return 'UNKNOWN';
-  }
-}