org.apache.pekko.http.impl.engine.parsing

Interface HttpMessageParser<Output extends ParserOutput>

All Known Implementing Classes:

HttpResponseParser

public interface HttpMessageParser<Output extends ParserOutput>

INTERNAL API

Common logic for http request and response message parsing

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	HttpMessageParser.StateResult
static class	HttpMessageParser.Trampoline
static class	HttpMessageParser.Trampoline$

Method Summary

Modifier and Type	Method and Description
<A extends ParserOutput> ParserOutput.StreamedEntityCreator<A,RequestEntity>	chunkedEntity(scala.Option<Content$minusType> cth)
scala.Function0<scala.Option<ParserOutput.ErrorOutput>>	completionHandling()
ContentType	contentType(scala.Option<Content$minusType> cth)
<A extends ParserOutput> ParserOutput.StreamedEntityCreator<A,UniversalEntity>	defaultEntity(scala.Option<Content$minusType> cth, long contentLength)
HttpMessageParser.StateResult	done() Use continue or terminate to suspend or terminate processing.
Output	doPull()
void	emit(Output output)
ParserOutput.StrictEntityCreator<Output,UniversalEntity>	emptyEntity(scala.Option<Content$minusType> cth)
HttpMessageParser.StateResult	failEntityStream(ErrorInfo info)
HttpMessageParser.StateResult	failEntityStream(java.lang.String summary)
HttpMessageParser.StateResult	failEntityStream(java.lang.String summary, java.lang.String detail)
HttpMessageParser.StateResult	failMessageStart(StatusCode status)
HttpMessageParser.StateResult	failMessageStart(StatusCode status, ErrorInfo info)
HttpMessageParser.StateResult	failMessageStart(StatusCode status, java.lang.String summary, java.lang.String detail)
HttpMessageParser.StateResult	failMessageStart(java.lang.String summary)
HttpMessageParser.StateResult	failMessageStart(java.lang.String summary, java.lang.String detail)
HttpHeaderParser	headerParser()
scala.collection.mutable.ListBuffer<HttpHeader>	initialHeaderBuffer()
boolean	isResponseParser()
scala.runtime.Nothing$	onBadProtocol(org.apache.pekko.util.ByteString input) invoked if the specified protocol is unknown
Output	parseBytes(org.apache.pekko.util.ByteString input)
HttpMessageParser.StateResult	parseChunk(org.apache.pekko.util.ByteString input, int offset, boolean isLastMessage, long totalBytesRead)
HttpMessageParser.StateResult	parseEntity(scala.collection.immutable.List<HttpHeader> headers, HttpProtocol protocol, org.apache.pekko.util.ByteString input, int bodyStart, scala.Option<Content$minusLength> clh, scala.Option<Content$minusType> cth, boolean isChunked, boolean expect100continue, boolean hostHeaderPresent, boolean closeAfterResponseCompletion, javax.net.ssl.SSLSession sslSession)
HttpMessageParser.StateResult	parseFixedLengthBody(long remainingBodyBytes, boolean isLastMessage, org.apache.pekko.util.ByteString input, int bodyStart)
HttpMessageParser.StateResult	parseHeaderLines(org.apache.pekko.util.ByteString input, int lineStart, scala.collection.mutable.ListBuffer<HttpHeader> headers, int headerCount, scala.Option<Connection> ch, scala.Option<Content$minusLength> clh, scala.Option<Content$minusType> cth, boolean isChunked, boolean e100c, boolean hh)
HttpMessageParser.StateResult	parseHeaderLinesAux(scala.collection.mutable.ListBuffer<HttpHeader> headers, int headerCount, scala.Option<Connection> ch, scala.Option<Content$minusLength> clh, scala.Option<Content$minusType> cth, boolean isChunked, boolean e100c, boolean hh, org.apache.pekko.util.ByteString input, int lineStart)
HttpMessageParser.StateResult	parseMessage(org.apache.pekko.util.ByteString input, int offset)
int	parseProtocol(org.apache.pekko.util.ByteString input, int cursor)
Output	parseSessionBytes(org.apache.pekko.stream.TLSProtocol.SessionBytes input)
void	setCompletionHandling(scala.Function0<scala.Option<ParserOutput.ErrorOutput>> completionHandling)
ParserSettings	settings()
boolean	shouldComplete()
HttpMessageParser.StateResult	startNewMessage(org.apache.pekko.util.ByteString input, int offset)
ParserOutput.StrictEntityCreator<Output,UniversalEntity>	strictEntity(scala.Option<Content$minusType> cth, org.apache.pekko.util.ByteString input, int bodyStart, int contentLength)
HttpMessageParser.StateResult	terminate()
boolean	terminated()

Method Detail

completionHandling

scala.Function0<scala.Option<ParserOutput.ErrorOutput>> completionHandling()

terminated

boolean terminated()

settings

ParserSettings settings()

headerParser

HttpHeaderParser headerParser()

isResponseParser

boolean isResponseParser()

onBadProtocol

scala.runtime.Nothing$ onBadProtocol(org.apache.pekko.util.ByteString input)

invoked if the specified protocol is unknown

parseMessage

