proxygen::HTTPTransactionIngressSMData Class Reference

#include <HTTPTransactionIngressSM.h>

Public Types
enum	State : uint8_t {   State::Start, State::HeadersReceived, State::RegularBodyReceived, State::ChunkHeaderReceived,   State::ChunkBodyReceived, State::ChunkCompleted, State::TrailersReceived, State::UpgradeComplete,   State::EOMQueued, State::ReceivingDone }
enum	Event : uint8_t {   Event::onHeaders, Event::onBody, Event::onChunkHeader, Event::onChunkComplete,   Event::onTrailers, Event::onUpgrade, Event::onEOM, Event::eomFlushed }

Static Public Member Functions
static State	getInitialState ()
static std::pair< State, bool >	find (State s, Event e)
static const std::string	getName ()

Detailed Description

Definition at line 18 of file HTTPTransactionIngressSM.h.

Member Enumeration Documentation

enum proxygen::HTTPTransactionIngressSMData::Event : uint8_t

strong

Enumerator
onHeaders
onBody
onChunkHeader
onChunkComplete
onTrailers
onUpgrade
onEOM
eomFlushed

Definition at line 34 of file HTTPTransactionIngressSM.h.

                  : uint8_t {
    // API accessible transitions
    onHeaders,
    onBody,
    onChunkHeader,
    onChunkComplete,
    onTrailers,
    onUpgrade,
    onEOM,
    // Internal state transitions
    eomFlushed,
  };

enum proxygen::HTTPTransactionIngressSMData::State : uint8_t

strong

Enumerator
Start
HeadersReceived
RegularBodyReceived
ChunkHeaderReceived
ChunkBodyReceived
ChunkCompleted
TrailersReceived
UpgradeComplete
EOMQueued
ReceivingDone

Definition at line 21 of file HTTPTransactionIngressSM.h.

                  : uint8_t {
    Start,
    HeadersReceived,
    RegularBodyReceived,
    ChunkHeaderReceived,
    ChunkBodyReceived,
    ChunkCompleted,
    TrailersReceived,
    UpgradeComplete,
    EOMQueued,
    ReceivingDone,
  };

Member Function Documentation

std::pair< HTTPTransactionIngressSMData::State, bool > proxygen::HTTPTransactionIngressSMData::find ( HTTPTransactionIngressSMData::State  s, HTTPTransactionIngressSMData::Event  e  )

static

Definition at line 28 of file HTTPTransactionIngressSM.cpp.

References ChunkBodyReceived, ChunkCompleted, ChunkHeaderReceived, eomFlushed, EOMQueued, HeadersReceived, onBody, onChunkComplete, onChunkHeader, onEOM, onHeaders, onTrailers, onUpgrade, ReceivingDone, RegularBodyReceived, Start, TrailersReceived, and UpgradeComplete.

Referenced by getInitialState().

                                                                        {
  using State = HTTPTransactionIngressSMData::State;
  using Event = HTTPTransactionIngressSMData::Event;
  using TransitionTable = std::map<std::pair<State, Event>, State>;

  static const folly::Indestructible<TransitionTable> transitions{
    TransitionTable{
    {{State::Start, Event::onHeaders}, State::HeadersReceived},

    // For HTTP receiving 100 response, then a regular response
    {{State::HeadersReceived, Event::onHeaders}, State::HeadersReceived},

    {{State::HeadersReceived, Event::onBody}, State::RegularBodyReceived},
    {{State::HeadersReceived, Event::onChunkHeader},
     State::ChunkHeaderReceived},
    // special case - 0 byte body with trailers
    {{State::HeadersReceived, Event::onTrailers}, State::TrailersReceived},
    {{State::HeadersReceived, Event::onUpgrade}, State::UpgradeComplete},
    {{State::HeadersReceived, Event::onEOM}, State::EOMQueued},

    {{State::RegularBodyReceived, Event::onBody}, State::RegularBodyReceived},
    // HTTP2 supports trailers and doesn't handle body as chunked events
    {{State::RegularBodyReceived, Event::onTrailers}, State::TrailersReceived},
    {{State::RegularBodyReceived, Event::onEOM}, State::EOMQueued},

    {{State::ChunkHeaderReceived, Event::onBody}, State::ChunkBodyReceived},

    {{State::ChunkBodyReceived, Event::onBody}, State::ChunkBodyReceived},
    {{State::ChunkBodyReceived, Event::onChunkComplete}, State::ChunkCompleted},

    {{State::ChunkCompleted, Event::onChunkHeader}, State::ChunkHeaderReceived},
    // TODO: "trailers" may be received at any time due to the SPDY HEADERS
    // frame coming at any time. We might want to have a
    // TransactionStateMachineFactory that takes a codec and generates the
    // appropriate transaction state machine from that.
    {{State::ChunkCompleted, Event::onTrailers}, State::TrailersReceived},
    {{State::ChunkCompleted, Event::onEOM}, State::EOMQueued},

    {{State::TrailersReceived, Event::onEOM}, State::EOMQueued},

    {{State::UpgradeComplete, Event::onBody}, State::UpgradeComplete},
    {{State::UpgradeComplete, Event::onEOM}, State::EOMQueued},

    {{State::EOMQueued, Event::eomFlushed}, State::ReceivingDone},
    }
  };

  auto const &it = transitions->find(std::make_pair(s, e));
  if (it == transitions->end()) {
    return std::make_pair(s, false);
  }

  return std::make_pair(it->second, true);
}

static State proxygen::HTTPTransactionIngressSMData::getInitialState ( )

inlinestatic

Definition at line 47 of file HTTPTransactionIngressSM.h.

References find(), s, and Start.

                                 {
    return State::Start;
  }

static const std::string proxygen::HTTPTransactionIngressSMData::getName ( )

inlinestatic

Definition at line 53 of file HTTPTransactionIngressSM.h.

References proxygen::operator<<(), and s.

                                   {
    return "HTTPTransactionIngress";
  }

---

The documentation for this class was generated from the following files:

• proxygen/lib/http/session/HTTPTransactionIngressSM.h
• proxygen/lib/http/session/HTTPTransactionIngressSM.cpp