ws/service.cc

Go to the documentation of this file.

/*
 * Copyright 2006-2010 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/service.h>

__BEGIN_NS_SSRC_WSPR_WS

void validate_call(const ActionConfig & action,
                   const call_handler_type & call_handler,
                   const WebServiceCall & wc,
                   const MessageInfo & msginfo)
  SSRC_DECL_THROW(std:::invalid_argument)
{
  typedef WebServiceProtocol::parameter_map parameter_map;

#ifdef WSPR_DEBUG
  std::cerr << "validate_call: " << action.action << " : " << action.call
            << std::endl;
#endif

  if(action.requires_session && !wc.session) {
    throw std::invalid_argument("valid session required");
  }

  if(action.parameters) {
    typedef
      std::pair<parameter_map::const_iterator,parameter_map::const_iterator>
      parameter_range;
    parameter_range p;

    for(parameter_sequence::const_iterator param = action.parameters->begin(),
          end = action.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) {
          while(p.first != p.second) {
            if(!param->validate(p.first->second)) {
              throw std::invalid_argument(string("invalid parameter value: ").append(param->name).append(" = ").append(p.first->second));;
            }

            ++p.first;
          }
        } else {
          if(!param->validate(p.first->second)) {
            throw std::invalid_argument(string("invalid parameter value: ").append(param->name).append(" = ").append(p.first->second));;
          }
        }
      } else if(!param->optional) {
        throw std::invalid_argument(string("missing parameter: ").append(param->name));
      }
    }
  }

  call_handler(wc, msginfo);
}

ActionConfig &
WebService::new_action(const Properties & action_map, const string & key)
  SSRC_DECL_THROW(std:::domain_error)
{
  const Properties *p = action_map.find(key);

  if(p == 0) {
    string msg("action not found: ");
    throw std::domain_error(msg.append(key));
  }

  _actions.push_back(new ActionConfig(key, *p));
  return _actions.back();
}

void WebService::clear_call_handlers() {
  _call_handlers_one_way.clear();
  _call_handlers_two_way.clear();
}

bool
WebService::set_call_handler_one_way(const string & call,
                                     const call_handler_type & call_handler)
{
  return
    _call_handlers_one_way.insert(call_handler_map::value_type(call, call_handler)).second;
}

bool
WebService::set_call_handler_two_way(const string & call,
                                     const call_handler_type & call_handler)
{
  return
    _call_handlers_two_way.insert(call_handler_map::value_type(call, call_handler)).second;
}

bool WebService::set_action_handler(ActionConfig & action,
                                    const call_handler_type & call_handler)
{
  bool handler_set = false;

  if(action.one_way) {
    if(action.requires_session || action.parameters) {
      handler_set = set_call_handler_one_way(action.action, boost::bind(validate_call, std::ref(action), call_handler, _1, _2));
    } else {
      handler_set = set_call_handler_one_way(action.action, call_handler);
    }
  } else {
    if(action.requires_session || action.parameters) {
      handler_set = set_call_handler_two_way(action.action, boost::bind(validate_call, std::ref(action), call_handler, _1, _2));
    } else {
      handler_set = set_call_handler_two_way(action.action, call_handler);
    }
  }

  return handler_set;
}

WebService::WebService(super::caller_type & caller) : super(caller) {
  super::add_service_type(protocol_traits::service_type());

  WISP_SERVICE_REQUEST(MessageOneWay);
  WISP_SERVICE_REQUEST(MessageTwoWay);
}

__END_NS_SSRC_WSPR_WS