XRootD
Loading...
Searching...
No Matches
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"
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
38namespace XrdCl
39{
40 //----------------------------------------------------------------------------
42 //----------------------------------------------------------------------------
44 {
45 public:
46 //------------------------------------------------------------------------
48 //------------------------------------------------------------------------
56
57 //------------------------------------------------------------------------
59 //------------------------------------------------------------------------
65
66 //------------------------------------------------------------------------
68 //------------------------------------------------------------------------
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 //------------------------------------------------------------------------
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 //----------------------------------------------------------------------------
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 //------------------------------------------------------------------------
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 //----------------------------------------------------------------------------
400 {
401 public:
402 //------------------------------------------------------------------------
404 //------------------------------------------------------------------------
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 //------------------------------------------------------------------------
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 //------------------------------------------------------------------------
737
738 //------------------------------------------------------------------------
740 //------------------------------------------------------------------------
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 //----------------------------------------------------------------------------
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 //----------------------------------------------------------------------------
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
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 //----------------------------------------------------------------------------
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 //------------------------------------------------------------------------
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
#define kXR_attrMeta
#define kXR_attrSuper
#define kXR_isServer
#define kXR_attrProxy
@ kXR_readable
@ kXR_isDir
@ kXR_offline
@ kXR_bkpexist
@ kXR_other
@ kXR_poscpend
@ kXR_writable
@ kXR_xset
static void parent()
#define access(a, b)
Definition XrdPosix.hh:39
Binary blob representation.
void SetStatInfo(StatInfo *info)
Set the stat info object (and transfer the ownership)
const StatInfo * GetStatInfo() const
Get the stat info object.
const std::string & GetName() const
Get file name.
const std::string & GetHostAddress() const
Get host address.
ListEntry(const std::string &hostAddress, const std::string &name, StatInfo *statInfo=0)
Constructor.
StatInfo * GetStatInfo()
Get the stat info object.
DirList::const_iterator ConstIterator
Directory listing const iterator.
void Add(ListEntry *entry)
Add an entry to the list - takes ownership.
uint32_t GetSize() const
Get the size of the listing.
const std::string & GetParentName() const
Get parent directory name.
Iterator End()
Get the end iterator.
static bool HasStatInfo(const char *data)
Returns true if data contain stat info.
DirList::iterator Iterator
Directory listing iterator.
Iterator Begin()
Get the begin iterator.
ConstIterator End() const
Get the end iterator.
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.
std::vector< ListEntry * > DirList
Directory listing.
ListEntry * At(uint32_t index)
Get an entry at given index.
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.
LocationList::iterator Iterator
Iterator over locations.
uint32_t GetSize() const
Get number of locations.
Iterator Begin()
Get the location begin iterator.
LocationList::const_iterator ConstIterator
Iterator over locations.
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.
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.
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.
ChunkList & GetChunks()
Get chunks.
void SetSize(uint32_t size)
Set size.
const std::string & GetErrorMessage() const
Get error message.
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.
XRootDStatus(const Status &st, const std::string &message="")
Constructor.
std::string ToStr() const
Convert to string.
const uint16_t errErrorResponse
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.
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
void * GetBuffer()
Get the buffer.
ChunkInfo(uint64_t off=0, uint32_t len=0, void *buff=0)
Constructor.
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.
RetryInfo(std::vector< std::tuple< uint64_t, uint32_t > > &&retries)
Constructor.
std::tuple< uint64_t, uint32_t > At(size_t i)
Procedure execution status.
uint16_t code
Error type, or additional hints on what to do.
std::string ToString() const
Create a string representation.
uint32_t errNo
Errno, if any.
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())