MFStpBookingSession.h

/*
 * Copyright (C) 2017 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_STPBOOKINGSESSION_H_
#define _MF_STPBOOKINGSESSION_H_

#define USERNAME_LENGTH 32
#define PASSWORD_LENGTH 32
#define CLORDID_LENGTH 32
#define STRATEGY_PARAMETERS_LENGTH 32
#define CONFIRMID_LENGTH 32
#define EXECID_LENGTH 32

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

#include <mfstp_booking/DecimalQtyNULL.hpp>
#include <mfstp_booking/Logon.hpp>
#include <mfstp_booking/Logout.hpp>
#include <mfstp_booking/LogoutResponse.hpp>
#include <mfstp_booking/Heartbeat.hpp>
#include <mfstp_booking/PriceNULL.hpp>
#include <mfstp_booking/SecurityDefinition.hpp>
#include <mfstp_booking/SecurityDefinitionRequest.hpp>
#include <mfstp_booking/Side.hpp>
#include <mfstp_booking/SubscriptionRequestType.hpp>
#include <mfstp_booking/TradeCaptureReportSpotForward.hpp>
#include <mfstp_booking/TradeCaptureReportSwap.hpp>
#include <mfstp_booking/Confirmation.hpp>

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

class MFStpBookingHandler;

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

 public:
  void logon();

  void logout();

  void logoutResponse();

  MFProtoMsgWrapper<mfstp_booking::TradeCaptureReportSpotForward>& tradeCaptureReportSpotForward(int numPartyIDs);

  void tradeCaptureReportSpotForwardSend();

  MFProtoMsgWrapper<mfstp_booking::TradeCaptureReportSwap>& tradeCaptureReportSwap(int numPartyIDs);

  void tradeCaptureReportSwapSend();

  void securityDefinitionRequest();

  void confirmation(uint32_t msgSeqNum, const char * confirmID, const char * execID);

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

  //----------------------------------------------------------------------------------------------------
  // StpBooking
  
 private:
  void sendLogonMessage();
  void sendLogoutMessage();
  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);
  void closeConnectionIfWaitedTooLongForServerLogoutResponse(
      TimeUtil::Timestamp now);

  MFStpBookingSession(MFStpBookingHandler& handler, boost::asio::io_service& ios,
                   const std::string& username, const std::string& password,
                   const std::string& hostname, uint16_t port,
                   bool reconnectOnDisconenect, uint16_t heartBtInt);

  void onStart();
  void onStop();

  void write_internal(MFProtoOutputBuffer& outputBuffer);

  MFStpBookingHandler& _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 bool _relogonOnDisconnect;
  SessionState _state;
  long _lastMessageSentTimestamp;
  long _lastMessageRecvTimestamp;
};

#endif