callback_server.h

// Copyright (c) 2010 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.

// The callback server listens for http connections on port 5199 (by default),
// and dispatches valid requests to javascript function registered by the
// policy.
//
// The incoming request must be an HTTP POST (libevent doesn't have an https
// server) to the uri "/dispatch".  It must have a content-type of
// "application/json", an "X-Entd-Request" header set to "magic", and a
// request entity no larger than 1k which represents a valid JSON object.
//
// The JSON object must have a property named "function" which contains the
// function name we want to dispatch, and may optionally contain an property
// named "argument", which is passed as the only argument to the target
// function.
//
// A policy can opt in to starting the callback server by calling
// "entd.callbackServer.start(callbacks[, port]). The callbacks parameter is
// required and must be a js object containing the callbacks to be served.
// The optional port can be used to specify the port to listen on. The server
// will bind to 120.7.7.1 only.

#ifndef ENTD_CALLBACK_SERVER_H_
#define ENTD_CALLBACK_SERVER_H_

#include <base/basictypes.h>
#include <base/logging.h>
#include <event.h>
#include <evhttp.h>
#include <v8.h>

#include "entd/js_object_wrapper.h"
#include "entd/utils.h"

namespace entd {

class Entd;

class CallbackServer : public JSObjectWrapper<CallbackServer> {
 public:
  explicit CallbackServer(Entd* entd);
  virtual ~CallbackServer();

  // JSObjectWrapper methods
  static const char* GetClassName() { return "CallbackServer"; }
  static void SetTemplateBindings(
      v8::Handle<v8::ObjectTemplate> template_object);

  // Initialize the CallbackServer instance.  Must be called before any
  // other method.
  virtual bool Initialize() {
    JSObjectWrapper<CallbackServer>::Initialize();
    return true;
  }

  // Start the callback server with a particular set of callbacks and
  // on a given port number.
  virtual bool Start(v8::Handle<v8::Object> callbacks, int port);

  // Stop the server.
  virtual void Stop();

  // Return true if the callback server has been started.
  virtual bool IsRunning();

  // Dispatch a given http request.
  virtual void OnRequest(struct evhttp_request* request);

  // Sets whether or not the server is busy.  While busy, it cannot be stopped.
  // This should only matter when someone attempts to stop the server from
  // script during a callback.  In other cases, the single threadedness of
  // entd should keep us from ever trying to stop while busy.  This is not
  // nestable.
  virtual void SetBusy(bool state) {
    if (state == busy_)
      LOG(WARNING) << "Busy status is already " << (state ? "set" : "clear");
    busy_ = state;
  };
  virtual bool IsBusy() { return busy_; }

  static void set_session_id(const std::string& session_id) {
    session_id_ = session_id;
  }

  static std::string session_id() {
    return session_id_;
  }

  static std::string required_origin;

 private:
  // State for SetBusy/IsBusy.
  bool busy_;

  // Parent entd object.
  Entd* entd_;

  // JS Object containing the callback functions we might dispatch to.
  v8::Persistent<v8::Object> callbacks_;

  // X-Entd-Session-Id that must come in every request.
  static std::string session_id_;

  // Non-null if the server is running.
  struct evhttp* evhttp_;

  // Port we're listening on, or 0 if not running.
  int port_;

  DISALLOW_COPY_AND_ASSIGN(CallbackServer);
};

}  // namespace entd

#endif  // ENTD_CALLBACK_SERVER_H_