libwebserv/server.h

// Copyright 2014 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef WEBSERVER_LIBWEBSERV_SERVER_H_
#define WEBSERVER_LIBWEBSERV_SERVER_H_

#include <map>
#include <memory>
#include <string>

#include <base/macros.h>
#include <dbus/bus.h>
#include <chromeos/dbus/async_event_sequencer.h>
#include <chromeos/dbus/dbus_object.h>
#include <libwebserv/export.h>
#include <libwebserv/request_handler_interface.h>

namespace org {
namespace chromium {
namespace WebServer {

class ObjectManagerProxy;
class ProtocolHandlerProxy;
class RequestHandlerAdaptor;
class ServerProxy;

}  // namespace WebServer
}  // namespace chromium
}  // namespace org

namespace libwebserv {

// Top-level wrapper class around HTTP server and provides an interface to
// the web server.
class LIBWEBSERV_EXPORT Server final {
 public:
  Server();
  ~Server();

  // Establish a connection to the system webserver.
  // |service_name| is the well known D-Bus name of the client's process, used
  // to expose a callback D-Bus object the web server calls back with incoming
  // requests.
  // |on_server_online| and |on_server_offline| will notify the caller when the
  // server comes up and down.
  // Note that we can Connect() even before the webserver attaches to D-Bus,
  // and appropriate state will be built up when the webserver appears on D-Bus.
  void Connect(
      const scoped_refptr<dbus::Bus>& bus,
      const std::string& service_name,
      const chromeos::dbus_utils::AsyncEventSequencer::CompletionAction& cb,
      const base::Closure& on_server_online,
      const base::Closure& on_server_offline);

  // Disconnects from the web server and removes the library interface from
  // D-Bus.
  void Disconnect();

  // A helper method that returns the default handler for "http".
  ProtocolHandler* GetDefaultHttpHandler();

  // A helper method that returns the default handler for "https".
  ProtocolHandler* GetDefaultHttpsHandler();

  // Returns an existing protocol handler by name.  If the handler with the
  // requested |name| does not exist, a new one will be created.
  //
  // The created handler is purely client side, and depends on the server
  // being configured to open a corresponding handler with the given name.
  // Because clients and the server come up asynchronously, we allow clients
  // to register anticipated handlers before server starts up.
  ProtocolHandler* GetProtocolHandler(const std::string& name);

  // Returns true if the web server daemon is connected to DBus and our
  // connection to it has been established.
  bool IsConnected() const { return proxy_ != nullptr; }

  // Set a user-callback to be invoked when a protocol handler is connect to the
  // server daemon.  Multiple calls to this method will overwrite previously set
  // callbacks.
  void OnProtocolHandlerConnected(
      const base::Callback<void(ProtocolHandler*)>& callback);

  // Set a user-callback to be invoked when a protocol handler is disconnected
  // from the server daemon (e.g. on shutdown).  Multiple calls to this method
  // will overwrite previously set callbacks.
  void OnProtocolHandlerDisconnected(
      const base::Callback<void(ProtocolHandler*)>& callback);

 private:
  friend class ProtocolHandler;
  class RequestHandler;

  // Handler invoked when a connection is established to web server daemon.
  LIBWEBSERV_PRIVATE void Online(org::chromium::WebServer::ServerProxy* server);

  // Handler invoked when the web server daemon connection is dropped.
  LIBWEBSERV_PRIVATE void Offline(const dbus::ObjectPath& object_path);

  // Handler invoked when a new protocol handler D-Bus proxy object becomes
  // available.
  LIBWEBSERV_PRIVATE void ProtocolHandlerAdded(
      org::chromium::WebServer::ProtocolHandlerProxy* handler);

  // Handler invoked when a protocol handler D-Bus proxy object disappears.
  LIBWEBSERV_PRIVATE void ProtocolHandlerRemoved(
      const dbus::ObjectPath& object_path);

  // Looks up a protocol handler by ID. If not found, returns nullptr.
  LIBWEBSERV_PRIVATE ProtocolHandler* GetProtocolHandlerByID(
      const std::string& id) const;

  // Private implementation of D-Bus RequestHandlerInterface called by the web
  // server daemon whenever a new request is available to be processed.
  std::unique_ptr<RequestHandler> request_handler_;
  // D-Bus object adaptor for RequestHandlerInterface.
  std::unique_ptr<org::chromium::WebServer::RequestHandlerAdaptor>
      dbus_adaptor_;
  // D-Bus object to handler registration of RequestHandlerInterface.
  std::unique_ptr<chromeos::dbus_utils::DBusObject> dbus_object_;

  // A mapping of protocol handler name to the associated object.
  std::map<std::string, std::unique_ptr<ProtocolHandler>>
      protocol_handlers_names_;
  // A mapping of protocol handler IDs to the associated object.
  std::map<std::string, ProtocolHandler*> protocol_handlers_ids_;
  // A map between D-Bus object path of protocol handler and remote protocol
  // handler ID.
  std::map<dbus::ObjectPath, std::string> protocol_handler_id_map_;

  // User-specified callbacks for server and protocol handler life-time events.
  base::Closure on_server_online_;
  base::Closure on_server_offline_;
  base::Callback<void(ProtocolHandler*)> on_protocol_handler_connected_;
  base::Callback<void(ProtocolHandler*)> on_protocol_handler_disconnected_;

  // D-Bus object manager proxy that receives notification of web server
  // daemon's D-Bus object creation and destruction.
  std::unique_ptr<org::chromium::WebServer::ObjectManagerProxy> object_manager_;

  // D-Bus proxy for the web server main object.
  org::chromium::WebServer::ServerProxy* proxy_{nullptr};

  // D-Bus service name used by the daemon hosting this object.
  std::string service_name_;

  DISALLOW_COPY_AND_ASSIGN(Server);
};

}  // namespace libwebserv

#endif  // WEBSERVER_LIBWEBSERV_SERVER_H_