ws/service.h

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.
 */

#ifndef __SSRC_WSPR_WS_SERVICE_H
#define __SSRC_WSPR_WS_SERVICE_H

#include <ssrc/wispers/service/service.h>
#include <ssrc/wispers/ws/types.h>
#include <ssrc/wispers/ws/ActionConfig.h>

__BEGIN_NS_SSRC_WSPR_WS

using namespace NS_SSRC_WSPR_SERVICE;

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

#define WS_DELEGATE_ONE_WAY_CALL(call, impl, function_ptr)                \
  set_call_handler_one_way(call, boost::bind(function_ptr, impl, _1, _2))
#define WS_DELEGATE_TWO_WAY_CALL(call, impl, function_ptr) \
  set_call_handler_two_way(call, boost::bind(function_ptr, impl, _1, _2))
#define WS_DELEGATE_ONE_WAY_CALL_WITH_PARAM(call, ws_type, param_type, impl, function_ptr) \
  set_call_handler_one_way(call, boost::bind(NS_SSRC_WSPR_WS::ws_call<ws_type, param_type>, impl, function_ptr, _1, _2))
#define WS_DELEGATE_TWO_WAY_CALL_WITH_PARAM(call, ws_type, param_type, impl, function_ptr) \
  set_call_handler_two_way(call, boost::bind(NS_SSRC_WSPR_WS::ws_call<ws_type, param_type>, impl, function_ptr, _1, _2))

#define WS_ONE_WAY_CALL(call, function_ptr) \
  WS_DELEGATE_ONE_WAY_CALL(call, this, function_ptr)
#define WS_TWO_WAY_CALL(call, function_ptr) \
  WS_DELEGATE_TWO_WAY_CALL(call, this, function_ptr)
#define WS_ONE_WAY_CALL_WITH_PARAM(call, ws_type, param_type, function_ptr) \
  WS_DELEGATE_ONE_WAY_CALL_WITH_PARAM(call, ws_type, param_type, this, function_ptr)
#define WS_TWO_WAY_CALL_WITH_PARAM(call, ws_type, param_type, function_ptr) \
  WS_DELEGATE_TWO_WAY_CALL_WITH_PARAM(call, ws_type, param_type, this, function_ptr)


#define WS_DELEGATE_ACTION(action, impl, function_ptr) \
  set_action_handler(action, boost::bind(function_ptr, impl, _1, _2))
#define WS_ACTION(action, function_ptr) \
  WS_DELEGATE_ACTION(action, this, function_ptr)

#define WS_DELEGATE_ACTION_WITH_PARAM(action, ws_type, param_type, impl, function_ptr) \
  set_action_handler(action, boost::bind(NS_SSRC_WSPR_WS::ws_call<ws_type, param_type>, impl, function_ptr, _1, _2))
#define WS_ACTION_WITH_PARAM(action, ws_type, param_type, function_ptr) \
  WS_DELEGATE_ACTION_WITH_PARAM(action, ws_type, param_type, this, function_ptr)

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

public:
  typedef WebServiceProtocol protocol_traits;

protected:
  WISP_IMPORT(protocol_traits, parameter_map);
  WISP_IMPORT(protocol_traits, MessageOneWay);
  WISP_IMPORT(protocol_traits, MessageTwoWay);
  WISP_IMPORT(protocol_traits, MessageResponse);
  WISP_IMPORT(protocol_traits, MessageDeliverEvent);
  WISP_IMPORT(protocol_traits, MessageDeliverEvents);
  WISP_IMPORT(protocol_traits, CallOneWay);
  WISP_IMPORT(protocol_traits, CallTwoWay);
  WISP_IMPORT(protocol_traits, CallResponse);
  WISP_IMPORT(protocol_traits, CallDeliverEvent);
  WISP_IMPORT(protocol_traits, CallDeliverEvents);

  // We need to hold on to ActionConfig references for validated calls.
  boost::ptr_vector<ActionConfig> _actions;

private:

  call_handler_map _call_handlers_one_way;
  call_handler_map _call_handlers_two_way;

  void reply_after_call_error(const WebServiceCall & call,
                              const MessageInfo & msginfo,
                              const string & error = "")
  {
    MessageResponse response(call.session, 0);
    response.set_error(error);
    _caller.reply<CallResponse>(msginfo.sender(), msginfo.token(), response);
  }

protected:

  ActionConfig & new_action(const Properties & action_map, const string & key)
    SSRC_DECL_THROW(std:::domain_error);

  void clear_call_handlers();
  bool set_call_handler_one_way(const string & call,
                                const call_handler_type & call_handler);
  bool set_call_handler_two_way(const string & call,
                                const call_handler_type & call_handler);
  bool set_action_handler(ActionConfig & action,
                          const call_handler_type & call_handler);

  // Allow one_way_call and two_way_call to be overridden in case we
  // want to change the behavior (for example, dynamic discovery of
  // call functions in a scripting context based on name).  Could
  // refactor and put the handler map stuff in a WebService subclass.
  //virtual
  void one_way_call(const WebServiceCall & call, const MessageInfo & msginfo) {
    call_handler_map::const_iterator it =
      _call_handlers_one_way.find(call.call);

    if(it != _call_handlers_one_way.end()) {
      try {
        it->second(call, msginfo);
      } catch(const std::exception & e) {
#ifdef WSPR_DEBUG
        std::cerr << "one_way_call EXCEPTION: " << e.what() << std::endl;
#endif
        // TODO: log error.
      } catch(...) {
#ifdef WSPR_DEBUG
        std::cerr << "one_way_call unknown exception\n";
#endif
        // TODO: log error.
      }
    }

    // TODO: Do we just ignore unsupported call attempt, log, delegate
    // to virtual error handling function?
  }

  //virtual
  void two_way_call(const WebServiceCall & call, const MessageInfo & msginfo) {
    call_handler_map::const_iterator it =
      _call_handlers_two_way.find(call.call);

    if(it != _call_handlers_two_way.end()) {
      try {
        it->second(call, msginfo);
      } catch(const std::exception & e) {
#ifdef WSPR_DEBUG
        std::cerr << "two_way_call EXCEPTION: " << e.what() << std::endl;
#endif
        // TODO: log error.
        reply_after_call_error(call, msginfo, e.what());
      } catch(...) {
#ifdef WSPR_DEBUG
        std::cerr << "two_way_call unknown exception\n";
#endif
        // TODO: log error.
        reply_after_call_error(call, msginfo);
      }
    }

    // TODO: Do we just ignore unsupported call attempt, log, delegate
    // to virtual error handling function?
  }

  void process_request(const MessageOneWay & msg,
                       const MessageInfo & msginfo)
  {
    one_way_call(msg.call, msginfo);
  }

  void process_request(const MessageTwoWay & msg,
                       const MessageInfo & msginfo)
  {
    two_way_call(msg.call, msginfo);
  }

public:

  explicit WebService(super::caller_type & caller);

  virtual ~WebService() { }
};

__END_NS_SSRC_WSPR_WS

#endif