D:/_work/fix/doc/manual/headers/B2BITS_AdminApplication.h

Go to the documentation of this file.

// <copyright>
// $Revision: 1.17 $
// 
// (c) B2BITS 2006. B2BITS is an abbreviation of
// Business to Business Information Technology Services corporation.
// "Licensor" shall mean B2BITS.
// 
// This software is for the use of the paying client of B2BITS (which may be
// a corporation, business area, business unit or single use subject to
// licence terms) to whom it was delivered (the "Licensee")and no other party,
// and any use beyond this business area is contrary to the terms of the licence grant.
// 
// The Licensee acknowledges and agrees that the Software and Documentation
// (the "Confidential Information") is confidential and proprietary to
// the Licensor and the Licensee hereby agrees to use the Confidential
// Information only as permitted by the full licence agreement betweeen
// the two parties, to maintain the confidentiality of the Confidential
// Information and not to disclose the confidential information, or any part
// thereof, to any other person, firm or corporation. The Licensee
// acknowledges that disclosure of the Confidential Information may give rise
// to an irreparable injury to the Licensor in-adequately compensable in
// damages. Accordingly the Licensor may seek (without the posting of any
// bond or other security) injunctive relief against the breach of the forgoing
// undertaking of confidentiality and non-disclosure, in addition to any other
// legal remedies which may be available, and the licensee consents to the
// obtaining of such injunctive relief. All of the undertakings and
// obligations relating to confidentiality and non-disclosure, whether
// contained in this section or elsewhere in this agreement, shall survive
// the termination or expiration of this agreement for a period of five (5)
// years.
// 
// The Licensor agrees that any information or data received from the Licensee
// in connection with the performance of the support agreement relating to this
// software shall be confidential, will be used only in connection with the
// performance of the Licensor's obligations hereunder, and will not be
// disclosed to third parties, including contractors, without the Licensor's
// express permission in writing.
// 
// Information regarding the software may be provided to the Licensee's outside
// auditors and attorneys only to the extent required by their respective
// functions.
// </copyright>


#ifndef __B2BITS_AdminApplication_h__
#define __B2BITS_AdminApplication_h__
#include <list>
#include <xercesc/util/XercesDefs.hpp>
#include "B2BITS_Application.h"
#include "B2BITS_Statistics.h"
#include "B2BITS_Mutex.h"

XERCES_CPP_NAMESPACE_BEGIN
    class DOMNode;
    class DOMDocument;
XERCES_CPP_NAMESPACE_END

namespace Engine{
    const std::string RESULT_SUCCESS               = "0";
    const std::string RESULT_NOT_IMPLEMENTED       = "1";
    const std::string RESULT_NOT_ENOUGH_PARAMETERS = "2";
    const std::string RESULT_UNKNOWN_SESSION       = "3";
    const std::string RESULT_INCORRECT_VALUE       = "4";
    const std::string RESULT_ENGINE_EXCEPTION      = "5";
    const std::string RESULT_UNKNOWN_ERROR         = "6";
    const std::string RESULT_OPERATION_REJECTED    = "7";
    const std::string RESULT_CONDITIONS_LACK       = "8";
    const std::string RESULT_INVALIDARG            = "9";
    const std::string RESULT_LOGIC_ERROR           = "10";
    const std::string RESULT_RUNTIME_ERROR         = "11";

class V12_API AdminApplication : protected Application
{
protected:
protected:
    typedef std::map<std::string, std::string> CommandTable;

//protected:
public:

struct Context
{    
    const Session& session_;
    const FIXMessage& message_;
    Context(const Session& sn, const FIXMessage& msg) : session_(sn), message_(msg) {};
};

public:
    AdminApplication();
    virtual ~AdminApplication();

    void bindSession(Session* pSession);

    void terminate();
protected:
    virtual bool process(const std::string& action, const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void sendResponse(const XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* response, const Context& context) const;

    virtual void sendResponse(const std::string& response, const Context& context) const;

    void sendResponse(const std::string& resultCode, const std::string& description, const std::string& additionalData, const Context& context) const;

    virtual void getAvailableCommands(CommandTable* commands) const;

    virtual bool process(const FIXMessage& msg, const Session& sn);

    virtual void OnBindAdminSession(const Session* pSession) {};

    void sendReject(const Session& sn, const FIXMessage& msg, const std::string& text );

    virtual void onLogonEvent(const LogonEvent* event, const Session& sn);

    virtual void onLogoutEvent(const LogoutEvent* event, const Session& sn) {};

    virtual void onUnexpectedMessageEvent(const UnexpectedMessageEvent* /*apEvent*/, const Session& /*aSn*/){}

    virtual void onSequenceGapEvent(const SequenceGapEvent* event, const Session& sn) {};

    virtual void onSessionLevelRejectEvent(const SessionLevelRejectEvent* event, const Session& sn) {};

    virtual void onMsgRejectEvent(const MsgRejectEvent* event, const Session& sn) {};

    virtual void onHeartbeatWithTestReqIDEvent(const HeartbeatWithTestReqIDEvent& event, const Session& sn) {};

    virtual void onResendRequestEvent(const ResendRequestEvent& event, const Session& sn) {};

    virtual void onNewStateEvent(const NewStateEvent& event, const Session& sn) {};

    virtual void onUnableToRouteMessage(const UnableToRouteMessageEvent& event, const Session& sn) {};

    virtual bool onResend(const FIXMessage& msg, const Session& sn) {return true;}

    //Comand executers
    void executeHelp(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeSessionStatus(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeSessionList(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeSessionStat(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeGeneralSessionsStat(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);


    void executeCreateAcceptor(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeDelete(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeAverageReceivedStat(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeAverageSentStat(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeAverageValidateStat(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeReceivedStat(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeSentStat(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeProceedStat(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeToBackup(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeChangeSeqNum(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeResetSeqNum(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeTestRequest(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeHeartbeat(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeSendMessage(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

    void executeDeleteAll(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const Context& context);

protected:


    bool getChildNodeValue(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const XMLCh* name, std::string* value ) const;

    bool getChildNodeValues(
          const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* parentNode, 
          const XMLCh* subnodeName,
          const XMLCh* paramName, 
          std::list<std::string>& values ) const;


    bool getChildNodeValues(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const XMLCh* name, std::list<std::string>& values ) const;


    bool getChildNodeValueInt(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const XMLCh* name, int* value, std::string* ) const;

    bool getChildNodeValueBool(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, const XMLCh* name, bool* value, std::string* ) const;

private:

    FIXMessage* createLogon(FIXVersion version, const SessionExtraParameters* params, int HBI) const;

    bool getSenderTarget(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, std::string* sender, std::string* target, const Context& context) const;

    bool getVersionType(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* element, FIXVersion* version, std::string* type, const Context& context) const;

    void createMsgProtocolTypeTSet(FIXVersion version, const std::string& type, std::set<StatisticsProvider::MsgProtocolTypeT>* typeSet) const ;

    Session* findSession(const std::string& sender, const std::string& target, const Context& context) const;

    void terminateSession(Session* session, bool sendLogout, const std::string& logoutReason) const;

        void clearSessionList();

private:

    typedef std::map<std::string, Session*> SESSIONS_CONTAINER;

    SESSIONS_CONTAINER sessions_;

    bool bStopped_;

    System::Mutex lock_;
};

} // namespace Engine

#endif //__B2BITS_AdminApplication_h__

---