xrootd
XrdClFileOperations.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_OPERATIONS_HH__
27 #define __XRD_CL_FILE_OPERATIONS_HH__
28 
29 #include "XrdCl/XrdClFile.hh"
30 #include "XrdCl/XrdClOperations.hh"
32 #include "XrdCl/XrdClCtx.hh"
33 
34 namespace XrdCl
35 {
36 
37  //----------------------------------------------------------------------------
43  //----------------------------------------------------------------------------
44  template<template<bool> class Derived, bool HasHndl, typename Response, typename ... Arguments>
45  class FileOperation: public ConcreteOperation<Derived, HasHndl, Response, Arguments...>
46  {
47 
48  template<template<bool> class, bool, typename, typename ...> friend class FileOperation;
49 
50  public:
51  //------------------------------------------------------------------------
56  //------------------------------------------------------------------------
57  FileOperation( Ctx<File> f, Arguments... args): ConcreteOperation<Derived, false, Response, Arguments...>( std::move( args )... ), file( std::move( f ) )
58  {
59  }
60 
61  //------------------------------------------------------------------------
67  //------------------------------------------------------------------------
68  template<bool from>
70  ConcreteOperation<Derived, HasHndl, Response, Arguments...>( std::move( op ) ), file( op.file )
71  {
72 
73  }
74 
75  //------------------------------------------------------------------------
77  //------------------------------------------------------------------------
78  virtual ~FileOperation()
79  {
80 
81  }
82 
83  protected:
84 
85  //------------------------------------------------------------------------
87  //------------------------------------------------------------------------
89  };
90 
91  //----------------------------------------------------------------------------
93  //----------------------------------------------------------------------------
94  template<bool HasHndl>
97  {
98  //------------------------------------------------------------------------
104  //------------------------------------------------------------------------
105  struct ExResp : public Resp<void>
106  {
107  //--------------------------------------------------------------------
111  //--------------------------------------------------------------------
112  ExResp( const Ctx<File> &file ): file( file )
113  {
114  }
115 
116  //--------------------------------------------------------------------
121  //--------------------------------------------------------------------
122  inline ResponseHandler* Create( std::function<void( XRootDStatus&,
123  StatInfo& )> func )
124  {
125  return new ExOpenFuncWrapper( this->file, func );
126  }
127 
128  //--------------------------------------------------------------------
130  //--------------------------------------------------------------------
131  using Resp<void>::Create;
132 
133  //--------------------------------------------------------------------
135  //--------------------------------------------------------------------
137  };
138 
139  public:
140 
141  //------------------------------------------------------------------------
143  //------------------------------------------------------------------------
146  FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>, Arg<OpenFlags::Flags>,
147  Arg<Access::Mode>>( std::move( f ), std::move( url ), std::move( flags ),
148  std::move( mode ) )
149  {
150  }
151 
152  //------------------------------------------------------------------------
158  //------------------------------------------------------------------------
159  template<bool from>
161  FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>, Arg<OpenFlags::Flags>,
162  Arg<Access::Mode>>( std::move( open ) )
163  {
164  }
165 
166 
167  //------------------------------------------------------------------------
169  //------------------------------------------------------------------------
170  enum { UrlArg, FlagsArg, ModeArg };
171 
172  //------------------------------------------------------------------------
177  //------------------------------------------------------------------------
178  template<typename Hdlr>
179  OpenImpl<true> operator>>( Hdlr &&hdlr )
180  {
181  ExResp factory( *this->file );
182  return this->StreamImpl( factory.Create( hdlr ) );
183  }
184 
185  //------------------------------------------------------------------------
187  //------------------------------------------------------------------------
188  std::string ToString()
189  {
190  return "Open";
191  }
192 
193  protected:
194 
195  //------------------------------------------------------------------------
200  //------------------------------------------------------------------------
201  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
202  {
203  const std::string &url = std::get<UrlArg>( this->args );
204  OpenFlags::Flags flags = std::get<FlagsArg>( this->args );
205  Access::Mode mode = std::get<ModeArg>( this->args );
206  uint16_t timeout = pipelineTimeout < this->timeout ?
207  pipelineTimeout : this->timeout;
208  return this->file->Open( url, flags, mode, handler, timeout );
209  }
210  };
212 
213  //----------------------------------------------------------------------------
215  //----------------------------------------------------------------------------
216  template<bool HasHndl>
217  class ReadImpl: public FileOperation<ReadImpl, HasHndl, Resp<ChunkInfo>,
218  Arg<uint64_t>, Arg<uint32_t>, Arg<void*>>
219  {
220  public:
221 
222  //------------------------------------------------------------------------
224  //------------------------------------------------------------------------
227 
228  //------------------------------------------------------------------------
230  //------------------------------------------------------------------------
232 
233  //------------------------------------------------------------------------
235  //------------------------------------------------------------------------
236  std::string ToString()
237  {
238  return "Read";
239  }
240 
241  protected:
242 
243  //------------------------------------------------------------------------
249  //------------------------------------------------------------------------
250  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
251  {
252  uint64_t offset = std::get<OffsetArg>( this->args ).Get();
253  uint32_t size = std::get<SizeArg>( this->args ).Get();
254  void *buffer = std::get<BufferArg>( this->args ).Get();
255  uint16_t timeout = pipelineTimeout < this->timeout ?
256  pipelineTimeout : this->timeout;
257  return this->file->Read( offset, size, buffer, handler, timeout );
258  }
259  };
260 
261  //----------------------------------------------------------------------------
263  //----------------------------------------------------------------------------
265  Arg<void*> buffer, uint16_t timeout = 0 )
266  {
267  return ReadImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
268  std::move( buffer ) ).Timeout( timeout );
269  }
270 
271  //----------------------------------------------------------------------------
273  //----------------------------------------------------------------------------
274  template<bool HasHndl>
275  class CloseImpl: public FileOperation<CloseImpl, HasHndl, Resp<void>>
276  {
277  public:
278 
279  //------------------------------------------------------------------------
281  //------------------------------------------------------------------------
283 
284  //------------------------------------------------------------------------
286  //------------------------------------------------------------------------
287  std::string ToString()
288  {
289  return "Close";
290  }
291 
292  protected:
293 
294  //------------------------------------------------------------------------
300  //------------------------------------------------------------------------
301  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
302  {
303  uint16_t timeout = pipelineTimeout < this->timeout ?
304  pipelineTimeout : this->timeout;
305  return this->file->Close( handler, timeout );
306  }
307  };
309 
310  //----------------------------------------------------------------------------
312  //----------------------------------------------------------------------------
313  template<bool HasHndl>
314  class StatImpl: public FileOperation<StatImpl, HasHndl, Resp<StatInfo>, Arg<bool>>
315  {
316  public:
317 
318  //------------------------------------------------------------------------
320  //------------------------------------------------------------------------
322 
323  //------------------------------------------------------------------------
325  //------------------------------------------------------------------------
326  enum { ForceArg };
327 
328  //------------------------------------------------------------------------
330  //------------------------------------------------------------------------
331  std::string ToString()
332  {
333  return "Stat";
334  }
335 
336  protected:
337 
338  //------------------------------------------------------------------------
344  //------------------------------------------------------------------------
345  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
346  {
347  bool force = std::get<ForceArg>( this->args ).Get();
348  uint16_t timeout = pipelineTimeout < this->timeout ?
349  pipelineTimeout : this->timeout;
350  return this->file->Stat( force, handler, timeout );
351  }
352  };
353 
354  //----------------------------------------------------------------------------
357  //----------------------------------------------------------------------------
358  inline StatImpl<false> Stat( Ctx<File> file, Arg<bool> force, uint16_t timeout = 0 )
359  {
360  return StatImpl<false>( std::move( file ), std::move( force ) ).Timeout( timeout );
361  }
362 
363  //----------------------------------------------------------------------------
365  //----------------------------------------------------------------------------
366  template<bool HasHndl>
367  class WriteImpl: public FileOperation<WriteImpl, HasHndl, Resp<void>, Arg<uint64_t>,
368  Arg<uint32_t>, Arg<const void*>>
369  {
370  public:
371 
372  //------------------------------------------------------------------------
374  //------------------------------------------------------------------------
377 
378  //------------------------------------------------------------------------
380  //------------------------------------------------------------------------
382 
383  //------------------------------------------------------------------------
385  //------------------------------------------------------------------------
386  std::string ToString()
387  {
388  return "Write";
389  }
390 
391  protected:
392 
393  //------------------------------------------------------------------------
399  //------------------------------------------------------------------------
400  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
401  {
402  uint64_t offset = std::get<OffsetArg>( this->args ).Get();
403  uint32_t size = std::get<SizeArg>( this->args ).Get();
404  const void *buffer = std::get<BufferArg>( this->args ).Get();
405  uint16_t timeout = pipelineTimeout < this->timeout ?
406  pipelineTimeout : this->timeout;
407  return this->file->Write( offset, size, buffer, handler, timeout );
408  }
409  };
410 
411  //----------------------------------------------------------------------------
413  //----------------------------------------------------------------------------
415  Arg<const void*> buffer, uint16_t timeout = 0 )
416  {
417  return WriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
418  std::move( buffer ) ).Timeout( timeout );
419  }
420 
421  //----------------------------------------------------------------------------
423  //----------------------------------------------------------------------------
424  template<bool HasHndl>
425  class SyncImpl: public FileOperation<SyncImpl, HasHndl, Resp<void>>
426  {
427  public:
428 
429  //------------------------------------------------------------------------
431  //------------------------------------------------------------------------
433 
434  //------------------------------------------------------------------------
436  //------------------------------------------------------------------------
437  std::string ToString()
438  {
439  return "Sync";
440  }
441 
442  protected:
443 
444  //------------------------------------------------------------------------
450  //------------------------------------------------------------------------
451  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
452  {
453  uint16_t timeout = pipelineTimeout < this->timeout ?
454  pipelineTimeout : this->timeout;
455  return this->file->Sync( handler, timeout );
456  }
457  };
459 
460  //----------------------------------------------------------------------------
462  //----------------------------------------------------------------------------
463  template<bool HasHndl>
464  class TruncateImpl: public FileOperation<TruncateImpl, HasHndl, Resp<void>, Arg<uint64_t>>
465  {
466  public:
467 
468  //------------------------------------------------------------------------
470  //------------------------------------------------------------------------
472 
473  //------------------------------------------------------------------------
475  //------------------------------------------------------------------------
476  enum { SizeArg };
477 
478  //------------------------------------------------------------------------
480  //------------------------------------------------------------------------
481  std::string ToString()
482  {
483  return "Truncate";
484  }
485 
486  protected:
487 
488  //------------------------------------------------------------------------
494  //------------------------------------------------------------------------
495  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
496  {
497  uint64_t size = std::get<SizeArg>( this->args ).Get();
498  uint16_t timeout = pipelineTimeout < this->timeout ?
499  pipelineTimeout : this->timeout;
500  return this->file->Truncate( size, handler, timeout );
501  }
502  };
503 
504  //----------------------------------------------------------------------------
507  //----------------------------------------------------------------------------
509  {
510  return TruncateImpl<false>( std::move( file ), std::move( size ) );
511  }
512 
513  //----------------------------------------------------------------------------
515  //----------------------------------------------------------------------------
516  template<bool HasHndl>
517  class VectorReadImpl: public FileOperation<VectorReadImpl, HasHndl,
518  Resp<VectorReadInfo>, Arg<ChunkList>, Arg<void*>>
519  {
520  public:
521 
522  //------------------------------------------------------------------------
524  //------------------------------------------------------------------------
527 
528  //------------------------------------------------------------------------
530  //------------------------------------------------------------------------
531  enum { ChunksArg, BufferArg };
532 
533  //------------------------------------------------------------------------
535  //------------------------------------------------------------------------
536  std::string ToString()
537  {
538  return "VectorRead";
539  }
540 
541  protected:
542 
543  //------------------------------------------------------------------------
549  //------------------------------------------------------------------------
550  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
551  {
552  ChunkList &chunks = std::get<ChunksArg>( this->args ).Get();
553  void *buffer = std::get<BufferArg>( this->args ).Get();
554  uint16_t timeout = pipelineTimeout < this->timeout ?
555  pipelineTimeout : this->timeout;
556  return this->file->VectorRead( chunks, buffer, handler, timeout );
557  }
558  };
560 
561  //----------------------------------------------------------------------------
563  //----------------------------------------------------------------------------
564  template<bool HasHndl>
565  class VectorWriteImpl: public FileOperation<VectorWriteImpl, HasHndl, Resp<void>,
566  Arg<ChunkList>>
567  {
568  public:
569 
570  //------------------------------------------------------------------------
572  //------------------------------------------------------------------------
574 
575  //------------------------------------------------------------------------
577  //------------------------------------------------------------------------
578  enum { ChunksArg };
579 
580  //------------------------------------------------------------------------
582  //------------------------------------------------------------------------
583  std::string ToString()
584  {
585  return "VectorWrite";
586  }
587 
588  protected:
589 
590  //------------------------------------------------------------------------
596  //------------------------------------------------------------------------
597  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
598  {
599  const ChunkList &chunks = std::get<ChunksArg>( this->args ).Get();
600  uint16_t timeout = pipelineTimeout < this->timeout ?
601  pipelineTimeout : this->timeout;
602  return this->file->VectorWrite( chunks, handler, timeout );
603  }
604  };
606 
607  //----------------------------------------------------------------------------
609  //----------------------------------------------------------------------------
610  template<bool HasHndl>
611  class WriteVImpl: public FileOperation<WriteVImpl, HasHndl, Resp<void>, Arg<uint64_t>,
612  Arg<struct iovec*>, Arg<int>>
613  {
614  public:
615 
616  //------------------------------------------------------------------------
618  //------------------------------------------------------------------------
621 
622  //------------------------------------------------------------------------
624  //------------------------------------------------------------------------
626 
627  //------------------------------------------------------------------------
629  //------------------------------------------------------------------------
630  std::string ToString()
631  {
632  return "WriteV";
633  }
634 
635  protected:
636 
637  //------------------------------------------------------------------------
643  //------------------------------------------------------------------------
644  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
645  {
646  uint64_t offset = std::get<OffsetArg>( this->args ).Get();
647  const struct iovec *iov = std::get<IovArg>( this->args ).Get();
648  int iovcnt = std::get<IovcntArg>( this->args ).Get();
649  uint16_t timeout = pipelineTimeout < this->timeout ?
650  pipelineTimeout : this->timeout;
651  return this->file->WriteV( offset, iov, iovcnt, handler, timeout );
652  }
653  };
655 
656  //----------------------------------------------------------------------------
658  //----------------------------------------------------------------------------
659  template<bool HasHndl>
660  class FcntlImpl: public FileOperation<FcntlImpl, HasHndl, Resp<Buffer>, Arg<Buffer>>
661  {
662  public:
663 
664  //------------------------------------------------------------------------
666  //------------------------------------------------------------------------
668 
669  //------------------------------------------------------------------------
671  //------------------------------------------------------------------------
672  enum { BufferArg };
673 
674  //------------------------------------------------------------------------
676  //------------------------------------------------------------------------
677  std::string ToString()
678  {
679  return "Fcntl";
680  }
681 
682  protected:
683 
684  //------------------------------------------------------------------------
690  //------------------------------------------------------------------------
691  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
692  {
693  Buffer &arg = std::get<BufferArg>( this->args ).Get();
694  uint16_t timeout = pipelineTimeout < this->timeout ?
695  pipelineTimeout : this->timeout;
696  return this->file->Fcntl( arg, handler, timeout );
697  }
698  };
700 
701  //----------------------------------------------------------------------------
703  //----------------------------------------------------------------------------
704  template<bool HasHndl>
705  class VisaImpl: public FileOperation<VisaImpl, HasHndl, Resp<Buffer>>
706  {
707  public:
708 
709  //------------------------------------------------------------------------
711  //------------------------------------------------------------------------
713 
714  //------------------------------------------------------------------------
716  //------------------------------------------------------------------------
717  std::string ToString()
718  {
719  return "Visa";
720  }
721 
722  protected:
723 
724  //------------------------------------------------------------------------
730  //------------------------------------------------------------------------
731  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
732  {
733  uint16_t timeout = pipelineTimeout < this->timeout ?
734  pipelineTimeout : this->timeout;
735  return this->file->Visa( handler, timeout );
736  }
737  };
739 
740  //----------------------------------------------------------------------------
742  //----------------------------------------------------------------------------
743  template<bool HasHndl>
744  class SetXAttrImpl: public FileOperation<SetXAttrImpl, HasHndl, Resp<void>,
745  Arg<std::string>, Arg<std::string>>
746  {
747  public:
748 
749  //------------------------------------------------------------------------
751  //------------------------------------------------------------------------
754 
755  //------------------------------------------------------------------------
757  //------------------------------------------------------------------------
758  enum { NameArg, ValueArg };
759 
760  //------------------------------------------------------------------------
762  //------------------------------------------------------------------------
763  std::string ToString()
764  {
765  return "SetXAttrImpl";
766  }
767 
768  protected:
769 
770  //------------------------------------------------------------------------
776  //------------------------------------------------------------------------
777  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
778  {
779  std::string &name = std::get<NameArg>( this->args ).Get();
780  std::string &value = std::get<ValueArg>( this->args ).Get();
781  // wrap the arguments with a vector
782  std::vector<xattr_t> attrs;
783  attrs.push_back( xattr_t( name, value ) );
784  // wrap the PipelineHandler so the response gets unpacked properly
786  uint16_t timeout = pipelineTimeout < this->timeout ?
787  pipelineTimeout : this->timeout;
788  XRootDStatus st = this->file->SetXAttr( attrs, h, timeout );
789  if( !st.IsOK() ) delete h;
790  return st;
791  }
792  };
793 
794  //----------------------------------------------------------------------------
797  //----------------------------------------------------------------------------
799  {
800  return SetXAttrImpl<false>( std::move( file ), std::move( name ), std::move( value ) );
801  }
802 
803  //----------------------------------------------------------------------------
805  //----------------------------------------------------------------------------
806  template<bool HasHndl>
807  class SetXAttrBulkImpl: public FileOperation<SetXAttrBulkImpl, HasHndl,
808  Resp<std::vector<XAttrStatus>>, Arg<std::vector<xattr_t>>>
809  {
810  public:
811 
812  //------------------------------------------------------------------------
814  //------------------------------------------------------------------------
817 
818  //------------------------------------------------------------------------
820  //------------------------------------------------------------------------
821  enum { AttrsArg };
822 
823  //------------------------------------------------------------------------
825  //------------------------------------------------------------------------
826  std::string ToString()
827  {
828  return "SetXAttrBulkImpl";
829  }
830 
831 
832  protected:
833 
834  //------------------------------------------------------------------------
840  //------------------------------------------------------------------------
841  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
842  {
843  std::vector<xattr_t> &attrs = std::get<AttrsArg>( this->args ).Get();
844  uint16_t timeout = pipelineTimeout < this->timeout ?
845  pipelineTimeout : this->timeout;
846  return this->file->SetXAttr( attrs, handler, timeout );
847  }
848  };
849 
850  //----------------------------------------------------------------------------
853  //----------------------------------------------------------------------------
854  inline SetXAttrBulkImpl<false> SetXAttr( Ctx<File> file, Arg<std::vector<xattr_t>> attrs )
855  {
856  return SetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
857  }
858 
859  //----------------------------------------------------------------------------
861  //----------------------------------------------------------------------------
862  template<bool HasHndl>
863  class GetXAttrImpl: public FileOperation<GetXAttrImpl, HasHndl, Resp<std::string>,
864  Arg<std::string>>
865  {
866  public:
867 
868  //------------------------------------------------------------------------
870  //------------------------------------------------------------------------
873 
874  //------------------------------------------------------------------------
876  //------------------------------------------------------------------------
877  enum { NameArg };
878 
879  //------------------------------------------------------------------------
881  //------------------------------------------------------------------------
882  std::string ToString()
883  {
884  return "GetXAttrImpl";
885  }
886 
887  protected:
888 
889  //------------------------------------------------------------------------
895  //------------------------------------------------------------------------
896  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
897  {
898  std::string &name = std::get<NameArg>( this->args ).Get();
899  // wrap the argument with a vector
900  std::vector<std::string> attrs;
901  attrs.push_back( name );
902  // wrap the PipelineHandler so the response gets unpacked properly
903  UnpackXAttr *h = new UnpackXAttr( handler );
904  uint16_t timeout = pipelineTimeout < this->timeout ?
905  pipelineTimeout : this->timeout;
906  XRootDStatus st = this->file->GetXAttr( attrs, h, timeout );
907  if( !st.IsOK() ) delete handler;
908  return st;
909  }
910  };
911 
912  //----------------------------------------------------------------------------
915  //----------------------------------------------------------------------------
917  {
918  return GetXAttrImpl<false>( std::move( file ), std::move( name ) );
919  }
920 
921  //----------------------------------------------------------------------------
923  //----------------------------------------------------------------------------
924  template<bool HasHndl>
925  class GetXAttrBulkImpl: public FileOperation<GetXAttrBulkImpl, HasHndl, Resp<std::vector<XAttr>>,
926  Arg<std::vector<std::string>>>
927  {
928  public:
929 
930  //------------------------------------------------------------------------
932  //------------------------------------------------------------------------
935 
936  //------------------------------------------------------------------------
938  //------------------------------------------------------------------------
939  enum { NamesArg };
940 
941  //------------------------------------------------------------------------
943  //------------------------------------------------------------------------
944  std::string ToString()
945  {
946  return "GetXAttrBulkImpl";
947  }
948 
949 
950  protected:
951 
952  //------------------------------------------------------------------------
958  //------------------------------------------------------------------------
959  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
960  {
961  std::vector<std::string> &attrs = std::get<NamesArg>( this->args ).Get();
962  uint16_t timeout = pipelineTimeout < this->timeout ?
963  pipelineTimeout : this->timeout;
964  return this->file->GetXAttr( attrs, handler, timeout );
965  }
966  };
967 
968  //----------------------------------------------------------------------------
971  //----------------------------------------------------------------------------
972  inline GetXAttrBulkImpl<false> GetXAttr( Ctx<File> file, Arg<std::vector<std::string>> attrs )
973  {
974  return GetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
975  }
976 
977  //----------------------------------------------------------------------------
979  //----------------------------------------------------------------------------
980  template<bool HasHndl>
981  class DelXAttrImpl: public FileOperation<DelXAttrImpl, HasHndl, Resp<void>,
982  Arg<std::string>>
983  {
984  public:
985 
986  //------------------------------------------------------------------------
988  //------------------------------------------------------------------------
990 
991  //------------------------------------------------------------------------
993  //------------------------------------------------------------------------
994  enum { NameArg };
995 
996  //------------------------------------------------------------------------
998  //------------------------------------------------------------------------
999  std::string ToString()
1000  {
1001  return "DelXAttrImpl";
1002  }
1003 
1004  protected:
1005 
1006  //------------------------------------------------------------------------
1012  //------------------------------------------------------------------------
1013  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
1014  {
1015  std::string &name = std::get<NameArg>( this->args ).Get();
1016  // wrap the argument with a vector
1017  std::vector<std::string> attrs;
1018  attrs.push_back( name );
1019  // wrap the PipelineHandler so the response gets unpacked properly
1021  uint16_t timeout = pipelineTimeout < this->timeout ?
1022  pipelineTimeout : this->timeout;
1023  XRootDStatus st = this->file->DelXAttr( attrs, h, timeout );
1024  if( !st.IsOK() ) delete h;
1025  return st;
1026  }
1027  };
1028 
1029  //----------------------------------------------------------------------------
1032  //----------------------------------------------------------------------------
1034  {
1035  return DelXAttrImpl<false>( std::move( file ), std::move( name ) );
1036  }
1037 
1038  //----------------------------------------------------------------------------
1040  //----------------------------------------------------------------------------
1041  template<bool HasHndl>
1042  class DelXAttrBulkImpl: public FileOperation<DelXAttrBulkImpl, HasHndl,
1043  Resp<std::vector<XAttrStatus>>, Arg<std::vector<std::string>>>
1044  {
1045  public:
1046 
1047  //------------------------------------------------------------------------
1049  //------------------------------------------------------------------------
1052 
1053  //------------------------------------------------------------------------
1055  //------------------------------------------------------------------------
1056  enum { NamesArg };
1057 
1058  //------------------------------------------------------------------------
1060  //------------------------------------------------------------------------
1061  std::string ToString()
1062  {
1063  return "DelXAttrBulkImpl";
1064  }
1065 
1066 
1067  protected:
1068 
1069  //------------------------------------------------------------------------
1075  //------------------------------------------------------------------------
1076  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
1077  {
1078  std::vector<std::string> &attrs = std::get<NamesArg>( this->args ).Get();
1079  uint16_t timeout = pipelineTimeout < this->timeout ?
1080  pipelineTimeout : this->timeout;
1081  return this->file->DelXAttr( attrs, handler, timeout );
1082  }
1083  };
1084 
1085  //----------------------------------------------------------------------------
1088  //----------------------------------------------------------------------------
1089  inline DelXAttrBulkImpl<false> DelXAttr( Ctx<File> file, Arg<std::vector<std::string>> attrs )
1090  {
1091  return DelXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
1092  }
1093 
1094  //----------------------------------------------------------------------------
1096  //----------------------------------------------------------------------------
1097  template<bool HasHndl>
1098  class ListXAttrImpl: public FileOperation<ListXAttrImpl, HasHndl,
1099  Resp<std::vector<XAttr>>>
1100  {
1101  public:
1102 
1103  //------------------------------------------------------------------------
1105  //------------------------------------------------------------------------
1107 
1108  //------------------------------------------------------------------------
1110  //------------------------------------------------------------------------
1111  std::string ToString()
1112  {
1113  return "ListXAttrImpl";
1114  }
1115 
1116 
1117  protected:
1118 
1119  //------------------------------------------------------------------------
1125  //------------------------------------------------------------------------
1126  XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
1127  {
1128  uint16_t timeout = pipelineTimeout < this->timeout ?
1129  pipelineTimeout : this->timeout;
1130  return this->file->ListXAttr( handler, timeout );
1131  }
1132  };
1133 
1134  //----------------------------------------------------------------------------
1137  //----------------------------------------------------------------------------
1139  {
1140  return ListXAttrImpl<false>( std::move( file ) );
1141  }
1142 }
1143 
1144 #endif // __XRD_CL_FILE_OPERATIONS_HH__
1145 
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:841
Definition: XrdClFileOperations.hh:821
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:777
ListXAttrImpl< false > ListXAttr(Ctx< File > file)
Definition: XrdClFileOperations.hh:1138
std::string ToString()
Definition: XrdClFileOperations.hh:630
CloseImpl< false > Close
Definition: XrdClFileOperations.hh:308
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:959
std::string ToString()
Definition: XrdClFileOperations.hh:763
Close operation (.
Definition: XrdClFileOperations.hh:275
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:1076
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:1013
SetXAttrImpl< false > SetXAttr(Ctx< File > file, Arg< std::string > name, Arg< std::string > value)
Definition: XrdClFileOperations.hh:798
Definition: XrdClFileOperations.hh:326
Definition: XrdClFileOperations.hh:476
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:400
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:1126
Utility class for storing a pointer to operation context.
Definition: XrdClCtx.hh:37
std::vector< ChunkInfo > ChunkList
List of chunks.
Definition: XrdClXRootDResponses.hh:970
VectorReadImpl< false > VectorRead
Definition: XrdClFileOperations.hh:559
Definition: XrdClFileOperations.hh:758
VectorRead operation (.
Definition: XrdClFileOperations.hh:517
FcntlImpl< false > Fcntl
Definition: XrdClFileOperations.hh:699
std::string ToString()
Definition: XrdClFileOperations.hh:826
Object stat info.
Definition: XrdClXRootDResponses.hh:399
std::string ToString()
Definition: XrdClFileOperations.hh:287
std::string ToString()
Definition: XrdClFileOperations.hh:188
Definition: XrdClFileOperations.hh:381
Definition: XrdClOperationTimeout.hh:20
FileOperation(FileOperation< Derived, from, Response, Arguments... > &&op)
Definition: XrdClFileOperations.hh:69
std::string ToString()
Definition: XrdClFileOperations.hh:1061
Definition: XrdClFileOperations.hh:625
Definition: XrdClFileOperations.hh:381
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:550
Ctx< File > file
The underlying XrdCl::File object.
Definition: XrdClFileOperations.hh:136
DelXAttr bulk operation (.
Definition: XrdClFileOperations.hh:1042
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:451
VectorWrite operation (.
Definition: XrdClFileOperations.hh:565
uint16_t timeout
Operation timeout.
Definition: XrdClOperations.hh:746
Fcntl operation (.
Definition: XrdClFileOperations.hh:660
DelXAttrImpl< false > DelXAttr(Ctx< File > file, Arg< std::string > name)
Definition: XrdClFileOperations.hh:1033
Definition: XrdClFileOperations.hh:381
Definition: XrdClFileOperations.hh:758
SyncImpl< false > Sync
Definition: XrdClFileOperations.hh:458
bool IsOK() const
We&#39;re fine.
Definition: XrdClStatus.hh:122
SetXAttr operation (.
Definition: XrdClFileOperations.hh:744
std::string ToString()
Definition: XrdClFileOperations.hh:386
Visa operation (.
Definition: XrdClFileOperations.hh:705
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:691
std::string ToString()
Definition: XrdClFileOperations.hh:481
WriteImpl< false > Write(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< const void *> buffer, uint16_t timeout=0)
Factory for creating WriteImpl objects.
Definition: XrdClFileOperations.hh:414
Access mode.
Definition: XrdClFileSystem.hh:116
GetXAttr operation (.
Definition: XrdClFileOperations.hh:863
std::string ToString()
Definition: XrdClFileOperations.hh:437
Definition: XrdClFileOperations.hh:170
Read operation (.
Definition: XrdClFileOperations.hh:217
std::string ToString()
Definition: XrdClFileOperations.hh:583
std::string ToString()
Definition: XrdClFileOperations.hh:677
Definition: XrdClFileOperations.hh:231
std::string ToString()
Definition: XrdClFileOperations.hh:236
OpenImpl< true > operator>>(Hdlr &&hdlr)
Definition: XrdClFileOperations.hh:179
std::string ToString()
Definition: XrdClFileOperations.hh:1111
GetXAttrImpl< false > GetXAttr(Ctx< File > file, Arg< std::string > name)
Definition: XrdClFileOperations.hh:916
TruncateImpl< false > Truncate(Ctx< File > file, Arg< uint64_t > size)
Definition: XrdClFileOperations.hh:508
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:731
VectorWriteImpl< false > VectorWrite
Definition: XrdClFileOperations.hh:605
ListXAttr bulk operation (.
Definition: XrdClFileOperations.hh:1098
std::string ToString()
Definition: XrdClFileOperations.hh:717
Definition: XrdClOperationHandlers.hh:623
Truncate operation (.
Definition: XrdClFileOperations.hh:464
WriteV operation (.
Definition: XrdClFileOperations.hh:611
Open flags, may be or&#39;d when appropriate.
Definition: XrdClFileSystem.hh:70
Definition: XrdOucIOVec.hh:65
Definition: XrdClFileOperations.hh:877
std::string ToString()
Definition: XrdClFileOperations.hh:331
virtual ~FileOperation()
Destructor.
Definition: XrdClFileOperations.hh:78
SetXAttr bulk operation (.
Definition: XrdClFileOperations.hh:807
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:644
Helper class for unpacking single XAttr from bulk response.
Definition: XrdClOperationHandlers.hh:76
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:201
std::tuple< Args... > args
Operation arguments.
Definition: XrdClOperations.hh:741
Definition: XrdClArg.hh:232
Definition: XrdClFileOperations.hh:105
Definition: XrdClArg.hh:294
Stat operation (.
Definition: XrdClFileOperations.hh:314
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:495
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:896
Request status.
Definition: XrdClXRootDResponses.hh:218
Definition: XrdClAnyObject.hh:25
ReadImpl< false > Read(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void *> buffer, uint16_t timeout=0)
Factory for creating ReadImpl objects.
Definition: XrdClFileOperations.hh:264
StatImpl< false > Stat(Ctx< File > file, Arg< bool > force, uint16_t timeout=0)
Definition: XrdClFileOperations.hh:358
GetXAttr bulk operation (.
Definition: XrdClFileOperations.hh:925
Sync operation (.
Definition: XrdClFileOperations.hh:425
std::string ToString()
Definition: XrdClFileOperations.hh:882
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:250
Definition: XrdClOperations.hh:58
Lambda wrapper.
Definition: XrdClOperationHandlers.hh:311
Definition: XrdClFileOperations.hh:625
OpenImpl(OpenImpl< from > &&open)
Definition: XrdClFileOperations.hh:160
Definition: XrdClFileOperations.hh:231
Definition: XrdClFileOperations.hh:45
Handle an async response.
Definition: XrdClXRootDResponses.hh:1040
Definition: XrdClFileSystem.hh:123
Helper class for unpacking single XAttrStatus from bulk response.
Definition: XrdClOperationHandlers.hh:41
std::string ToString()
Definition: XrdClFileOperations.hh:536
OpenImpl< false > Open
Definition: XrdClFileOperations.hh:211
friend class FileOperation
Definition: XrdClFileOperations.hh:48
ResponseHandler * Create(std::function< void(XRootDStatus &, StatInfo &)> func)
Definition: XrdClFileOperations.hh:122
Open operation (.
Definition: XrdClFileOperations.hh:95
Definition: XrdClFileOperations.hh:1056
Definition: XrdClFileOperations.hh:578
Definition: XrdClFileOperations.hh:231
WriteVImpl< false > WriteV
Definition: XrdClFileOperations.hh:654
Definition: XrdClFileOperations.hh:531
Mode
Access mode.
Definition: XrdClFileSystem.hh:121
std::string ToString()
Definition: XrdClFileOperations.hh:999
#define open
Definition: XrdPosix.hh:71
VisaImpl< false > Visa
Definition: XrdClFileOperations.hh:738
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:345
Definition: XrdClFileOperations.hh:672
Definition: XrdClFileOperations.hh:625
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:597
FileOperation(Ctx< File > f, Arguments... args)
Definition: XrdClFileOperations.hh:57
XRootDStatus RunImpl(PipelineHandler *handler, uint16_t pipelineTimeout)
Definition: XrdClFileOperations.hh:301
Definition: XrdClFileOperations.hh:994
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:289
Ctx< File > file
The file object itself.
Definition: XrdClFileOperations.hh:88
Write operation (.
Definition: XrdClFileOperations.hh:367
std::string ToString()
Definition: XrdClFileOperations.hh:944
ExResp(const Ctx< File > &file)
Definition: XrdClFileOperations.hh:112
std::unique_ptr< PipelineHandler > handler
Operation handler.
Definition: XrdClOperations.hh:304
Definition: XrdClFileOperations.hh:939
OpenImpl(Ctx< File > f, Arg< std::string > url, Arg< OpenFlags::Flags > flags, Arg< Access::Mode > mode=Access::None)
Constructor (.
Definition: XrdClFileOperations.hh:144
Binary blob representation.
Definition: XrdClBuffer.hh:33
DelXAttr operation (.
Definition: XrdClFileOperations.hh:981
Definition: XrdClFileOperations.hh:531
Definition: XrdClOperations.hh:521