service/service.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_SERVICE_SERVICE_H
#define __SSRC_WSPR_SERVICE_SERVICE_H

#include <ssrc/wispers/service/protocol.h>
#include <ssrc/wispers/registry/protocol.h>

#include <ssrc/wisp/service.h>

__BEGIN_NS_SSRC_WSPR_SERVICE

using NS_SSRC_SPREAD::MembershipInfo;
using NS_SSRC_SPREAD::Message;
using NS_SSRC_SPREAD::GroupList;

using NS_SSRC_WISP_PROTOCOL::MessageInfo;

using NS_SSRC_WISP_SERVICE::EventLoop;
using NS_SSRC_WISP_SERVICE::EventHandler;
using NS_SSRC_WISP_SERVICE::EventInfo;
using NS_SSRC_WISP_SERVICE::ServiceEventHandler;
using NS_SSRC_WISP_SERVICE::Service;
using NS_SSRC_WISP_SERVICE::timeout_handler;
using NS_SSRC_WISP_SERVICE::timeout_ptr;
using NS_SSRC_WISP_SERVICE::message_handler_type;
using NS_SSRC_WISP_SERVICE::message_handler_entry;
using NS_SSRC_WISP_SERVICE::message_handler_map;

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

  registry::service_type_list _service_types;

  void register_service_types(const string & reg) {
    if(_service_types.size() > 0) {
      GroupList dest;
      dest.add(reg);
      if(reg != registry::event_group_register())
        dest.add(registry::event_group_register());
      _caller.
        send<registry::CallReregister>(Message::Safe,
                                       dest, _caller.name(), _service_types);
    }
  }

protected:
  WISP_IMPORT(ServiceProtocol, MessageStop);
  WISP_IMPORT(ServiceProtocol, MessageEchoRequest);
  WISP_IMPORT(ServiceProtocol, MessageReregister);
  WISP_IMPORT(ServiceProtocol, MessageStatusRequest);
  WISP_IMPORT(ServiceProtocol, CallStop);
  WISP_IMPORT(ServiceProtocol, CallEchoReply);
  WISP_IMPORT(ServiceProtocol, CallStatusReply);

  virtual void process_request(const MessageStop & msg, const MessageInfo &) {
    stop();
  }

  virtual void process_request(const MessageEchoRequest & msg,
                               const MessageInfo & msginfo)
  {
    _caller.
      reply<CallEchoReply>(msginfo.sender(), msginfo.token(),
                           Message::FIFOSelfDiscard);
  }

  virtual void process_request(const MessageReregister & msg,
                               const MessageInfo &)
  {
    register_service_types(msg.registry);
  }

  virtual properties_ptr get_status();

  void process_request(const MessageStatusRequest & msg,
                       const MessageInfo & msginfo);

  virtual void transition(State state) {
    super::transition(state);
    if(state == Started)
      register_service_types(registry::service_group_registry());
  }

public:
  typedef registry::service_type_list::const_iterator service_type_iterator;

  explicit ServiceProtocolProcessor(caller_type & caller) :
    super(caller), _service_types(2)
  {
    _service_types.resize(0);

    WISP_SERVICE_REQUEST(MessageStop);
    WISP_SERVICE_REQUEST(MessageEchoRequest);
    WISP_SERVICE_REQUEST(MessageReregister);
    WISP_SERVICE_REQUEST(MessageStatusRequest);
  }

  virtual ~ServiceProtocolProcessor() { }

  void add_service_type(const string & service_type) {
    _service_types.push_back(service_type);
  }

  service_type_iterator service_types_begin() {
    return _service_types.begin();
  }

  service_type_iterator service_types_end() {
    return _service_types.end();
  }

  void start() {
    _caller.join(ServiceProtocol::service_group());
    transition(Starting);
  }

  // Services listening for membership messages should wait for self-leave
  // before transitioning to Stopped.
  void stop() {
    _caller.leave(ServiceProtocol::service_group());
    transition(Stopping);
  }

  void membership(const MessageInfo & msginfo,
                  const MembershipInfo & meminfo)
  {
    if(meminfo.is_self_leave() &&
       msginfo.sender() == ServiceProtocol::service_group())
      transition(Stopped);
    else if(state() != Stopping) {
      process_membership_message(msginfo, meminfo);
    }
  }
};

__END_NS_SSRC_WSPR_SERVICE

#endif