httpserver.h

Go to the documentation of this file.

#ifndef ION_REMOTE_HTTPSERVER_H_
#define ION_REMOTE_HTTPSERVER_H_

#include <map>
#include <string>

#include "ion/base/referent.h"
#include "ion/port/mutex.h"

struct mg_connection;
struct mg_context;

namespace ion {
namespace remote {

class ION_API HttpServer {
 public:
  typedef std::map<std::string, std::string> QueryMap;

  class WebsocketHelper;
  typedef std::map<void*, WebsocketHelper*> WebsocketMap;

  class Websocket : public base::Referent {
   public:
    Websocket() : helper_(NULL) {}
    ~Websocket() override {}

    virtual void ConnectionReady() {}

    virtual int ReceiveData(char* data, size_t data_len, bool is_binary) = 0;

   protected:
    void SendData(const char* data, size_t data_len, bool is_binary);

   private:
    void SetHelper(WebsocketHelper* helper) { helper_ = helper; }
    friend class WebsocketHelper;
    WebsocketHelper* helper_;
  };
  typedef base::ReferentPtr<Websocket>::Type WebsocketPtr;

  class RequestHandler : public base::Referent {
   public:
    virtual const std::string HandleRequest(const std::string& path,
                                            const QueryMap& args,
                                            std::string* content_type) = 0;

    virtual const WebsocketPtr ConnectWebsocket(const std::string& path,
                                                const QueryMap& args) {
      return WebsocketPtr();
    }

    const std::string& GetBasePath() const { return base_path_; }

   protected:
    explicit RequestHandler(const std::string& base_path);

    ~RequestHandler() override;

   private:
    const std::string base_path_;
  };
  typedef base::ReferentPtr<RequestHandler>::Type RequestHandlerPtr;
  typedef std::map<std::string, RequestHandlerPtr> HandlerMap;

  HttpServer(int port, int num_threads);
  virtual ~HttpServer();

  const std::string GetUriData(const std::string& uri) const;

  bool IsRunning() const;

  void RegisterHandler(const RequestHandlerPtr& handler);
  void UnregisterHandler(const std::string& path);

  HandlerMap GetHandlers() const;

  bool EmbedLocalSourcedFiles() const { return embed_local_sourced_files_; }
  void SetEmbedLocalSourcedFiles(bool embed) {
    embed_local_sourced_files_ = embed;
  }

  size_t WebsocketCount();

  const std::string& GetFooterHtml() const { return footer_; }
  const std::string& GetHeaderHtml() const { return header_; }
  void SetFooterHtml(const std::string& str) { footer_ = str; }
  void SetHeaderHtml(const std::string& str) { header_ = str; }

 private:
  friend class WebsocketHelper;
  void RegisterWebsocket(void* key, WebsocketHelper* helper);
  void UnregisterWebsocket(void* key);
  WebsocketHelper* FindWebsocket(void* key);
  WebsocketMap websockets_;
  port::Mutex websocket_mutex_;

  mg_context* context_;
  HandlerMap handlers_;
  mutable ion::port::Mutex handlers_mutex_;

  std::string header_;
  std::string footer_;

  bool embed_local_sourced_files_;
};

}  // namespace remote
}  // namespace ion

#endif  // ION_REMOTE_HTTPSERVER_H_