renderer/service.cc

Go to the documentation of this file.

/* Copyright 2006-2011 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.
 */

#include <ssrc/wispers/renderer/service.h>
#include <ssrc/wispers/renderer/util.h>
#include <ssrc/wispers/utility/Properties.h>

#include <boost/filesystem/operations.hpp>

__BEGIN_NS_SSRC_WSPR_RENDERER

using namespace NS_SSRC_WSPR_LUA;

Renderer::Renderer(caller_type & caller,
                   const RendererInitializer & initializer)
  SSRC_DECL_THROW(LoadError, std::invalid_argument) :
  super_fcgi(), super_service(caller),
  _global_env_file(initializer.global_env),
  _template_prefix(),
  _template_dir(),
  _get_path_pattern(),
  _lua_state(luaL_newstate()),
  _lua_render_ref(LUA_NOREF),
  _lua_load_environment_ref(LUA_NOREF),
  _lua_uncache_template_ref(LUA_NOREF),
  _lua_uncache_environment_ref(LUA_NOREF),
  _lua_clear_rendering_cache_ref(LUA_NOREF),
  _lua_init_global_environment_ref(LUA_NOREF)
{
  add_service_type(protocol_traits::service_type());

  luaL_openlibs(_lua_state);

  init_path_pattern(_get_path_pattern,
                    initializer.content_dirs,
                    initializer.get_leaf_pattern);

  if(!_global_env_file.empty() &&
     boost::filesystem::is_regular_file(_global_env_file))
  {
    path global_env_path = _global_env_file;

    if(initializer.template_dir.empty()) {
      _template_dir = global_env_path.parent_path();
    } else {
      _template_dir = initializer.template_dir;

      if(!boost::filesystem::is_directory(_template_dir)) {
        throw std::invalid_argument(initializer.template_dir);
      }
    }

    prepend_package_path(_lua_state,
                         initializer.module_dirs.begin(),
                         initializer.module_dirs.end());
    load_config(_lua_state);

    _template_prefix = _template_dir.string();
    _template_prefix.append("/");
  } else {
    throw std::invalid_argument(_global_env_file);
  }

  WISP_SERVICE_REQUEST(MessageReloadConfig);
}

Renderer::~Renderer() {
  unref_globals(_lua_state);
  lua_close(_lua_state);
}

void Renderer::transition(State state) {
  switch(state) {
  case Starting:
    state = Started;
    break;
  case Stopping:
    state = Stopped;
    break;
  default:
    break;
  }

  super_service::transition(state);
}

utility::properties_ptr Renderer::get_status() {
  utility::properties_ptr && status = ServiceProtocolProcessor::get_status();
  utility::Properties *lua_status = status->create_node("lua");

  lua_status->set(lua_gc(_lua_state, LUA_GCCOUNT, 0), "gccount");
  lua_status->set(lua_gc(_lua_state, LUA_GCCOUNTB, 0), "gccountb");

  return status;
}

void Renderer::clear_template_cache() {
  lua_rawgeti(_lua_state, LUA_REGISTRYINDEX, _lua_clear_rendering_cache_ref);
  try {
    NS_SSRC_WSPR_LUA::pcall(_lua_state);
    // Run garbage collector to free memory immediately.
    lua_gc(_lua_state, LUA_GCCOLLECT, 0);
  } catch(const LuaCallError & lce) {
    // TODO: log
#ifdef WSPR_DEBUG
    std::cerr << "clear_template_cache: caught unexpected LuaCallError: "
              << lce.what();
#endif
  }
}

