ws_lua/service.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/ws_lua/service.h>

#ifdef WSPR_DEBUG
#include <ssrc/wispers/utility/PropertiesToString.h>
#endif

#include <boost/filesystem/path.hpp>

__BEGIN_NS_SSRC_WSPR_WS_LUA

using namespace Lua;
using namespace NS_SSRC_WSPR_LUA;

namespace {
  inline void get_parameters(lua_State* state,
                             const int index,
                             parameter_sequence & parameters)
  {
    lua_getfield(state, index, "parameters");

    if(lua_istable(state, -1)) {
      int count_parameters = 0;

      lua_pushnil(state);
      while(lua_next(state, -2)) {
        ++count_parameters;
        lua_pop(state, 1);
      }

      if(count_parameters > 0) {
        SSRC_UNIQUE_PTR<CallParameter> param;

        parameters.reserve(count_parameters);

        lua_pushnil(state);
        while(lua_next(state, -2)) {
          const unsigned int min_size =
            get_field<int>(1, state, -1, "min_size");
          const unsigned int max_size =
            get_field<int>(128, state, -1, "max_size");
          const bool multi_value =
            get_field<bool>(false, state, -1, "multi_value");
          const bool optional = get_field<bool>(false, state, -1, "optional");
          const string && pattern =
            get_field<string>(state, -1, "matches", "");

          if(pattern.empty()) {
            param.reset(new CallParameter(lua_tostring(state, -2),
                                          min_size, max_size, multi_value,
                                          optional));
          } else {
            param.reset(new PatternParameter(lua_tostring(state, -2), pattern,
                                             min_size, max_size, multi_value,
                                             optional));
          }

          parameters.push_back(param.release());

          lua_pop(state, 1);
        }
      }
    }

    lua_pop(state, 1);
  }
}

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

  super::transition(state);
}

inline void Service::do_call(const WebServiceCall & wc,
                             const MessageInfo & msginfo)
{
  using NS_SSRC_WSPR_FCGI::parameter_map;
  call_map_type::const_iterator call_it = _call_map.find(wc.call);

  if(call_it != _call_map.end()) {
    const CallEntry & call = *(call_it->second);
    lua_rawgeti(_lua_state, LUA_REGISTRYINDEX, call.ref);

    if(!call.requires_session || wc.session) {
      int nargs = 0;

      if(!call.parameters.empty()) {
        lua_newtable(_lua_state);
        typedef
          std::pair<parameter_map::const_iterator,parameter_map::const_iterator>
          parameter_range;
        parameter_range p;

        // Set parameters
         for(parameter_sequence::const_iterator param =
              call.parameters.begin(), end = call.parameters.end();
            param != end; ++param)
        {
          if(param->multi_value) {
            p = wc.parameters.equal_range(param->name);
          } else {
            p.first = wc.parameters.find(param->name);
            p.second = wc.parameters.end();
          }

          if(p.first != p.second) {
            if(param->multi_value) {
              int pos = 0;
              lua_newtable(_lua_state);

              while(p.first != p.second) {
                if(param->validate(p.first->second)) {
                  lua_pushstring(_lua_state, p.first->second.c_str());
                  lua_rawseti(_lua_state, -2, ++pos);
                } else {
                  string error("invalid parameter value: ");
                  reply_error(error.append(param->name).append(" = ").append(p.first->second), msginfo);
#ifdef WSPR_DEBUG
                  std::cerr << error << std::endl;
#endif
                  lua_pop(_lua_state, 2);
                  return;
                }
                ++p.first;
              }
            } else {
              if(param->validate(p.first->second)) {
                 lua_pushstring(_lua_state, p.first->second.c_str());
              } else {
                string error("invalid parameter value: ");
                reply_error(error.append(param->name).append(" = ").append(p.first->second), msginfo);
#ifdef WSPR_DEBUG
                std::cerr << error << std::endl;
#endif
                lua_pop(_lua_state, 2);
                return;
              }
            }

            lua_setfield(_lua_state, -2, param->name.c_str());
          } else if(!param->optional) {
            lua_pop(_lua_state, 2);
            if(!call.one_way) {
              string error("missing parameter: ");
              reply_error(error.append(param->name), msginfo);
#ifdef WSPR_DEBUG
              std::cerr << error << std::endl;
#endif
            }
            return;
          }
        }

        nargs = 1;
      }

      /*
        TODO: Populate module context (use separate function).  If
        modules can perform asynchronous calls completed via
        continuations, then we'll need a new module context instance
        for each module call, allowing the module call to hold onto
        the context for its continuation.
       */
      MessageResponse response(wc.session, new NS_SSRC_WSPR_UTILITY::Properties);
      _context.start_call(&wc, &msginfo, &response);

      if(lua_pcall(_lua_state, nargs, 0, 0) != 0) {
#ifdef WSPR_DEBUG
        std::cerr << "ERROR!  " << lua_tostring(_lua_state, -1) << std::endl;
#endif
        lua_pop(_lua_state, 1);
        // TODO: handle error somehow.
      }

      _context.end_call();

      if(!call.one_way) {
#ifdef WSPR_DEBUG
        std::cerr << "RESPONSE:\n"
                  << NS_SSRC_WSPR_UTILITY::to_string(*response.template_data)
                  << std::endl;
#endif
        _caller.reply<CallResponse>(msginfo.sender(), msginfo.token(), response, Message::FIFOSelfDiscard);
      }

    } else if(!call.one_way) {
      string error("valid session required");
      reply_error(error, msginfo);
#ifdef WSPR_DEBUG
      std::cerr << error << std::endl;
#endif
    }
  }
}

