WebServiceRunner.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/WebServiceRunner.h>

#include <boost/filesystem/path.hpp>
#include <boost/filesystem/operations.hpp>

__BEGIN_NS_SSRC_WSPR_WS

void WebServiceRunner::load_modules() SSRC_DECL_THROW(LoadError) {
  // A scratch variable to keep track of modules we've already loaded.
  // This allows multiple module instances to be created from the same .so
  // without loading the same .so multiple times.
  typedef std::unordered_map<string, ws_module_factory_ptr> factory_map;
  factory_map factories;

  // Initialize modules.
  for(unsigned int i = 0; i < _module_configs.size(); ++i) {
    WebServiceModuleConfig & config = _module_configs[i];
    ws_module_map::iterator it = _module_map.find(config.name);

    if(it == _module_map.end()) {
      unsigned int j = 0;
      while(j < _module_dirs.size()) {
        boost::filesystem::path filename = _module_dirs[j];
        filename /= config.module;

        if(boost::filesystem::exists(filename)) {
          string modfile = filename.string();
          factory_map::iterator fit = factories.find(modfile);
          ws_module_factory_ptr factory;

          if(fit == factories.end()) {
            factory = new_module_factory(modfile);
            factories.insert(factory_map::value_type(modfile, factory));
          } else {
            factory = fit->second;
          }

          ws_module_ptr module(factory->new_module(ws_module_context_ptr(new WebServiceModuleContext(*this, _caller, config.type, config.properties))));

          if(module) {
            it = _module_map.insert(ws_module_map::value_type(config.name,
                                                              ws_module_entry(factory, module))).first;
            super::add_service_type(module->ws_type());

            // Register request/response handlers;
            // TODO: report attempted overwrite of existing handler.
            // Eventually we'll allow multiple handlers for the same
            // message type and simply deliver messages to both handlers.
            for(message_handler_map::iterator it = module->request_begin();
                it != module->request_end(); ++it)
              set_request_handler(*it);
            for(message_handler_map::iterator it = module->response_begin();
                it != module->response_end(); ++it)
              set_response_handler(*it);
          } else
            throw LoadError(modfile);

          break;
        }

        ++j;
      }

      if(j >= _module_dirs.size()) {
        string msg(config.module);
        throw LoadError(msg.append(" not found"));
      }
    }
  }

  // Initialize actions.
  for(boost::ptr_vector<ActionConfig>::iterator action = _actions.begin(),
        end = _actions.end(); action != end; ++action)
  {
    ws_module_map::iterator it = _module_map.find(action->target);

    // TODO: report missing module
    if(it != _module_map.end()) {
      call_handler_map::iterator handler =
        it->second.module->call_find(action->call);

      // TODO: report missing handlers
      if(handler != it->second.module->call_end()) {
        set_action_handler(*action, handler->second);
      }
    }
  }
}

__END_NS_SSRC_WSPR_WS