MFMarketDataSession.h

/*
 * Copyright (C) 2015 MarketFactory, Inc. All rights reserved.
 * Use in source and binary forms, with or without modification, is permitted
 * provided that the following conditions are met:
 * 1. You may only use this software for internal evaluation and testing
 * purposes and may not use the software for engaging
 * in live trades, unless and until you have entered into a separate agreement
 * with MarketFactory governing the use of
 * MarketFactory software in a production environment.
 * 2. You may not distribute the software (in either source or binary forms) to
 * third parties.
 * 3. All copies of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *    THIS SOFTWARE IS PROVIDED BY MARKETFACTORY AND ITS LICENSORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
 *    BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
 *    NO EVENT SHALL MARKETFACTORY OR ITS LICENSORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 *    OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT
 *    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 *    ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef _MF_MFMARKETDATASESSION_H_
#define _MF_MFMARKETDATASESSION_H_

#define USERNAME_LENGTH 32
#define PASSWORD_LENGTH 32 
#define TEXT_LENGTH 64

#include <MFProto.h>
#include <MFProtoInputBuffer.h>
#include <MFProtoOutputBuffer.h>
#include <MFProtoMsgWrapper.h>
#include <SessionState.h>

#include <mfmarketdata/SubscriptionRequestType.hpp>
#include <mfmarketdata/Logon.hpp>
#include <mfmarketdata/SecurityDefinitionRequest.hpp>
#include <mfmarketdata/MarketDataRequest.hpp>
#include <mfmarketdata/RegisterForBatch.hpp>
#include <mfmarketdata/UnregisterForBatch.hpp>
#include <mfmarketdata/Logout.hpp>
#include <mfmarketdata/LogoutResponse.hpp>
#include <mfmarketdata/Heartbeat.hpp>

#include <boost/asio.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/noncopyable.hpp>

class MFMarketDataHandler;

class MFMarketDataSession : private boost::noncopyable {
  friend class MFClient;

 public:
  uint16_t getVenueID() const { return _venueID; }

  const std::string getVenueName() const { return _venueName; }

  uint64_t getSendingTime() const { return _inputBuffer.getSendingTime(); }

  void logon();

  void logout(const char* text);

  void logoutResponse();

  void securityDefinitionRequest();

  void marketDataRequest(mfmarketdata::SubscriptionRequestType::Value subType,
                         MFProto::SecurityID securityID);

  void marketDataRequestHistoric(
      mfmarketdata::SubscriptionRequestType::Value subType,
      MFProto::VenueID venueID, MFProto::SecurityID securityID,
      uint64_t startTime, uint64_t endTime);

  void registerForBatch(MFProto::VenueID venueID,
                        MFProto::BatchDefID batchDefID,
                        MFProto::SecurityID* securityIDs, int numSecurityIDs);

  void unregisterFromBatch(MFProto::BatchDefID batchDefID);

  bool isLoggedOn() const;

 private:
  void sendLogonMessage();
  void sendLogoutMessage(const char* text);

  void relogonIfNecessary();

  bool disconnect(bool reconnect = true);

  void connect();

  //-- Socket methods
  template <typename T>
  void write(MFProtoMsgWrapper<T>& msgWrapper) {
    write(msgWrapper.buf());
  }

  void write(MFProtoOutputBuffer& outputBuffer);

  void handle_connect(const boost::system::error_code& ec);
  void handle_read(const boost::system::error_code& ec,
                   size_t bytes_transferred);

  void onTimer(TimeUtil::Timestamp now);
  void checkForDeadConnection(TimeUtil::Timestamp now);
  void sendHeartbeatIfNecessary(TimeUtil::Timestamp now);

  MFMarketDataSession(MFMarketDataHandler& handler,
                      boost::asio::io_service& ios,
                      const std::string& venueName, MFProto::VenueID venueID,
                      const std::string& username, const std::string& password,
                      const std::string& hostname, int port,
                      bool relogonOnDisconnect, uint32_t heartBtInt);

  void onStart();
  void onStop();

  void write_internal(MFProtoOutputBuffer& outputBuffer);

  MFMarketDataHandler& _handler;
  const uint16_t _heartBtInt;
  boost::asio::ip::tcp::socket _socket;
  MFProtoInputBuffer _inputBuffer;
  mutable boost::mutex _outputBufferLock;
  uint32_t _outputBufferPacketSeqNum;
  const std::string _username;
  const std::string _password;
  const std::string _hostname;
  const uint16_t _port;
  const std::string _venueName;
  const uint16_t _venueID;
  const bool _relogonOnDisconnect;
  SessionState _state;
  uint64_t _lastMessageSentTimestamp;
  uint64_t _lastMessageRecvTimestamp;
};

#endif