xrootd
XrdClFileSystemOperations.hh
Go to the documentation of this file.
1 //------------------------------------------------------------------------------
2 // Copyright (c) 2011-2017 by European Organization for Nuclear Research (CERN)
3 // Author: Krzysztof Jamrog <krzysztof.piotr.jamrog@cern.ch>,
4 // Michal Simon <michal.simon@cern.ch>
5 //------------------------------------------------------------------------------
6 // This file is part of the XRootD software suite.
7 //
8 // XRootD is free software: you can redistribute it and/or modify
9 // it under the terms of the GNU Lesser General Public License as published by
10 // the Free Software Foundation, either version 3 of the License, or
11 // (at your option) any later version.
12 //
13 // XRootD is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
17 //
18 // You should have received a copy of the GNU Lesser General Public License
19 // along with XRootD. If not, see <http://www.gnu.org/licenses/>.
20 //
21 // In applying this licence, CERN does not waive the privileges and immunities
22 // granted to it by virtue of its status as an Intergovernmental Organization
23 // or submit itself to any jurisdiction.
24 //------------------------------------------------------------------------------
25 
26 #ifndef __XRD_CL_FILE_SYSTEM_OPERATIONS_HH__
27 #define __XRD_CL_FILE_SYSTEM_OPERATIONS_HH__
28 
29 #include "XrdCl/XrdClFileSystem.hh"
30 #include "XrdCl/XrdClOperations.hh"
32 
33 namespace XrdCl
34 {
35 
36  //----------------------------------------------------------------------------
42  //----------------------------------------------------------------------------
43  template<template<bool> class Derived, bool HasHndl, typename Response, typename ... Args>
44  class FileSystemOperation: public ConcreteOperation<Derived, HasHndl, Response, Args...>
45  {
46 
47  template<template<bool> class, bool, typename, typename ...> friend class FileSystemOperation;
48 
49  public:
50  //------------------------------------------------------------------------
55  //------------------------------------------------------------------------
57  false, Response, Args...>( std::move( args )... ), filesystem(fs)
58  {
59  }
60 
61  //------------------------------------------------------------------------
66  //------------------------------------------------------------------------
67  FileSystemOperation( FileSystem &fs, Args... args): FileSystemOperation( &fs, std::move( args )... )
68  {
69  }
70 
71  //------------------------------------------------------------------------
77  //------------------------------------------------------------------------
78  template<bool from>
80  ConcreteOperation<Derived, HasHndl, Response, Args...>( std::move( op ) ), filesystem( op.filesystem )
81  {
82  }
83 
84  //------------------------------------------------------------------------
86  //------------------------------------------------------------------------
88  {
89  }
90 
91  protected:
92 
93  //------------------------------------------------------------------------
95  //------------------------------------------------------------------------
97  };
98 
99  //----------------------------------------------------------------------------
101  //----------------------------------------------------------------------------
102  template<bool HasHndl>
105  {
106  public:
107 
108  //------------------------------------------------------------------------
110  //------------------------------------------------------------------------
113 
114  //------------------------------------------------------------------------
116  //------------------------------------------------------------------------
117  enum { PathArg, FlagsArg };
118 
119  //------------------------------------------------------------------------
121  //------------------------------------------------------------------------
122  std::string ToString()
123  {
124  return "Locate";
125  }
126 
127  protected:
128 
129  //------------------------------------------------------------------------
135  //------------------------------------------------------------------------
137  {
138  try
139  {
140  std::string path = std::get<PathArg>( this->args ).Get();
141  OpenFlags::Flags flags = std::get<FlagsArg>( this->args ).Get();
142  return this->filesystem->Locate( path, flags, this->handler.get() );
143  }
144  catch( const PipelineException& ex )
145  {
146  return ex.GetError();
147  }
148  catch( const std::exception& ex )
149  {
150  return XRootDStatus( stError, ex.what() );
151  }
152  }
153  };
155 
156  //----------------------------------------------------------------------------
158  //----------------------------------------------------------------------------
159  template<bool HasHndl>
160  class DeepLocateImpl: public FileSystemOperation<DeepLocateImpl, HasHndl,
161  Resp<LocationInfo>, Arg<std::string>, Arg<OpenFlags::Flags>>
162  {
163  public:
164 
165  //------------------------------------------------------------------------
167  //------------------------------------------------------------------------
170 
171  //------------------------------------------------------------------------
173  //------------------------------------------------------------------------
174  enum { PathArg, FlagsArg };
175 
176  //------------------------------------------------------------------------
178  //------------------------------------------------------------------------
179  std::string ToString()
180  {
181  return "DeepLocate";
182  }
183 
184  protected:
185 
186  //------------------------------------------------------------------------
192  //------------------------------------------------------------------------
194  {
195  try
196  {
197  std::string path = std::get<PathArg>( this->args ).Get();
198  OpenFlags::Flags flags = std::get<FlagsArg>( this->args ).Get();
199  return this->filesystem->DeepLocate( path, flags, this->handler.get() );
200  }
201  catch( const PipelineException& ex )
202  {
203  return ex.GetError();
204  }
205  catch( const std::exception& ex )
206  {
207  return XRootDStatus( stError, ex.what() );
208  }
209  }
210  };
212 
213  //----------------------------------------------------------------------------
215  //----------------------------------------------------------------------------
216  template<bool HasHndl>
217  class MvImpl: public FileSystemOperation<MvImpl, HasHndl, Resp<void>, Arg<std::string>,
218  Arg<std::string>>
219  {
220  public:
221 
222  //------------------------------------------------------------------------
224  //------------------------------------------------------------------------
227 
228  //------------------------------------------------------------------------
230  //------------------------------------------------------------------------
231  enum { SourceArg, DestArg };
232 
233  //------------------------------------------------------------------------
235  //------------------------------------------------------------------------
236  std::string ToString()
237  {
238  return "Mv";
239  }
240 
241  protected:
242 
243  //------------------------------------------------------------------------
249  //------------------------------------------------------------------------
251  {
252  try
253  {
254  std::string source = std::get<SourceArg>( this->args ).Get();
255  std::string dest = std::get<DestArg>( this->args ).Get();
256  return this->filesystem->Mv( source, dest, this->handler.get() );
257  }
258  catch( const PipelineException& ex )
259  {
260  return ex.GetError();
261  }
262  catch( const std::exception& ex )
263  {
264  return XRootDStatus( stError, ex.what() );
265  }
266  }
267  };
268  typedef MvImpl<false> Mv;
269 
270  //----------------------------------------------------------------------------
272  //----------------------------------------------------------------------------
273  template<bool HasHndl>
274  class QueryImpl: public FileSystemOperation<QueryImpl, HasHndl, Resp<Buffer>,
275  Arg<QueryCode::Code>, Arg<Buffer>>
276  {
277  public:
278 
279  //------------------------------------------------------------------------
281  //------------------------------------------------------------------------
284 
285  //------------------------------------------------------------------------
287  //------------------------------------------------------------------------
289 
290  //------------------------------------------------------------------------
292  //------------------------------------------------------------------------
293  std::string ToString()
294  {
295  return "Query";
296  }
297 
298  protected:
299 
300  //------------------------------------------------------------------------
306  //------------------------------------------------------------------------
308  {
309  try
310  {
311  QueryCode::Code queryCode = std::get<QueryCodeArg>( this->args ).Get();
312  const Buffer buffer( std::get<BufferArg>( this->args ).Get() );
313  return this->filesystem->Query( queryCode, buffer, this->handler.get() );
314  }
315  catch( const PipelineException& ex )
316  {
317  return ex.GetError();
318  }
319  catch( const std::exception& ex )
320  {
321  return XRootDStatus( stError, ex.what() );
322  }
323  }
324  };
326 
327  //----------------------------------------------------------------------------
329  //----------------------------------------------------------------------------
330  template<bool HasHndl>
331  class TruncateFsImpl: public FileSystemOperation<TruncateFsImpl, HasHndl, Resp<void>,
332  Arg<std::string>, Arg<uint64_t>>
333  {
334  public:
335 
336  //------------------------------------------------------------------------
338  //------------------------------------------------------------------------
341 
342  //------------------------------------------------------------------------
344  //------------------------------------------------------------------------
345  enum { PathArg, SizeArg };
346 
347  //------------------------------------------------------------------------
349  //------------------------------------------------------------------------
350  std::string ToString()
351  {
352  return "Truncate";
353  }
354 
355  protected:
356 
357  //------------------------------------------------------------------------
363  //------------------------------------------------------------------------
365  {
366  try
367  {
368  std::string path = std::get<PathArg>( this->args ).Get();
369  uint64_t size = std::get<SizeArg>( this->args ).Get();
370  return this->filesystem->Truncate( path, size, this->handler.get() );
371  }
372  catch( const PipelineException& ex )
373  {
374  return ex.GetError();
375  }
376  catch( const std::exception& ex )
377  {
378  return XRootDStatus( stError, ex.what() );
379  }
380  }
381  };
382 
384  {
385  return TruncateFsImpl<false>( fs, std::move( path ), std::move( size ) );
386  }
387 
389  {
390  return TruncateFsImpl<false>( fs, std::move( path ), std::move( size ) );
391  }
392 
393  //----------------------------------------------------------------------------
395  //----------------------------------------------------------------------------
396  template<bool HasHndl>
397  class RmImpl: public FileSystemOperation<RmImpl, HasHndl, Resp<void>, Arg<std::string>>
398  {
399  public:
400 
401  //------------------------------------------------------------------------
403  //------------------------------------------------------------------------
405 
406  //------------------------------------------------------------------------
408  //------------------------------------------------------------------------
409  enum { PathArg };
410 
411  //------------------------------------------------------------------------
413  //------------------------------------------------------------------------
414  std::string ToString()
415  {
416  return "Rm";
417  }
418 
419  protected:
420 
421  //------------------------------------------------------------------------
427  //------------------------------------------------------------------------
429  {
430  try
431  {
432  std::string path = std::get<PathArg>( this->args ).Get();
433  return this->filesystem->Rm( path, this->handler.get() );
434  }
435  catch( const PipelineException& ex )
436  {
437  return ex.GetError();
438  }
439  catch( const std::exception& ex )
440  {
441  return XRootDStatus( stError, ex.what() );
442  }
443  }
444  };
445  typedef RmImpl<false> Rm;
446 
447  //----------------------------------------------------------------------------
449  //----------------------------------------------------------------------------
450  template<bool HasHndl>
451  class MkDirImpl: public FileSystemOperation<MkDirImpl, HasHndl, Resp<void>,
452  Arg<std::string>, Arg<MkDirFlags::Flags>, Arg<Access::Mode>>
453  {
454  public:
455 
456  //------------------------------------------------------------------------
458  //------------------------------------------------------------------------
461 
462  //------------------------------------------------------------------------
464  //------------------------------------------------------------------------
466 
467  //------------------------------------------------------------------------
469  //------------------------------------------------------------------------
470  std::string ToString()
471  {
472  return "MkDir";
473  }
474 
475  protected:
476 
477  //------------------------------------------------------------------------
483  //------------------------------------------------------------------------
485  {
486  try
487  {
488  std::string path = std::get<PathArg>( this->args ).Get();
489  MkDirFlags::Flags flags = std::get<FlagsArg>( this->args ).Get();
490  Access::Mode mode = std::get<ModeArg>( this->args ).Get();
491  return this->filesystem->MkDir( path, flags, mode, this->handler.get() );
492  }
493  catch( const PipelineException& ex )
494  {
495  return ex.GetError();
496  }
497  catch( const std::exception& ex )
498  {
499  return XRootDStatus( stError, ex.what() );
500  }
501  }
502  };
504 
505  //----------------------------------------------------------------------------
507  //----------------------------------------------------------------------------
508  template<bool HasHndl>
509  class RmDirImpl: public FileSystemOperation<RmDirImpl, HasHndl, Resp<void>,
510  Arg<std::string>>
511  {
512  public:
513 
514  //------------------------------------------------------------------------
516  //------------------------------------------------------------------------
518 
519  //------------------------------------------------------------------------
521  //------------------------------------------------------------------------
522  enum { PathArg };
523 
524  //------------------------------------------------------------------------
526  //------------------------------------------------------------------------
527  std::string ToString()
528  {
529  return "RmDir";
530  }
531 
532  protected:
533 
534  //------------------------------------------------------------------------
540  //------------------------------------------------------------------------
542  {
543  try
544  {
545  std::string path = std::get<PathArg>( this->args ).Get();
546  return this->filesystem->RmDir( path, this->handler.get() );
547  }
548  catch( const PipelineException& ex )
549  {
550  return ex.GetError();
551  }
552  catch( const std::exception& ex )
553  {
554  return XRootDStatus( stError, ex.what() );
555  }
556  }
557  };
559 
560  //----------------------------------------------------------------------------
562  //----------------------------------------------------------------------------
563  template<bool HasHndl>
564  class ChModImpl: public FileSystemOperation<ChModImpl, HasHndl, Resp<void>,
565  Arg<std::string>, Arg<Access::Mode>>
566  {
567  public:
568 
569  //------------------------------------------------------------------------
571  //------------------------------------------------------------------------
574 
575  //------------------------------------------------------------------------
577  //------------------------------------------------------------------------
578  enum { PathArg, ModeArg };
579 
580  //------------------------------------------------------------------------
582  //------------------------------------------------------------------------
583  std::string ToString()
584  {
585  return "ChMod";
586  }
587 
588  protected:
589 
590  //------------------------------------------------------------------------
596  //------------------------------------------------------------------------
598  {
599  try
600  {
601  std::string path = std::get<PathArg>( this->args ).Get();
602  Access::Mode mode = std::get<ModeArg>( this->args ).Get();
603  return this->filesystem->ChMod( path, mode, this->handler.get() );
604  }
605  catch( const PipelineException& ex )
606  {
607  return ex.GetError();
608  }
609  catch( const std::exception& ex )
610  {
611  return XRootDStatus( stError, ex.what() );
612  }
613  }
614  };
616 
617  //----------------------------------------------------------------------------
619  //----------------------------------------------------------------------------
620  template<bool HasHndl>
621  class PingImpl: public FileSystemOperation<PingImpl, HasHndl, Resp<void>>
622  {
623  public:
624 
625  //------------------------------------------------------------------------
627  //------------------------------------------------------------------------
629 
630  //------------------------------------------------------------------------
632  //------------------------------------------------------------------------
633  std::string ToString()
634  {
635  return "Ping";
636  }
637 
638  protected:
639 
640  //------------------------------------------------------------------------
646  //------------------------------------------------------------------------
648  {
649  return this->filesystem->Ping( this->handler.get() );
650  }
651  };
653 
654  //----------------------------------------------------------------------------
656  //----------------------------------------------------------------------------
657  template<bool HasHndl>
658  class StatFsImpl: public FileSystemOperation<StatFsImpl, HasHndl, Resp<StatInfo>,
659  Arg<std::string>>
660  {
661  public:
662 
663  //------------------------------------------------------------------------
665  //------------------------------------------------------------------------
668 
669  //------------------------------------------------------------------------
671  //------------------------------------------------------------------------
672  enum { PathArg };
673 
674  //------------------------------------------------------------------------
676  //------------------------------------------------------------------------
677  std::string ToString()
678  {
679  return "Stat";
680  }
681 
682  protected:
683 
684  //------------------------------------------------------------------------
690  //------------------------------------------------------------------------
692  {
693  try
694  {
695  std::string path = std::get<PathArg>( this->args ).Get();
696  return this->filesystem->Stat( path, this->handler.get() );
697  }
698  catch( const PipelineException& ex )
699  {
700  return ex.GetError();
701  }
702  catch( const std::exception& ex )
703  {
704  return XRootDStatus( stError, ex.what() );
705  }
706  }
707  };
708 
710  {
711  return StatFsImpl<false>( fs, std::move( path ) );
712  }
713 
715  {
716  return StatFsImpl<false>( fs, std::move( path ) );
717  }
718 
719  //----------------------------------------------------------------------------
721  //----------------------------------------------------------------------------
722  template<bool HasHndl>
723  class StatVFSImpl: public FileSystemOperation<StatVFSImpl, HasHndl,
724  Resp<StatInfoVFS>, Arg<std::string>>
725  {
726  public:
727 
728  //------------------------------------------------------------------------
730  //------------------------------------------------------------------------
733 
734  //------------------------------------------------------------------------
736  //------------------------------------------------------------------------
737  enum { PathArg };
738 
739  //------------------------------------------------------------------------
741  //------------------------------------------------------------------------
742  std::string ToString()
743  {
744  return "StatVFS";
745  }
746 
747  protected:
748 
749  //------------------------------------------------------------------------
755  //------------------------------------------------------------------------
757  {
758  try
759  {
760  std::string path = std::get<PathArg>( this->args ).Get();
761  return this->filesystem->StatVFS( path, this->handler.get() );
762  }
763  catch( const PipelineException& ex )
764  {
765  return ex.GetError();
766  }
767  catch( const std::exception& ex )
768  {
769  return XRootDStatus( stError, ex.what() );
770  }
771  }
772  };
774 
775  //----------------------------------------------------------------------------
777  //----------------------------------------------------------------------------
778  template<bool HasHndl>
779  class ProtocolImpl: public FileSystemOperation<ProtocolImpl, HasHndl,
780  Resp<ProtocolInfo>>
781  {
782  public:
783 
784  //------------------------------------------------------------------------
786  //------------------------------------------------------------------------
788 
789  //------------------------------------------------------------------------
791  //------------------------------------------------------------------------
792  std::string ToString()
793  {
794  return "Protocol";
795  }
796 
797  protected:
798 
799  //------------------------------------------------------------------------
805  //------------------------------------------------------------------------
807  {
808  return this->filesystem->Protocol( this->handler.get() );
809  }
810  };
812 
813  //----------------------------------------------------------------------------
815  //----------------------------------------------------------------------------
816  template<bool HasHndl>
817  class DirListImpl: public FileSystemOperation<DirListImpl, HasHndl, Resp<DirectoryList>,
818  Arg<std::string>, Arg<DirListFlags::Flags>>
819  {
820  public:
821 
822  //------------------------------------------------------------------------
824  //------------------------------------------------------------------------
827 
828  //------------------------------------------------------------------------
830  //------------------------------------------------------------------------
831  enum { PathArg, FlagsArg };
832 
833  //------------------------------------------------------------------------
835  //------------------------------------------------------------------------
836  std::string ToString()
837  {
838  return "DirList";
839  }
840 
841  protected:
842 
843  //------------------------------------------------------------------------
849  //------------------------------------------------------------------------
851  {
852  try
853  {
854  std::string path = std::get<PathArg>( this->args ).Get();
855  DirListFlags::Flags flags = std::get<FlagsArg>( this->args ).Get();
856  return this->filesystem->DirList( path, flags, this->handler.get() );
857  }
858  catch( const PipelineException& ex )
859  {
860  return ex.GetError();
861  }
862  catch( const std::exception& ex )
863  {
864  return XRootDStatus( stError, ex.what() );
865  }
866  }
867  };
869 
870  //----------------------------------------------------------------------------
872  //----------------------------------------------------------------------------
873  template<bool HasHndl>
874  class SendInfoImpl: public FileSystemOperation<SendInfoImpl, HasHndl, Resp<Buffer>,
875  Arg<std::string>>
876  {
877  public:
878 
879  //------------------------------------------------------------------------
881  //------------------------------------------------------------------------
884 
885  //------------------------------------------------------------------------
887  //------------------------------------------------------------------------
888  enum { InfoArg };
889 
890  //------------------------------------------------------------------------
892  //------------------------------------------------------------------------
893  std::string ToString()
894  {
895  return "SendInfo";
896  }
897 
898  protected:
899 
900  //------------------------------------------------------------------------
906  //------------------------------------------------------------------------
908  {
909  try
910  {
911  std::string info = std::get<InfoArg>( this->args ).Get();
912  return this->filesystem->SendInfo( info, this->handler.get() );
913  }
914  catch( const PipelineException& ex )
915  {
916  return ex.GetError();
917  }
918  catch( const std::exception& ex )
919  {
920  return XRootDStatus( stError, ex.what() );
921  }
922  }
923  };
925 
926  //----------------------------------------------------------------------------
928  //----------------------------------------------------------------------------
929  template<bool HasHndl>
930  class PrepareImpl: public FileSystemOperation<PrepareImpl, HasHndl, Resp<Buffer>,
931  Arg<std::vector<std::string>>, Arg<PrepareFlags::Flags>, Arg<uint8_t>>
932  {
933  public:
934 
935  //------------------------------------------------------------------------
937  //------------------------------------------------------------------------
940 
941  //------------------------------------------------------------------------
943  //------------------------------------------------------------------------
945 
946  //------------------------------------------------------------------------
948  //------------------------------------------------------------------------
949  std::string ToString()
950  {
951  return "Prepare";
952  }
953 
954  protected:
955 
956  //------------------------------------------------------------------------
962  //------------------------------------------------------------------------
964  {
965  try
966  {
967  std::vector<std::string> fileList = std::get<FileListArg>( this->args ).Get();
968  PrepareFlags::Flags flags = std::get<FlagsArg>( this->args ).Get();
969  uint8_t priority = std::get<PriorityArg>( this->args ).Get();
970  return this->filesystem->Prepare( fileList, flags, priority,
971  this->handler.get() );
972  }
973  catch( const PipelineException& ex )
974  {
975  return ex.GetError();
976  }
977  catch( const std::exception& ex )
978  {
979  return XRootDStatus( stError, ex.what() );
980  }
981  }
982  };
984 
985  //----------------------------------------------------------------------------
987  //----------------------------------------------------------------------------
988  template<bool HasHndl>
989  class SetXAttrFsImpl: public FileSystemOperation<SetXAttrFsImpl, HasHndl, Resp<void>,
990  Arg<std::string>, Arg<std::string>, Arg<std::string>>
991  {
992  public:
993 
994  //------------------------------------------------------------------------
996  //------------------------------------------------------------------------
999 
1000  //------------------------------------------------------------------------
1002  //------------------------------------------------------------------------
1004 
1005  //------------------------------------------------------------------------
1007  //------------------------------------------------------------------------
1008  std::string ToString()
1009  {
1010  return "SetXAttrFsImpl";
1011  }
1012 
1013  protected:
1014 
1015  //------------------------------------------------------------------------
1021  //------------------------------------------------------------------------
1023  {
1024  try
1025  {
1026  std::string path = std::get<PathArg>( this->args ).Get();
1027  std::string name = std::get<NameArg>( this->args ).Get();
1028  std::string value = std::get<ValueArg>( this->args ).Get();
1029  // wrap the arguments with a vector
1030  std::vector<xattr_t> attrs;
1031  attrs.push_back( xattr_t( std::move( name ), std::move( value ) ) );
1032  // wrap the PipelineHandler so the response gets unpacked properly
1033  UnpackXAttrStatus *handler = new UnpackXAttrStatus( this->handler.get() );
1034  XRootDStatus st = this->filesystem->SetXAttr( path, attrs, handler );
1035  if( !st.IsOK() ) delete handler;
1036  return st;
1037  }
1038  catch( const PipelineException& ex )
1039  {
1040  return ex.GetError();
1041  }
1042  catch( const std::exception& ex )
1043  {
1044  return XRootDStatus( stError, ex.what() );
1045  }
1046  }
1047  };
1048 
1049  //----------------------------------------------------------------------------
1052  //----------------------------------------------------------------------------
1054  Arg<std::string> name, Arg<std::string> value )
1055  {
1056  return SetXAttrFsImpl<false>( fs, std::move( path ), std::move( name ),
1057  std::move( value ) );
1058  }
1059 
1060  //----------------------------------------------------------------------------
1063  //----------------------------------------------------------------------------
1065  Arg<std::string> name, Arg<std::string> value )
1066  {
1067  return SetXAttrFsImpl<false>( fs, std::move( path ), std::move( name ),
1068  std::move( value ) );
1069  }
1070 
1071  //----------------------------------------------------------------------------
1073  //----------------------------------------------------------------------------
1074  template<bool HasHndl>
1075  class SetXAttrFsBulkImpl: public FileSystemOperation<SetXAttrFsBulkImpl, HasHndl,
1076  Resp<std::vector<XAttrStatus>>, Arg<std::string>, Arg<std::vector<xattr_t>>>
1077  {
1078  public:
1079 
1080  //------------------------------------------------------------------------
1082  //------------------------------------------------------------------------
1085 
1086  //------------------------------------------------------------------------
1088  //------------------------------------------------------------------------
1089  enum { PathArg, AttrsArg };
1090 
1091  //------------------------------------------------------------------------
1093  //------------------------------------------------------------------------
1094  std::string ToString()
1095  {
1096  return "SetXAttrBulkImpl";
1097  }
1098 
1099 
1100  protected:
1101 
1102  //------------------------------------------------------------------------
1106  //------------------------------------------------------------------------
1108  {
1109  try
1110  {
1111  std::string path = std::get<PathArg>( this->args ).Get();
1112  std::vector<xattr_t> attrs = std::get<AttrsArg>( this->args ).Get();
1113  return this->filesystem->SetXAttr( path, attrs, this->handler.get() );
1114  }
1115  catch( const PipelineException& ex )
1116  {
1117  return ex.GetError();
1118  }
1119  catch( const std::exception& ex )
1120  {
1121  return XRootDStatus( stError, ex.what() );
1122  }
1123  }
1124  };
1125 
1126  //----------------------------------------------------------------------------
1129  //----------------------------------------------------------------------------
1131  Arg<std::vector<xattr_t>> attrs )
1132  {
1133  return SetXAttrFsBulkImpl<false>( fs, std::move( path ), std::move( attrs ) );
1134  }
1135 
1136  //----------------------------------------------------------------------------
1139  //----------------------------------------------------------------------------
1141  Arg<std::vector<xattr_t>> attrs )
1142  {
1143  return SetXAttrFsBulkImpl<false>( fs, std::move( path ), std::move( attrs ) );
1144  }
1145 
1146  //----------------------------------------------------------------------------
1148  //----------------------------------------------------------------------------
1149  template<bool HasHndl>
1150  class GetXAttrFsImpl: public FileSystemOperation<GetXAttrFsImpl, HasHndl, Resp<std::string>,
1151  Arg<std::string>, Arg<std::string>>
1152  {
1153  public:
1154 
1155  //------------------------------------------------------------------------
1157  //------------------------------------------------------------------------
1160 
1161  //------------------------------------------------------------------------
1163  //------------------------------------------------------------------------
1164  enum { PathArg, NameArg };
1165 
1166  //------------------------------------------------------------------------
1168  //------------------------------------------------------------------------
1169  std::string ToString()
1170  {
1171  return "GetXAttrFsImpl";
1172  }
1173 
1174  protected:
1175 
1176  //------------------------------------------------------------------------
1180  //------------------------------------------------------------------------
1182  {
1183  try
1184  {
1185  std::string path = std::get<PathArg>( this->args ).Get();
1186  std::string name = std::get<NameArg>( this->args ).Get();
1187  // wrap the argument with a vector
1188  std::vector<std::string> attrs;
1189  attrs.push_back( std::move( name ) );
1190  // wrap the PipelineHandler so the response gets unpacked properly
1191  UnpackXAttr *handler = new UnpackXAttr( this->handler.get() );
1192  XRootDStatus st = this->filesystem->GetXAttr( path, attrs, handler );
1193  if( !st.IsOK() ) delete handler;
1194  return st;
1195  }
1196  catch( const PipelineException& ex )
1197  {
1198  return ex.GetError();
1199  }
1200  catch( const std::exception& ex )
1201  {
1202  return XRootDStatus( stError, ex.what() );
1203  }
1204  }
1205  };
1206 
1207  //----------------------------------------------------------------------------
1210  //----------------------------------------------------------------------------
1212  Arg<std::string> name )
1213  {
1214  return GetXAttrFsImpl<false>( fs, std::move( path ), std::move( name ) );
1215  }
1216 
1217  //----------------------------------------------------------------------------
1220  //----------------------------------------------------------------------------
1222  Arg<std::string> name )
1223  {
1224  return GetXAttrFsImpl<false>( fs, std::move( path ), std::move( name ) );
1225  }
1226 
1227  //----------------------------------------------------------------------------
1229  //----------------------------------------------------------------------------
1230  template<bool HasHndl>
1231  class GetXAttrFsBulkImpl: public FileSystemOperation<GetXAttrFsBulkImpl, HasHndl,
1232  Resp<std::vector<XAttr>>, Arg<std::string>, Arg<std::vector<std::string>>>
1233  {
1234  public:
1235 
1236  //------------------------------------------------------------------------
1238  //------------------------------------------------------------------------
1241 
1242  //------------------------------------------------------------------------
1244  //------------------------------------------------------------------------
1245  enum { PathArg, NamesArg };
1246 
1247  //------------------------------------------------------------------------
1249  //------------------------------------------------------------------------
1250  std::string ToString()
1251  {
1252  return "GetXAttrFsBulkImpl";
1253  }
1254 
1255 
1256  protected:
1257 
1258  //------------------------------------------------------------------------
1262  //------------------------------------------------------------------------
1264  {
1265  try
1266  {
1267  std::string path = std::get<PathArg>( this->args ).Get();
1268  std::vector<std::string> attrs = std::get<NamesArg>( this->args ).Get();
1269  return this->filesystem->GetXAttr( path, attrs, this->handler.get() );
1270  }
1271  catch( const PipelineException& ex )
1272  {
1273  return ex.GetError();
1274  }
1275  catch( const std::exception& ex )
1276  {
1277  return XRootDStatus( stError, ex.what() );
1278  }
1279  }
1280  };
1281 
1282  //----------------------------------------------------------------------------
1285  //----------------------------------------------------------------------------
1287  Arg<std::vector<std::string>> attrs )
1288  {
1289  return GetXAttrFsBulkImpl<false>( fs, std::move( path ), std::move( attrs ) );
1290  }
1291 
1292  //----------------------------------------------------------------------------
1295  //----------------------------------------------------------------------------
1297  Arg<std::vector<std::string>> attrs )
1298  {
1299  return GetXAttrFsBulkImpl<false>( fs, std::move( path ), std::move( attrs ) );
1300  }
1301 
1302  //----------------------------------------------------------------------------
1304  //----------------------------------------------------------------------------
1305  template<bool HasHndl>
1306  class DelXAttrFsImpl: public FileSystemOperation<DelXAttrFsImpl, HasHndl, Resp<void>,
1307  Arg<std::string>, Arg<std::string>>
1308  {
1309  public:
1310 
1311  //------------------------------------------------------------------------
1313  //------------------------------------------------------------------------
1316 
1317  //------------------------------------------------------------------------
1319  //------------------------------------------------------------------------
1320  enum { PathArg, NameArg };
1321 
1322  //------------------------------------------------------------------------
1324  //------------------------------------------------------------------------
1325  std::string ToString()
1326  {
1327  return "DelXAttrFsImpl";
1328  }
1329 
1330  protected:
1331 
1332  //------------------------------------------------------------------------
1338  //------------------------------------------------------------------------
1340  {
1341  try
1342  {
1343  std::string path = std::get<PathArg>( this->args ).Get();
1344  std::string name = std::get<NameArg>( this->args ).Get();
1345  // wrap the argument with a vector
1346  std::vector<std::string> attrs;
1347  attrs.push_back( std::move( name ) );
1348  // wrap the PipelineHandler so the response gets unpacked properly
1349  UnpackXAttrStatus *handler = new UnpackXAttrStatus( this->handler.get() );
1350  XRootDStatus st = this->filesystem->DelXAttr( path, attrs, handler );
1351  if( !st.IsOK() ) delete handler;
1352  return st;
1353  }
1354  catch( const PipelineException& ex )
1355  {
1356  return ex.GetError();
1357  }
1358  catch( const std::exception& ex )
1359  {
1360  return XRootDStatus( stError, ex.what() );
1361  }
1362  }
1363  };
1364 
1365  //----------------------------------------------------------------------------
1368  //----------------------------------------------------------------------------
1370  Arg<std::string> name )
1371  {
1372  return DelXAttrFsImpl<false>( fs, std::move( path ), std::move( name ) );
1373  }
1374 
1375  //----------------------------------------------------------------------------
1378  //----------------------------------------------------------------------------
1380  Arg<std::string> name )
1381  {
1382  return DelXAttrFsImpl<false>( fs, std::move( path ), std::move( name ) );
1383  }
1384 
1385  //----------------------------------------------------------------------------
1387  //----------------------------------------------------------------------------
1388  template<bool HasHndl>
1389  class DelXAttrFsBulkImpl: public FileSystemOperation<DelXAttrFsBulkImpl, HasHndl,
1390  Resp<std::vector<XAttrStatus>>, Arg<std::string>, Arg<std::vector<std::string>>>
1391  {
1392  public:
1393 
1394  //------------------------------------------------------------------------
1396  //------------------------------------------------------------------------
1399 
1400  //------------------------------------------------------------------------
1402  //------------------------------------------------------------------------
1403  enum { PathArg, NamesArg };
1404 
1405  //------------------------------------------------------------------------
1407  //------------------------------------------------------------------------
1408  std::string ToString()
1409  {
1410  return "DelXAttrBulkImpl";
1411  }
1412 
1413 
1414  protected:
1415 
1416  //------------------------------------------------------------------------
1422  //------------------------------------------------------------------------
1424  {
1425  try
1426  {
1427  std::string path = std::get<PathArg>( this->args ).Get();
1428  std::vector<std::string> attrs = std::get<NamesArg>( this->args ).Get();
1429  return this->filesystem->DelXAttr( path, attrs, this->handler.get() );
1430  }
1431  catch( const PipelineException& ex )
1432  {
1433  return ex.GetError();
1434  }
1435  catch( const std::exception& ex )
1436  {
1437  return XRootDStatus( stError, ex.what() );
1438  }
1439  }
1440  };
1441 
1442  //----------------------------------------------------------------------------
1445  //----------------------------------------------------------------------------
1447  Arg<std::vector<std::string>> attrs )
1448  {
1449  return DelXAttrFsBulkImpl<false>( fs, std::move( path ), std::move( attrs ) );
1450  }
1451 
1452  //----------------------------------------------------------------------------
1455  //----------------------------------------------------------------------------
1457  Arg<std::vector<std::string>> attrs )
1458  {
1459  return DelXAttrFsBulkImpl<false>( fs, std::move( path ), std::move( attrs ) );
1460  }
1461 
1462  //----------------------------------------------------------------------------
1464  //----------------------------------------------------------------------------
1465  template<bool HasHndl>
1466  class ListXAttrFsImpl: public FileSystemOperation<ListXAttrFsImpl, HasHndl,
1467  Resp<std::vector<XAttr>>, Arg<std::string>>
1468  {
1469  public:
1470 
1471  //------------------------------------------------------------------------
1473  //------------------------------------------------------------------------
1476 
1477  //------------------------------------------------------------------------
1479  //------------------------------------------------------------------------
1480  enum { PathArg };
1481 
1482  //------------------------------------------------------------------------
1484  //------------------------------------------------------------------------
1485  std::string ToString()
1486  {
1487  return "ListXAttrFsImpl";
1488  }
1489 
1490  protected:
1491 
1492  //------------------------------------------------------------------------
1498  //------------------------------------------------------------------------
1500  {
1501  try
1502  {
1503  std::string path = std::get<PathArg>( this->args ).Get();
1504  return this->filesystem->ListXAttr( path, this->handler.get() );
1505  }
1506  catch( const PipelineException& ex )
1507  {
1508  return ex.GetError();
1509  }
1510  catch( const std::exception& ex )
1511  {
1512  return XRootDStatus( stError, ex.what() );
1513  }
1514  }
1515  };
1516 
1517  //----------------------------------------------------------------------------
1520  //----------------------------------------------------------------------------
1522  {
1523  return ListXAttrFsImpl<false>( fs, std::move( path ) );
1524  }
1525 
1526  //----------------------------------------------------------------------------
1529  //----------------------------------------------------------------------------
1531  {
1532  return ListXAttrFsImpl<false>( fs, std::move( path ) );
1533  }
1534 }
1535 
1536 #endif // __XRD_CL_FILE_SYSTEM_OPERATIONS_HH__
Definition: XrdClFileSystemOperations.hh:1089
ProtocolImpl< false > Protocol
Definition: XrdClFileSystemOperations.hh:811
std::string ToString()
Definition: XrdClFileSystemOperations.hh:1094
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:1499
friend class FileSystemOperation
Definition: XrdClFileSystemOperations.hh:47
SendInfoImpl< false > SendInfo
Definition: XrdClFileSystemOperations.hh:924
Protocol operation (.
Definition: XrdClFileSystemOperations.hh:779
GetXAttrImpl< false > GetXAttr(File *file, Arg< std::string > name)
Definition: XrdClFileOperations.hh:1055
Definition: XrdClFileSystemOperations.hh:522
Definition: XrdClFileSystemOperations.hh:1003
std::string ToString()
Definition: XrdClFileSystemOperations.hh:742
std::string ToString()
Definition: XrdClFileSystemOperations.hh:1250
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:1181
MvImpl< false > Mv
Definition: XrdClFileSystemOperations.hh:268
std::string ToString()
Definition: XrdClFileSystemOperations.hh:527
QueryImpl< false > Query
Definition: XrdClFileSystemOperations.hh:325
XRootDStatus SetXAttr(const std::string &path, const std::vector< xattr_t > &attrs, ResponseHandler *handler, uint16_t timeout=0)
std::string ToString()
Definition: XrdClFileSystemOperations.hh:350
XRootDStatus Stat(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus ChMod(const std::string &path, Access::Mode mode, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
StatVFSImpl< false > StatVFS
Definition: XrdClFileSystemOperations.hh:773
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:541
Definition: XrdClFileSystemOperations.hh:1245
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:963
Definition: XrdClFileSystemOperations.hh:831
GetXAttr operation (.
Definition: XrdClFileSystemOperations.hh:1150
std::string ToString()
Definition: XrdClFileSystemOperations.hh:179
Definition: XrdClFileSystemOperations.hh:944
Definition: XrdClFileSystemOperations.hh:672
XRootDStatus Ping(ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Definition: XrdClFileSystemOperations.hh:44
XRootDStatus SendInfo(const std::string &info, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:250
std::string ToString()
Definition: XrdClFileSystemOperations.hh:1169
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:193
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:364
Definition: XrdClFileSystemOperations.hh:737
XRootDStatus Truncate(const std::string &path, uint64_t size, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
SetXAttr bulk operation (.
Definition: XrdClFileSystemOperations.hh:1075
Definition: XrdClFileSystemOperations.hh:231
std::string ToString()
Definition: XrdClFileSystemOperations.hh:949
Stat operation (.
Definition: XrdClFileSystemOperations.hh:658
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:428
Definition: XrdClFileSystemOperations.hh:888
std::string ToString()
Definition: XrdClFileSystemOperations.hh:1325
LocateImpl< false > Locate
Definition: XrdClFileSystemOperations.hh:154
std::string ToString()
Definition: XrdClFileSystemOperations.hh:1008
ListXAttr bulk operation (.
Definition: XrdClFileSystemOperations.hh:1466
Definition: XrdClFileSystemOperations.hh:831
std::string ToString()
Definition: XrdClFileSystemOperations.hh:633
Definition: XrdClFileSystemOperations.hh:174
Definition: XrdClFileSystemOperations.hh:174
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:691
SetXAttr operation (.
Definition: XrdClFileSystemOperations.hh:989
Flags
Definition: XrdClFileSystem.hh:174
MkDir operation (.
Definition: XrdClFileSystemOperations.hh:451
Prepare operation (.
Definition: XrdClFileSystemOperations.hh:930
FileSystemOperation(FileSystem *fs, Args... args)
Definition: XrdClFileSystemOperations.hh:56
Definition: XrdClFileSystemOperations.hh:1089
DelXAttr bulk operation (.
Definition: XrdClFileSystemOperations.hh:1389
std::string ToString()
Definition: XrdClFileSystemOperations.hh:293
Ping operation (.
Definition: XrdClFileSystemOperations.hh:621
RmImpl< false > Rm
Definition: XrdClFileSystemOperations.hh:445
MkDirImpl< false > MkDir
Definition: XrdClFileSystemOperations.hh:503
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:647
Definition: XrdClFileSystemOperations.hh:1164
Query operation (.
Definition: XrdClFileSystemOperations.hh:274
Definition: XrdClFileSystemOperations.hh:465
FileSystemOperation(FileSystemOperation< Derived, from, Response, Args... > &&op)
Definition: XrdClFileSystemOperations.hh:79
std::string ToString()
Definition: XrdClFileSystemOperations.hh:470
XRootDStatus ListXAttr(const std::string &path, ResponseHandler *handler, uint16_t timeout=0)
Pipeline exception, wrapps an XRootDStatus.
Definition: XrdClOperationHandlers.hh:359
XRootDStatus Prepare(const std::vector< std::string > &fileList, PrepareFlags::Flags flags, uint8_t priority, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
std::string ToString()
Definition: XrdClFileSystemOperations.hh:1485
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:806
Definition: XrdClFileSystemOperations.hh:117
Definition: XrdClFileSystemOperations.hh:1403
XRootDStatus RmDir(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Flags
Definition: XrdClFileSystem.hh:142
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:1339
Truncate operation (.
Definition: XrdClFileSystemOperations.hh:331
Definition: XrdClFileSystemOperations.hh:1003
FileSystemOperation(FileSystem &fs, Args... args)
Definition: XrdClFileSystemOperations.hh:67
Helper class for unpacking single XAttr from bulk response.
Definition: XrdClOperationHandlers.hh:76
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:136
std::tuple< Args... > args
Operation arguments.
Definition: XrdClOperations.hh:698
std::string ToString()
Definition: XrdClFileSystemOperations.hh:414
XRootDStatus Mv(const std::string &source, const std::string &dest, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:597
Definition: XrdClArg.hh:223
Definition: XrdClArg.hh:285
StatImpl< false > Stat(File *file, Arg< bool > force)
Definition: XrdClFileOperations.hh:393
DirListImpl< false > DirList
Definition: XrdClFileSystemOperations.hh:868
RmDir operation (.
Definition: XrdClFileSystemOperations.hh:509
const uint16_t stError
An error occurred that could potentially be retried.
Definition: XrdClStatus.hh:32
XRootDStatus StatVFS(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Request status.
Definition: XrdClXRootDResponses.hh:214
StatVS operation (.
Definition: XrdClFileSystemOperations.hh:723
std::string ToString()
Definition: XrdClFileSystemOperations.hh:677
Definition: XrdClFileSystemOperations.hh:944
Definition: XrdClAnyObject.hh:25
Definition: XrdClFileSystemOperations.hh:1003
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:307
Definition: XrdClFileSystemOperations.hh:465
FileSystem * filesystem
The file system object itself.
Definition: XrdClFileSystemOperations.hh:96
Definition: XrdClFileSystemOperations.hh:288
Definition: XrdClFileSystemOperations.hh:465
virtual ~FileSystemOperation()
Destructor.
Definition: XrdClFileSystemOperations.hh:87
Definition: XrdClFileSystemOperations.hh:231
const XRootDStatus & GetError() const
Definition: XrdClOperationHandlers.hh:399
Definition: XrdClFileSystemOperations.hh:1320
Definition: XrdClFileSystemOperations.hh:1480
ChMod operation (.
Definition: XrdClFileSystemOperations.hh:564
Definition: XrdClFileSystemOperations.hh:1320
Definition: XrdClFileSystemOperations.hh:578
DelXAttr operation (.
Definition: XrdClFileSystemOperations.hh:1306
XRootDStatus DirList(const std::string &path, DirListFlags::Flags flags, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
std::string ToString()
Definition: XrdClFileSystemOperations.hh:836
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:1107
XRootDStatus DelXAttr(const std::string &path, const std::vector< std::string > &attrs, ResponseHandler *handler, uint16_t timeout=0)
Definition: XrdClFileSystemOperations.hh:288
std::string ToString()
Definition: XrdClFileSystemOperations.hh:583
Mv operation (.
Definition: XrdClFileSystemOperations.hh:217
Helper class for unpacking single XAttrStatus from bulk response.
Definition: XrdClOperationHandlers.hh:40
Definition: XrdClFileSystemOperations.hh:1245
Definition: XrdClFileSystemOperations.hh:1164
Code
XRootD query request codes.
Definition: XrdClFileSystem.hh:52
XRootDStatus DeepLocate(const std::string &path, OpenFlags::Flags flags, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
GetXAttr bulk operation (.
Definition: XrdClFileSystemOperations.hh:1231
Rm operation (.
Definition: XrdClFileSystemOperations.hh:397
Flags
Definition: XrdClFileSystem.hh:155
XRootDStatus Protocol(ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus MkDir(const std::string &path, MkDirFlags::Flags flags, Access::Mode mode, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Definition: XrdClFileSystemOperations.hh:944
std::string ToString()
Definition: XrdClFileSystemOperations.hh:893
ChModImpl< false > ChMod
Definition: XrdClFileSystemOperations.hh:615
Mode
Access mode.
Definition: XrdClFileSystem.hh:121
ListXAttrImpl< false > ListXAttr(File *file)
Definition: XrdClFileOperations.hh:1338
SendInfo operation (.
Definition: XrdClFileSystemOperations.hh:874
Definition: XrdClFileSystemOperations.hh:345
Send file/filesystem queries to an XRootD cluster.
Definition: XrdClFileSystem.hh:201
DelXAttrImpl< false > DelXAttr(File *file, Arg< std::string > name)
Definition: XrdClFileOperations.hh:1208
SetXAttrImpl< false > SetXAttr(File *file, Arg< std::string > name, Arg< std::string > value)
Definition: XrdClFileOperations.hh:901
PingImpl< false > Ping
Definition: XrdClFileSystemOperations.hh:652
DeepLocateImpl< false > DeepLocate
Definition: XrdClFileSystemOperations.hh:211
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:756
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:1423
std::string ToString()
Definition: XrdClFileSystemOperations.hh:1408
std::string ToString()
Definition: XrdClFileSystemOperations.hh:236
Definition: XrdClFileSystemOperations.hh:1403
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:1263
std::string ToString()
Definition: XrdClFileSystemOperations.hh:122
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:850
Flags
Open flags, may be or&#39;d when appropriate.
Definition: XrdClFileSystem.hh:75
std::tuple< std::string, std::string > xattr_t
Extended attribute key - value pair.
Definition: XrdClXRootDResponses.hh:285
TruncateImpl< false > Truncate(File *file, Arg< uint64_t > size)
Definition: XrdClFileOperations.hh:559
PrepareImpl< false > Prepare
Definition: XrdClFileSystemOperations.hh:983
Locate operation (.
Definition: XrdClFileSystemOperations.hh:103
XRootDStatus Rm(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus Query(QueryCode::Code queryCode, const Buffer &arg, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
std::string ToString()
Definition: XrdClFileSystemOperations.hh:792
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:1022
std::unique_ptr< PipelineHandler > handler
Operation handler.
Definition: XrdClOperations.hh:288
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:907
RmDirImpl< false > RmDir
Definition: XrdClFileSystemOperations.hh:558
Definition: XrdClFileSystemOperations.hh:578
Definition: XrdClFileSystemOperations.hh:345
Binary blob representation.
Definition: XrdClBuffer.hh:33
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:484
XRootDStatus GetXAttr(const std::string &path, const std::vector< std::string > &attrs, ResponseHandler *handler, uint16_t timeout=0)
Definition: XrdClOperations.hh:475
DirList operation (.
Definition: XrdClFileSystemOperations.hh:817
DeepLocate operation (.
Definition: XrdClFileSystemOperations.hh:160
Definition: XrdClFileSystemOperations.hh:409