Package org.apache.tika.pipes.core.server

Class ServerProtocolIO

java.lang.Object
org.apache.tika.pipes.core.server.ServerProtocolIO
public class ServerProtocolIO extends Object
Centralizes protocol I/O operations shared by PipesServer and ConnectionHandler.

This class handles the pure protocol mechanics — serialization, framing, and ACK exchange. It does not make lifecycle decisions (exit vs. return, close connection vs. shut down JVM). Callers are responsible for catching exceptions and responding according to their own lifecycle policy.

  • Field Details

    • MIN_FALLBACK_PAYLOAD_BYTES

      public static final int MIN_FALLBACK_PAYLOAD_BYTES
      The minimum value accepted for maxPayloadBytes in the constructor and in PipesConfig.setMaxIpcPayloadBytes(int): the serialized byte length of FALLBACK_PAYLOAD_BYTES. Any configured limit smaller than this cannot carry even the fallback frame.

  • Constructor Details

  • Method Details

    • writeFinished

      public void writeFinished(PipesResult pipesResult) throws IOException
      Writes a FINISHED message with the serialized result and waits for ACK.

      Serialization is streamed into a ServerProtocolIO.BoundedOutputStream capped at maxIpcPayloadBytes. If the payload overflows the cap, the stream aborts before any bytes are sent to the client and a pre-computed PAYLOAD_LIMIT_EXCEEDED frame is sent instead. This keeps the original result status intact when the payload fits, avoids unbounded heap allocation, and prevents wire desynchronization on the client side.

      Throws:
      ShutDownReceivedException - if SHUT_DOWN is received instead of ACK
      IOException - on serialization or I/O errors

    • writeIntermediate

      public void writeIntermediate(Metadata metadata) throws IOException
      Writes an INTERMEDIATE_RESULT message with the serialized metadata and waits for ACK. If the metadata exceeds maxIpcPayloadBytes, the intermediate is silently skipped (the FINISHED message will still follow).
      Throws:
      ShutDownReceivedException - if SHUT_DOWN is received instead of ACK
      IOException - on serialization or I/O errors

    • writeIntermediate

      public void writeIntermediate(Metadata metadata, Runnable afterFrameWritten) throws IOException
      Like writeIntermediate(Metadata), but runs afterFrameWritten once the frame is flushed to the socket, before waiting for the client's ACK. Lets the caller unblock the parse worker while the ACK is still in flight -- the ACK round trip would otherwise sit between pre-parse and parse on every request. Not invoked when the oversized intermediate is skipped or the write fails; callers must handle those paths themselves.
      Throws:
      IOException

    • writeCrash

      public void writeCrash(PipesMessageType crashType, Throwable t) throws IOException
      Writes a crash message (OOM, TIMEOUT, or UNSPECIFIED_CRASH) with the serialized stack trace and waits for ACK. Serialization is streamed into a ServerProtocolIO.BoundedOutputStream capped at maxIpcPayloadBytes. If the stack trace overflows the cap, an empty payload is sent instead.
      Throws:
      IOException - on serialization, I/O, or unexpected ACK response

    • awaitAck

      public void awaitAck() throws IOException
      Reads a framed message and verifies it is an ACK.
      Throws:
      ShutDownReceivedException - if the message is SHUT_DOWN
      IOException - if the message is any other non-ACK type, or on I/O error

    • validateParseContext

      public static void validateParseContext(ParseContext context) throws TikaConfigException
      Validates a (resolved) ParseContext's configuration. Must be called after ParseContextUtils.resolveAll(org.apache.tika.parser.ParseContext, java.lang.ClassLoader), since configs are lazy and only populated once resolved.
      Throws:
      TikaConfigException

    • clampRequestTimeoutLimits

      public static void clampRequestTimeoutLimits(ParseContext requestContext, ParseContext operatorContext, ParseContext mergedContext, long maxMillis)
      Caps request-supplied TimeoutLimits (typed or unresolved timeout-limits JSON) field by field at the operator's own limits (operatorContext: the server's config plus any preset, or the class defaults) and at pipes.maxTotalTaskTimeoutMillis: a request may shorten a timeout but not extend it. The operator's limits are never clamped. Must run after ParseContextUtils.resolveAll and before ParseTimeout is armed.

    • clampRequestLimits

      public static void clampRequestLimits(ParseContext operatorContext, ParseContext merged) throws TikaConfigException
      A request may tighten the operator's OutputLimits, EmbeddedLimits, content-handler write limit, metadata limiter and maxUnpackBytes but not loosen them. Render limits in "pages" are bounded where the parser resolves them, by the PagesConfig.OperatorPages recorded here. operatorContext is the server's config plus any preset, before the request was overlaid; entries it already holds are the operator's and are left alone. Must run after ParseContextUtils.resolveAll.
      Throws:
      TikaConfigException