ws_lua/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_WS_LUA_SERVICE_H
#define __SSRC_WSPR_WS_LUA_SERVICE_H

#include <ssrc/wispers/ws_lua/ModuleContext.h>
#include <ssrc/wispers/ws/service.h>
#include <ssrc/wispers/utility/DynamicLibrary.h>
#include <ssrc/wispers/lua/lua.h>

#include <boost/ptr_container/ptr_unordered_map.hpp>

__BEGIN_NS_SSRC_WSPR_WS_LUA

using ssrc::spread::Message;
using NS_SSRC_WISP_PROTOCOL::MessageInfo;
using NS_SSRC_WSPR_WS::WebService;
using NS_SSRC_WSPR_WS::WebServiceCall;
using NS_SSRC_WSPR_WS::CallParameter;
using NS_SSRC_WSPR_WS::PatternParameter;
using NS_SSRC_WSPR_WS::parameter_sequence;
using NS_SSRC_WSPR_UTILITY::LoadError;

using std::string;

struct ServiceInitializer {
  typedef std::vector<string> module_list;
  string module_dir;
  module_list modules;
};

struct CallEntry {
  int ref;
  bool one_way;
  bool requires_session;
  parameter_sequence parameters;

  CallEntry() { }

  CallEntry(const int ref) :
    ref(ref), one_way(false), requires_session(true), parameters(0)
  { }
};

typedef boost::ptr_unordered_map<string, CallEntry> call_map_type;

class Service : public WebService {
  typedef WebService super;
  friend class ssrc::wisp::service::ServiceProtocolProcessor<packing_traits>;

  WISP_IMPORT(ServiceInitializer, module_list);

  struct ModuleEntry {
    int module_ref;
    int unload_ref;

    explicit
    ModuleEntry(int module_ref = LUA_NOREF, int unload_ref = LUA_NOREF) :
      module_ref(module_ref), unload_ref(unload_ref)
    { }
  };

  // For now, all modules share the same state.  We may decide to change that.
  Lua::lua_State *_lua_state;
  call_map_type _call_map;
  ModuleContext _context;
  typedef std::vector<ModuleEntry> module_entry_list;
  module_entry_list _modules;

  virtual void transition(State state);

  void reply_error(const string & error, const MessageInfo & msginfo) {
    MessageResponse response;
    response.set_error(error);
    _caller.reply<CallResponse>(msginfo.sender(), msginfo.token(), response, Message::FIFOSelfDiscard);
  }

  void do_call(const WebServiceCall & call, const MessageInfo & msginfo);

  void load_module(const string & module_dir, const string & module)
    SSRC_DECL_THROW(LoadError);

  void load_modules(const string & module_dir, const module_list & modules)
    SSRC_DECL_THROW(LoadError);

  void unload_module(const ModuleEntry & module);

  void unload_modules();

public:

  Service(caller_type & caller, const ServiceInitializer & initializer)
    SSRC_DECL_THROW(LoadError) :
    super(caller),
    _lua_state(Lua::luaL_newstate()), _call_map(), _context(),
    _modules(0)
  {
    super::add_service_type(WSPR_WS_TYPE("lua"));
    _modules.reserve(initializer.modules.size());
    load_modules(initializer.module_dir, initializer.modules);
  }

  virtual ~Service() { unload_modules(); Lua::lua_close(_lua_state); }
};

__END_NS_SSRC_WSPR_WS_LUA

#endif