relay/service.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_RELAY_SERVICE_H
#define __SSRC_WSPR_RELAY_SERVICE_H

#include <ssrc/wispers/ws/protocol.h>
#include <ssrc/wispers/ws/ActionConfig.h>
#include <ssrc/wispers/fcgi/parse_query.h>

#include <ssrc/wispers/renderer/service.h>
#include <ssrc/wispers/relay/protocol.h>
#include <ssrc/wispers/lua/Properties.h>

__BEGIN_NS_SSRC_WSPR_RELAY

using std::string;
using boost::filesystem::path;
using NS_SSRC_WISP_PROTOCOL::MessageInfo;
using NS_SSRC_WSPR_UTILITY::LoadError;
using NS_SSRC_WSPR_FCGI::parameter_map;
using NS_SSRC_WSPR_FCGI::parse_post_parameters;
using NS_SSRC_WSPR_FCGI::parse_get_parameters;
using NS_SSRC_WSPR_FCGI::HTTPRequestMethod;
using NS_SSRC_WSPR_SESSION::SessionProtocol;
using NS_SSRC_WSPR_WS::ActionConfig;
using NS_SSRC_WSPR_LUA::PropertiesToTable;

struct RelayInitializer : public renderer::RendererInitializer {
  string service_config_dir;
  string post_leaf_pattern;
};

class Relay : public renderer::Renderer {
  friend class NS_SSRC_WISP_SERVICE::ServiceProtocolProcessor<packing_traits>;

public:
  typedef boost::shared_ptr<ActionConfig> action_config_ptr;

private:
  typedef renderer::Renderer super;
  typedef RelayProtocol protocol_traits;
  typedef NS_SSRC_WSPR_WS::WebServiceProtocol ws_protocol;

  typedef std::unordered_map<string, action_config_ptr> action_config_map;

  WISP_IMPORT(ws_protocol, MessageResponse);
  WISP_IMPORT(ws_protocol, CallOneWay);
  WISP_IMPORT(ws_protocol, CallTwoWay);

  WISP_IMPORT(SessionProtocol, MessageSingleQueryResult);
  WISP_IMPORT(SessionProtocol, CallSingleQueryByDefault);
  WISP_IMPORT(SessionProtocol, CallCreateSession);
  WISP_IMPORT(SessionProtocol, CallGetSession);

  WISP_IMPORT(protocol_traits, MessageClearCaches);

  path _service_conf_dir;
  boost::regex _post_path_pattern;
  action_config_map _action_config_cache;
  PropertiesToTable _to_table;

  void http_post(const request_ptr & request, response_ptr & response,
                 parameter_map && parameters);

  inline const action_config_ptr get_action(const string & service_name,
                                            const string & action_name);

  void clear_caches();

  void process_request(const MessageClearCaches & msg,
                       const MessageInfo &);

  virtual void process_request(const MessageReloadConfig & msg,
                               const MessageInfo & msginfo);

protected:

  virtual void set_lua_state(Lua::lua_State *state) {
    super::set_lua_state(state);
    _to_table.reset(state);
  }

public:

  struct FinishPostContext {
    const HTTPRequestMethod request_method;
    const Relay::request_ptr request;
    Relay::response_ptr response;
    path parent_path;
    const action_config_ptr action;
    parameter_map parameters;

    FinishPostContext(const HTTPRequestMethod request_method,
                      const Relay::request_ptr & request,
                      Relay::response_ptr & response,
                      const path & parent_path,
                      const action_config_ptr & action,
                      parameter_map && parameters) :
      request_method(request_method), request(request), response(response),
      parent_path(parent_path), action(action),
      parameters(std::move(parameters))
    { }
  };

  Relay(caller_type & caller, const RelayInitializer & initializer)
    SSRC_DECL_THROW(LoadError, std::invalid_argument);

  virtual ~Relay() { }

  virtual void http_post(const request_ptr & request, response_ptr & response) {
    parameter_map parameters;
    parse_post_parameters(*request, parameters);
    http_post(request, response, std::move(parameters));
  }

  virtual void http_get(const request_ptr & request, response_ptr & response) {
    parameter_map parameters;
    parse_get_parameters(*request, parameters);
    if(parameters.empty()) {
      super::http_get(request, response);
    } else {
      http_post(request, response, std::move(parameters));
    }
  }

  void continue_post(FinishPostContext & context,
                     const MessageSingleQueryResult & session_result);


  void finish_post(FinishPostContext & context,
                   const MessageResponse & result);
};

__END_NS_SSRC_WSPR_RELAY

#endif