XRootD
XrdClXRootDResponses.hh
Go to the documentation of this file.
1 //------------------------------------------------------------------------------
2 // Copyright (c) 2011-2012 by European Organization for Nuclear Research (CERN)
3 // Author: Lukasz Janyst <ljanyst@cern.ch>
4 //------------------------------------------------------------------------------
5 // XRootD is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU Lesser General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // XRootD is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public License
16 // along with XRootD. If not, see <http://www.gnu.org/licenses/>.
17 //------------------------------------------------------------------------------
18 
19 #ifndef __XRD_CL_XROOTD_RESPONSES_HH__
20 #define __XRD_CL_XROOTD_RESPONSES_HH__
21 
22 #include "XrdCl/XrdClBuffer.hh"
23 #include "XrdCl/XrdClStatus.hh"
24 #include "XrdCl/XrdClURL.hh"
25 #include "XrdCl/XrdClAnyObject.hh"
26 #include "XProtocol/XProtocol.hh"
27 
28 #include <string>
29 #include <vector>
30 #include <list>
31 #include <ctime>
32 #include <tuple>
33 #include <memory>
34 #include <functional>
35 
36 #include <sys/uio.h>
37 
38 namespace XrdCl
39 {
40  //----------------------------------------------------------------------------
42  //----------------------------------------------------------------------------
44  {
45  public:
46  //------------------------------------------------------------------------
48  //------------------------------------------------------------------------
50  {
55  };
56 
57  //------------------------------------------------------------------------
59  //------------------------------------------------------------------------
61  {
62  Read,
63  ReadWrite
64  };
65 
66  //------------------------------------------------------------------------
68  //------------------------------------------------------------------------
69  class Location
70  {
71  public:
72 
73  //--------------------------------------------------------------------
75  //--------------------------------------------------------------------
76  Location( const std::string &address,
77  LocationType type,
79  pAddress( address ),
80  pType( type ),
81  pAccess( access ) {}
82 
83  //--------------------------------------------------------------------
85  //--------------------------------------------------------------------
86  const std::string &GetAddress() const
87  {
88  return pAddress;
89  }
90 
91  //--------------------------------------------------------------------
93  //--------------------------------------------------------------------
95  {
96  return pType;
97  }
98 
99  //--------------------------------------------------------------------
101  //--------------------------------------------------------------------
103  {
104  return pAccess;
105  }
106 
107  //--------------------------------------------------------------------
109  //--------------------------------------------------------------------
110  bool IsServer() const
111  {
112  return pType == ServerOnline || pType == ServerPending;
113  }
114 
115  //--------------------------------------------------------------------
117  //--------------------------------------------------------------------
118  bool IsManager() const
119  {
120  return pType == ManagerOnline || pType == ManagerPending;
121  }
122 
123  private:
124  std::string pAddress;
125  LocationType pType;
126  AccessType pAccess;
127  };
128 
129  //------------------------------------------------------------------------
131  //------------------------------------------------------------------------
132  typedef std::vector<Location> LocationList;
133 
134  //------------------------------------------------------------------------
136  //------------------------------------------------------------------------
137  typedef LocationList::iterator Iterator;
138 
139  //------------------------------------------------------------------------
141  //------------------------------------------------------------------------
142  typedef LocationList::const_iterator ConstIterator;
143 
144  //------------------------------------------------------------------------
146  //------------------------------------------------------------------------
147  LocationInfo();
148 
149  //------------------------------------------------------------------------
151  //------------------------------------------------------------------------
152  uint32_t GetSize() const
153  {
154  return pLocations.size();
155  }
156 
157  //------------------------------------------------------------------------
159  //------------------------------------------------------------------------
160  Location &At( uint32_t index )
161  {
162  return pLocations[index];
163  }
164 
165  //------------------------------------------------------------------------
167  //------------------------------------------------------------------------
169  {
170  return pLocations.begin();
171  }
172 
173  //------------------------------------------------------------------------
175  //------------------------------------------------------------------------
177  {
178  return pLocations.begin();
179  }
180 
181  //------------------------------------------------------------------------
183  //------------------------------------------------------------------------
185  {
186  return pLocations.end();
187  }
188 
189  //------------------------------------------------------------------------
191  //------------------------------------------------------------------------
193  {
194  return pLocations.end();
195  }
196 
197  //------------------------------------------------------------------------
199  //------------------------------------------------------------------------
200  void Add( const Location &location )
201  {
202  pLocations.push_back( location );
203  }
204 
205  //------------------------------------------------------------------------
207  //------------------------------------------------------------------------
208  bool ParseServerResponse( const char *data );
209 
210  private:
211  bool ProcessLocation( std::string &location );
212  LocationList pLocations;
213  };
214 
215  //----------------------------------------------------------------------------
217  //----------------------------------------------------------------------------
218  class XRootDStatus: public Status
219  {
220  public:
221  //------------------------------------------------------------------------
223  //------------------------------------------------------------------------
224  XRootDStatus( uint16_t st = 0,
225  uint16_t code = 0,
226  uint32_t errN = 0,
227  const std::string &message = "" ):
228  Status( st, code, errN ),
229  pMessage( message ) {}
230 
231  //------------------------------------------------------------------------
233  //------------------------------------------------------------------------
234  XRootDStatus( const Status &st,
235  const std::string &message = "" ):
236  Status( st ),
237  pMessage( message ) {}
238 
239  //------------------------------------------------------------------------
241  //------------------------------------------------------------------------
242  const std::string &GetErrorMessage() const
243  {
244  return pMessage;
245  }
246 
247  //------------------------------------------------------------------------
249  //------------------------------------------------------------------------
250  void SetErrorMessage( const std::string &message )
251  {
252  pMessage = message;
253  }
254 
255  //------------------------------------------------------------------------
257  //------------------------------------------------------------------------
258  std::string ToStr() const
259  {
260  if( code == errErrorResponse )
261  {
262  std::ostringstream o;
263  o << "[ERROR] Server responded with an error: [" << errNo << "] ";
264  o << pMessage << std::endl;
265  return o.str();
266  }
267  std::string str = ToString();
268  if( !pMessage.empty() )
269  str += ": " + pMessage;
270  return str;
271  }
272 
273  private:
274  std::string pMessage;
275  };
276 
277  //----------------------------------------------------------------------------
279  //----------------------------------------------------------------------------
280  enum
281  {
283  xattr_value = 1
284  };
285 
286  //----------------------------------------------------------------------------
288  //----------------------------------------------------------------------------
289  typedef std::tuple<std::string, std::string> xattr_t;
290 
291  //----------------------------------------------------------------------------
293  //----------------------------------------------------------------------------
294  struct XAttrStatus
295  {
296  friend class FileStateHandler;
297  friend class FileSystem;
298 
299  XAttrStatus( const std::string &name, const XRootDStatus &status ) :
300  name( name ), status( status )
301  {
302 
303  }
304 
305  std::string name;
307  };
308 
309  //----------------------------------------------------------------------------
311  //----------------------------------------------------------------------------
312  struct XAttr : public XAttrStatus
313  {
314  friend class FileStateHandler;
315  friend class FileSystem;
316 
317  XAttr( const std::string &name, const XRootDStatus &status ) :
319  {
320 
321  }
322 
323  XAttr( const std::string &name, const std::string &value = "",
324  const XRootDStatus &status = XRootDStatus() ) :
326  {
327 
328  }
329 
330  std::string value;
331  };
332 
333  //----------------------------------------------------------------------------
335  //----------------------------------------------------------------------------
337 
338  //----------------------------------------------------------------------------
340  //----------------------------------------------------------------------------
342  {
343  public:
344  //------------------------------------------------------------------------
346  //------------------------------------------------------------------------
348  {
354  };
355 
356  //------------------------------------------------------------------------
358  //------------------------------------------------------------------------
359  ProtocolInfo( uint32_t version, uint32_t hostInfo ):
360  pVersion( version ), pHostInfo( hostInfo ) {}
361 
362  //------------------------------------------------------------------------
364  //------------------------------------------------------------------------
365  uint32_t GetVersion() const
366  {
367  return pVersion;
368  }
369 
370  //------------------------------------------------------------------------
372  //------------------------------------------------------------------------
373  uint32_t GetHostInfo() const
374  {
375  return pHostInfo;
376  }
377 
378  //------------------------------------------------------------------------
380  //------------------------------------------------------------------------
381  bool TestHostInfo( uint32_t flags )
382  {
383  return pHostInfo & flags;
384  }
385 
386  private:
387  uint32_t pVersion;
388  uint32_t pHostInfo;
389  };
390 
391  //----------------------------------------------------------------------------
393  //----------------------------------------------------------------------------
394  struct StatInfoImpl;
395 
396  //----------------------------------------------------------------------------
398  //----------------------------------------------------------------------------
399  class StatInfo
400  {
401  public:
402  //------------------------------------------------------------------------
404  //------------------------------------------------------------------------
405  enum Flags
406  {
416  };
417 
418  //------------------------------------------------------------------------
420  //------------------------------------------------------------------------
421  StatInfo();
422 
423  //------------------------------------------------------------------------
425  //------------------------------------------------------------------------
426  StatInfo( const std::string &id, uint64_t size, uint32_t flags,
427  uint64_t modTime );
428 
429  //------------------------------------------------------------------------
431  //------------------------------------------------------------------------
432  StatInfo( const StatInfo &info );
433 
434  //------------------------------------------------------------------------
436  //------------------------------------------------------------------------
438 
439  //------------------------------------------------------------------------
441  //------------------------------------------------------------------------
442  const std::string& GetId() const;
443 
444  //------------------------------------------------------------------------
446  //------------------------------------------------------------------------
447  uint64_t GetSize() const;
448 
449  //------------------------------------------------------------------------
451  //------------------------------------------------------------------------
452  void SetSize( uint64_t size );
453 
454  //------------------------------------------------------------------------
456  //------------------------------------------------------------------------
457  uint32_t GetFlags() const;
458 
459  //------------------------------------------------------------------------
461  //------------------------------------------------------------------------
462  void SetFlags( uint32_t flags );
463 
464  //------------------------------------------------------------------------
466  //------------------------------------------------------------------------
467  bool TestFlags( uint32_t flags ) const;
468 
469  //------------------------------------------------------------------------
471  //------------------------------------------------------------------------
472  uint64_t GetModTime() const;
473 
474  //------------------------------------------------------------------------
476  //------------------------------------------------------------------------
477  std::string GetModTimeAsString() const;
478 
479  //------------------------------------------------------------------------
481  //------------------------------------------------------------------------
482  uint64_t GetChangeTime() const;
483 
484  //------------------------------------------------------------------------
486  //------------------------------------------------------------------------
487  std::string GetChangeTimeAsString() const;
488 
489  //------------------------------------------------------------------------
491  //------------------------------------------------------------------------
492  uint64_t GetAccessTime() const;
493 
494  //------------------------------------------------------------------------
496  //------------------------------------------------------------------------
497  std::string GetAccessTimeAsString() const;
498 
499  //------------------------------------------------------------------------
501  //------------------------------------------------------------------------
502  const std::string& GetModeAsString() const;
503 
504  //------------------------------------------------------------------------
506  //------------------------------------------------------------------------
507  const std::string GetModeAsOctString() const;
508 
509  //------------------------------------------------------------------------
511  //------------------------------------------------------------------------
512  const std::string& GetOwner() const;
513 
514  //------------------------------------------------------------------------
516  //------------------------------------------------------------------------
517  const std::string& GetGroup() const;
518 
519  //------------------------------------------------------------------------
521  //------------------------------------------------------------------------
522  const std::string& GetChecksum() const;
523 
524  //------------------------------------------------------------------------
526  //------------------------------------------------------------------------
527  bool ParseServerResponse( const char *data );
528 
529  //------------------------------------------------------------------------
531  //------------------------------------------------------------------------
532  bool ExtendedFormat() const;
533 
534  //------------------------------------------------------------------------
536  //------------------------------------------------------------------------
537  bool HasChecksum() const;
538 
539  private:
540 
541  static inline std::string TimeToString( uint64_t time )
542  {
543  char ts[256];
544  time_t modTime = time;
545  tm *t = gmtime( &modTime );
546  strftime( ts, 255, "%F %T", t );
547  return ts;
548  }
549 
550  static inline void OctToString( uint8_t oct, std::string &str )
551  {
552  static const uint8_t r_mask = 0x4;
553  static const uint8_t w_mask = 0x2;
554  static const uint8_t x_mask = 0x1;
555 
556  if( r_mask & oct ) str.push_back( 'r' );
557  else str.push_back( '-' );
558 
559  if( w_mask & oct ) str.push_back( 'w' );
560  else str.push_back( '-' );
561 
562  if( x_mask & oct ) str.push_back( 'x' );
563  else str.push_back( '-' );
564  }
565 
566  std::unique_ptr<StatInfoImpl> pImpl;
567  };
568 
569  //----------------------------------------------------------------------------
571  //----------------------------------------------------------------------------
573  {
574  public:
575  //------------------------------------------------------------------------
577  //------------------------------------------------------------------------
578  StatInfoVFS();
579 
580  //------------------------------------------------------------------------
582  //------------------------------------------------------------------------
583  uint64_t GetNodesRW() const
584  {
585  return pNodesRW;
586  }
587 
588  //------------------------------------------------------------------------
590  //------------------------------------------------------------------------
591  uint64_t GetFreeRW() const
592  {
593  return pFreeRW;
594  }
595 
596  //------------------------------------------------------------------------
598  //------------------------------------------------------------------------
599  uint8_t GetUtilizationRW() const
600  {
601  return pUtilizationRW;
602  }
603 
604  //------------------------------------------------------------------------
606  //------------------------------------------------------------------------
607  uint64_t GetNodesStaging() const
608  {
609  return pNodesStaging;
610  }
611 
612  //------------------------------------------------------------------------
614  //------------------------------------------------------------------------
615  uint64_t GetFreeStaging() const
616  {
617  return pFreeStaging;
618  }
619 
620  //------------------------------------------------------------------------
622  //------------------------------------------------------------------------
623  uint8_t GetUtilizationStaging() const
624  {
625  return pUtilizationStaging;
626  }
627 
628  //------------------------------------------------------------------------
630  //------------------------------------------------------------------------
631  bool ParseServerResponse( const char *data );
632 
633  private:
634 
635  //------------------------------------------------------------------------
636  // kXR_vfs stat
637  //------------------------------------------------------------------------
638  uint64_t pNodesRW;
639  uint64_t pFreeRW;
640  uint32_t pUtilizationRW;
641  uint64_t pNodesStaging;
642  uint64_t pFreeStaging;
643  uint32_t pUtilizationStaging;
644  };
645 
646  //----------------------------------------------------------------------------
648  //----------------------------------------------------------------------------
650  {
651  public:
652 
653  //------------------------------------------------------------------------
655  //------------------------------------------------------------------------
656  class ListEntry
657  {
658  public:
659  //--------------------------------------------------------------------
661  //--------------------------------------------------------------------
662  ListEntry( const std::string &hostAddress,
663  const std::string &name,
664  StatInfo *statInfo = 0):
665  pHostAddress( hostAddress ),
666  pName( SanitizeName( name ) ),
667  pStatInfo( statInfo )
668  {}
669 
670  //--------------------------------------------------------------------
672  //--------------------------------------------------------------------
674  {
675  delete pStatInfo;
676  }
677 
678  //--------------------------------------------------------------------
680  //--------------------------------------------------------------------
681  const std::string &GetHostAddress() const
682  {
683  return pHostAddress;
684  }
685 
686  //--------------------------------------------------------------------
688  //--------------------------------------------------------------------
689  const std::string &GetName() const
690  {
691  return pName;
692  }
693 
694  //--------------------------------------------------------------------
696  //--------------------------------------------------------------------
698  {
699  return pStatInfo;
700  }
701 
702  //--------------------------------------------------------------------
704  //--------------------------------------------------------------------
705  const StatInfo *GetStatInfo() const
706  {
707  return pStatInfo;
708  }
709 
710  //--------------------------------------------------------------------
712  //--------------------------------------------------------------------
713  void SetStatInfo( StatInfo *info )
714  {
715  pStatInfo = info;
716  }
717 
718  private:
719 
720  inline static std::string SanitizeName( const std::string &name )
721  {
722  const char *cstr = name.c_str();
723  while( *cstr == '/' ) // the C string is guaranteed to end with '\0'
724  ++cstr;
725  return cstr;
726  }
727 
728  std::string pHostAddress;
729  std::string pName;
730  StatInfo *pStatInfo;
731  };
732 
733  //------------------------------------------------------------------------
735  //------------------------------------------------------------------------
736  DirectoryList();
737 
738  //------------------------------------------------------------------------
740  //------------------------------------------------------------------------
741  ~DirectoryList();
742 
743  //------------------------------------------------------------------------
745  //------------------------------------------------------------------------
746  typedef std::vector<ListEntry*> DirList;
747 
748  //------------------------------------------------------------------------
750  //------------------------------------------------------------------------
751  typedef DirList::iterator Iterator;
752 
753  //------------------------------------------------------------------------
755  //------------------------------------------------------------------------
756  typedef DirList::const_iterator ConstIterator;
757 
758  //------------------------------------------------------------------------
760  //------------------------------------------------------------------------
761  void Add( ListEntry *entry )
762  {
763  pDirList.push_back( entry );
764  }
765 
766  //------------------------------------------------------------------------
768  //------------------------------------------------------------------------
769  ListEntry *At( uint32_t index )
770  {
771  return pDirList[index];
772  }
773 
774  //------------------------------------------------------------------------
776  //------------------------------------------------------------------------
778  {
779  return pDirList.begin();
780  }
781 
782  //------------------------------------------------------------------------
784  //------------------------------------------------------------------------
786  {
787  return pDirList.begin();
788  }
789 
790  //------------------------------------------------------------------------
792  //------------------------------------------------------------------------
794  {
795  return pDirList.end();
796  }
797 
798  //------------------------------------------------------------------------
800  //------------------------------------------------------------------------
802  {
803  return pDirList.end();
804  }
805 
806  //------------------------------------------------------------------------
808  //------------------------------------------------------------------------
809  uint32_t GetSize() const
810  {
811  return pDirList.size();
812  }
813 
814  //------------------------------------------------------------------------
816  //------------------------------------------------------------------------
817  const std::string &GetParentName() const
818  {
819  return pParent;
820  }
821 
822  //------------------------------------------------------------------------
824  //------------------------------------------------------------------------
825  void SetParentName( const std::string &parent )
826  {
827  size_t pos = parent.find( '?' );
828  pParent = pos == std::string::npos ? parent : parent.substr( 0, pos );
829  if( !pParent.empty() && pParent[pParent.length()-1] != '/' )
830  pParent += "/";
831  }
832 
833  //------------------------------------------------------------------------
835  //------------------------------------------------------------------------
836  bool ParseServerResponse( const std::string &hostId,
837  const char *data );
838 
839  //------------------------------------------------------------------------
841  //------------------------------------------------------------------------
842  bool ParseServerResponse( const std::string &hostId,
843  const char *data,
844  bool isDStat );
845 
846  //------------------------------------------------------------------------
848  //------------------------------------------------------------------------
849  static bool HasStatInfo( const char *data );
850 
851  private:
852  DirList pDirList;
853  std::string pParent;
854 
855  static const std::string dStatPrefix;
856  };
857 
858  //----------------------------------------------------------------------------
860  //----------------------------------------------------------------------------
861  class OpenInfo
862  {
863  public:
864  //------------------------------------------------------------------------
866  //------------------------------------------------------------------------
867  OpenInfo( const uint8_t *fileHandle,
868  uint64_t sessionId,
869  StatInfo *statInfo = 0 ):
870  pSessionId(sessionId), pStatInfo( statInfo )
871  {
872  memcpy( pFileHandle, fileHandle, 4 );
873  }
874 
875  //------------------------------------------------------------------------
877  //------------------------------------------------------------------------
879  {
880  delete pStatInfo;
881  }
882 
883  //------------------------------------------------------------------------
885  //------------------------------------------------------------------------
886  void GetFileHandle( uint8_t *fileHandle ) const
887  {
888  memcpy( fileHandle, pFileHandle, 4 );
889  }
890 
891  //------------------------------------------------------------------------
893  //------------------------------------------------------------------------
894  const StatInfo *GetStatInfo() const
895  {
896  return pStatInfo;
897  }
898 
899  //------------------------------------------------------------------------
900  // Get session ID
901  //------------------------------------------------------------------------
902  uint64_t GetSessionId() const
903  {
904  return pSessionId;
905  }
906 
907  private:
908  uint8_t pFileHandle[4];
909  uint64_t pSessionId;
910  StatInfo *pStatInfo;
911  };
912 
913  //----------------------------------------------------------------------------
915  //----------------------------------------------------------------------------
916  struct ChunkInfo
917  {
918  //--------------------------------------------------------------------------
920  //--------------------------------------------------------------------------
921  ChunkInfo( uint64_t off = 0, uint32_t len = 0, void *buff = 0 ):
922  offset( off ), length( len ), buffer(buff) {}
923 
924  //----------------------------------------------------------------------------
926  //----------------------------------------------------------------------------
927  inline uint64_t GetOffset() const
928  {
929  return offset;
930  }
931 
932  //----------------------------------------------------------------------------
934  //----------------------------------------------------------------------------
935  inline uint32_t GetLength() const
936  {
937  return length;
938  }
939 
940  //----------------------------------------------------------------------------
942  //----------------------------------------------------------------------------
943  inline void* GetBuffer()
944  {
945  return buffer;
946  }
947 
948  uint64_t offset;
949  uint32_t length;
950  void *buffer;
951  };
952 
953  struct PageInfoImpl;
954 
955  struct PageInfo
956  {
957  //----------------------------------------------------------------------------
959  //----------------------------------------------------------------------------
960  PageInfo( uint64_t offset = 0, uint32_t length = 0, void *buffer = 0,
961  std::vector<uint32_t> &&cksums = std::vector<uint32_t>() );
962 
963  //----------------------------------------------------------------------------
965  //----------------------------------------------------------------------------
966  PageInfo( PageInfo &&pginf );
967 
968  //----------------------------------------------------------------------------
970  //----------------------------------------------------------------------------
971  PageInfo& operator=( PageInfo &&pginf );
972 
973  //----------------------------------------------------------------------------
975  //----------------------------------------------------------------------------
976  ~PageInfo();
977 
978  //----------------------------------------------------------------------------
980  //----------------------------------------------------------------------------
981  uint64_t GetOffset() const;
982 
983  //----------------------------------------------------------------------------
985  //----------------------------------------------------------------------------
986  uint32_t GetLength() const;
987 
988  //----------------------------------------------------------------------------
990  //----------------------------------------------------------------------------
991  void* GetBuffer();
992 
993  //----------------------------------------------------------------------------
995  //----------------------------------------------------------------------------
996  std::vector<uint32_t>& GetCksums();
997 
998  //----------------------------------------------------------------------------
1000  //----------------------------------------------------------------------------
1001  size_t GetNbRepair();
1002 
1003  //----------------------------------------------------------------------------
1005  //----------------------------------------------------------------------------
1006  void SetNbRepair( size_t nbrepair );
1007 
1008  private:
1009  //--------------------------------------------------------------------------
1011  //--------------------------------------------------------------------------
1012  std::unique_ptr<PageInfoImpl> pImpl;
1013  };
1014 
1015  struct RetryInfoImpl;
1016 
1017  struct RetryInfo
1018  {
1019  //----------------------------------------------------------------------------
1021  //----------------------------------------------------------------------------
1022  RetryInfo( std::vector<std::tuple<uint64_t, uint32_t>> && retries );
1023 
1024  //----------------------------------------------------------------------------
1026  //----------------------------------------------------------------------------
1027  ~RetryInfo();
1028 
1029  //----------------------------------------------------------------------------
1031  //----------------------------------------------------------------------------
1032  bool NeedRetry();
1033 
1034  //----------------------------------------------------------------------------
1036  //----------------------------------------------------------------------------
1037  size_t Size();
1038 
1039  //----------------------------------------------------------------------------
1041  // retransmitted
1042  //----------------------------------------------------------------------------
1043  std::tuple<uint64_t, uint32_t> At( size_t i );
1044 
1045  private:
1046  //--------------------------------------------------------------------------
1048  //--------------------------------------------------------------------------
1049  std::unique_ptr<RetryInfoImpl> pImpl;
1050  };
1051 
1052  //----------------------------------------------------------------------------
1054  //----------------------------------------------------------------------------
1055  typedef std::vector<ChunkInfo> ChunkList;
1056 
1057  //----------------------------------------------------------------------------
1059  //----------------------------------------------------------------------------
1061  {
1062  public:
1063  //------------------------------------------------------------------------
1065  //------------------------------------------------------------------------
1066  VectorReadInfo(): pSize( 0 ) {}
1067 
1068  //------------------------------------------------------------------------
1070  //------------------------------------------------------------------------
1071  uint32_t GetSize() const
1072  {
1073  return pSize;
1074  }
1075 
1076  //------------------------------------------------------------------------
1078  //------------------------------------------------------------------------
1079  void SetSize( uint32_t size )
1080  {
1081  pSize = size;
1082  }
1083 
1084  //------------------------------------------------------------------------
1086  //------------------------------------------------------------------------
1088  {
1089  return pChunks;
1090  }
1091 
1092  //------------------------------------------------------------------------
1094  //------------------------------------------------------------------------
1095  const ChunkList &GetChunks() const
1096  {
1097  return pChunks;
1098  }
1099 
1100  private:
1101  ChunkList pChunks;
1102  uint32_t pSize;
1103  };
1104 
1105  //----------------------------------------------------------------------------
1106  // List of URLs
1107  //----------------------------------------------------------------------------
1108  struct HostInfo
1109  {
1111  flags(0), protocol(0), loadBalancer(false) {}
1112  HostInfo( const URL &u, bool lb = false ):
1113  flags(0), protocol(0), loadBalancer(lb), url(u) {}
1114  uint32_t flags;
1115  uint32_t protocol;
1118  };
1119 
1120  typedef std::vector<HostInfo> HostList;
1121 
1122  //----------------------------------------------------------------------------
1124  //----------------------------------------------------------------------------
1126  {
1127  public:
1128  virtual ~ResponseHandler() {}
1129 
1130  //------------------------------------------------------------------------
1138  //------------------------------------------------------------------------
1139  virtual void HandleResponseWithHosts( XRootDStatus *status,
1140  AnyObject *response,
1141  HostList *hostList )
1142  {
1143  delete hostList;
1144  HandleResponse( status, response );
1145  }
1146 
1147  //------------------------------------------------------------------------
1154  //------------------------------------------------------------------------
1155  virtual void HandleResponse( XRootDStatus *status,
1156  AnyObject *response )
1157  {
1158  (void)status; (void)response;
1159  }
1160 
1161  //------------------------------------------------------------------------
1166  //------------------------------------------------------------------------
1167  static ResponseHandler* Wrap( std::function<void(XRootDStatus&, AnyObject&)> func );
1168 
1169  //------------------------------------------------------------------------
1174  //------------------------------------------------------------------------
1175  static ResponseHandler* Wrap( std::function<void(XRootDStatus*, AnyObject*)> func );
1176  };
1177 }
1178 
1179 #endif // __XRD_CL_XROOTD_RESPONSES_HH__
#define kXR_isManager
Definition: XProtocol.hh:1156
#define kXR_attrMeta
Definition: XProtocol.hh:1159
#define kXR_attrSuper
Definition: XProtocol.hh:1161
#define kXR_isServer
Definition: XProtocol.hh:1157
#define kXR_attrProxy
Definition: XProtocol.hh:1160
@ kXR_readable
Definition: XProtocol.hh:1224
@ kXR_isDir
Definition: XProtocol.hh:1221
@ kXR_offline
Definition: XProtocol.hh:1223
@ kXR_bkpexist
Definition: XProtocol.hh:1227
@ kXR_other
Definition: XProtocol.hh:1222
@ kXR_poscpend
Definition: XProtocol.hh:1226
@ kXR_writable
Definition: XProtocol.hh:1225
@ kXR_xset
Definition: XProtocol.hh:1220
static void parent()
int access(const char *path, int amode)
Binary blob representation.
Definition: XrdClBuffer.hh:34
void SetStatInfo(StatInfo *info)
Set the stat info object (and transfer the ownership)
const StatInfo * GetStatInfo() const
Get the stat info object.
ListEntry(const std::string &hostAddress, const std::string &name, StatInfo *statInfo=0)
Constructor.
const std::string & GetHostAddress() const
Get host address.
const std::string & GetName() const
Get file name.
StatInfo * GetStatInfo()
Get the stat info object.
DirList::const_iterator ConstIterator
Directory listing const iterator.
ListEntry * At(uint32_t index)
Get an entry at given index.
void Add(ListEntry *entry)
Add an entry to the list - takes ownership.
uint32_t GetSize() const
Get the size of the listing.
DirList::iterator Iterator
Directory listing iterator.
Iterator End()
Get the end iterator.
static bool HasStatInfo(const char *data)
Returns true if data contain stat info.
std::vector< ListEntry * > DirList
Directory listing.
Iterator Begin()
Get the begin iterator.
ConstIterator End() const
Get the end iterator.
const std::string & GetParentName() const
Get parent directory name.
void SetParentName(const std::string &parent)
Set name of the parent directory.
bool ParseServerResponse(const std::string &hostId, const char *data)
Parse server response and fill up the object.
ConstIterator Begin() const
Get the begin iterator.
Handle the stateful operations.
Send file/filesystem queries to an XRootD cluster.
LocationType GetType() const
Get location type.
bool IsServer() const
Check whether the location is a server.
Location(const std::string &address, LocationType type, AccessType access)
Constructor.
const std::string & GetAddress() const
Get address.
AccessType GetAccessType() const
Get access type.
bool IsManager() const
Check whether the location is a manager.
Path location info.
uint32_t GetSize() const
Get number of locations.
Iterator Begin()
Get the location begin iterator.
Location & At(uint32_t index)
Get the location at index.
void Add(const Location &location)
Add a location.
std::vector< Location > LocationList
List of locations.
LocationList::const_iterator ConstIterator
Iterator over locations.
ConstIterator Begin() const
Get the location begin iterator.
bool ParseServerResponse(const char *data)
Parse server response and fill up the object.
AccessType
Describes the allowed access type for the file at given location.
@ Read
read access is allowed
@ ReadWrite
write access is allowed
LocationType
Describes the node type and file status for a given location.
@ ServerPending
server node where the file is pending to be online
@ ManagerOnline
manager node where the file is online
@ ServerOnline
server node where the file is online
@ ManagerPending
manager node where the file is pending to be online
ConstIterator End() const
Get the location end iterator.
LocationList::iterator Iterator
Iterator over locations.
Iterator End()
Get the location end iterator.
Information returned by file open operation.
void GetFileHandle(uint8_t *fileHandle) const
Get the file handle (4bytes)
const StatInfo * GetStatInfo() const
Get the stat info.
OpenInfo(const uint8_t *fileHandle, uint64_t sessionId, StatInfo *statInfo=0)
Constructor.
uint64_t GetSessionId() const
bool TestHostInfo(uint32_t flags)
Test host info flags.
HostTypes
Types of XRootD servers.
@ AttrProxy
Proxy attribute.
@ AttrSuper
Supervisor attribute.
uint32_t GetVersion() const
Get version info.
ProtocolInfo(uint32_t version, uint32_t hostInfo)
Constructor.
uint32_t GetHostInfo() const
Get host info.
Handle an async response.
virtual void HandleResponseWithHosts(XRootDStatus *status, AnyObject *response, HostList *hostList)
static ResponseHandler * Wrap(std::function< void(XRootDStatus &, AnyObject &)> func)
virtual void HandleResponse(XRootDStatus *status, AnyObject *response)
uint64_t GetFreeRW() const
Get size of the largest contiguous area of free r/w space (in MB)
uint64_t GetNodesStaging() const
Get number of nodes that can provide staging space.
uint8_t GetUtilizationStaging() const
Get percentage of the partition utilization represented by FreeStaging.
uint64_t GetFreeStaging() const
Get size of the largest contiguous area of free staging space (in MB)
uint8_t GetUtilizationRW() const
Get percentage of the partition utilization represented by FreeRW.
bool ParseServerResponse(const char *data)
Parse server response and fill up the object.
uint64_t GetNodesRW() const
Get number of nodes that can provide read/write space.
Object stat info.
uint64_t GetChangeTime() const
Get change time (in seconds since epoch)
std::string GetChangeTimeAsString() const
Get change time.
std::string GetModTimeAsString() const
Get modification time.
bool HasChecksum() const
Has checksum.
bool TestFlags(uint32_t flags) const
Test flags.
uint64_t GetSize() const
Get size (in bytes)
const std::string GetModeAsOctString() const
Get mode.
~StatInfo()
Destructor.
const std::string & GetOwner() const
Get owner.
bool ParseServerResponse(const char *data)
Parse server response and fill up the object.
@ IsReadable
Read access is allowed.
@ IsDir
This is a directory.
@ Other
Neither a file nor a directory.
@ BackUpExists
Back up copy exists.
@ XBitSet
Executable/searchable bit set.
@ Offline
File is not online (ie. on disk)
@ IsWritable
Write access is allowed.
uint32_t GetFlags() const
Get flags.
bool ExtendedFormat() const
Has extended stat information.
const std::string & GetModeAsString() const
Get mode.
const std::string & GetId() const
Get id.
const std::string & GetGroup() const
Get group.
uint64_t GetModTime() const
Get modification time (in seconds since epoch)
std::string GetAccessTimeAsString() const
Get change time.
void SetSize(uint64_t size)
Set size.
uint64_t GetAccessTime() const
Get change time (in seconds since epoch)
void SetFlags(uint32_t flags)
Set flags.
const std::string & GetChecksum() const
Get checksum.
URL representation.
Definition: XrdClURL.hh:31
uint32_t GetSize() const
Get Size.
const ChunkList & GetChunks() const
Get chunks.
void SetSize(uint32_t size)
Set size.
ChunkList & GetChunks()
Get chunks.
void SetErrorMessage(const std::string &message)
Set the error message.
XRootDStatus(uint16_t st=0, uint16_t code=0, uint32_t errN=0, const std::string &message="")
Constructor.
const std::string & GetErrorMessage() const
Get error message.
XRootDStatus(const Status &st, const std::string &message="")
Constructor.
std::string ToStr() const
Convert to string.
const uint16_t errErrorResponse
Definition: XrdClStatus.hh:105
std::vector< HostInfo > HostList
std::tuple< std::string, std::string > xattr_t
Extended attribute key - value pair.
std::vector< ChunkInfo > ChunkList
List of chunks.
Buffer BinaryDataInfo
Binary buffer.
@ oct
Definition: XrdSysTrace.hh:42
Describe a data chunk for vector read.
void * buffer
length of the chunk
uint64_t GetOffset() const
Get the offset.
uint32_t GetLength() const
Get the data length.
uint32_t length
offset in the file
ChunkInfo(uint64_t off=0, uint32_t len=0, void *buff=0)
Constructor.
void * GetBuffer()
Get the buffer.
HostInfo(const URL &u, bool lb=false)
URL url
URL of the host.
uint32_t protocol
Version of the protocol the host is speaking.
bool loadBalancer
Was the host used as a load balancer.
uint32_t flags
Host type.
size_t GetNbRepair()
Get number of repaired pages.
void SetNbRepair(size_t nbrepair)
Set number of repaired pages.
PageInfo(uint64_t offset=0, uint32_t length=0, void *buffer=0, std::vector< uint32_t > &&cksums=std::vector< uint32_t >())
Default constructor.
PageInfo & operator=(PageInfo &&pginf)
Move assigment operator.
std::vector< uint32_t > & GetCksums()
Get the checksums.
uint32_t GetLength() const
Get the data length.
uint64_t GetOffset() const
Get the offset.
void * GetBuffer()
Get the buffer.
std::tuple< uint64_t, uint32_t > At(size_t i)
RetryInfo(std::vector< std::tuple< uint64_t, uint32_t >> &&retries)
Constructor.
Procedure execution status.
Definition: XrdClStatus.hh:115
uint16_t code
Error type, or additional hints on what to do.
Definition: XrdClStatus.hh:147
std::string ToString() const
Create a string representation.
Definition: XrdClStatus.cc:97
uint32_t errNo
Errno, if any.
Definition: XrdClStatus.hh:148
Extended attribute operation status.
XAttrStatus(const std::string &name, const XRootDStatus &status)
Extended attributes with status.
XAttr(const std::string &name, const XRootDStatus &status)
XAttr(const std::string &name, const std::string &value="", const XRootDStatus &status=XRootDStatus())