session/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_SESSION_SERVICE_H
#define __SSRC_WSPR_SESSION_SERVICE_H

#include <ssrc/wispers/index/DictionaryService.h>
#include <ssrc/wispers/session/protocol.h>
#include <ssrc/wispers/utility/RandomId.h>

__BEGIN_NS_SSRC_WSPR_SESSION

using NS_SSRC_WSPR_SERVICE::timeout_ptr;
using NS_SSRC_WSPR_UTILITY::RandomId;

struct SessionInitializer {
  unsigned int expirations_per_message;
  // These are in seconds.  For best results, max_idle_time should be
  // an integer multiple of poll_interval.
  unsigned int poll_interval;
  unsigned int max_idle_time;
  std::string checkpoint_path;

  SessionInitializer() :
    expirations_per_message(1024), poll_interval(300), max_idle_time(1800)
  { }
};

class Session : public DictionaryService<SessionProtocol> {
public:
  WISP_IMPORT(SessionProtocol, MessageSingleQueryResult);
  WISP_IMPORT(SessionProtocol, MessageInsert);
  WISP_IMPORT(SessionProtocol, MessageCreateSession);
  WISP_IMPORT(SessionProtocol, MessageGetSession);
  WISP_IMPORT(SessionProtocol, MessageExpireSession);
  WISP_IMPORT(SessionProtocol, MessageSetAttributes);
  WISP_IMPORT(SessionProtocol, MessageUpdateSession);
  WISP_IMPORT(SessionProtocol, MessageLoginSession);
  WISP_IMPORT(SessionProtocol, MessageLogoutSession);

  WISP_IMPORT(SessionProtocol, CallExpireSession);

private:
  struct TouchSession {
    idle_count_type idle_count;

    TouchSession(const idle_count_type idle_count) : idle_count(idle_count) { }

    void operator()(SessionData & session) {
      session.idle_count = idle_count;
    }
  };

  friend class NS_SSRC_WISP_SERVICE::ServiceProtocolProcessor<packing_traits>;
  typedef DictionaryService<SessionProtocol> super;


  const RandomId<std::int32_t> _random_id;
  const unsigned int _expirations_per_message;
  const sec_type _poll_interval;
  const sec_type _max_idle_time;
  idle_count_type _low_count;
  TouchSession _touch_session;
  timeout_ptr _poll_timeout;
  const std::string _checkpoint_path;

  void load_checkpoint(const std::string & filename)
    SSRC_DECL_THROW(std::runtime_error, boost::archive::archive_exception);

  void touch_session(const session_map::iterator & it) {
    if(it->idle_count != _touch_session.idle_count) {
      get_index<BySID>().modify(it, _touch_session);
    }
  }

  virtual void process_request(const MessageInsert & msg, const MessageInfo &);

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

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

  void process_request(MessageSetAttributes & msg, const MessageInfo &);

  void update_session(const SessionData & update);

  void process_request(const MessageUpdateSession & msg, const MessageInfo &) {
    update_session(msg.session);
  }

  void process_request(const MessageLoginSession & msg, const MessageInfo &) {
    update_session(msg.session);
  }

  void process_request(const MessageLogoutSession & msg, const MessageInfo &);

  void check_for_expirations() {
    // We don't worry about wraparound effects because the process will never
    // run long enough for wraparound even at a poll interval of one second.
    // Still, it's easy enough to handle if we have to.
    expire_sessions(_low_count);
    ++_low_count;
    ++_touch_session.idle_count;
  }

  virtual void transition(State state);

public:

  Session(super::caller_type & caller, const SessionInitializer & initializer)
    SSRC_DECL_THROW(std::runtime_error, boost::archive::archive_exception);

  virtual ~Session() { }

  string create_sid();

  string create_xsrf_token() {
    return _random_id(SessionIdNumChars);
  }

  std::pair<session_map::iterator, bool> create_session() {
    return
      insert<BySID>(SessionData(create_sid(), create_xsrf_token(),
                                _touch_session.idle_count));
  }

  void expire_sessions(const idle_count_type low_count);

};

__END_NS_SSRC_WSPR_SESSION

#endif