ServletRunner.cc

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.
 */

#include <ssrc/wispers/fcgi_lua/ServletRunner.h>

__BEGIN_NS_SSRC_WSPR_FCGI_LUA

using namespace Lua;
using namespace NS_SSRC_WSPR_LUA;

const char * const ServletRunner::ServletFunctions[MethodNum] = {
  "http_delete", "http_get", "http_head", "http_options", "http_post",
  "http_put", "http_trace"
};

ServletRunner::ServletRunner(caller_type & caller,
                             const ServletRunnerInitializer & initializer)
  SSRC_DECL_THROW(LoadError) :
  super(caller), _lua_state(Lua::luaL_newstate())
{
  super::add_service_type(WSPR_SERVICE_TYPE(lua_servlet));

  luaL_openlibs(_lua_state);

  NS_SSRC_WSPR_LUA::prepend_package_path(_lua_state,
                                         initializer.module_dirs.begin(),
                                         initializer.module_dirs.end());
  load_servlet(initializer.servlet_file);

  for(unsigned int i = 0; i < MethodNum; ++i) {
    lua_getglobal(_lua_state, ServletFunctions[i]);
    _method_ref[i] = luaL_ref(_lua_state, LUA_REGISTRYINDEX);
  }
}

ServletRunner::~ServletRunner() {
  for(unsigned int i = 0; i < MethodNum; ++i) {
    luaL_unref(_lua_state, LUA_REGISTRYINDEX, _method_ref[i]);
  }
  Lua::lua_close(_lua_state);
}

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

  super::transition(state);
}

void ServletRunner::load_servlet(const string & servlet_file)
  SSRC_DECL_THROW(LoadError)
{
  if(luaL_dofile(_lua_state, servlet_file.c_str()))
    throw LoadError(lua_tostring(_lua_state, -1));
}

void ServletRunner::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) {
    const int ref = _method_ref[method];
    if(ref != LUA_REFNIL) {
      lua_rawgeti(_lua_state, LUA_REGISTRYINDEX, ref);

      try {
        pcall_nopop(1, _lua_state, &http_request, &http_response);

        if(!http_response->completed() && !http_response->suspended()) {
          std::size_t content_length = 0;
          const char *content = lua_tolstring(_lua_state, -1, &content_length);
          http_response->complete(content, content_length);
        }
        lua_pop(_lua_state, 1);
      } catch(const LuaCallError & lce) {
#ifdef WSPR_DEBUG
        std::cerr << "ERROR!  " << lce.what() << std::endl;
#endif
        http_response->send_error(StatusInternalServerError);
      }
    } else {
      http_response->send_error(StatusMethodNotAllowed);
    }
  } else {
    http_response->send_error(StatusMethodNotImplemented);
  }
}

__END_NS_SSRC_WSPR_FCGI_LUA