soa/service/http_endpoint.h

/* http_endpoint.h                                                 -*- C++ -*-
   Jeremy Barnes, 18 February 2011
   Copyright (c) 2011 Datacratic.  All rights reserved.

   Endpoint for generic HTTP connections.
*/

#pragma once

#include "soa/service//passive_endpoint.h"
#include "soa/types/date.h"
#include "http_header.h"
#include <boost/make_shared.hpp>
#include <boost/algorithm/string.hpp>

namespace Datacratic {


class HttpEndpoint;


/*****************************************************************************/
/* HTTP RESPONSE                                                             */
/*****************************************************************************/

struct HttpResponse {
    HttpResponse(int responseCode,
                 std::string contentType,
                 std::string body,
                 std::vector<std::pair<std::string, std::string> > extraHeaders
                     = std::vector<std::pair<std::string, std::string> >())
        : responseCode(responseCode),
          responseStatus(getResponseReasonPhrase(responseCode)),
          contentType(contentType),
          body(body),
          extraHeaders(extraHeaders)
    {
    }

    HttpResponse(int responseCode,
                 Json::Value body,
                 std::vector<std::pair<std::string, std::string> > extraHeaders
                     = std::vector<std::pair<std::string, std::string> >())
        : responseCode(responseCode),
          responseStatus(getResponseReasonPhrase(responseCode)),
          contentType("application/json"),
          body(boost::trim_copy(body.toString())),
          extraHeaders(extraHeaders)
    {
    }

    int responseCode;
    std::string responseStatus;
    std::string contentType;
    std::string body;
    std::vector<std::pair<std::string, std::string> > extraHeaders;
};


/*****************************************************************************/
/* HTTP CONNECTION HANDLER                                                   */
/*****************************************************************************/

struct HttpConnectionHandler : public PassiveConnectionHandler {

    HttpConnectionHandler();

    enum ReadState {
        INVALID,
        HEADER,
        PAYLOAD,       // non chunk only
        CHUNK_HEADER,  // chunk only
        CHUNK_BODY,    // chunk only
        DONE
    } readState;

    std::string headerText;

    HttpHeader header;

    std::string payload;

    std::string chunkHeader;
    size_t chunkSize;
    std::string chunkBody;

    Date firstData;

    HttpEndpoint * httpEndpoint;

    virtual void onGotTransport();

    std::shared_ptr<ConnectionHandler> makeNewHandlerShared();

    //virtual void handleNewConnection();
    virtual void handleData(const std::string & data);
    virtual void handleSendFinished();
    virtual void handleError(const std::string & message);
    virtual void onCleanup();

    virtual void handleHttpHeader(const HttpHeader & header);

    virtual void handleHttpData(const std::string & data);

    virtual void handleHttpPayload(const HttpHeader & header,
                                   const std::string & payload);

    virtual void handleHttpChunk(const HttpHeader & header,
                                 const std::string & chunkHeader,
                                 const std::string & chunk);

    void sendHttpChunk(const std::string & chunk,
                       NextAction next = NEXT_CONTINUE,
                       OnWriteFinished onWriteFinished = OnWriteFinished());

    virtual void putResponseOnWire(HttpResponse response,
                                   std::function<void ()> onSendFinished
                                       = std::function<void ()>());

};


/*****************************************************************************/
/* HTTP ENDPOINT                                                             */
/*****************************************************************************/

struct HttpEndpoint: public PassiveEndpointT<SocketTransport> {

    HttpEndpoint(const std::string & name);

    virtual ~HttpEndpoint();

    typedef std::function<std::shared_ptr<ConnectionHandler> ()>
    HandlerFactory;

    HandlerFactory handlerFactory;

    virtual std::shared_ptr<ConnectionHandler>
    makeNewHandler()
    {
        if (handlerFactory)
            return handlerFactory();
        return std::make_shared<HttpConnectionHandler>();
    }
};

} // namespace Datacratic