ws/protocol.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_PROTOCOL_H
#define __SSRC_WSPR_WS_PROTOCOL_H

#include <ssrc/wispers/protocol.h>
#include <ssrc/wispers/fcgi/parameter_map.h>
#include <ssrc/wispers/session/protocol.h>
#include <ssrc/wispers/utility/StringTo.h>
#include <ssrc/wispers/utility/AppendToContainer.h>

#include <boost/preprocessor/stringize.hpp>

#ifdef WSPR_DEBUG
#include <iostream>
#endif

__BEGIN_NS_SSRC_WSPR_PROTOCOL

WSPR_DEFINE_PROTOCOL(WebService,ws);

__END_NS_SSRC_WSPR_PROTOCOL

__BEGIN_NS_SSRC_WSPR_WS

using std::string;
using NS_SSRC_WISP_PROTOCOL::wisp_call_token;
using NS_SSRC_WISP_PROTOCOL::MessageInfo;
using NS_SSRC_WSPR_UTILITY::Properties;
using NS_SSRC_WSPR_UTILITY::property_vector;
using NS_SSRC_WSPR_UTILITY::properties_ptr;
using NS_SSRC_WSPR_UTILITY::properties_unique_ptr;
using NS_SSRC_WSPR_UTILITY::AppendToContainer;
using NS_SSRC_WSPR_SESSION::session_ptr;

#define WSPR_WS_TYPE(service_base_str) "wspr.ws." service_base_str

inline Properties & set_web_event_header(Properties & properties,
                                         const string & protocol,
                                         const string & call)
{
  properties.set(protocol, "protocol");
  properties.set(call, "call");
  return properties;
}

inline Properties & set_web_event_header(Properties & properties,
                                         const string & protocol,
                                         const string & call,
                                         const gsid_type gsid)
{
  properties.set(gsid, "gsid");
  return set_web_event_header(properties, protocol, call);
}

inline properties_unique_ptr
web_event(const string & protocol, const string & call) {
  properties_unique_ptr props(new Properties);
  set_web_event_header(*props, protocol, call);
  return props;
}

inline properties_unique_ptr
web_event(const string & protocol, const string & call, const gsid_type gsid) {
  properties_unique_ptr props(new Properties);
  set_web_event_header(*props, protocol, call, gsid);
  return props;
}

inline Properties & web_event_indirect(Properties & properties,
                                       const string & protocol,
                                       const string & call)
{
  return set_web_event_header(properties, protocol, call);
}

inline Properties & web_event_indirect(Properties & properties,
                                       const string & protocol,
                                       const string & call,
                                       const gsid_type gsid)
{
  return set_web_event_header(properties, protocol, call, gsid);
}

inline Properties & web_event_direct(Properties & properties,
                                     const string & protocol,
                                     const string & call)
{
  Properties *node;
  property_vector & v = properties.create_property_vector("wspr", "event");
  v.push_back(node = new Properties);
  return set_web_event_header(*node, protocol, call);
}

inline Properties & web_event_direct(Properties & properties,
                                     const string & protocol,
                                     const string & call,
                                     const gsid_type gsid)
{
  Properties *node;
  property_vector & v = properties.create_property_vector("wspr", "event");
  v.push_back(node = new Properties);
  return set_web_event_header(*node, protocol, call, gsid);
}

struct WebServiceCall {
  WISP_IMPORT(NS_SSRC_WSPR_FCGI, parameter_map);
  string call;
  parameter_map parameters;
  session_ptr session;

  WebServiceCall() { }

  WebServiceCall(const string & call,
             const parameter_map & parameters,
             const session_ptr & session = session_ptr()) :
    call(call), parameters(parameters), session(session)
  { }

  bool is_parameter(const string & param_name) const {
    parameter_map::const_iterator && it = parameters.find(param_name);

    if(it == parameters.end())
      return false;

    return true;
  }

  template<typename param_type>
  bool get_parameter(const string & param_name, param_type & value) const
    SSRC_DECL_THROW(std::bad_cast)
  {
    parameter_map::const_iterator && it = parameters.find(param_name);

    if(it == parameters.end())
      return false;

    value = utility::string_to<param_type>(it->second);

    return true;
  }

