session/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_SESSION_PROTOCOL_H
#define __SSRC_WSPR_SESSION_PROTOCOL_H

#include <ssrc/wispers/index/DictionaryProtocol.h>
#include <ssrc/wispers/session/SessionData.h>

__BEGIN_NS_SSRC_WSPR_PROTOCOL

WSPR_DEFINE_PROTOCOL(Session,session);

__END_NS_SSRC_WSPR_PROTOCOL

__BEGIN_NS_SSRC_WSPR_SESSION

using namespace NS_SSRC_WSPR_INDEX;

enum SessionIndexScheme { BySID, ByUID, ByLastAccess };

typedef boost::multi_index_container<
  SessionData,
  boost::multi_index::indexed_by<
    boost::multi_index::hashed_unique<
      boost::multi_index::member<SessionData, sid_type, &SessionData::sid> >,
    boost::multi_index::hashed_unique<
      boost::multi_index::member<SessionData, uid_type, &SessionData::uid> >,
      boost::multi_index::ordered_non_unique<
        boost::multi_index::member<SessionData, idle_count_type,
                                   &SessionData::idle_count> >
    > > session_map;

typedef session_map::nth_index<BySID>::type index_by_sid;
typedef session_map::nth_index<ByUID>::type index_by_uid;
typedef session_map::nth_index<ByLastAccess>::type index_by_access;

struct SessionProtocol :
  public DictionaryProtocol<protocol::MessageSession, session_map,
                            SessionIndexScheme>
{
  static string event_group_expire() {
    return WSPR_EVENT_GROUP("session", "expire");
  }

  static string event_group_login() {
    return WSPR_EVENT_GROUP("session", "login");
  }

  static string event_group_logout() {
    return WSPR_EVENT_GROUP("session", "logout");
  }

  enum {
    CreateSession = MaxDictionaryMessageID + 1,
    GetSession,
    ExpireSession,
    SetAttributes,
    UpdateSession,
    LoginSession,
    LogoutSession
  };


  WISP_PROTOCOL_MESSAGE_WITH_INIT(CreateSession, protocol::MessageSession,
                                 ((sid_type, sid)), (""));
  WISP_PROTOCOL_MESSAGE_WITH_INIT(GetSession, protocol::MessageSession,
                                 ((sid_type, sid))((bool, update_access_time)),
                                 ("")(true));

  struct MessageExpireSession : public protocol::MessageSession<ExpireSession>
  {
    typedef uid_type session_value;
    typedef std::vector<session_value> session_container;
    session_container sessions;

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

  struct MessageSetAttributes : public protocol::MessageSession<ExpireSession>
  {
    sid_type sid;
    Properties attributes;

    MessageSetAttributes(const sid_type & sid = sid_type()) :
      sid(sid), attributes()
    { }

    MessageSetAttributes(const sid_type & sid, Properties && attributes) :
      sid(sid), attributes(attributes)
    { }

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

  WISP_PROTOCOL_MESSAGE(UpdateSession, protocol::MessageSession,
                       ((SessionData, session)));

  WISP_PROTOCOL_MESSAGE(LoginSession, protocol::MessageSession,
                       ((SessionData, session)));

  WISP_PROTOCOL_MESSAGE(LogoutSession, protocol::MessageSession,
                       ((SessionData, session)));

  WISP_ONE_WAY_CALL(caller_type, ExpireSession);
  WISP_ONE_WAY_CALL(caller_type, SetAttributes);
  WISP_ONE_WAY_CALL(caller_type, UpdateSession);
  WISP_ONE_WAY_CALL(caller_type, LoginSession);
  WISP_ONE_WAY_CALL(caller_type, LogoutSession);

  WISP_TWO_WAY_CALL(caller_type, CreateSession, SingleQueryResult);
  WISP_TWO_WAY_CALL(caller_type, GetSession, SingleQueryResult);
};

__END_NS_SSRC_WSPR_SESSION

#endif