HttpMessageParser.StateResult parseMessage(org.apache.pekko.util.ByteString input,
                                           int offset)

parseEntity

HttpMessageParser.StateResult parseEntity(scala.collection.immutable.List<HttpHeader> headers,
                                          HttpProtocol protocol,
                                          org.apache.pekko.util.ByteString input,
                                          int bodyStart,
                                          scala.Option<Content$minusLength> clh,
                                          scala.Option<Content$minusType> cth,
                                          boolean isChunked,
                                          boolean expect100continue,
                                          boolean hostHeaderPresent,
                                          boolean closeAfterResponseCompletion,
                                          javax.net.ssl.SSLSession sslSession)

initialHeaderBuffer

scala.collection.mutable.ListBuffer<HttpHeader> initialHeaderBuffer()

parseSessionBytes

Output parseSessionBytes(org.apache.pekko.stream.TLSProtocol.SessionBytes input)

parseBytes

Output parseBytes(org.apache.pekko.util.ByteString input)

doPull

Output doPull()

shouldComplete

boolean shouldComplete()

startNewMessage

HttpMessageParser.StateResult startNewMessage(org.apache.pekko.util.ByteString input,
                                              int offset)

parseProtocol

int parseProtocol(org.apache.pekko.util.ByteString input,
                  int cursor)

parseHeaderLines

HttpMessageParser.StateResult parseHeaderLines(org.apache.pekko.util.ByteString input,
                                               int lineStart,
                                               scala.collection.mutable.ListBuffer<HttpHeader> headers,
                                               int headerCount,
                                               scala.Option<Connection> ch,
                                               scala.Option<Content$minusLength> clh,
                                               scala.Option<Content$minusType> cth,
                                               boolean isChunked,
                                               boolean e100c,
                                               boolean hh)

Parameters:

ch - connection header

clh - content-length

cth - content-type

teh - transfer-encoding

e100c - expect 100 continue

hh - host header seen

input - (undocumented)

lineStart - (undocumented)

headers - (undocumented)

headerCount - (undocumented)

isChunked - (undocumented)

Returns:

(undocumented)

parseHeaderLinesAux

HttpMessageParser.StateResult parseHeaderLinesAux(scala.collection.mutable.ListBuffer<HttpHeader> headers,
                                                  int headerCount,
                                                  scala.Option<Connection> ch,
                                                  scala.Option<Content$minusLength> clh,
                                                  scala.Option<Content$minusType> cth,
                                                  boolean isChunked,
                                                  boolean e100c,
                                                  boolean hh,
                                                  org.apache.pekko.util.ByteString input,
                                                  int lineStart)

parseFixedLengthBody

HttpMessageParser.StateResult parseFixedLengthBody(long remainingBodyBytes,
                                                   boolean isLastMessage,
                                                   org.apache.pekko.util.ByteString input,
                                                   int bodyStart)

parseChunk

HttpMessageParser.StateResult parseChunk(org.apache.pekko.util.ByteString input,
                                         int offset,
                                         boolean isLastMessage,
                                         long totalBytesRead)

emit

void emit(Output output)

failMessageStart

HttpMessageParser.StateResult failMessageStart(java.lang.String summary)

failMessageStart

HttpMessageParser.StateResult failMessageStart(java.lang.String summary,
                                               java.lang.String detail)

failMessageStart

HttpMessageParser.StateResult failMessageStart(StatusCode status)

failMessageStart

HttpMessageParser.StateResult failMessageStart(StatusCode status,
                                               java.lang.String summary,
                                               java.lang.String detail)

failMessageStart

HttpMessageParser.StateResult failMessageStart(StatusCode status,
                                               ErrorInfo info)

failEntityStream

HttpMessageParser.StateResult failEntityStream(java.lang.String summary)

failEntityStream

HttpMessageParser.StateResult failEntityStream(java.lang.String summary,
                                               java.lang.String detail)

failEntityStream

HttpMessageParser.StateResult failEntityStream(ErrorInfo info)

terminate

HttpMessageParser.StateResult terminate()

done

HttpMessageParser.StateResult done()

Use continue or terminate to suspend or terminate processing. Do not call this directly.

Returns:

(undocumented)

contentType

ContentType contentType(scala.Option<Content$minusType> cth)

emptyEntity

ParserOutput.StrictEntityCreator<Output,UniversalEntity> emptyEntity(scala.Option<Content$minusType> cth)

strictEntity

ParserOutput.StrictEntityCreator<Output,UniversalEntity> strictEntity(scala.Option<Content$minusType> cth,
                                                                      org.apache.pekko.util.ByteString input,
                                                                      int bodyStart,
                                                                      int contentLength)

defaultEntity

<A extends ParserOutput> ParserOutput.StreamedEntityCreator<A,UniversalEntity> defaultEntity(scala.Option<Content$minusType> cth,
                                                                                             long contentLength)

chunkedEntity

<A extends ParserOutput> ParserOutput.StreamedEntityCreator<A,RequestEntity> chunkedEntity(scala.Option<Content$minusType> cth)

setCompletionHandling

void setCompletionHandling(scala.Function0<scala.Option<ParserOutput.ErrorOutput>> completionHandling)