StaticService::StaticHandler Class Reference

#include <StaticHandler.h>

Inheritance diagram for StaticService::StaticHandler:

Public Member Functions
void	onRequest (std::unique_ptr< proxygen::HTTPMessage > headers) noexceptoverride
void	onBody (std::unique_ptr< folly::IOBuf > body) noexceptoverride
void	onEOM () noexceptoverride
void	onUpgrade (proxygen::UpgradeProtocol proto) noexceptoverride
void	requestComplete () noexceptoverride
void	onError (proxygen::ProxygenError err) noexceptoverride
void	onEgressPaused () noexceptoverride
void	onEgressResumed () noexceptoverride
Public Member Functions inherited from proxygen::RequestHandler
virtual void	setResponseHandler (ResponseHandler *handler) noexcept
virtual bool	canHandleExpect () noexcept
virtual ExMessageHandler *	getExHandler () noexcept
virtual ResponseHandler *	getDownstream () noexcept
virtual	~RequestHandler ()

Private Member Functions
void	readFile (folly::EventBase *evb)
bool	checkForCompletion ()

Private Attributes
std::unique_ptr< folly::File >	file_
bool	readFileScheduled_ {false}
std::atomic< bool >	paused_ {false}
bool	finished_ {false}

Additional Inherited Members
Protected Attributes inherited from proxygen::RequestHandler
ResponseHandler *	downstream_ {nullptr}

Detailed Description

Definition at line 22 of file StaticHandler.h.

Member Function Documentation

bool StaticService::StaticHandler::checkForCompletion ( )

private

Definition at line 147 of file StaticHandler.cpp.

                                       {
  if (finished_ && !readFileScheduled_) {
    VLOG(4) << "deleting StaticHandler";
    delete this;
    return true;
  }
  return false;
}

void StaticService::StaticHandler::onBody ( std::unique_ptr< folly::IOBuf >  body )

overridevirtualnoexcept

Invoked when we get part of body for the request.

Implements proxygen::RequestHandler.

Definition at line 124 of file StaticHandler.cpp.

                                                               {
  // ignore, only support GET
}

void StaticService::StaticHandler::onEgressPaused ( )

overridevirtualnoexcept

Signals from HTTP layer when client queue is full or empty. If you are sending a streaming response, consider implementing these and acting accordingly. Saves your server from running out of memory.

Reimplemented from proxygen::RequestHandler.

Definition at line 103 of file StaticHandler.cpp.

                                            {
  // This will terminate readFile soon
  VLOG(4) << "StaticHandler paused";
  paused_ = true;
}

void StaticService::StaticHandler::onEgressResumed ( )

overridevirtualnoexcept

Reimplemented from proxygen::RequestHandler.

Definition at line 109 of file StaticHandler.cpp.

References folly::netops::bind(), folly::EventBaseManager::get(), folly::getCPUExecutor(), folly::getEventBase(), and folly::readFile().

                                             {
  VLOG(4) << "StaticHandler resumed";
  paused_ = false;
  // If readFileScheduled_, it will reschedule itself
  if (!readFileScheduled_ && file_) {
    readFileScheduled_ = true;
    folly::getCPUExecutor()->add(
      std::bind(&StaticHandler::readFile, this,
                folly::EventBaseManager::get()->getEventBase()));
  } else {
    VLOG(4) << "Deferred scheduling readFile";
  }
}

void StaticService::StaticHandler::onEOM ( )

overridevirtualnoexcept

Invoked when we finish receiving the body.

Implements proxygen::RequestHandler.

Definition at line 128 of file StaticHandler.cpp.

                                   {
}

void StaticService::StaticHandler::onError ( proxygen::ProxygenError  err )

overridevirtualnoexcept

Request failed. Maybe because of read/write error on socket or client not being able to send request in time.

NOTE: Can be invoked at any time (except for before onRequest).

No more callbacks will be invoked after this. You should clean up after yourself.

Implements proxygen::RequestHandler.

Definition at line 141 of file StaticHandler.cpp.

                                                    {
  finished_ = true;
  paused_ = true;
  checkForCompletion();
}

void StaticService::StaticHandler::onRequest ( std::unique_ptr< proxygen::HTTPMessage >  headers )

overridevirtualnoexcept

Handles requests by serving the file named in path. Only supports GET. reads happen in a CPU thread pool since read(2) is blocking. If egress pauses, file reading is also paused.

Implements proxygen::RequestHandler.

Definition at line 28 of file StaticHandler.cpp.

