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->RmDir( 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 
986 #endif // __XRD_CL_FILE_SYSTEM_OPERATIONS_HH__
ProtocolImpl< false > Protocol
Definition: XrdClFileSystemOperations.hh:811
Definition: XrdClFileSystemOperations.hh:174
Definition: XrdClFileSystemOperations.hh:888
friend class FileSystemOperation
Definition: XrdClFileSystemOperations.hh:47
SendInfoImpl< false > SendInfo
Definition: XrdClFileSystemOperations.hh:924
Protocol operation (.
Definition: XrdClFileSystemOperations.hh:779
Definition: XrdClFileSystemOperations.hh:465
std::string ToString()
Definition: XrdClFileSystemOperations.hh:742
Definition: XrdClFileSystemOperations.hh:465
MvImpl< false > Mv
Definition: XrdClFileSystemOperations.hh:268
std::string ToString()
Definition: XrdClFileSystemOperations.hh:527
QueryImpl< false > Query
Definition: XrdClFileSystemOperations.hh:325
std::string ToString()
Definition: XrdClFileSystemOperations.hh:350
Definition: XrdClFileSystemOperations.hh:409
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
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:963
std::string ToString()
Definition: XrdClFileSystemOperations.hh:179
Definition: XrdClFileSystemOperations.hh:117
XRootDStatus Ping(ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Definition: XrdClFileSystemOperations.hh:44
Definition: XrdClFileSystemOperations.hh:672
XRootDStatus SendInfo(const std::string &info, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:250
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:193
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:364
XRootDStatus Truncate(const std::string &path, uint64_t size, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
std::string ToString()
Definition: XrdClFileSystemOperations.hh:949
Stat operation (.
Definition: XrdClFileSystemOperations.hh:658
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:428
Definition: XrdClFileSystemOperations.hh:578
LocateImpl< false > Locate
Definition: XrdClFileSystemOperations.hh:154
std::string ToString()
Definition: XrdClFileSystemOperations.hh:633
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:691
Definition: XrdClFileSystemOperations.hh:737
Flags
Definition: XrdClFileSystem.hh:173
MkDir operation (.
Definition: XrdClFileSystemOperations.hh:451
Prepare operation (.
Definition: XrdClFileSystemOperations.hh:930
Definition: XrdClFileSystemOperations.hh:944
FileSystemOperation(FileSystem *fs, Args... args)
Definition: XrdClFileSystemOperations.hh:56
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
Query operation (.
Definition: XrdClFileSystemOperations.hh:274
FileSystemOperation(FileSystemOperation< Derived, from, Response, Args... > &&op)
Definition: XrdClFileSystemOperations.hh:79
std::string ToString()
Definition: XrdClFileSystemOperations.hh:470
Definition: XrdClFileSystemOperations.hh:231
Definition: XrdClFileSystemOperations.hh:174
Definition: XrdClFileSystemOperations.hh:345
Pipeline exception, wrapps an XRootDStatus.
Definition: XrdClOperationHandlers.hh:311
XRootDStatus Prepare(const std::vector< std::string > &fileList, PrepareFlags::Flags flags, uint8_t priority, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:806
XRootDStatus RmDir(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Flags
Definition: XrdClFileSystem.hh:141
Definition: XrdClFileSystemOperations.hh:288
Truncate operation (.
Definition: XrdClFileSystemOperations.hh:331
Definition: XrdClFileSystemOperations.hh:465
FileSystemOperation(FileSystem &fs, Args... args)
Definition: XrdClFileSystemOperations.hh:67
Definition: XrdClFileSystemOperations.hh:578
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:136
std::tuple< Args... > args
Operation arguments.
Definition: XrdClOperations.hh:686
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:398
DirListImpl< false > DirList
Definition: XrdClFileSystemOperations.hh:868
Definition: XrdClFileSystemOperations.hh:944
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:212
StatVS operation (.
Definition: XrdClFileSystemOperations.hh:723
std::string ToString()
Definition: XrdClFileSystemOperations.hh:677
Definition: XrdClFileSystemOperations.hh:831
Definition: XrdClAnyObject.hh:25
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:307
FileSystem * filesystem
The file system object itself.
Definition: XrdClFileSystemOperations.hh:96
virtual ~FileSystemOperation()
Destructor.
Definition: XrdClFileSystemOperations.hh:87
const XRootDStatus & GetError() const
Definition: XrdClOperationHandlers.hh:351
ChMod operation (.
Definition: XrdClFileSystemOperations.hh:564
XRootDStatus DirList(const std::string &path, DirListFlags::Flags flags, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Definition: XrdClFileSystemOperations.hh:831
std::string ToString()
Definition: XrdClFileSystemOperations.hh:836
Definition: XrdClFileSystemOperations.hh:345
std::string ToString()
Definition: XrdClFileSystemOperations.hh:583
Mv operation (.
Definition: XrdClFileSystemOperations.hh:217
Code
XRootD query request codes.
Definition: XrdClFileSystem.hh:53
XRootDStatus DeepLocate(const std::string &path, OpenFlags::Flags flags, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Definition: XrdClFileSystemOperations.hh:522
Rm operation (.
Definition: XrdClFileSystemOperations.hh:397
Flags
Definition: XrdClFileSystem.hh:154
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
std::string ToString()
Definition: XrdClFileSystemOperations.hh:893
Definition: XrdClFileSystemOperations.hh:231
ChModImpl< false > ChMod
Definition: XrdClFileSystemOperations.hh:615
Mode
Access mode.
Definition: XrdClFileSystem.hh:120
SendInfo operation (.
Definition: XrdClFileSystemOperations.hh:874
Send file/filesystem queries to an XRootD cluster.
Definition: XrdClFileSystem.hh:195
Definition: XrdClFileSystemOperations.hh:944
PingImpl< false > Ping
Definition: XrdClFileSystemOperations.hh:652
DeepLocateImpl< false > DeepLocate
Definition: XrdClFileSystemOperations.hh:211
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:756
std::string ToString()
Definition: XrdClFileSystemOperations.hh:236
std::string ToString()
Definition: XrdClFileSystemOperations.hh:122
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:850
Flags
Open flags, may be or'd when appropriate.
Definition: XrdClFileSystem.hh:76
TruncateImpl< false > Truncate(File *file, Arg< uint64_t > size)
Definition: XrdClFileOperations.hh:564
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
std::unique_ptr< PipelineHandler > handler
Operation handler.
Definition: XrdClOperations.hh:280
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:907
RmDirImpl< false > RmDir
Definition: XrdClFileSystemOperations.hh:558
Definition: XrdClFileSystemOperations.hh:288
Binary blob representation.
Definition: XrdClBuffer.hh:33
XRootDStatus RunImpl()
Definition: XrdClFileSystemOperations.hh:484
Definition: XrdClOperations.hh:467
DirList operation (.
Definition: XrdClFileSystemOperations.hh:817
DeepLocate operation (.
Definition: XrdClFileSystemOperations.hh:160