WebServiceRunner.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_WEB_SERVICE_RUNNER_H
#define __SSRC_WSPR_WS_WEB_SERVICE_RUNNER_H

#include <ssrc/wispers/ws/service.h>
#include <ssrc/wispers/ws/WebServiceModule.h>
#include <ssrc/wispers/utility/DynamicLibrary.h>

__BEGIN_NS_SSRC_WSPR_WS

using NS_SSRC_WSPR_UTILITY::LoadError;
using NS_SSRC_WSPR_UTILITY::DynamicLibrary;

namespace detail {
  extern "C" typedef void fun_delete_module(WebServiceModule *);
  extern "C" typedef fun_delete_module* fun_ptr_delete_module;

  class WebServiceModuleDeleter {
    fun_ptr_delete_module _delete_module;

  public:
    explicit WebServiceModuleDeleter(const fun_ptr_delete_module delete_module) :
      _delete_module(delete_module)
    { }

    void operator()(WebServiceModule *module) const {
      _delete_module(module);
    }
  };

  template<typename PT = BinaryPackingTraits>
  class WebServiceModuleFactory {
    typedef NS_SSRC_WISP_PROTOCOL::ContinuationCaller<PT> caller_type;

    // Should really be extern "C", but we can only do that in namespace scope.
    typedef WebServiceModule* fun_new_module(const ws_module_context_ptr &);
    typedef fun_new_module* fun_ptr_new_module;

    DynamicLibrary _lib;
    fun_ptr_new_module _new_module;
    fun_ptr_delete_module _delete_module;

  public:

    typedef boost::shared_ptr<WebServiceModule> ws_module_ptr;

#define WS_MODULE_SYM_NEW "ws_module_new"
#define WS_MODULE_SYM_DELETE "ws_module_delete"

    explicit WebServiceModuleFactory(const string & filename,
                                     const DynamicLibrary::Mode mode =
                                     DynamicLibrary::NowLocal)
      SSRC_DECL_THROW(LoadError) :
      _lib(filename, mode),
      _new_module(_lib.symbol<fun_ptr_new_module>(WS_MODULE_SYM_NEW)),
      _delete_module(_lib.symbol<fun_ptr_delete_module>(WS_MODULE_SYM_DELETE))
    { }

#undef WS_MODULE_SYM_NEW
#undef WS_MODULE_SYM_DELETE

    ws_module_ptr new_module(const ws_module_context_ptr & context) {
      if(_new_module && _delete_module)
        return
          ws_module_ptr(_new_module(context),
                        WebServiceModuleDeleter(_delete_module));

      return ws_module_ptr();
    }
  };
}

struct WebServiceRunnerInitializer {
  typedef std::vector<string> dir_list;
  dir_list module_dirs;
  Properties actions;
};

struct WebServiceModuleConfig {
  string name;
  string module;
  string type;
  Properties properties;

  WebServiceModuleConfig(const string & name,
                         const string & module,
                         const string & type,
                         const Properties & properties) :
    name(name), module(module), type(type), properties(properties)
  { }
};

template<typename container_type>
void get_ws_module_configs(container_type & result, const Properties & modules)
{
  const Properties *p = modules.find("Module");

  if(p != 0) {
    Properties::child_container_const_iterator && it = p->child_begin();
    Properties::child_container_const_iterator && end = p->child_end();

    while(it != end) {
      const string & name = it->first;
      const Properties *node = it->second;
      const string & module = node->get<string>("", "module");
      const string & type   = node->get<string>("", "type");
      result.push_back(WebServiceModuleConfig(name, module, type,
                                              *node->find("properties")));
      ++it;
    }
  }
}

class WebServiceRunner : public WebService {
  typedef WebService super;
  friend class NS_SSRC_WISP_SERVICE::ServiceProtocolProcessor<packing_traits>;

  typedef detail::WebServiceModuleFactory<packing_traits> ws_module_factory;
  typedef boost::shared_ptr<ws_module_factory> ws_module_factory_ptr;

  WISP_IMPORT(ws_module_factory, ws_module_ptr);

  struct ws_module_entry {
    // Important: must be first so it is destroyed after module.
    ws_module_factory_ptr factory;
    ws_module_ptr module;

    ws_module_entry(const ws_module_factory_ptr & factory,
                    const ws_module_ptr & module) :
      factory(factory), module(module)
    { }
  };

  typedef std::unordered_map<string, ws_module_entry> ws_module_map;

  WebServiceRunnerInitializer::dir_list _module_dirs;
  std::vector<WebServiceModuleConfig> _module_configs;
  ws_module_map _module_map;

  static ws_module_factory_ptr
  new_module_factory(const string & filename,
                     const DynamicLibrary::Mode mode =
                     DynamicLibrary::NowLocal)
  {
    return
      ws_module_factory_ptr(new ws_module_factory(filename, mode));
  }

  void load_modules() SSRC_DECL_THROW(LoadError);

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

    super::transition(state);
  }

public:

  WebServiceRunner(caller_type & caller,
                   const WebServiceRunnerInitializer & initializer) :
    super(caller), _module_dirs(initializer.module_dirs)
  {
    super::add_service_type(WSPR_WS_TYPE("runner"));
    get_ws_module_configs(_module_configs, initializer.actions);
    get_actions(_actions, initializer.actions);
  }

  virtual ~WebServiceRunner() {
    // All references to dynamically loaded memory must be removed since
    // call handler maps are destroyed after unloading dynamic library.
    clear_call_handlers();
    clear_request_handlers();
    clear_response_handlers();
    // Even though these may be redundant because they happen when a
    // service enters the stopped state, we want to make sure that no
    // continuations or timeouts reference module memory spaces.
    clear_timeouts();
    _caller.cancel_all();
  }
};

__END_NS_SSRC_WSPR_WS

#endif