#define LTP_RENDER_FUNCTION_NAME "render"
#define LTP_LOAD_ENVIRONMENT_FUNCTION_NAME "load_environment"
#define LTP_UNCACHE_TEMPLATE_FUNCTION_NAME "uncache_template"
#define LTP_UNCACHE_ENVIRONMENT_FUNCTION_NAME "uncache_environment"
#define LTP_CLEAR_RENDERING_CACHE_FUNCTION_NAME "clear_rendering_cache"
#define LTP_INIT_GLOBAL_ENVIRONMENT_FUNCTION_NAME "init_global_environment"
void Renderer::ref_globals(lua_State *state) {
  lua_getglobal(state, LTP_RENDER_FUNCTION_NAME);
  _lua_render_ref = luaL_ref(state, LUA_REGISTRYINDEX);
  lua_getglobal(state, LTP_LOAD_ENVIRONMENT_FUNCTION_NAME);
  _lua_load_environment_ref = luaL_ref(state, LUA_REGISTRYINDEX);
  lua_getglobal(state, LTP_UNCACHE_TEMPLATE_FUNCTION_NAME);
  _lua_uncache_template_ref = luaL_ref(state, LUA_REGISTRYINDEX);
  lua_getglobal(state, LTP_UNCACHE_ENVIRONMENT_FUNCTION_NAME);
  _lua_uncache_environment_ref = luaL_ref(state, LUA_REGISTRYINDEX);
  lua_getglobal(state, LTP_CLEAR_RENDERING_CACHE_FUNCTION_NAME);
  _lua_clear_rendering_cache_ref = luaL_ref(state, LUA_REGISTRYINDEX);
  lua_getglobal(state, LTP_INIT_GLOBAL_ENVIRONMENT_FUNCTION_NAME);
  _lua_init_global_environment_ref = luaL_ref(state, LUA_REGISTRYINDEX);
}
#undef LTP_RENDER_FUNCTION_NAME
#undef LTP_UNCACHE_TEMPLATE_FUNCTION_NAME
#undef LTP_UNCACHE_ENVIRONMENT_FUNCTION_NAME
#undef LTP_CLEAR_RENDERING_CACHE_FUNCTION_NAME
#undef LTP_INIT_GLOBAL_ENVIRONMENT_FUNCTION_NAME

void Renderer::unref_globals(lua_State *state) {
  luaL_unref(state, LUA_REGISTRYINDEX, _lua_render_ref);
  luaL_unref(state, LUA_REGISTRYINDEX, _lua_load_environment_ref);
  luaL_unref(state, LUA_REGISTRYINDEX, _lua_uncache_template_ref);
  luaL_unref(state, LUA_REGISTRYINDEX, _lua_uncache_environment_ref);
  luaL_unref(state, LUA_REGISTRYINDEX, _lua_clear_rendering_cache_ref);
  luaL_unref(state, LUA_REGISTRYINDEX, _lua_init_global_environment_ref);
  _lua_render_ref =  _lua_load_environment_ref =
    _lua_uncache_template_ref = _lua_uncache_environment_ref =
    _lua_clear_rendering_cache_ref = _lua_init_global_environment_ref =
    LUA_NOREF;
}

void Renderer::load_config(lua_State *state) SSRC_DECL_THROW(LoadError) {
  create_value(state, _template_dir.string(), "global", "template", "dir");

  // We give the global environment file the option to override
  // wspr.template.dir as well as to add it to package.path.
  if(luaL_dofile(state, _global_env_file.c_str()))
    throw LoadError(lua_tostring(state, -1));

  path error_template =
    get_value<string>(state, "wspr", "template", "error");

  if(error_template.empty())
    set_value(state, "/error.html", "wspr", "template", "error");

  error_template = get_value<string>(state, "global", "template", "dir");

  if(!error_template.empty() && _template_dir != error_template)
    _template_dir = error_template;

  set_value(state, _template_dir.string(), "global", "template", "dir");
  ref_globals(state);
}

void Renderer::reload_config() {
  lua_State *state = luaL_newstate();

#ifdef WSPR_DEBUG
  std::cerr << "reload_config\n";
#endif

  luaL_openlibs(state);
  set_value(state, get_value<string>(_lua_state, "package", "path"),
            "package", "path");

  try {
    unref_globals(_lua_state);
    load_config(state);
    // Only switch to new state if load_config doesn't throw.
    lua_close(_lua_state);
    set_lua_state(state);
  } catch(const LoadError & le) {
    // TODO: log error
#ifdef WSPR_DEBUG
    std::cerr << "reload_config: LoadError: " << le.what() << std::endl;
#endif
    lua_close(state);
    ref_globals(_lua_state);
  }
}

void Renderer::process_fcgi_request(const fcgx_request_ptr & request) {
  using namespace NS_SSRC_WSPR_FCGI;

  request_ptr http_request(new request_type(request));
  response_ptr http_response(new response_type(http_request));

  const HTTPRequestMethod method = http_request->http_request_method();

  if(method <= MethodMax) {
    (this->*(RequestMethodHandler[method]))(http_request, http_response);
  } else {
    http_response->send_error(StatusMethodNotImplemented);
  }

  if(!http_response->completed() && !http_response->suspended()) {
    // TODO: Log this.  All responses should either complete or suspend
    // before getting here, else it's a bug.
    http_response->send_error(StatusInternalServerError);
  }
}

