XrdClMonitor.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Copyright (c) 2012 by the Board of Trustees of the Leland Stanford, Jr.,
// University
// Copyright (c) 2012 by European Organization for Nuclear Research (CERN)
// Author: Andrew Hanushevsky <abh@stanford.edu>
// Author: Lukasz Janyst <ljanyst@cern.ch>
//------------------------------------------------------------------------------
// XRootD is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// XRootD is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#ifndef __XRD_CL_MONITOR_HH__
#define __XRD_CL_MONITOR_HH__

#include "XrdCl/XrdClFileSystem.hh"

namespace XrdCl
{
  class URL;

  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class Monitor
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Monitor() {}

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~Monitor() {}

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      struct ConnectInfo
      {
        ConnectInfo(): streams( 0 )
        {
          sTOD.tv_sec = 0; sTOD.tv_usec = 0;
          eTOD.tv_sec = 0; eTOD.tv_usec = 0;
        }
        std::string server;  
        std::string auth;    
        timeval     sTOD;    
        timeval     eTOD;    
        uint16_t    streams; 
      };

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      struct DisconnectInfo
      {
        DisconnectInfo(): rBytes(0), sBytes(0), cTime(0)
        {}
        std::string server;  
        uint64_t    rBytes;  
        uint64_t    sBytes;  
        time_t      cTime;   
        Status      status;  
      };

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      struct OpenInfo
      {
        OpenInfo(): file(0), fSize(0), oFlags(0) {}
        const URL   *file;        
        std::string  dataServer;  
        uint64_t     fSize;       
        uint16_t     oFlags;      
      };

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      struct CloseInfo
      {
        CloseInfo():
          file(0), rBytes(0), vBytes(0), wBytes(0), vSegs(0), rCount(0),
          vCount(0), wCount(0), status(0)
        {
          oTOD.tv_sec = 0; oTOD.tv_usec = 0;
          cTOD.tv_sec = 0; cTOD.tv_usec = 0;
        }
        const URL          *file;    
        timeval             oTOD;    
        timeval             cTOD;    
        uint64_t            rBytes;  
        uint64_t            vBytes;  
        uint64_t            wBytes;  
        uint64_t            vSegs;   
        uint32_t            rCount;  
        uint32_t            vCount;  
        uint32_t            wCount;  
        const XRootDStatus *status;  
      };

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      struct ErrorInfo
      {
        enum Operation
        {
          ErrOpen = 0,  
          ErrRead,      
          ErrReadV,     
          ErrWrite,     
          ErrUnc        
        };

        ErrorInfo(): file(0), status(0), opCode( ErrUnc ) {}
        const URL          *file;    
        const XRootDStatus *status;  
        Operation           opCode;  
      };

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      struct TransferInfo
      {
        TransferInfo(): origin(0), target(0) {}
        const URL *origin;  
        const URL *target;  
      };

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      struct CopyBInfo
      {
        TransferInfo transfer; 
      };

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      struct CopyEInfo
      {
        CopyEInfo(): sources(0), status(0)
        {
          bTOD.tv_sec = 0; bTOD.tv_usec = 0;
          eTOD.tv_sec = 0; eTOD.tv_usec = 0;
        }
        TransferInfo        transfer; 
        int                 sources;  
        timeval             bTOD;     
        timeval             eTOD;     
        const XRootDStatus *status;   
      };

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      struct CheckSumInfo
      {
        CheckSumInfo(): oTime(0), tTime(0), isOK(false) {}
        TransferInfo transfer;  
        std::string  cksum;     
        uint64_t     oTime;     
        uint64_t     tTime;     
        bool         isOK;      
      };

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum EventCode
      {
        EvCopyBeg,        
        EvCopyEnd,        
        EvCheckSum,       
        EvOpen,           
        EvClose,          
        EvErrIO,          
        EvConnect,        
        EvDisconnect      

      };

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void Event( EventCode evCode, void *evData ) = 0;
  };
}

#endif // __XRD_CL_MONITOR_HH