renderer/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_RENDERER_SERVICE_H
#define __SSRC_WSPR_RENDERER_SERVICE_H

#include <vector>

#include <boost/regex.hpp>
#include <boost/filesystem/path.hpp>

#include <ssrc/wispers/service/service.h>
#include <ssrc/wispers/fcgi/HTTPServlet.h>
#include <ssrc/wispers/fcgi/FCGIResponse.h>
#include <ssrc/wispers/fcgi/FCGIServiceInitializer.h>
#include <ssrc/wispers/utility/LoadError.h>
#include <ssrc/wispers/lua/lua.h>
#include <ssrc/wispers/renderer/protocol.h>

__BEGIN_NS_SSRC_WSPR_RENDERER

using std::string;
using boost::filesystem::path;
using NS_SSRC_WISP_PROTOCOL::MessageInfo;
using NS_SSRC_WSPR_SERVICE::ServiceProtocolProcessor;
using NS_SSRC_WSPR_FCGI::HTTPStatusCode;
using NS_SSRC_WSPR_FCGI::HTTPServlet;
using NS_SSRC_WSPR_FCGI::fcgx_request_ptr;
using NS_SSRC_WSPR_FCGI::FCGIRequest;
using NS_SSRC_WSPR_FCGI::FCGIResponse;
using NS_SSRC_WSPR_UTILITY::LoadError;
using NS_SSRC_WSPR_LUA::LuaCallError;

struct RendererInitializer : NS_SSRC_WSPR_FCGI::FCGIServiceInitializer {
  typedef std::vector<string> dir_list;

  string global_env;

  string template_dir;

  string get_leaf_pattern;

  dir_list content_dirs;

  dir_list module_dirs;
};

class Renderer :
  public HTTPServlet<FCGIRequest, FCGIResponse>,
  public ServiceProtocolProcessor
{
  friend class NS_SSRC_WISP_SERVICE::ServiceProtocolProcessor<packing_traits>;
  typedef RendererProtocol protocol_traits;

  void load_config(Lua::lua_State *state) SSRC_DECL_THROW(LoadError);
  void reload_config();

  void ref_globals(Lua::lua_State *state);
  void unref_globals(Lua::lua_State *state);

protected:
  typedef HTTPServlet<FCGIRequest, FCGIResponse> super_fcgi;
  typedef ServiceProtocolProcessor super_service;

  WISP_IMPORT(protocol_traits, MessageReloadConfig);

  string _global_env_file;
  string _template_prefix;
  path _template_dir;
  boost::regex _get_path_pattern;

  Lua::lua_State *_lua_state;
  int _lua_render_ref;
  int _lua_load_environment_ref;
  int _lua_uncache_template_ref;
  int _lua_uncache_environment_ref;
  int _lua_clear_rendering_cache_ref;
  int _lua_init_global_environment_ref;

  virtual void transition(State state);

  virtual utility::properties_ptr get_status();

  virtual void set_lua_state(Lua::lua_State *state) {
    _lua_state = state;
  }

  void render_and_cache(const request_ptr & request, response_ptr & response,
                        const bool flush = true);

  path find_error_template(const path & error_template,
                           const path & parent_path);

  path find_error_template(const path & parent_path) {
    return find_error_template(NS_SSRC_WSPR_LUA::get_value<string>(_lua_state, "wspr", "template", "error"), parent_path);
  }

  path find_error_template(const path & parent_path, int index) {
    return find_error_template(NS_SSRC_WSPR_LUA::get_field<string>(_lua_state, index, "wspr", "template", "error"), parent_path);
  }

  void send_error(const HTTPStatusCode status,
                  const request_ptr & request,
                  response_ptr & response,
                  const path & error_template);

  void load_environment(const string & environment_name,
                        const bool cache_template)
    SSRC_DECL_THROW(LuaCallError)
  {
    Lua::lua_rawgeti(_lua_state, LUA_REGISTRYINDEX, _lua_load_environment_ref);
    NS_SSRC_WSPR_LUA::pcall_nopop(1, _lua_state,
                                  environment_name, cache_template);
  }

  void uncache_template(const string & template_name)
    SSRC_DECL_THROW(LuaCallError)
  {
    Lua::lua_rawgeti(_lua_state, LUA_REGISTRYINDEX, _lua_uncache_template_ref);
    NS_SSRC_WSPR_LUA::pcall(_lua_state, template_name);
  }

  void uncache_environment(const string & environment_name)
    SSRC_DECL_THROW(LuaCallError)
  {
    Lua::lua_rawgeti(_lua_state, LUA_REGISTRYINDEX,
                     _lua_uncache_environment_ref);
    NS_SSRC_WSPR_LUA::pcall(_lua_state, environment_name);
  }

  void clear_template_cache();

  path load_template_args(const path & template_path,
                          const char * template_key,
                          const bool cache_environment = false,
                          const bool cache_template = true)
    SSRC_DECL_THROW(LoadError);

  path load_template_args(const path & template_path,
                          const bool cache_environment = false,
                          const bool cache_template = true)
    SSRC_DECL_THROW(LoadError)
  {
    return
      load_template_args(template_path, template_path.extension().c_str() + 1,
                         cache_environment, cache_template);
  }

  virtual void process_request(const MessageReloadConfig & msg,
                               const MessageInfo &)
  {
    reload_config();
  }

public:

  Renderer(caller_type & caller, const RendererInitializer & initializer)
    SSRC_DECL_THROW(LoadError, std::invalid_argument);

  virtual ~Renderer();

  virtual void http_get(const request_ptr & request, response_ptr & response) {
    render_and_cache(request, response);
  }

  virtual void http_head(const request_ptr & request, response_ptr & response) {
    render_and_cache(request, response, false);
  }

  void process_fcgi_request(const fcgx_request_ptr & request);
};

__END_NS_SSRC_WSPR_RENDERER

#endif