  template<typename param_type>
  param_type get_parameter(const string & param_name) const
    SSRC_DECL_THROW(std::bad_cast)
  {
    parameter_map::const_iterator && it = parameters.find(param_name);

    if(it == parameters.end())
      return param_type();

    return utility::string_to<param_type>(it->second);
  }


  template<typename container_type>
  unsigned int get_parameters(const string & param_name,
                              container_type & container) const
    SSRC_DECL_THROW(std::bad_cast)
  {
    WISP_IMPORT_T(container_type, value_type);
    unsigned int count(0);
    std::pair<parameter_map::const_iterator,parameter_map::const_iterator> &&
      range = parameters.equal_range(param_name);
    AppendToContainer<container_type> append(container);

    while(range.first != range.second) {
      append(utility::string_to<value_type>(range.first->second));
      ++range.first;
      ++count;
    }

    return count;
  }

  template<class Archive>
  void serialize(Archive & ar, const unsigned int) {
    ar & call & parameters & session;
  }
};

template<> inline
bool WebServiceCall::get_parameter<string>(const string & param_name,
                                           string & value) const 
{
  parameter_map::const_iterator && it = parameters.find(param_name);

  if(it == parameters.end())
    return false;

  value = it->second;

  return true;
}

template<> inline
string WebServiceCall::get_parameter<string>(const string & param_name) const {
  parameter_map::const_iterator && it = parameters.find(param_name);

  if(it == parameters.end())
    return string();

  return it->second;
}

#define __WS_DEFINE_CALL_PARAM(r, data, arg) \
  BOOST_PP_TUPLE_ELEM(2, 0, arg) BOOST_PP_TUPLE_ELEM(2, 1, arg);

#define __WS_INIT_CALL_PARAM(r, data, i, arg)                          \
  BOOST_PP_COMMA_IF(i)  BOOST_PP_TUPLE_ELEM(2, 1, arg)(call . get_parameter<BOOST_PP_TUPLE_ELEM(2, 0, arg)>(BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(2, 1, arg))))
// This is for the benefit of client code that wants to define its own
// macros that add extra functionality to the generated structure.
#define __WS_CALL_PARAM(name, param_sequence) \
    BOOST_PP_SEQ_FOR_EACH(__WS_DEFINE_CALL_PARAM, _, param_sequence)  \
      name (const NS_SSRC_WSPR_WS::WebServiceCall & call) SSRC_DECL_THROW(std::bad_cast) : \
      BOOST_PP_SEQ_FOR_EACH_I(__WS_INIT_CALL_PARAM, call, param_sequence) \
      { }                                                               \

#define WS_CALL_PARAM(name, param_sequence)                         \
  struct name {                                                         \
    __WS_CALL_PARAM(name, param_sequence)                           \
  }

template<typename ws_type, typename param_type> inline
void ws_call(ws_type * impl,
             void (ws_type::* call_handler)(const WebServiceCall &, const param_type &, const MessageInfo &),
             const WebServiceCall & call,
             const MessageInfo & msginfo)
{
#ifdef WSPR_DEBUG
  try {
#endif
    (impl->*call_handler)(call, param_type(call), msginfo);
#ifdef WSPR_DEBUG
  } catch(const std::bad_cast & blc) {
    // TODO: log
    std::cerr << "bad parameters for " << call.call << std::endl
              << blc.what() << std::endl;
    for(WebServiceCall::parameter_map::const_iterator it = call.parameters.begin();
        it != call.parameters.end(); ++it)
    {
      std::cerr << it->first << " : " << it->second << std::endl;
    }
    throw;
  }
#endif
}

struct WebServiceProtocol :
  public protocol::ServiceProtocol<protocol::WebService>
{
  WISP_IMPORT(NS_SSRC_WSPR_FCGI, parameter_map);

  enum MessageType {
    OneWay,
    TwoWay,
    Response,
    DeliverEvent,
    DeliverEvents
  };

  template<MessageType type>
  struct MessageCallBase : public protocol::MessageWebService<type> {
    WebServiceCall call;

    MessageCallBase() { }

    MessageCallBase(const string & call,
                    const parameter_map & parameters,
                    const session_ptr & session = session_ptr()) :
      call(call, parameters, session)
    { }

