db/d99/XrdClFileStateHandler_8hh_source.html

 //------------------------------------------------------------------------------

 // Copyright (c) 2011-2014 by European Organization for Nuclear Research (CERN)

 // Author: Lukasz Janyst <ljanyst@cern.ch>

 //------------------------------------------------------------------------------

 // This file is part of the XRootD software suite.

 //

 // XRootD is free software: you can redistribute it and/or modify

 // it under the terms of the GNU Lesser General Public License as published by

 // the Free Software Foundation, either version 3 of the License, or

 // (at your option) any later version.

 //

 // XRootD is distributed in the hope that it will be useful,

 // but WITHOUT ANY WARRANTY; without even the implied warranty of

 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 // GNU General Public License for more details.

 //

 // You should have received a copy of the GNU Lesser General Public License

 // along with XRootD.  If not, see <http://www.gnu.org/licenses/>.

 //

 // In applying this licence, CERN does not waive the privileges and immunities

 // granted to it by virtue of its status as an Intergovernmental Organization

 // or submit itself to any jurisdiction.

 //------------------------------------------------------------------------------


 #ifndef __XRD_CL_FILE_STATE_HANDLER_HH__

 #define __XRD_CL_FILE_STATE_HANDLER_HH__


 #include "XrdCl/XrdClXRootDResponses.hh"

 #include "XrdCl/XrdClPostMasterInterfaces.hh"

 #include "XrdCl/XrdClFileSystem.hh"

 #include "XrdCl/XrdClMessageUtils.hh"

 #include "XrdCl/XrdClLocalFileHandler.hh"

 #include "XrdCl/XrdClOptional.hh"

 #include "XrdCl/XrdClPlugInInterface.hh"

 #include "XrdSys/XrdSysPthread.hh"

 #include "XrdSys/XrdSysPageSize.hh"


 #include <list>

 #include <set>

 #include <vector>


 #include <sys/time.h>

 #include <sys/uio.h>

 #include <cstdint>


 namespace

 {

   class PgReadHandler;

   class PgReadRetryHandler;

   class PgReadSubstitutionHandler;

   class OpenHandler;

 }


 namespace XrdCl

 {

   class Message;

   class EcHandler;


   //----------------------------------------------------------------------------

   //----------------------------------------------------------------------------

   struct PgReadFlags

   {

       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       enum Flags

       {

         None  = 0,                      //< Nothing

         Retry = XrdProto::kXR_pgRetry  //< Retry reading currupted page


       };

   };

   XRDOUC_ENUM_OPERATORS( PgReadFlags::Flags )


   //----------------------------------------------------------------------------

   //----------------------------------------------------------------------------

   class FileStateHandler

   {

       friend class ::PgReadHandler;

       friend class ::PgReadRetryHandler;

       friend class ::PgReadSubstitutionHandler;

       friend class ::OpenHandler;


     public:

       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       enum FileStatus

       {

         Closed,

         Opened,

         Error,

         Recovering,

         OpenInProgress,

         CloseInProgress

       };


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       FileStateHandler( FilePlugIn *& plugin );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       FileStateHandler( bool useVirtRedirector, FilePlugIn *& plugin );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       ~FileStateHandler();


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Open( std::shared_ptr<FileStateHandler> &self,

                                 const std::string                 &url,

                                 uint16_t                           flags,

                                 uint16_t                           mode,

                                 ResponseHandler                   *handler,

                                 time_t                             timeout  = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Close( std::shared_ptr<FileStateHandler> &self,

                                  ResponseHandler                   *handler,

                                  time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Stat( std::shared_ptr<FileStateHandler> &self,

                                 bool                               force,

                                 ResponseHandler                   *handler,

                                 time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Read( std::shared_ptr<FileStateHandler> &self,

                                 uint64_t                           offset,

                                 uint32_t                           size,

                                 void                              *buffer,

                                 ResponseHandler                   *handler,

                                 time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus PgRead( std::shared_ptr<FileStateHandler> &self,

                                   uint64_t                           offset,

                                   uint32_t                           size,

                                   void                              *buffer,

                                   ResponseHandler                   *handler,

                                   time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus PgReadRetry( std::shared_ptr<FileStateHandler> &self,

                                        uint64_t                           offset,

                                        uint32_t                           size,

                                        size_t                             pgnb,

                                        void                              *buffer,

                                        PgReadHandler                     *handler,

                                        time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus PgReadImpl( std::shared_ptr<FileStateHandler> &self,

                                       uint64_t                           offset,

                                       uint32_t                           size,

                                       void                              *buffer,

                                       uint16_t                           flags,

                                       ResponseHandler                   *handler,

                                       time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Write( std::shared_ptr<FileStateHandler> &self,

                                  uint64_t                           offset,

                                  uint32_t                           size,

                                  const void                        *buffer,

                                  ResponseHandler                   *handler,

                                  time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Write( std::shared_ptr<FileStateHandler> &self,

                                  uint64_t                           offset,

                                  Buffer                           &&buffer,

                                  ResponseHandler                   *handler,

                                  time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Write( std::shared_ptr<FileStateHandler> &self,

                                  uint64_t                           offset,

                                  uint32_t                           size,

                                  Optional<uint64_t>                 fdoff,

                                  int                                fd,

                                  ResponseHandler                   *handler,

                                  time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus PgWrite( std::shared_ptr<FileStateHandler> &self,

                                    uint64_t                           offset,

                                    uint32_t                           size,

                                    const void                        *buffer,

                                    std::vector<uint32_t>             &cksums,

                                    ResponseHandler                   *handler,

                                    time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus PgWriteRetry( std::shared_ptr<FileStateHandler> &self,

                                         uint64_t                           offset,

                                         uint32_t                           size,

                                         const void                        *buffer,

                                         uint32_t                           digest,

                                         ResponseHandler                   *handler,

                                         time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus PgWriteImpl( std::shared_ptr<FileStateHandler> &self,

                                        uint64_t                           offset,

                                        uint32_t                           size,

                                        const void                        *buffer,

                                        std::vector<uint32_t>             &cksums,

                                        kXR_char                           flags,

                                        ResponseHandler                   *handler,

                                        time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Sync( std::shared_ptr<FileStateHandler> &self,

                                 ResponseHandler                   *handler,

                                 time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Truncate( std::shared_ptr<FileStateHandler> &self,

                                     uint64_t                           size,

                                     ResponseHandler                   *handler,

                                     time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus VectorRead( std::shared_ptr<FileStateHandler> &self,

                                       const ChunkList                   &chunks,

                                       void                              *buffer,

                                       ResponseHandler                   *handler,

                                       time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus VectorWrite( std::shared_ptr<FileStateHandler> &self,

                                        const ChunkList                   &chunks,

                                        ResponseHandler                   *handler,

                                        time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus WriteV( std::shared_ptr<FileStateHandler> &self,

                                   uint64_t                           offset,

                                   const struct iovec                *iov,

                                   int                                iovcnt,

                                   ResponseHandler                   *handler,

                                   time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus ReadV( std::shared_ptr<FileStateHandler> &self,

                                  uint64_t                           offset,

                                  struct iovec                      *iov,

                                  int                                iovcnt,

                                  ResponseHandler                   *handler,

                                  time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Fcntl( std::shared_ptr<FileStateHandler> &self,

                                  const Buffer                      &arg,

                                  ResponseHandler                   *handler,

                                  time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Visa( std::shared_ptr<FileStateHandler> &self,

                                 ResponseHandler                   *handler,

                                 time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus SetXAttr( std::shared_ptr<FileStateHandler> &self,

                                     const std::vector<xattr_t>        &attrs,

                                     ResponseHandler                   *handler,

                                     time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus GetXAttr( std::shared_ptr<FileStateHandler> &self,

                                     const std::vector<std::string>    &attrs,

                                     ResponseHandler                   *handler,

                                     time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus DelXAttr( std::shared_ptr<FileStateHandler> &self,

                                     const std::vector<std::string>    &attrs,

                                     ResponseHandler                   *handler,

                                     time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus ListXAttr( std::shared_ptr<FileStateHandler> &self,

                                      ResponseHandler                  *handler,

                                      time_t                            timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus Checkpoint( std::shared_ptr<FileStateHandler> &self,

                                       kXR_char                           code,

                                       ResponseHandler                   *handler,

                                       time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus ChkptWrt( std::shared_ptr<FileStateHandler> &self,

                                     uint64_t                           offset,

                                     uint32_t                           size,

                                     const void                        *buffer,

                                     ResponseHandler                   *handler,

                                     time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus ChkptWrtV( std::shared_ptr<FileStateHandler> &self,

                                      uint64_t                           offset,

                                      const struct iovec                *iov,

                                      int                                iovcnt,

                                      ResponseHandler                   *handler,

                                      time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void OnOpen( const XRootDStatus *status,

                    const OpenInfo     *openInfo,

                    const HostList     *hostList );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void OnClose( const XRootDStatus *status );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static void OnStateError( std::shared_ptr<FileStateHandler> &self,

                                 XRootDStatus                      *status,

                                 Message                           *message,

                                 ResponseHandler                   *userHandler,

                                 MessageSendParams                 &sendParams );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static void OnStateRedirection( std::shared_ptr<FileStateHandler> &self,

                                       const std::string                 &redirectUrl,

                                       Message                           *message,

                                       ResponseHandler                   *userHandler,

                                       MessageSendParams                 &sendParams );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static void OnStateResponse( std::shared_ptr<FileStateHandler> &self,

                                    XRootDStatus                      *status,

                                    Message                           *message,

                                    AnyObject                         *response,

                                    HostList                          *hostList );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       bool IsOpen() const;


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       inline bool IsSecure() const

       {

         return pIsChannelEncrypted;

       }


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       bool SetProperty( const std::string &name, const std::string &value );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       bool GetProperty( const std::string &name, std::string &value ) const;


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void Lock()

       {

         pMutex.Lock();

       }


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void UnLock()

       {

         pMutex.UnLock();

       }


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void Tick( time_t now );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void TimeOutRequests( time_t now );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void AfterForkChild();


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus TryOtherServer( std::shared_ptr<FileStateHandler> &self,

                                           time_t                             timeout );


     private:

       //------------------------------------------------------------------------

       // Helper for queuing messages

       //------------------------------------------------------------------------

       struct RequestData

       {

         RequestData(): request(0), handler(0) {}

         RequestData( Message *r, ResponseHandler *h,

                      const MessageSendParams &p ):

           request(r), handler(h), params(p) {}

         Message           *request;

         ResponseHandler   *handler;

         MessageSendParams  params;

       };

       typedef std::list<RequestData> RequestList;


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       template<typename T>

       static Status XAttrOperationImpl( std::shared_ptr<FileStateHandler> &self,

                                         kXR_char                           subcode,

                                         kXR_char                           options,

                                         const std::vector<T>              &attrs,

                                         ResponseHandler                   *handler,

                                         time_t                             timeout = 0 );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static Status SendOrQueue( std::shared_ptr<FileStateHandler> &self,

                                  const URL                         &url,

                                  Message                           *msg,

                                  ResponseHandler                   *handler,

                                  MessageSendParams                 &sendParams );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       bool IsRecoverable( const XRootDStatus &stataus ) const;


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static Status RecoverMessage( std::shared_ptr<FileStateHandler> &self,

                                     RequestData                        rd,

                                     bool callbackOnFailure = true );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static Status RunRecovery( std::shared_ptr<FileStateHandler> &self );


       //------------------------------------------------------------------------

       // Send a close and ignore the response

       //------------------------------------------------------------------------

       static XRootDStatus SendClose( std::shared_ptr<FileStateHandler> &self,

                                      time_t                             timeout );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       bool IsReadOnly() const;


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus ReOpenFileAtServer( std::shared_ptr<FileStateHandler> &self,

                                               const URL                         &url,

                                               time_t                             timeout );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void FailMessage( RequestData rd, XRootDStatus status );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void FailQueuedMessages( XRootDStatus status );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void ReSendQueuedMessages();


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void ReWriteFileHandle( Message *msg );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void ResetMonitoringVars()

       {

         pOpenTime.tv_sec = 0; pOpenTime.tv_usec = 0;

         pRBytes      = 0;

         pVRBytes     = 0;

         pWBytes      = 0;

         pVSegs       = 0;

         pRCount      = 0;

         pVRCount     = 0;

         pWCount      = 0;

         pCloseReason = Status();

       }


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       void MonitorClose( const XRootDStatus *status );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       XRootDStatus IssueRequest( const URL         &url,

                                  Message           *msg,

                                  ResponseHandler   *handler,

                                  MessageSendParams &sendParams );


       //------------------------------------------------------------------------

       //------------------------------------------------------------------------

       static XRootDStatus WriteKernelBuffer( std::shared_ptr<FileStateHandler>     &self,

                                              uint64_t                               offset,

                                              uint32_t                               length,

                                              std::unique_ptr<XrdSys::KernelBuffer>  kbuff,

                                              ResponseHandler                       *handler,

                                              time_t                                 timeout );


       mutable XrdSysMutex     pMutex;

       FileStatus              pFileState;

       XRootDStatus            pStatus;

       StatInfo               *pStatInfo;

       URL                    *pFileUrl;

       URL                    *pDataServer;

       URL                    *pLoadBalancer;

       URL                    *pStateRedirect;

       URL                    *pWrtRecoveryRedir;

       uint8_t                *pFileHandle;

       uint16_t                pOpenMode;

       uint16_t                pOpenFlags;

       RequestList             pToBeRecovered;

       std::set<Message*>      pInTheFly;

       uint64_t                pSessionId;

       bool                    pDoRecoverRead;

       bool                    pDoRecoverWrite;

       bool                    pFollowRedirects;

       bool                    pUseVirtRedirector;

       bool                    pIsChannelEncrypted;

       bool                    pAllowBundledClose;


       //------------------------------------------------------------------------

       // Monitoring variables

       //------------------------------------------------------------------------

       timeval                  pOpenTime;

       uint64_t                 pRBytes;

       uint64_t                 pVRBytes;

       uint64_t                 pWBytes;

       uint64_t                 pVWBytes;

       uint64_t                 pVSegs;

       uint64_t                 pRCount;

       uint64_t                 pVRCount;

       uint64_t                 pWCount;

       uint64_t                 pVWCount;

       XRootDStatus             pCloseReason;


       //------------------------------------------------------------------------

       // Responsible for file:// operations on the local filesystem

       //------------------------------------------------------------------------

       LocalFileHandler      *pLFileHandler;


       //------------------------------------------------------------------------

       // Responsible for Writing/Reading erasure-coded files

       //------------------------------------------------------------------------

       FilePlugIn           *&pPlugin;

   };

 }


 #endif // __XRD_CL_FILE_STATE_HANDLER_HH__

kXR_char
unsigned char kXR_char
Definition: XPtypes.hh:65

XrdClFileSystem.hh

XrdClLocalFileHandler.hh

XrdClMessageUtils.hh

XrdClOptional.hh

XrdClPlugInInterface.hh

XrdClPostMasterInterfaces.hh

XrdClXRootDResponses.hh

XRDOUC_ENUM_OPERATORS
#define XRDOUC_ENUM_OPERATORS(T)
Definition: XrdOucEnum.hh:22

XrdSysPageSize.hh

XrdSysPthread.hh

XrdCl::AnyObject
Definition: XrdClAnyObject.hh:33

XrdCl::Buffer
Binary blob representation.
Definition: XrdClBuffer.hh:34

XrdCl::FilePlugIn
An interface for file plug-ins.
Definition: XrdClPlugInInterface.hh:39

XrdCl::FileStateHandler
Handle the stateful operations.
Definition: XrdClFileStateHandler.hh:80

XrdCl::FileStateHandler::FileStatus
FileStatus
State of the file.
Definition: XrdClFileStateHandler.hh:91

XrdCl::FileStateHandler::OpenInProgress
@ OpenInProgress
Opening is in progress.
Definition: XrdClFileStateHandler.hh:96

XrdCl::FileStateHandler::Closed
@ Closed
The file is closed.
Definition: XrdClFileStateHandler.hh:92

XrdCl::FileStateHandler::Opened
@ Opened
Opening has succeeded.
Definition: XrdClFileStateHandler.hh:93

XrdCl::FileStateHandler::Error
@ Error
Opening has failed.
Definition: XrdClFileStateHandler.hh:94

XrdCl::FileStateHandler::Recovering
@ Recovering
Recovering from an error.
Definition: XrdClFileStateHandler.hh:95

XrdCl::FileStateHandler::UnLock
void UnLock()
Unlock the internal lock.
Definition: XrdClFileStateHandler.hh:688

XrdCl::FileStateHandler::IsSecure
bool IsSecure() const
Check if the file is using an encrypted connection.
Definition: XrdClFileStateHandler.hh:658

XrdCl::FileStateHandler::Lock
void Lock()
Lock the internal lock.
Definition: XrdClFileStateHandler.hh:680

XrdCl::Message
The message representation used throughout the system.
Definition: XrdClMessage.hh:30

XrdCl::OpenInfo
Information returned by file open operation.
Definition: XrdClXRootDResponses.hh:862

XrdCl::Optional
Definition: XrdClOptional.hh:44

XrdCl::PgReadImpl
PgRead operation (.
Definition: XrdClFileOperations.hh:286

XrdCl::PgWriteImpl
PgWrite operation (.
Definition: XrdClFileOperations.hh:374

XrdCl::ResponseHandler
Handle an async response.
Definition: XrdClXRootDResponses.hh:1126

XrdCl::XRootDStatus
Request status.
Definition: XrdClXRootDResponses.hh:219

XrdSysMutex
Definition: XrdSysPthread.hh:165

XrdCl
Definition: XrdClAction.hh:34

XrdCl::Read
ReadImpl< false > Read(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, time_t timeout=0)
Factory for creating ReadImpl objects.
Definition: XrdClFileOperations.hh:273

XrdCl::WriteV
WriteVImpl< false > WriteV(Ctx< File > file, Arg< uint64_t > offset, Arg< std::vector< iovec >> iov, time_t timeout=0)
Factory for creating WriteVImpl objects.
Definition: XrdClFileOperations.hh:872

XrdCl::DelXAttr
DelXAttrImpl< false > DelXAttr(Ctx< File > file, Arg< std::string > name)
Definition: XrdClFileOperations.hh:1256

XrdCl::Open
OpenImpl< false > Open(Ctx< File > file, Arg< std::string > url, Arg< OpenFlags::Flags > flags, Arg< Access::Mode > mode=Access::None, time_t timeout=0)
Factory for creating ReadImpl objects.
Definition: XrdClFileOperations.hh:215

XrdCl::ChkptWrt
ChkptWrtImpl< false > ChkptWrt(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< const void * > buffer, time_t timeout=0)
Factory for creating ReadImpl objects.
Definition: XrdClCheckpointOperation.hh:129

XrdCl::SetXAttr
SetXAttrImpl< false > SetXAttr(Ctx< File > file, Arg< std::string > name, Arg< std::string > value)
Definition: XrdClFileOperations.hh:1021

XrdCl::Truncate
TruncateImpl< false > Truncate(Ctx< File > file, Arg< uint64_t > size, time_t timeout)
Definition: XrdClFileOperations.hh:692

XrdCl::Stat
StatImpl< false > Stat(Ctx< File > file, Arg< bool > force, time_t timeout=0)
Definition: XrdClFileOperations.hh:535

XrdCl::HostList
std::vector< HostInfo > HostList
Definition: XrdClXRootDResponses.hh:1120

XrdCl::GetXAttr
GetXAttrImpl< false > GetXAttr(Ctx< File > file, Arg< std::string > name)
Definition: XrdClFileOperations.hh:1139

XrdCl::Fcntl
FcntlImpl< false > Fcntl
Definition: XrdClFileOperations.hh:922

XrdCl::Visa
VisaImpl< false > Visa
Definition: XrdClFileOperations.hh:961

XrdCl::ChkptWrtV
ChkptWrtVImpl< false > ChkptWrtV(Ctx< File > file, Arg< uint64_t > offset, Arg< std::vector< iovec >> iov, time_t timeout=0)
Factory for creating ChkptWrtVImpl objects.
Definition: XrdClCheckpointOperation.hh:197

XrdCl::ChunkList
std::vector< ChunkInfo > ChunkList
List of chunks.
Definition: XrdClXRootDResponses.hh:1055

XrdCl::Sync
SyncImpl< false > Sync(Ctx< File > file, time_t timeout=0)
Factory for creating SyncImpl objects.
Definition: XrdClFileOperations.hh:639

XrdCl::Write
WriteImpl< false > Write(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< const void * > buffer, time_t timeout=0)
Factory for creating WriteImpl objects.
Definition: XrdClFileOperations.hh:591

XrdCl::Close
CloseImpl< false > Close(Ctx< File > file, time_t timeout=0)
Factory for creating CloseImpl objects.
Definition: XrdClFileOperations.hh:482

XrdCl::PgRead
PgReadImpl< false > PgRead(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, time_t timeout=0)
Factory for creating PgReadImpl objects.
Definition: XrdClFileOperations.hh:331

XrdCl::ListXAttr
ListXAttrImpl< false > ListXAttr(Ctx< File > file)
Definition: XrdClFileOperations.hh:1361

XrdCl::VectorRead
VectorReadImpl< false > VectorRead(Ctx< File > file, Arg< ChunkList > chunks, Arg< void * > buffer, time_t timeout=0)
Factory for creating VectorReadImpl objects.
Definition: XrdClFileOperations.hh:747

XrdCl::PgWrite
PgWriteImpl< false > PgWrite(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, Arg< std::vector< uint32_t >> cksums, time_t timeout=0)
Factory for creating PgReadImpl objects.
Definition: XrdClFileOperations.hh:420

XrdCl::Checkpoint
CheckpointImpl< false > Checkpoint(Ctx< File > file, Arg< ChkPtCode > code, time_t timeout=0)
Factory for creating ReadImpl objects.
Definition: XrdClCheckpointOperation.hh:72

XrdCl::VectorWrite
VectorWriteImpl< false > VectorWrite(Ctx< File > file, Arg< ChunkList > chunks, time_t timeout=0)
Factory for creating VectorWriteImpl objects.
Definition: XrdClFileOperations.hh:807

XrdCl::None
none object for initializing empty Optional
Definition: XrdClOptional.hh:35

XrdProto::kXR_pgRetry
static const int kXR_pgRetry
Definition: XProtocol.hh:503

XrdCl::MessageSendParams
Definition: XrdClMessageUtils.hh:132

XrdCl::PgReadFlags
PgRead flags.
Definition: XrdClFileStateHandler.hh:63

XrdCl::PgReadFlags::Flags
Flags
PgRead flags.
Definition: XrdClFileStateHandler.hh:68

XrdCl::PgReadFlags::Retry
@ Retry
Definition: XrdClFileStateHandler.hh:70

iov
Definition: XrdOucIOVec.hh:65