// Changed approach to throw exception on failing to find template.
path Renderer::load_template_args(const path & template_path,
                                  const char * template_key,
                                  const bool cache_environment,
                                  const bool cache_template)
  SSRC_DECL_THROW(LoadError, LuaCallError)
{
  // We don't perform any security checks on the paths because
  // they should be performed before calling this function.  The
  // document_path regex match is sufficient validation.
  path ltp_file(template_path.string() + ".lua");

  if(boost::filesystem::is_regular_file(ltp_file)) {
    try {
      load_environment(ltp_file.string(), cache_environment);
    } catch(const LuaCallError & lce) {
      uncache_environment(ltp_file.string());
      throw;
    }

    // TODO: Be more robust and pop any extra return values.  This
    // code assumes no return values when top of stack is not a table.
    if(!lua_istable(_lua_state, -1))
      throw LoadError(string("load_template_args expected table, got: ").append(lua_typename(_lua_state, lua_type(_lua_state, -1))));

    // Now the table returned by the environment is on the top of the stack.
    const string && file =
      get_field<string>(_lua_state, -1, "wspr", "template", template_key);

    if(file.empty()) {
      ltp_file = template_path;
      ltp_file.replace_extension(".ltp");
    } else {
      ltp_file = file;

      if(!ltp_file.has_root_path()) {
        ltp_file = template_path.parent_path() / ltp_file.relative_path();
      } else {
        ltp_file = _template_dir / ltp_file.relative_path();
      }

      ltp_file.normalize();
    }

    if((ltp_file.string().find(_template_prefix) != 0) ||
       !boost::filesystem::is_regular_file(ltp_file))
    {
      lua_pop(_lua_state, 1);
      throw LoadError(string("invalid template: ").append(ltp_file.string()));
    }
  } else {
    ltp_file = template_path;
    ltp_file.replace_extension(".ltp");

    if(!boost::filesystem::is_regular_file(ltp_file)) {
      throw LoadError(string("missing template: ").append(ltp_file.string()));
    }

    // Push empty rendering environment.
    lua_newtable(_lua_state);
  }

  // When provided, the rendering environment specifies whether or not the
  // template should be cached.  Otherwise, the host program specifies.
  if(cache_template) {
    set_field(_lua_state, -1, cache_template, "cache_template");
  }

  return ltp_file;
}

path Renderer::find_error_template(const path & error_template,
                                   const path & parent_path)
{
  path et(error_template);

  if(et.empty()) {
    et = _template_dir / "error.html";
  } else {
    if(!et.has_root_path()) {
      et = parent_path / et.relative_path();
    } else {
      // Force root paths to be interpreted relative to template directory.
      et = _template_dir / error_template.relative_path();
    }
    // Limit all templates to fall under the template directory.
    // We don't want to allow arbitrary access to the file system.
    if(et.string().find(_template_prefix) != 0 ||
       !boost::filesystem::is_regular_file(et))
    {
      et = _template_dir / "error.html";
    }
  }

  return et;
}


void Renderer::send_error(const HTTPStatusCode status,
                          const request_ptr & request,
                          response_ptr & response,
                          const path & error_template)
{
  using namespace NS_SSRC_WSPR_FCGI;

  response->set_status(status);
  lua_rawgeti(_lua_state, LUA_REGISTRYINDEX, _lua_render_ref);

  try {
    path && et = load_template_args(error_template, "error", true);

    try {
      pcall_nopop(4, 2, _lua_state, et.string(), &request, &response);
    } catch(const LuaCallError & lce) {
#ifdef WSPR_DEBUG
      std::cerr << "send_error: LuaCallError: " << lce.what() << std::endl;
#endif
      uncache_template(et.string());
      response->send_error(StatusInternalServerError);
      return;
    }
  } catch(const LoadError & le) {
#ifdef WSPR_DEBUG
      std::cerr << "send_error: LoadError: " << le.what() << std::endl;
#endif
    lua_pop(_lua_state, 1);
    response->send_error(StatusInternalServerError);
    return;
  } catch(const LuaCallError & lce) {
#ifdef WSPR_DEBUG
      std::cerr << "send_error: LuaCallError: " << lce.what() << std::endl;
#endif
    response->send_error(StatusInternalServerError);
    return;
  }

  std::size_t content_length = 0;
  const char *content = lua_tolstring(_lua_state, -2, &content_length);

  if(content) {
    response->set_content_type("text/html");
    response->complete(content, content_length, CacheDisable);
  } else {
    response->send_error(static_cast<HTTPStatusCode>(lua_tointeger(_lua_state, -2)));
  }

  lua_pop(_lua_state, 2);
}