    template<class Archive>
    void serialize(Archive & ar, const unsigned int) {
      ar & call;
    }
  };

  typedef MessageCallBase<OneWay> MessageOneWay;
  typedef MessageCallBase<TwoWay> MessageTwoWay;

  // IMPORTANT: Changes to MessageResponse must be reflected in SWIG binding.
  // SWIG does not automatically handle nested classes, so we have a separate
  // SWIG interface that must be synchronized to this definition.
  class MessageResponse : public protocol::MessageWebService<Response> {
    enum Status { Succeeded, Failed, Error };

    unsigned int status;
    string status_msg;

    void set_status(Status s, const string & msg) {
      status = s;
      status_msg = msg;
    }

  public:
    session_ptr session;
    properties_ptr template_data;

    explicit MessageResponse(const session_ptr & session = session_ptr()) :
      status(Succeeded), status_msg(), session(session),
      template_data(new Properties)
    { }

    // template_data must be the result of new Properties or 0.
    explicit MessageResponse(const session_ptr & session,
                             Properties * template_data) :
      status(Succeeded), status_msg(), session(session),
      template_data(template_data)
    { }

    explicit MessageResponse(const session_ptr & session,
                             const properties_ptr & template_data) :
      status(Succeeded), status_msg(), session(session),
      template_data(template_data)
    { }

    void set_succeeded(const string & msg = ""){
      set_status(Succeeded, msg);
    }

    void set_failed(const string & msg = "") {
      set_status(Failed, msg);
    }

    void set_error(const string & msg = "") {
      set_status(Error, msg);
    }

    bool succeeded() const { return (status == Succeeded); }

    bool failed() const { return (status == Failed); }

    bool error() const { return (status == Error); }

    const string & status_message() const { return status_msg; }

    template<class Archive>
    void serialize(Archive & ar, const unsigned int) {
      ar & status & status_msg & session & template_data;
    }
  };


  // This is for the EventQueue.  It should go in a separate protocol.
  static string event_queue_ws_type() {
    return WSPR_WS_TYPE("event");
  }

  static string event_queue_ws_group() {
    return WSPR_WS_TYPE("event");
  }

  // This is for the EventQueue.  It should go in a separate protocol.
  struct MessageDeliverEvent :
    public protocol::MessageWebService<DeliverEvent>
  {
    typedef std::vector<uid_type> key_container;
    key_container keys;
    properties_ptr template_data;

    explicit MessageDeliverEvent(Properties * template_data = new Properties) :
      keys(), template_data(template_data)
    { }

    explicit MessageDeliverEvent(const properties_ptr & template_data) :
      keys(), template_data(template_data)
    { }

    template<class Archive>
    void serialize(Archive & ar, const unsigned int) {
      ar & keys & template_data;
    }
  };

  struct MessageDeliverEvents :
    public protocol::MessageWebService<DeliverEvents>
  {
    typedef std::vector<uid_type> key_container;
    typedef std::vector<Properties> event_container;
    key_container keys;
    event_container events;

    explicit MessageDeliverEvents(const unsigned int size = 1) :
      keys(), events(size)
    { }

    explicit MessageDeliverEvents(event_container && events) :
      keys(), events(events)
    { }

    template<class Archive>
    void serialize(Archive & ar, const unsigned int) {
      ar & keys & events;
    }
  };

  WISP_ONE_WAY_CALL(caller_type, OneWay);
  WISP_ONE_WAY_CALL(caller_type, Response);
  WISP_ONE_WAY_CALL(caller_type, DeliverEvent);
  WISP_ONE_WAY_CALL(caller_type, DeliverEvents);

  WISP_TWO_WAY_CALL(caller_type, TwoWay, Response);
};

struct WebServiceCallContextOneWay {
  session_ptr session;

  WebServiceCallContextOneWay(const session_ptr & session) :
    session(session)
  { }
};

struct WebServiceCallContextTwoWay : public WebServiceCallContextOneWay {
  wisp_call_token token;
  string sender;

  WebServiceCallContextTwoWay(const session_ptr & session,
                              const wisp_call_token token,
                              const string & sender) :
    WebServiceCallContextOneWay(session), token(token), sender(sender)
  { }
};

__END_NS_SSRC_WSPR_WS

#endif