XrdClXRootDResponses.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Copyright (c) 2011-2012 by European Organization for Nuclear Research (CERN)
// 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_XROOTD_RESPONSES_HH__
#define __XRD_CL_XROOTD_RESPONSES_HH__
 
#include "XrdCl/XrdClBuffer.hh"
#include "XrdCl/XrdClStatus.hh"
#include "XrdCl/XrdClURL.hh"
#include "XrdCl/XrdClAnyObject.hh"
#include "XProtocol/XProtocol.hh"
 
#include <string>
#include <vector>
#include <list>
#include <ctime>
#include <tuple>
#include <memory>
#include <functional>
 
#include <sys/uio.h>
 
namespace XrdCl
{
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class LocationInfo
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum LocationType
      {
        ManagerOnline,   
        ManagerPending,  
        ServerOnline,    
        ServerPending    
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum AccessType
      {
        Read,            
        ReadWrite        
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      class Location
      {
        public:
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          Location( const std::string  &address,
                    LocationType        type,
                    AccessType          access ):
            pAddress( address ),
            pType( type ),
            pAccess( access ) {}
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          const std::string &GetAddress() const
          {
            return pAddress;
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          LocationType GetType() const
          {
            return pType;
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          AccessType GetAccessType() const
          {
            return pAccess;
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          bool IsServer() const
          {
            return pType == ServerOnline || pType == ServerPending;
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          bool IsManager() const
          {
            return pType == ManagerOnline || pType == ManagerPending;
          }
 
        private:
          std::string  pAddress;
          LocationType pType;
          AccessType   pAccess;
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      typedef std::vector<Location>        LocationList;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      typedef LocationList::iterator       Iterator;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      typedef LocationList::const_iterator ConstIterator;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      LocationInfo();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~LocationInfo() {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint32_t GetSize() const
      {
        return pLocations.size();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Location &At( uint32_t index )
      {
        return pLocations[index];
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Iterator Begin()
      {
        return pLocations.begin();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ConstIterator Begin() const
      {
        return pLocations.begin();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Iterator End()
      {
        return pLocations.end();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ConstIterator End() const
      {
        return pLocations.end();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void Add( const Location &location )
      {
        pLocations.push_back( location );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool ParseServerResponse( const char *data );
 
    private:
      bool ProcessLocation( std::string &location );
      LocationList pLocations;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class XRootDStatus: public Status
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus( uint16_t           st      = 0,
                    uint16_t           code    = 0,
                    uint32_t           errN    = 0,
                    const std::string &message = "" ):
        Status( st, code, errN ),
        pMessage( message ) {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus( const Status      &st,
                    const std::string &message = "" ):
        Status( st ),
        pMessage( message ) {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string &GetErrorMessage() const
      {
        return pMessage;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetErrorMessage( const std::string &message )
      {
        pMessage = message;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToStr() const
      {
        if( code == errErrorResponse )
        {
          std::ostringstream o;
          o << "[ERROR] Server responded with an error: [" << errNo << "] ";
          o << pMessage << std::endl;
          return o.str();
        }
        std::string str = ToString();
        if( !pMessage.empty() )
          str += ": " + pMessage;
        return str;
      }
 
    private:
      std::string pMessage;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  enum
  {
    xattr_name  = 0,
    xattr_value = 1
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  typedef std::tuple<std::string, std::string> xattr_t;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  struct XAttrStatus
  {
      friend class FileStateHandler;
      friend class FileSystem;
 
      XAttrStatus( const std::string &name, const XRootDStatus &status ) :
        name( name ), status( status )
      {
 
      }
 
      virtual ~XAttrStatus(){}
 
      std::string name;
      XRootDStatus status;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  struct XAttr : public XAttrStatus
  {
      friend class FileStateHandler;
      friend class FileSystem;
 
      XAttr( const std::string  &name, const XRootDStatus &status ) :
        XAttrStatus( name, status )
      {
 
      }
 
      XAttr( const std::string  &name, const std::string &value = "",
             const XRootDStatus &status = XRootDStatus() ) :
        XAttrStatus( name, status ), value( value )
      {
 
      }
 
      virtual ~XAttr(){}
 
      std::string value;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  typedef Buffer BinaryDataInfo;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class ProtocolInfo
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum HostTypes
      {
        IsManager = kXR_isManager,   
        IsServer  = kXR_isServer,    
        AttrCache = kXR_attrCache,   
        AttrMeta  = kXR_attrMeta,    
        AttrProxy = kXR_attrProxy,   
        AttrSuper = kXR_attrSuper    
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ProtocolInfo( uint32_t version, uint32_t hostInfo ):
        pVersion( version ), pHostInfo( hostInfo ) {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~ProtocolInfo() {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint32_t GetVersion() const
      {
        return pVersion;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint32_t GetHostInfo() const
      {
        return pHostInfo;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool TestHostInfo( uint32_t flags )
      {
        return pHostInfo & flags;
      }
 
    private:
      uint32_t pVersion;
      uint32_t pHostInfo;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  struct StatInfoImpl;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class StatInfo
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum Flags
      {
        XBitSet      = kXR_xset,      
        IsDir        = kXR_isDir,     
        Other        = kXR_other,     
        Offline      = kXR_offline,   
        POSCPending  = kXR_poscpend,  
        IsReadable   = kXR_readable,  
        IsWritable   = kXR_writable,  
        BackUpExists = kXR_bkpexist   
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      StatInfo();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      StatInfo( const std::string &id, uint64_t size, uint32_t flags,
                uint64_t modTime );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      StatInfo( const StatInfo &info );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~StatInfo();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string& GetId() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint64_t GetSize() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetSize( uint64_t size );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint32_t GetFlags() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetFlags( uint32_t flags );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool TestFlags( uint32_t flags ) const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint64_t GetModTime() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetModTimeAsString() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint64_t GetChangeTime() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetChangeTimeAsString() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint64_t GetAccessTime() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetAccessTimeAsString() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string& GetModeAsString() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string GetModeAsOctString() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string& GetOwner() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string& GetGroup() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string& GetChecksum() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool ParseServerResponse( const char *data );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool ExtendedFormat() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool HasChecksum() const;
 
    private:
 
      static inline std::string TimeToString( uint64_t time )
      {
        char ts[256];
        time_t modTime = time;
        tm t;
        localtime_r( &modTime, &t );
        strftime( ts, sizeof( ts ), "%F %T %z", &t );
        return ts;
      }
 
      static inline void OctToString( uint8_t oct, std::string &str )
      {
        static const uint8_t r_mask = 0x4;
        static const uint8_t w_mask = 0x2;
        static const uint8_t x_mask = 0x1;
 
        if( r_mask & oct ) str.push_back( 'r' );
        else str.push_back( '-' );
 
        if( w_mask & oct ) str.push_back( 'w' );
        else str.push_back( '-' );
 
        if( x_mask & oct ) str.push_back( 'x' );
        else str.push_back( '-' );
      }
 
      std::unique_ptr<StatInfoImpl> pImpl;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class StatInfoVFS
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      StatInfoVFS();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~StatInfoVFS() {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint64_t GetNodesRW() const
      {
        return pNodesRW;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint64_t GetFreeRW() const
      {
        return pFreeRW;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint8_t GetUtilizationRW() const
      {
        return pUtilizationRW;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint64_t GetNodesStaging() const
      {
        return pNodesStaging;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint64_t GetFreeStaging() const
      {
        return pFreeStaging;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint8_t GetUtilizationStaging() const
      {
        return pUtilizationStaging;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool ParseServerResponse( const char *data );
 
    private:
 
      //------------------------------------------------------------------------
      // kXR_vfs stat
      //------------------------------------------------------------------------
      uint64_t    pNodesRW;
      uint64_t    pFreeRW;
      uint32_t    pUtilizationRW;
      uint64_t    pNodesStaging;
      uint64_t    pFreeStaging;
      uint32_t    pUtilizationStaging;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class DirectoryList
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      class ListEntry
      {
        public:
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          ListEntry( const std::string &hostAddress,
                     const std::string &name,
                     StatInfo          *statInfo = 0):
            pHostAddress( hostAddress ),
            pName( SanitizeName( name ) ),
            pStatInfo( statInfo )
          {}
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          ~ListEntry()
          {
            delete pStatInfo;
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          const std::string &GetHostAddress() const
          {
            return pHostAddress;
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          const std::string &GetName() const
          {
            return pName;
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          StatInfo *GetStatInfo()
          {
            return pStatInfo;
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          const StatInfo *GetStatInfo() const
          {
            return pStatInfo;
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          void SetStatInfo( StatInfo *info )
          {
            pStatInfo = info;
          }
 
        private:
 
          inline static std::string SanitizeName( const std::string &name )
          {
            const char *cstr = name.c_str();
            while( *cstr == '/' ) // the C string is guaranteed to end with '\0'
              ++cstr;
            return cstr;
          }
 
          std::string  pHostAddress;
          std::string  pName;
          StatInfo    *pStatInfo;
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      DirectoryList();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~DirectoryList();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      typedef std::vector<ListEntry*>  DirList;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      typedef DirList::iterator       Iterator;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      typedef DirList::const_iterator ConstIterator;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void Add( ListEntry *entry )
      {
        pDirList.push_back( entry );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ListEntry *At( uint32_t index )
      {
        return pDirList[index];
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Iterator Begin()
      {
        return pDirList.begin();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ConstIterator Begin() const
      {
        return pDirList.begin();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Iterator End()
      {
        return pDirList.end();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ConstIterator End() const
      {
        return pDirList.end();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint32_t GetSize() const
      {
        return pDirList.size();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string &GetParentName() const
      {
        return pParent;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetParentName( const std::string &parent )
      {
        size_t pos = parent.find( '?' );
        pParent = pos == std::string::npos ? parent : parent.substr( 0, pos );
        if( !pParent.empty() && pParent[pParent.length()-1] != '/' )
          pParent += "/";
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool ParseServerResponse( const std::string &hostId,
                                const char *data );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool ParseServerResponse( const std::string &hostId,
                                const char *data,
                                bool isDStat );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static bool HasStatInfo( const char *data );
 
    private:
      DirList     pDirList;
      std::string pParent;
 
      static const std::string dStatPrefix;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class OpenInfo
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      OpenInfo( const uint8_t *fileHandle,
                uint64_t       sessionId,
                StatInfo *statInfo        = 0 ):
        pSessionId(sessionId), pStatInfo( statInfo )
      {
        memcpy( pFileHandle, fileHandle, 4 );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~OpenInfo()
      {
        delete pStatInfo;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void GetFileHandle( uint8_t *fileHandle ) const
      {
        memcpy( fileHandle, pFileHandle, 4 );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const StatInfo *GetStatInfo() const
      {
        return pStatInfo;
      }
 
      //------------------------------------------------------------------------
      // Get session ID
      //------------------------------------------------------------------------
      uint64_t GetSessionId() const
      {
        return pSessionId;
      }
 
    private:
      uint8_t   pFileHandle[4];
      uint64_t  pSessionId;
      StatInfo *pStatInfo;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  struct ChunkInfo
  {
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    ChunkInfo( uint64_t off = 0, uint32_t len = 0, void *buff = 0 ):
      offset( off ), length( len ), buffer(buff) {}
 
      //--------------------------------------------------------------------------
      //--------------------------------------------------------------------------
      virtual ~ChunkInfo() {}
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline uint64_t GetOffset() const
    {
      return offset;
    }
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline uint32_t GetLength() const
    {
      return length;
    }
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline void* GetBuffer()
    {
      return buffer;
    }
 
    uint64_t  offset; 
    uint32_t  length; 
    void     *buffer; 
  };
 
  struct PageInfoImpl;
 
  struct PageInfo
  {
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    PageInfo( uint64_t offset = 0, uint32_t length = 0, void *buffer = 0,
              std::vector<uint32_t> &&cksums = std::vector<uint32_t>() );
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    PageInfo( PageInfo &&pginf );
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    PageInfo& operator=( PageInfo &&pginf );
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    virtual ~PageInfo();
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    uint64_t GetOffset() const;
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    uint32_t GetLength() const;
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    void* GetBuffer();
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    std::vector<uint32_t>& GetCksums();
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    size_t GetNbRepair();
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    void SetNbRepair( size_t nbrepair );
 
    private:
      //--------------------------------------------------------------------------
      //--------------------------------------------------------------------------
      std::unique_ptr<PageInfoImpl> pImpl;
  };
 
  struct RetryInfoImpl;
 
  struct RetryInfo
  {
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    RetryInfo( std::vector<std::tuple<uint64_t, uint32_t>> && retries );
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    virtual ~RetryInfo();
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    bool NeedRetry();
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    size_t Size();
 
    //----------------------------------------------------------------------------
    //            retransmitted
    //----------------------------------------------------------------------------
    std::tuple<uint64_t, uint32_t> At( size_t i );
 
    private:
      //--------------------------------------------------------------------------
      //--------------------------------------------------------------------------
      std::unique_ptr<RetryInfoImpl> pImpl;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class  File;
 
  struct TractInfo
  {
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    TractInfo( uint64_t off = 0, uint32_t len = 0, File* fp = 0 ):
      offset( off ), length( len ), pFile( fp ) {}
 
      //--------------------------------------------------------------------------
      //--------------------------------------------------------------------------
      virtual ~TractInfo() {}
 
    uint64_t offset; 
    uint32_t length; 
    File*    pFile;  
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  typedef std::vector<ChunkInfo> ChunkList;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  typedef std::vector<TractInfo> TractList;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class VectorReadInfo
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      VectorReadInfo(): pSize( 0 ) {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~VectorReadInfo() {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint32_t GetSize() const
      {
        return pSize;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetSize( uint32_t size )
      {
        pSize = size;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ChunkList &GetChunks()
      {
        return pChunks;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const ChunkList &GetChunks() const
      {
        return pChunks;
      }
 
    private:
      ChunkList pChunks;
      uint32_t  pSize;
  };
 
  //----------------------------------------------------------------------------
  // List of URLs
  //----------------------------------------------------------------------------
  struct HostInfo
  {
    HostInfo():
      flags(0), protocol(0), loadBalancer(false) {}
    HostInfo( const URL &u, bool lb = false ):
      flags(0), protocol(0), loadBalancer(lb), url(u) {}
    virtual ~HostInfo(){};
 
    uint32_t flags;        
    uint32_t protocol;     
    bool     loadBalancer; 
    URL      url;          
  };
 
  typedef std::vector<HostInfo> HostList;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class ResponseHandler
  {
    public:
      virtual ~ResponseHandler() {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void HandleResponseWithHosts( XRootDStatus *status,
                                            AnyObject    *response,
                                            HostList     *hostList )
      {
        delete hostList;
        HandleResponse( status, response );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void HandleResponse( XRootDStatus *status,
                                   AnyObject    *response )
      {
        (void)status; (void)response;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static ResponseHandler* Wrap( std::function<void(XRootDStatus&, AnyObject&)> func );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static ResponseHandler* Wrap( std::function<void(XRootDStatus*, AnyObject*)> func );
  };
}
 
#endif // __XRD_CL_XROOTD_RESPONSES_HH__