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>
 
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();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  typedef Buffer BinaryDataInfo;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class ProtocolInfo
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum HostTypes
      {
        IsManager = kXR_isManager,   
        IsServer  = kXR_isServer,    
        AttrMeta  = kXR_attrMeta,    
        AttrProxy = kXR_attrProxy,   
        AttrSuper = kXR_attrSuper    
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ProtocolInfo( uint32_t version, uint32_t hostInfo ):
        pVersion( version ), pHostInfo( hostInfo ) {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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);
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string GetId() const
      {
        return pId;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint64_t GetSize() const
      {
        return pSize;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint32_t GetFlags() const
      {
        return pFlags;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool TestFlags( uint32_t flags ) const
      {
        return pFlags & flags;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      uint64_t GetModTime() const
      {
        return pModTime;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetModTimeAsString() const
      {
        char ts[256];
        time_t modTime = pModTime;
        tm *t = gmtime( &modTime );
        strftime( ts, 255, "%F %T", t );
        return ts;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool ParseServerResponse( const char *data );
 
    private:
 
      //------------------------------------------------------------------------
      // Normal stat
      //------------------------------------------------------------------------
      std::string pId;
      uint64_t    pSize;
      uint32_t    pFlags;
      uint64_t    pModTime;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class StatInfoVFS
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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( 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:
          std::string  pHostAddress;
          std::string  pName;
          StatInfo    *pStatInfo;
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      DirectoryList();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ~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 );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ~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) {}
 
    uint64_t  offset; 
    uint32_t  length; 
    void     *buffer; 
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  typedef std::vector<ChunkInfo> ChunkList;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class VectorReadInfo
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      VectorReadInfo(): pSize( 0 ) {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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) {}
    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;
      }
  };
}
 
#endif // __XRD_CL_XROOTD_RESPONSES_HH__