void Service::load_module(const string & module_dir, const string & module)
  SSRC_DECL_THROW(LoadError)
{
  boost::filesystem::path module_path(module_dir);
  string module_file(module);
  ModuleEntry module_entry;

  module_file.append(".lua");
  module_path /= module_file;

  // We don't pop the error string because error is fatal.
  if(luaL_dofile(_lua_state, module_path.string().c_str()))
    throw LoadError(lua_tostring(_lua_state, -1));

  lua_getglobal(_lua_state, module.c_str());
  lua_getfield(_lua_state, -1, "load");

  lua_pushvalue(_lua_state, -2);
  lua_pushlightuserdata(_lua_state, &_context);

  if(lua_pcall(_lua_state, 2, 0, 0) != 0)
    throw LoadError(lua_tostring(_lua_state, -1));

  lua_getfield(_lua_state, -1, "unload");
  if(!lua_isfunction(_lua_state, -1))
    throw LoadError("unload() is undefined");
  module_entry.unload_ref = luaL_ref(_lua_state, LUA_REGISTRYINDEX);

  lua_getfield(_lua_state, -1, "ws_methods");

  if(lua_istable(_lua_state, -1)) {
    lua_pushnil(_lua_state);
    while(lua_next(_lua_state, -2)) {
      if(lua_istable(_lua_state, -1)) {

        lua_getfield(_lua_state, -1, "call");

        if(lua_isfunction(_lua_state, -1)) {
          string call_name = lua_tostring(_lua_state, -3);
          SSRC_UNIQUE_PTR<CallEntry> call_entry(new CallEntry(luaL_ref(_lua_state, LUA_REGISTRYINDEX)));

          call_entry->one_way = get_field<bool>(false, _lua_state, -1, "one_way");

          if(call_entry->one_way) {
            WS_ONE_WAY_CALL(call_name, &Service::do_call);
          } else {
            WS_TWO_WAY_CALL(call_name, &Service::do_call);
          }

          call_entry->requires_session =
            get_field<bool>(true, _lua_state, -1, "requires_session");

          get_parameters(_lua_state, -1, call_entry->parameters);

          if(!_call_map.insert(call_name, call_entry.release()).second) {
            string msg("duplicate method name: ");
            throw LoadError(msg.append(call_name));
          }
        } else {
          lua_pop(_lua_state, 1);
        }
      }

      lua_pop(_lua_state, 1);
    }
  }

  lua_pop(_lua_state, 1);
  module_entry.module_ref = luaL_ref(_lua_state, LUA_REGISTRYINDEX);
  _modules.push_back(module_entry);
}

void Service::load_modules(const string & module_dir,
                           const module_list & modules)
  SSRC_DECL_THROW(LoadError)
{
  boost::filesystem::path lua_path(module_dir);

  lua_path /= "?.lua;";

  luaL_openlibs(_lua_state);

  /* Set package.path to module_dir/?.lua. */
  lua_getglobal(_lua_state, "package");
  lua_getfield(_lua_state, -1, "path");

  string lua_path_str = lua_path.string();
  lua_path_str.append(lua_tostring(_lua_state, -1));
  lua_pushstring(_lua_state, lua_path_str.c_str());
  lua_setfield(_lua_state, -3, "path");
  lua_pop(_lua_state, 2);

  for(module_list::const_iterator it = modules.begin(), end = modules.end();
      it != end; ++it)
  {
    load_module(module_dir, *it);
  }
}

void Service::unload_module(const ModuleEntry & module) {
  lua_rawgeti(_lua_state, LUA_REGISTRYINDEX, module.unload_ref);
  lua_rawgeti(_lua_state, LUA_REGISTRYINDEX, module.module_ref);

  if(lua_pcall(_lua_state, 1, 0, 0) != 0) {
#ifdef WSPR_DEBUG
    std::cerr << "unload error: " << lua_tostring(_lua_state, -1)
              << std::endl;
#endif
    lua_pop(_lua_state, 1);
  }

  luaL_unref(_lua_state, LUA_REGISTRYINDEX, module.unload_ref);
  luaL_unref(_lua_state, LUA_REGISTRYINDEX, module.module_ref);
}

void Service::unload_modules() {
  // Unload modules in reverse order from which they were loaded.
  for(module_entry_list::const_reverse_iterator it = _modules.rbegin(),
        end = _modules.rend(); it != end; ++it)
  {
    unload_module(*it);
  }

  // If we're going to support unloading a single module, then
  // we have to store the module reference in CallEntry so we
  // can unreference all calls that belong to the module.
  // For now, however, we simply unload everything at once,
  // unreferencing the modules first and then the methods.
  for(call_map_type::const_iterator it = _call_map.begin(),
        end = _call_map.end(); it != end; ++it)
  {
    luaL_unref(_lua_state, LUA_REGISTRYINDEX, it->second->ref);
  }

  _modules.clear();
  _call_map.clear();
}

__END_NS_SSRC_WSPR_WS_LUA