References folly::netops::bind(), proxygen::ResponseBuilder::body(), folly::exceptionStr(), proxygen::GET, folly::EventBaseManager::get(), folly::getCPUExecutor(), folly::getEventBase(), folly::readFile(), proxygen::ResponseBuilder::send(), proxygen::ResponseBuilder::sendWithEOM(), and proxygen::ResponseBuilder::status().

                                                                         {
  if (headers->getMethod() != HTTPMethod::GET) {
    ResponseBuilder(downstream_)
      .status(400, "Bad method")
      .body("Only GET is supported")
      .sendWithEOM();
    return;
  }
  // a real webserver would validate this path didn't contain malicious
  // characters like '//' or '..'
  try {
    // + 1 to kill leading /
    file_ = std::make_unique<folly::File>(headers->getPath().c_str() + 1);
  } catch (const std::system_error& ex) {
    ResponseBuilder(downstream_)
      .status(404, "Not Found")
      .body(folly::to<std::string>("Could not find ", headers->getPath(),
                                   " ex=", folly::exceptionStr(ex)))
      .sendWithEOM();
    return;
  }
  ResponseBuilder(downstream_)
    .status(200, "Ok")
    .send();
  // use a CPU executor since read(2) of a file can block
  readFileScheduled_ = true;
  folly::getCPUExecutor()->add(
    std::bind(&StaticHandler::readFile, this,
              folly::EventBaseManager::get()->getEventBase()));
}

void StaticService::StaticHandler::onUpgrade ( proxygen::UpgradeProtocol  prot )

overridevirtualnoexcept

Invoked when the session has been upgraded to a different protocol

Implements proxygen::RequestHandler.

Definition at line 131 of file StaticHandler.cpp.

                                                        {
  // handler doesn't support upgrades
}

void StaticService::StaticHandler::readFile ( folly::EventBase *  evb )

private

Definition at line 59 of file StaticHandler.cpp.

References proxygen::ResponseBuilder::body(), data, proxygen::ERROR, folly::IOBufQueue::move(), folly::gen::move, folly::IOBufQueue::postallocate(), folly::IOBufQueue::preallocate(), folly::readNoInt(), folly::EventBase::runInEventBaseThread(), proxygen::ResponseBuilder::send(), and proxygen::ResponseBuilder::sendWithEOM().

                                                {
  folly::IOBufQueue buf;
  while (file_ && !paused_) {
    // read 4k-ish chunks and foward each one to the client
    auto data = buf.preallocate(4000, 4000);
    auto rc = folly::readNoInt(file_->fd(), data.first, data.second);
    if (rc < 0) {
      // error
      VLOG(4) << "Read error=" << rc;
      file_.reset();
      evb->runInEventBaseThread([this] {
          LOG(ERROR) << "Error reading file";
          downstream_->sendAbort();
        });
      break;
    } else if (rc == 0) {
      // done
      file_.reset();
      VLOG(4) << "Read EOF";
      evb->runInEventBaseThread([this] {
          ResponseBuilder(downstream_)
            .sendWithEOM();
        });
      break;
    } else {
      buf.postallocate(rc);
      evb->runInEventBaseThread([this, body=buf.move()] () mutable {
          ResponseBuilder(downstream_)
            .body(std::move(body))
            .send();
        });
    }
  }

  // Notify the request thread that we terminated the readFile loop
  evb->runInEventBaseThread([this] {
      readFileScheduled_ = false;
      if (!checkForCompletion() && !paused_) {
        VLOG(4) << "Resuming deferred readFile";
        onEgressResumed();
      }
    });
}

void StaticService::StaticHandler::requestComplete ( )

overridevirtualnoexcept

Invoked when request processing has been completed and nothing more needs to be done. This may be a good place to log some stats and clean up resources. This is distinct from onEOM() because it is invoked after the response is fully sent. Once this callback has been received, downstream_ should be considered invalid.

Implements proxygen::RequestHandler.

Definition at line 135 of file StaticHandler.cpp.

                                             {
  finished_ = true;
  paused_ = true;
  checkForCompletion();
}

Member Data Documentation

std::unique_ptr<folly::File> StaticService::StaticHandler::file_

private

Definition at line 45 of file StaticHandler.h.

bool StaticService::StaticHandler::finished_ {false}

private

Definition at line 48 of file StaticHandler.h.

std::atomic<bool> StaticService::StaticHandler::paused_ {false}

private

Definition at line 47 of file StaticHandler.h.

bool StaticService::StaticHandler::readFileScheduled_ {false}

private

Definition at line 46 of file StaticHandler.h.

---

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

• proxygen/httpserver/samples/static/StaticHandler.h
• proxygen/httpserver/samples/static/StaticHandler.cpp