XrdClXRootDResponses.hh

Go to the documentation of this file.
00001 //------------------------------------------------------------------------------
00002 // Copyright (c) 2011-2012 by European Organization for Nuclear Research (CERN)
00003 // Author: Lukasz Janyst <ljanyst@cern.ch>
00004 //------------------------------------------------------------------------------
00005 // XRootD is free software: you can redistribute it and/or modify
00006 // it under the terms of the GNU Lesser General Public License as published by
00007 // the Free Software Foundation, either version 3 of the License, or
00008 // (at your option) any later version.
00009 //
00010 // XRootD is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 // GNU General Public License for more details.
00014 //
00015 // You should have received a copy of the GNU Lesser General Public License
00016 // along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
00017 //------------------------------------------------------------------------------
00018 
00019 #ifndef __XRD_CL_XROOTD_RESPONSES_HH__
00020 #define __XRD_CL_XROOTD_RESPONSES_HH__
00021 
00022 #include "XrdCl/XrdClBuffer.hh"
00023 #include "XrdCl/XrdClStatus.hh"
00024 #include "XrdCl/XrdClURL.hh"
00025 #include "XrdCl/XrdClAnyObject.hh"
00026 #include "XProtocol/XProtocol.hh"
00027 #include <string>
00028 #include <vector>
00029 #include <list>
00030 #include <ctime>
00031 
00032 namespace XrdCl
00033 {
00034   //----------------------------------------------------------------------------
00036   //----------------------------------------------------------------------------
00037   class LocationInfo
00038   {
00039     public:
00040       //------------------------------------------------------------------------
00042       //------------------------------------------------------------------------
00043       enum LocationType
00044       {
00045         ManagerOnline,   
00046         ManagerPending,  
00047         ServerOnline,    
00048         ServerPending    
00049       };
00050 
00051       //------------------------------------------------------------------------
00053       //------------------------------------------------------------------------
00054       enum AccessType
00055       {
00056         Read,            
00057         ReadWrite        
00058       };
00059 
00060       //------------------------------------------------------------------------
00062       //------------------------------------------------------------------------
00063       class Location
00064       {
00065         public:
00066 
00067           //--------------------------------------------------------------------
00069           //--------------------------------------------------------------------
00070           Location( const std::string  &address,
00071                     LocationType        type,
00072                     AccessType          access ):
00073             pAddress( address ),
00074             pType( type ),
00075             pAccess( access ) {}
00076 
00077           //--------------------------------------------------------------------
00079           //--------------------------------------------------------------------
00080           const std::string &GetAddress() const
00081           {
00082             return pAddress;
00083           }
00084 
00085           //--------------------------------------------------------------------
00087           //--------------------------------------------------------------------
00088           LocationType GetType() const
00089           {
00090             return pType;
00091           }
00092 
00093           //--------------------------------------------------------------------
00095           //--------------------------------------------------------------------
00096           AccessType GetAccessType() const
00097           {
00098             return pAccess;
00099           }
00100 
00101           //--------------------------------------------------------------------
00103           //--------------------------------------------------------------------
00104           bool IsServer() const
00105           {
00106             return pType == ServerOnline || pType == ServerPending;
00107           }
00108 
00109           //--------------------------------------------------------------------
00111           //--------------------------------------------------------------------
00112           bool IsManager() const
00113           {
00114             return pType == ManagerOnline || pType == ManagerPending;
00115           }
00116 
00117         private:
00118           std::string  pAddress;
00119           LocationType pType;
00120           AccessType   pAccess;
00121       };
00122 
00123       //------------------------------------------------------------------------
00125       //------------------------------------------------------------------------
00126       typedef std::vector<Location>        LocationList;
00127 
00128       //------------------------------------------------------------------------
00130       //------------------------------------------------------------------------
00131       typedef LocationList::iterator       Iterator;
00132 
00133       //------------------------------------------------------------------------
00135       //------------------------------------------------------------------------
00136       typedef LocationList::const_iterator ConstIterator;
00137 
00138       //------------------------------------------------------------------------
00140       //------------------------------------------------------------------------
00141       LocationInfo();
00142 
00143       //------------------------------------------------------------------------
00145       //------------------------------------------------------------------------
00146       uint32_t GetSize() const
00147       {
00148         return pLocations.size();
00149       }
00150 
00151       //------------------------------------------------------------------------
00153       //------------------------------------------------------------------------
00154       Location &At( uint32_t index )
00155       {
00156         return pLocations[index];
00157       }
00158 
00159       //------------------------------------------------------------------------
00161       //------------------------------------------------------------------------
00162       Iterator Begin()
00163       {
00164         return pLocations.begin();
00165       }
00166 
00167       //------------------------------------------------------------------------
00169       //------------------------------------------------------------------------
00170       ConstIterator Begin() const
00171       {
00172         return pLocations.begin();
00173       }
00174 
00175       //------------------------------------------------------------------------
00177       //------------------------------------------------------------------------
00178       Iterator End()
00179       {
00180         return pLocations.end();
00181       }
00182 
00183       //------------------------------------------------------------------------
00185       //------------------------------------------------------------------------
00186       ConstIterator End() const
00187       {
00188         return pLocations.end();
00189       }
00190 
00191       //------------------------------------------------------------------------
00193       //------------------------------------------------------------------------
00194       void Add( const Location &location )
00195       {
00196         pLocations.push_back( location );
00197       }
00198 
00199       //------------------------------------------------------------------------
00201       //------------------------------------------------------------------------
00202       bool ParseServerResponse( const char *data );
00203 
00204     private:
00205       bool ProcessLocation( std::string &location );
00206       LocationList pLocations;
00207   };
00208 
00209   //----------------------------------------------------------------------------
00211   //----------------------------------------------------------------------------
00212   class XRootDStatus: public Status
00213   {
00214     public:
00215       //------------------------------------------------------------------------
00217       //------------------------------------------------------------------------
00218       XRootDStatus( uint16_t           st      = 0,
00219                     uint16_t           code    = 0,
00220                     uint32_t           errN    = 0,
00221                     const std::string &message = "" ):
00222         Status( st, code, errN ),
00223         pMessage( message ) {}
00224 
00225       //------------------------------------------------------------------------
00227       //------------------------------------------------------------------------
00228       XRootDStatus( const Status      &st,
00229                     const std::string &message = "" ):
00230         Status( st ),
00231         pMessage( message ) {}
00232 
00233       //------------------------------------------------------------------------
00235       //------------------------------------------------------------------------
00236       const std::string &GetErrorMessage() const
00237       {
00238         return pMessage;
00239       }
00240 
00241       //------------------------------------------------------------------------
00243       //------------------------------------------------------------------------
00244       void SetErrorMessage( const std::string &message )
00245       {
00246         pMessage = message;
00247       }
00248 
00249       //------------------------------------------------------------------------
00251       //------------------------------------------------------------------------
00252       std::string ToStr() const
00253       {
00254         if( code == errErrorResponse )
00255         {
00256           std::ostringstream o;
00257           o << "[ERROR] Server responded with an error: [" << errNo << "] ";
00258           o << pMessage << std::endl;
00259           return o.str();
00260         }
00261         std::string str = ToString();
00262         if( !pMessage.empty() )
00263           str += ": " + pMessage;
00264         return str;
00265       }
00266 
00267     private:
00268       std::string pMessage;
00269   };
00270 
00271   //----------------------------------------------------------------------------
00273   //----------------------------------------------------------------------------
00274   typedef Buffer BinaryDataInfo;
00275 
00276   //----------------------------------------------------------------------------
00278   //----------------------------------------------------------------------------
00279   class ProtocolInfo
00280   {
00281     public:
00282       //------------------------------------------------------------------------
00284       //------------------------------------------------------------------------
00285       enum HostTypes
00286       {
00287         IsManager = kXR_isManager,   
00288         IsServer  = kXR_isServer,    
00289         AttrMeta  = kXR_attrMeta,    
00290         AttrProxy = kXR_attrProxy,   
00291         AttrSuper = kXR_attrSuper    
00292       };
00293 
00294       //------------------------------------------------------------------------
00296       //------------------------------------------------------------------------
00297       ProtocolInfo( uint32_t version, uint32_t hostInfo ):
00298         pVersion( version ), pHostInfo( hostInfo ) {}
00299 
00300       //------------------------------------------------------------------------
00302       //------------------------------------------------------------------------
00303       uint32_t GetVersion() const
00304       {
00305         return pVersion;
00306       }
00307 
00308       //------------------------------------------------------------------------
00310       //------------------------------------------------------------------------
00311       uint32_t GetHostInfo() const
00312       {
00313         return pHostInfo;
00314       }
00315 
00316       //------------------------------------------------------------------------
00318       //------------------------------------------------------------------------
00319       bool TestHostInfo( uint32_t flags )
00320       {
00321         return pHostInfo & flags;
00322       }
00323 
00324     private:
00325       uint32_t pVersion;
00326       uint32_t pHostInfo;
00327   };
00328 
00329   //----------------------------------------------------------------------------
00331   //----------------------------------------------------------------------------
00332   class StatInfo
00333   {
00334     public:
00335       //------------------------------------------------------------------------
00337       //------------------------------------------------------------------------
00338       enum Flags
00339       {
00340         XBitSet      = kXR_xset,      
00341         IsDir        = kXR_isDir,     
00342         Other        = kXR_other,     
00343         Offline      = kXR_offline,   
00344         POSCPending  = kXR_poscpend,  
00345 
00346         IsReadable   = kXR_readable,  
00347         IsWritable   = kXR_writable,  
00348         BackUpExists = kXR_bkpexist   
00349       };
00350 
00351       //------------------------------------------------------------------------
00353       //------------------------------------------------------------------------
00354       StatInfo();
00355 
00356       //------------------------------------------------------------------------
00358       //------------------------------------------------------------------------
00359       const std::string GetId() const
00360       {
00361         return pId;
00362       }
00363 
00364       //------------------------------------------------------------------------
00366       //------------------------------------------------------------------------
00367       uint64_t GetSize() const
00368       {
00369         return pSize;
00370       }
00371 
00372       //------------------------------------------------------------------------
00374       //------------------------------------------------------------------------
00375       uint32_t GetFlags() const
00376       {
00377         return pFlags;
00378       }
00379 
00380       //------------------------------------------------------------------------
00382       //------------------------------------------------------------------------
00383       bool TestFlags( uint32_t flags ) const
00384       {
00385         return pFlags & flags;
00386       }
00387 
00388       //------------------------------------------------------------------------
00390       //------------------------------------------------------------------------
00391       uint64_t GetModTime() const
00392       {
00393         return pModTime;
00394       }
00395 
00396       //------------------------------------------------------------------------
00398       //------------------------------------------------------------------------
00399       std::string GetModTimeAsString() const
00400       {
00401         char ts[256];
00402         time_t modTime = pModTime;
00403         tm *t = gmtime( &modTime );
00404         strftime( ts, 255, "%F %T", t );
00405         return ts;
00406       }
00407 
00408       //------------------------------------------------------------------------
00410       //------------------------------------------------------------------------
00411       bool ParseServerResponse( const char *data );
00412 
00413     private:
00414 
00415       //------------------------------------------------------------------------
00416       // Normal stat
00417       //------------------------------------------------------------------------
00418       std::string pId;
00419       uint64_t    pSize;
00420       uint32_t    pFlags;
00421       uint64_t    pModTime;
00422   };
00423 
00424   //----------------------------------------------------------------------------
00426   //----------------------------------------------------------------------------
00427   class StatInfoVFS
00428   {
00429     public:
00430       //------------------------------------------------------------------------
00432       //------------------------------------------------------------------------
00433       StatInfoVFS();
00434 
00435       //------------------------------------------------------------------------
00437       //------------------------------------------------------------------------
00438       uint64_t GetNodesRW() const
00439       {
00440         return pNodesRW;
00441       }
00442 
00443       //------------------------------------------------------------------------
00445       //------------------------------------------------------------------------
00446       uint64_t GetFreeRW() const
00447       {
00448         return pFreeRW;
00449       }
00450 
00451       //------------------------------------------------------------------------
00453       //------------------------------------------------------------------------
00454       uint8_t GetUtilizationRW() const
00455       {
00456         return pUtilizationRW;
00457       }
00458 
00459       //------------------------------------------------------------------------
00461       //------------------------------------------------------------------------
00462       uint64_t GetNodesStaging() const
00463       {
00464         return pNodesStaging;
00465       }
00466 
00467       //------------------------------------------------------------------------
00469       //------------------------------------------------------------------------
00470       uint64_t GetFreeStaging() const
00471       {
00472         return pFreeStaging;
00473       }
00474 
00475       //------------------------------------------------------------------------
00477       //------------------------------------------------------------------------
00478       uint8_t GetUtilizationStaging() const
00479       {
00480         return pUtilizationStaging;
00481       }
00482 
00483       //------------------------------------------------------------------------
00485       //------------------------------------------------------------------------
00486       bool ParseServerResponse( const char *data );
00487 
00488     private:
00489 
00490       //------------------------------------------------------------------------
00491       // kXR_vfs stat
00492       //------------------------------------------------------------------------
00493       uint64_t    pNodesRW;
00494       uint64_t    pFreeRW;
00495       uint32_t    pUtilizationRW;
00496       uint64_t    pNodesStaging;
00497       uint64_t    pFreeStaging;
00498       uint32_t    pUtilizationStaging;
00499   };
00500 
00501   //----------------------------------------------------------------------------
00503   //----------------------------------------------------------------------------
00504   class DirectoryList
00505   {
00506     public:
00507       //------------------------------------------------------------------------
00509       //------------------------------------------------------------------------
00510       class ListEntry
00511       {
00512         public:
00513           //--------------------------------------------------------------------
00515           //--------------------------------------------------------------------
00516           ListEntry( const std::string &hostAddress,
00517                      const std::string &name,
00518                      StatInfo          *statInfo = 0):
00519             pHostAddress( hostAddress ),
00520             pName( name ),
00521             pStatInfo( statInfo )
00522           {}
00523 
00524           //--------------------------------------------------------------------
00526           //--------------------------------------------------------------------
00527           ~ListEntry()
00528           {
00529             delete pStatInfo;
00530           }
00531 
00532           //--------------------------------------------------------------------
00534           //--------------------------------------------------------------------
00535           const std::string &GetHostAddress() const
00536           {
00537             return pHostAddress;
00538           }
00539 
00540           //--------------------------------------------------------------------
00542           //--------------------------------------------------------------------
00543           const std::string &GetName() const
00544           {
00545             return pName;
00546           }
00547 
00548           //--------------------------------------------------------------------
00550           //--------------------------------------------------------------------
00551           StatInfo *GetStatInfo()
00552           {
00553             return pStatInfo;
00554           }
00555 
00556           //--------------------------------------------------------------------
00558           //--------------------------------------------------------------------
00559           const StatInfo *GetStatInfo() const
00560           {
00561             return pStatInfo;
00562           }
00563 
00564           //--------------------------------------------------------------------
00566           //--------------------------------------------------------------------
00567           void SetStatInfo( StatInfo *info )
00568           {
00569             pStatInfo = info;
00570           }
00571 
00572         private:
00573           std::string  pHostAddress;
00574           std::string  pName;
00575           StatInfo    *pStatInfo;
00576       };
00577 
00578       //------------------------------------------------------------------------
00580       //------------------------------------------------------------------------
00581       DirectoryList();
00582 
00583       //------------------------------------------------------------------------
00585       //------------------------------------------------------------------------
00586       ~DirectoryList();
00587 
00588       //------------------------------------------------------------------------
00590       //------------------------------------------------------------------------
00591       typedef std::vector<ListEntry*>  DirList;
00592 
00593       //------------------------------------------------------------------------
00595       //------------------------------------------------------------------------
00596       typedef DirList::iterator       Iterator;
00597 
00598       //------------------------------------------------------------------------
00600       //------------------------------------------------------------------------
00601       typedef DirList::const_iterator ConstIterator;
00602 
00603       //------------------------------------------------------------------------
00605       //------------------------------------------------------------------------
00606       void Add( ListEntry *entry )
00607       {
00608         pDirList.push_back( entry );
00609       }
00610 
00611       //------------------------------------------------------------------------
00613       //------------------------------------------------------------------------
00614       ListEntry *At( uint32_t index )
00615       {
00616         return pDirList[index];
00617       }
00618 
00619       //------------------------------------------------------------------------
00621       //------------------------------------------------------------------------
00622       Iterator Begin()
00623       {
00624         return pDirList.begin();
00625       }
00626 
00627       //------------------------------------------------------------------------
00629       //------------------------------------------------------------------------
00630       ConstIterator Begin() const
00631       {
00632         return pDirList.begin();
00633       }
00634 
00635       //------------------------------------------------------------------------
00637       //------------------------------------------------------------------------
00638       Iterator End()
00639       {
00640         return pDirList.end();
00641       }
00642 
00643       //------------------------------------------------------------------------
00645       //------------------------------------------------------------------------
00646       ConstIterator End() const
00647       {
00648         return pDirList.end();
00649       }
00650 
00651       //------------------------------------------------------------------------
00653       //------------------------------------------------------------------------
00654       uint32_t GetSize() const
00655       {
00656         return pDirList.size();
00657       }
00658 
00659       //------------------------------------------------------------------------
00661       //------------------------------------------------------------------------
00662       const std::string &GetParentName() const
00663       {
00664         return pParent;
00665       }
00666 
00667       //------------------------------------------------------------------------
00669       //------------------------------------------------------------------------
00670       void SetParentName( const std::string &parent )
00671       {
00672         size_t pos = parent.find( '?' );
00673         pParent = pos == std::string::npos ? parent : parent.substr( 0, pos );
00674         if( !pParent.empty() && pParent[pParent.length()-1] != '/' )
00675           pParent += "/";
00676       }
00677 
00678       //------------------------------------------------------------------------
00680       //------------------------------------------------------------------------
00681       bool ParseServerResponse( const std::string &hostId,
00682                                 const char *data );
00683 
00684     private:
00685       DirList     pDirList;
00686       std::string pParent;
00687   };
00688 
00689   //----------------------------------------------------------------------------
00691   //----------------------------------------------------------------------------
00692   class OpenInfo
00693   {
00694     public:
00695       //------------------------------------------------------------------------
00697       //------------------------------------------------------------------------
00698       OpenInfo( const uint8_t *fileHandle,
00699                 uint64_t       sessionId,
00700                 StatInfo *statInfo        = 0 ):
00701         pSessionId(sessionId), pStatInfo( statInfo )
00702       {
00703         memcpy( pFileHandle, fileHandle, 4 );
00704       }
00705 
00706       //------------------------------------------------------------------------
00708       //------------------------------------------------------------------------
00709       ~OpenInfo()
00710       {
00711         delete pStatInfo;
00712       }
00713 
00714       //------------------------------------------------------------------------
00716       //------------------------------------------------------------------------
00717       void GetFileHandle( uint8_t *fileHandle ) const
00718       {
00719         memcpy( fileHandle, pFileHandle, 4 );
00720       }
00721 
00722       //------------------------------------------------------------------------
00724       //------------------------------------------------------------------------
00725       const StatInfo *GetStatInfo() const
00726       {
00727         return pStatInfo;
00728       }
00729 
00730       //------------------------------------------------------------------------
00731       // Get session ID
00732       //------------------------------------------------------------------------
00733       uint64_t GetSessionId() const
00734       {
00735         return pSessionId;
00736       }
00737 
00738     private:
00739       uint8_t   pFileHandle[4];
00740       uint64_t  pSessionId;
00741       StatInfo *pStatInfo;
00742   };
00743 
00744   //----------------------------------------------------------------------------
00746   //----------------------------------------------------------------------------
00747   struct ChunkInfo
00748   {
00749     //--------------------------------------------------------------------------
00751     //--------------------------------------------------------------------------
00752     ChunkInfo( uint64_t off = 0, uint32_t len = 0, void *buff = 0 ):
00753       offset( off ), length( len ), buffer(buff) {}
00754 
00755     uint64_t  offset; 
00756     uint32_t  length; 
00757     void     *buffer; 
00758   };
00759 
00760   //----------------------------------------------------------------------------
00762   //----------------------------------------------------------------------------
00763   typedef std::vector<ChunkInfo> ChunkList;
00764 
00765   //----------------------------------------------------------------------------
00767   //----------------------------------------------------------------------------
00768   class VectorReadInfo
00769   {
00770     public:
00771       //------------------------------------------------------------------------
00773       //------------------------------------------------------------------------
00774       VectorReadInfo(): pSize( 0 ) {}
00775 
00776       //------------------------------------------------------------------------
00778       //------------------------------------------------------------------------
00779       uint32_t GetSize() const
00780       {
00781         return pSize;
00782       }
00783 
00784       //------------------------------------------------------------------------
00786       //------------------------------------------------------------------------
00787       void SetSize( uint32_t size )
00788       {
00789         pSize = size;
00790       }
00791 
00792       //------------------------------------------------------------------------
00794       //------------------------------------------------------------------------
00795       ChunkList &GetChunks()
00796       {
00797         return pChunks;
00798       }
00799 
00800       //------------------------------------------------------------------------
00802       //------------------------------------------------------------------------
00803       const ChunkList &GetChunks() const
00804       {
00805         return pChunks;
00806       }
00807 
00808     private:
00809       ChunkList pChunks;
00810       uint32_t  pSize;
00811   };
00812 
00813   //----------------------------------------------------------------------------
00814   // List of URLs
00815   //----------------------------------------------------------------------------
00816   struct HostInfo
00817   {
00818     HostInfo():
00819       flags(0), protocol(0), loadBalancer(false) {}
00820     HostInfo( const URL &u, bool lb = false ):
00821       flags(0), protocol(0), loadBalancer(lb), url(u) {}
00822     uint32_t flags;        
00823     uint32_t protocol;     
00824     bool     loadBalancer; 
00825     URL      url;          
00826   };
00827 
00828   typedef std::vector<HostInfo> HostList;
00829 
00830   //----------------------------------------------------------------------------
00832   //----------------------------------------------------------------------------
00833   class ResponseHandler
00834   {
00835     public:
00836       virtual ~ResponseHandler() {}
00837 
00838       //------------------------------------------------------------------------
00846       //------------------------------------------------------------------------
00847       virtual void HandleResponseWithHosts( XRootDStatus *status,
00848                                             AnyObject    *response,
00849                                             HostList     *hostList )
00850       {
00851         delete hostList;
00852         HandleResponse( status, response );
00853       }
00854 
00855       //------------------------------------------------------------------------
00862       //------------------------------------------------------------------------
00863       virtual void HandleResponse( XRootDStatus *status,
00864                                    AnyObject    *response )
00865       {
00866         (void)status; (void)response;
00867       }
00868   };
00869 }
00870 
00871 #endif // __XRD_CL_XROOTD_RESPONSES_HH__

Generated on 5 Oct 2016 for xrootd by  doxygen 1.4.7