MFTradingSession.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_TRADINGSESSION_H_
#define _MF_TRADINGSESSION_H_

#define USERNAME_LENGTH 32
#define PASSWORD_LENGTH 32
#define CLORDID_LENGTH 32
#define STRATEGY_PARAMETERS_LENGTH 32

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

#include <mftrading/DecimalQtyNULL.hpp>
#include <mftrading/TradingSessionStatusRequest.hpp>
#include <mftrading/NewOrderSingle.hpp>
#include <mftrading/Logon.hpp>
#include <mftrading/MarketDefinitionRequest.hpp>
#include <mftrading/OrderCancelReplaceRequest.hpp>
#include <mftrading/OrderCancelRequest.hpp>
#include <mftrading/Logout.hpp>
#include <mftrading/LogoutResponse.hpp>
#include <mftrading/Heartbeat.hpp>
#include <mftrading/OrdType.hpp>
#include <mftrading/PriceNULL.hpp>
#include <mftrading/Side.hpp>
#include <mftrading/SubscriptionRequestType.hpp>
#include <mftrading/TimeInForce.hpp>

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

class MFTradingHandler;

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

 public:
  void logon();

  void logout();

  void logoutResponse();

  void marketDefinitionRequest();

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

  //----------------------------------------------------------------------------------------------------
  // Trading

  void tradingRequest
  (
    MFProto::VenueID                          venueID,
    mftrading::SubscriptionRequestType::Value subType,
    MFProto::SeqNum                     nextExpSeqNum
  );

  void newOrderSingle();

  mftrading::NewOrderSingle& createNewOrderSingle
  (
      MFProto::VenueID                                   venueID,
      MFProto::SecurityID                             securityID,
      const char*                                        clOrdId,
      mftrading::Side::Value                                side,
      mftrading::OrdType::Value                          ordType,
      mftrading::TimeInForce::Value                  timeInForce,
      const char**                             strategyParamName = NULL,
      mftrading::StrategyParameterType::Value* strategyParamType = NULL,
      const char**                            strategyParamValue = NULL, 
      int                                        nStrategyParams = 0
  );

  void orderCancelReplaceRequest();

  mftrading::OrderCancelReplaceRequest& createOrderCancelReplaceRequest
  (
    MFProto::VenueID                  venueID,
    MFProto::SecurityID            securityID,
    const char*                       clOrdID,
    const char*                     origOrdID,
    MFProto::OrderID                  orderID,
    mftrading::Side::Value               side,
    mftrading::OrdType::Value         ordType,
    mftrading::TimeInForce::Value timeInForce
  );

  void orderCancelRequest();

  mftrading::OrderCancelRequest& createOrderCancelRequest
  (
      MFProto::VenueID       venueID, 
      MFProto::SecurityID securityID,
      const char*            clOrdID, 
      const char*        origClOrdID, 
      MFProto::OrderID       orderID
  );

 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);

  MFTradingSession(MFTradingHandler& 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);

  MFTradingHandler& _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