TXConnectionMgr

class TXConnectionMgr : public TXAbsUnsolicitedMsgHandler, public TXUnsolicitedMsgSender

    private:

      virtual Bool_t ProcessUnsolicitedMsg(TXUnsolicitedMsgSender* sender, TXMessage* unsolmsg)
                void RemoveLogConn(TXLogConnection*)
                void RemovePhyConn(TXPhyConnection*)

    protected:

      void GarbageCollect()

    public:

                       TXConnectionMgr()
                       TXConnectionMgr(const TXConnectionMgr&)
               virtual ~TXConnectionMgr()
        static TClass* Class()
               Short_t Connect(TString RemoteAddress, Int_t TcpPort, Int_t TcpWindowSize)
                  void Disconnect(Short_t LogConnectionID, Bool_t ForcePhysicalDisc)
      TXLogConnection* GetConnection(Short_t LogConnectionID)
                 short GetPhyConnectionRefCount(TXPhyConnection* PhyConn)
                  void Init()
       virtual TClass* IsA() const
      TXConnectionMgr& operator=(const TXConnectionMgr&)
            TXMessage* ReadMsg(Short_t LogConnectionID, ESendRecvOptions opt = kDefault)
                 Int_t ReadRaw(Short_t LogConnectionID, void* buffer, Int_t BufferLength, ESendRecvOptions opt = kDefault)
          virtual void ShowMembers(TMemberInspector& insp, char* parent)
          virtual void Streamer(TBuffer& b)
                  void StreamerNVirtual(TBuffer& b)
                Bool_t ThreadKilled() const
                 Int_t WriteRaw(Short_t LogConnectionID, const void* buffer, Int_t BufferLength, ESendRecvOptions opt = kDefault)

Data Members

    private:

                        Bool_t fInitialized    
      vector<TXLogConnection*> fLogVec         
      vector<TXPhyConnection*> fPhyVec         
                       TMutex* fMutex          mutex used to protect local variables
                      TThread* fThreadHandler  
                        Bool_t fThreadKilled   

Class Description

                                                                      
 TXConnectionMgr                                                      
                                                                      
 Authors: Alvise Dorigo, Fabrizio Furano                              
          INFN Padova, 2003                                           
                                                                      
 The Connection Manager handles socket communications for TXNetFile   
 action: connect, disconnect, read, write. It is a static object of   
 the TXNetFile class such that within a single application multiple   
 TXNetFile objects share the same connection manager.                 
 The connection manager maps multiple logical connections on a single 
 physical connection.                                                 
 There is one and only one logical connection per client (XNTetFile   
 object), and one and only one physical connection per server:port.   
 Thus multiple TXNetFile objects withing a given application share    
 the same physical TCP channel to communicate with the server.        
 This reduces the time overhead for socket creation and reduces also  
 the server load due to handling many sockets.                        
                                                                      

 TXConnectionMgr constructor.
 Used only to create the static instance when loading libNetx.

 Full initialization of the TXConnectionMgr instance.
 Creates a Connection Manager object.
 Starts the garbage collector thread, if requested

 Deletes mutex locks, stops garbage collector thread.

 Get rid of unused physical connections. 'Unused' means not used for a
 TTL time from any logical one. The TTL depends on the kind of remote
 server. For a load balancer the TTL is very high, while for a data server
 is quite small.

 Deletes a logical connection.
 Also deletes the related physical one if ForcePhysicalDisc=TRUE.

 Read BufferLength bytes from the logical connection LogConnectionID

 Write BufferLength bytes into the logical connection LogConnectionID

 Return a logical connection object that has LogConnectionID as its ID.

 We are here if an unsolicited response comes from a physical connection
 The response comes in the form of an TXMessage *, that must NOT be
 destroyed after processing. It is destroyed by the first sender.
 Remember that we are in a separate thread, since unsolicited responses
 are asynchronous by nature.

 Remove logc from the list of logical connections

 Remove phyc from the list of physical connections

Inline Functions

                 Short_t Connect(TString RemoteAddress, Int_t TcpPort, Int_t TcpWindowSize)
                   short GetPhyConnectionRefCount(TXPhyConnection* PhyConn)
                  Bool_t ThreadKilled() const
                 TClass* Class()
                 TClass* IsA() const
                    void ShowMembers(TMemberInspector& insp, char* parent)
                    void Streamer(TBuffer& b)
                    void StreamerNVirtual(TBuffer& b)
         TXConnectionMgr TXConnectionMgr(const TXConnectionMgr&)
        TXConnectionMgr& operator=(const TXConnectionMgr&)