void Renderer::render_and_cache(const request_ptr & request,
                                response_ptr & response,
                                const bool flush)
{
  using namespace NS_SSRC_WSPR_FCGI;

  HTTPStatusCode status = StatusNotFound;

  path && request_uri   = request->request_uri();
  path && document_path = request->document_root() / request_uri;
  path && template_path = _template_dir / request_uri;
  const string & str = document_path.string();

  if(!str.empty() && str[str.size() - 1] == '/') {
    document_path /= "index.html";
    template_path /= "index.html";
  }
  // WARNING: normalize() is deprecated
  document_path.normalize();
  template_path.normalize();

  do {
    lua_rawgeti(_lua_state, LUA_REGISTRYINDEX, _lua_init_global_environment_ref);
    try {
      pcall(_lua_state);
    } catch(const LuaCallError & lce) {
#ifdef WSPR_DEBUG
      std::cerr << "LuaCallError: " << lce.what() << std::endl;
#endif
      set_value(_lua_state, lce.what(), "wspr", "message", "debug");
      status = StatusInternalServerError;
      break;
    }

    if(!boost::regex_match(document_path.string(), _get_path_pattern))
      break;

    try {
      lua_rawgeti(_lua_state, LUA_REGISTRYINDEX, _lua_render_ref);

      const path && ltp_file = load_template_args(template_path);

      try {
        pcall_nopop(4, 2, _lua_state, ltp_file.string(), &request, &response);
      } catch(const LuaCallError & lce) {
#ifdef WSPR_DEBUG
        std::cerr << "LuaCallError: " << lce.what() << std::endl;
#endif
        set_value(_lua_state, lce.what(), "wspr", "message", "debug");
        status = StatusInternalServerError;
        uncache_template(ltp_file.string());
        break;
      }

    } catch(const LoadError & le) {
#ifdef WSPR_DEBUG
      std::cerr << "LoadError: " << le.what() << std::endl;
#endif
      lua_pop(_lua_state, 1);
      set_value(_lua_state, le.what(), "wspr", "message", "debug");
      break;
    } catch(const LuaCallError & lce) {
#ifdef WSPR_DEBUG
      std::cerr << "LuaCallError: " << lce.what() << std::endl;
#endif
      set_value(_lua_state, lce.what(), "wspr", "message", "debug");
      break;
    }

    if(lua_isstring(_lua_state, -2)) {
      status = StatusOK;
      response->set_status(StatusOK);

      std::size_t content_length = 0;
      const char *content = lua_tolstring(_lua_state, -2, &content_length);

      if(content) {
        bool cache_content =
          get_field<bool>(true, _lua_state, -1, "wspr", "template", "cache_content");

        if(cache_content) {
          cache_to_file(content, content_length, document_path);
        }

        if(!flush) {
          content_length = 0;
        }

        response->set_content_type(get_value<string>("text/html", _lua_state,
                                                     "global", "content_type",
                                                     template_path.extension().c_str()));

        response->complete(content, content_length,
                           get_field<bool>(_lua_state, -1, "wspr", "client_cache_disabled"));
      }
    } else {
      send_error(static_cast<HTTPStatusCode>(lua_tointeger(_lua_state, -2)),
                 request, response,
                 find_error_template(template_path.parent_path(), -1));
      status = StatusOK;
    }

    lua_pop(_lua_state, 2);
  } while(0);

  if(status != StatusOK) {
    send_error(status, request, response,
               find_error_template(template_path.parent_path()));
  }

  lua_rawgeti(_lua_state, LUA_REGISTRYINDEX, _lua_init_global_environment_ref);
  try {
    pcall(_lua_state);
  } catch(const LuaCallError & lce) {
    // TODO: log
  }
}
__END_NS_SSRC_WSPR_RENDERER