XRootD
Loading...
Searching...
No Matches
XrdCl::FileStateHandler Class Reference

Handle the stateful operations. More...

#include <XrdClFileStateHandler.hh>

+ Collaboration diagram for XrdCl::FileStateHandler:

Public Types

enum  FileStatus {
  Closed ,
  Opened ,
  Error ,
  Recovering ,
  OpenInProgress ,
  CloseInProgress
}
 State of the file. More...
 

Public Member Functions

 FileStateHandler (bool useVirtRedirector, FilePlugIn *&plugin)
 
 FileStateHandler (FilePlugIn *&plugin)
 Constructor.
 
 ~FileStateHandler ()
 Destructor.
 
void AfterForkChild ()
 Called in the child process after the fork.
 
bool GetProperty (const std::string &name, std::string &value) const
 
bool IsOpen () const
 Check if the file is open.
 
bool IsSecure () const
 Check if the file is using an encrypted connection.
 
void Lock ()
 Lock the internal lock.
 
void OnClose (const XRootDStatus *status)
 Process the results of the closing operation.
 
void OnOpen (const XRootDStatus *status, const OpenInfo *openInfo, const HostList *hostList)
 Process the results of the opening operation.
 
bool SetProperty (const std::string &name, const std::string &value)
 
void Tick (time_t now)
 Tick.
 
void TimeOutRequests (time_t now)
 Declare timeout on requests being recovered.
 
void UnLock ()
 Unlock the internal lock.
 

Static Public Member Functions

static XRootDStatus Checkpoint (std::shared_ptr< FileStateHandler > &self, kXR_char code, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus ChkptWrt (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, const void *buffer, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus ChkptWrtV (std::shared_ptr< FileStateHandler > &self, uint64_t offset, const struct iovec *iov, int iovcnt, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus Close (std::shared_ptr< FileStateHandler > &self, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus DelXAttr (std::shared_ptr< FileStateHandler > &self, const std::vector< std::string > &attrs, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus Fcntl (std::shared_ptr< FileStateHandler > &self, const Buffer &arg, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus GetXAttr (std::shared_ptr< FileStateHandler > &self, const std::vector< std::string > &attrs, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus ListXAttr (std::shared_ptr< FileStateHandler > &self, ResponseHandler *handler, uint16_t timeout=0)
 
static void OnStateError (std::shared_ptr< FileStateHandler > &self, XRootDStatus *status, Message *message, ResponseHandler *userHandler, MessageSendParams &sendParams)
 Handle an error while sending a stateful message.
 
static void OnStateRedirection (std::shared_ptr< FileStateHandler > &self, const std::string &redirectUrl, Message *message, ResponseHandler *userHandler, MessageSendParams &sendParams)
 Handle stateful redirect.
 
static void OnStateResponse (std::shared_ptr< FileStateHandler > &self, XRootDStatus *status, Message *message, AnyObject *response, HostList *hostList)
 Handle stateful response.
 
static XRootDStatus Open (std::shared_ptr< FileStateHandler > &self, const std::string &url, uint16_t flags, uint16_t mode, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus PgRead (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus PgReadImpl (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, void *buffer, uint16_t flags, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus PgReadRetry (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, size_t pgnb, void *buffer, PgReadHandler *handler, uint16_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, uint16_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, uint16_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, uint16_t timeout=0)
 
static XRootDStatus Read (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus ReadV (std::shared_ptr< FileStateHandler > &self, uint64_t offset, struct iovec *iov, int iovcnt, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus SetXAttr (std::shared_ptr< FileStateHandler > &self, const std::vector< xattr_t > &attrs, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus Stat (std::shared_ptr< FileStateHandler > &self, bool force, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus Sync (std::shared_ptr< FileStateHandler > &self, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus Truncate (std::shared_ptr< FileStateHandler > &self, uint64_t size, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus TryOtherServer (std::shared_ptr< FileStateHandler > &self, uint16_t timeout)
 Try other data server.
 
static XRootDStatus VectorRead (std::shared_ptr< FileStateHandler > &self, const ChunkList &chunks, void *buffer, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus VectorWrite (std::shared_ptr< FileStateHandler > &self, const ChunkList &chunks, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus Visa (std::shared_ptr< FileStateHandler > &self, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus Write (std::shared_ptr< FileStateHandler > &self, uint64_t offset, Buffer &&buffer, ResponseHandler *handler, uint16_t timeout=0)
 
static XRootDStatus Write (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, const void *buffer, ResponseHandler *handler, uint16_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, uint16_t timeout=0)
 
static XRootDStatus WriteV (std::shared_ptr< FileStateHandler > &self, uint64_t offset, const struct iovec *iov, int iovcnt, ResponseHandler *handler, uint16_t timeout=0)
 

Friends

class ::OpenHandler
 
class ::PgReadHandler
 
class ::PgReadRetryHandler
 
class ::PgReadSubstitutionHandler
 

Detailed Description

Handle the stateful operations.

Definition at line 79 of file XrdClFileStateHandler.hh.

Member Enumeration Documentation

◆ FileStatus

State of the file.

Enumerator
Closed 

The file is closed.

Opened 

Opening has succeeded.

Error 

Opening has failed.

Recovering 

Recovering from an error.

OpenInProgress 

Opening is in progress.

CloseInProgress 

Closing operation is in progress.

Definition at line 90 of file XrdClFileStateHandler.hh.

91 {
92 Closed,
93 Opened,
94 Error,
98 };
@ OpenInProgress
Opening is in progress.
@ CloseInProgress
Closing operation is in progress.
@ Opened
Opening has succeeded.
@ Recovering
Recovering from an error.

Constructor & Destructor Documentation

◆ FileStateHandler() [1/2]

XrdCl::FileStateHandler::FileStateHandler ( FilePlugIn *& plugin)

Constructor.

Definition at line 641 of file XrdClFileStateHandler.cc.

641 :
642 pFileState( Closed ),
643 pStatInfo( 0 ),
644 pFileUrl( 0 ),
645 pDataServer( 0 ),
646 pLoadBalancer( 0 ),
647 pStateRedirect( 0 ),
648 pWrtRecoveryRedir( 0 ),
649 pFileHandle( 0 ),
650 pOpenMode( 0 ),
651 pOpenFlags( 0 ),
652 pSessionId( 0 ),
653 pDoRecoverRead( true ),
654 pDoRecoverWrite( true ),
655 pFollowRedirects( true ),
656 pUseVirtRedirector( true ),
657 pIsChannelEncrypted( false ),
658 pAllowBundledClose( false ),
659 pPlugin( plugin )
660 {
661 pFileHandle = new uint8_t[4];
662 ResetMonitoringVars();
665 pLFileHandler = new LocalFileHandler();
666 }
static FileTimer * GetFileTimer()
Get file timer task.
static ForkHandler * GetForkHandler()
Get the fork handler.
void RegisterFileObject(FileStateHandler *file)
Register a file state handler.
void RegisterFileObject(FileStateHandler *file)
Register a file object.

References XrdCl::DefaultEnv::GetFileTimer(), XrdCl::DefaultEnv::GetForkHandler(), XrdCl::FileTimer::RegisterFileObject(), and XrdCl::ForkHandler::RegisterFileObject().

+ Here is the call graph for this function:

◆ FileStateHandler() [2/2]

XrdCl::FileStateHandler::FileStateHandler ( bool useVirtRedirector,
FilePlugIn *& plugin )

Constructor

Parameters
useVirtRedirectorif true Metalink files will be treated as a VirtualRedirectors

Definition at line 674 of file XrdClFileStateHandler.cc.

674 :
675 pFileState( Closed ),
676 pStatInfo( 0 ),
677 pFileUrl( 0 ),
678 pDataServer( 0 ),
679 pLoadBalancer( 0 ),
680 pStateRedirect( 0 ),
681 pWrtRecoveryRedir( 0 ),
682 pFileHandle( 0 ),
683 pOpenMode( 0 ),
684 pOpenFlags( 0 ),
685 pSessionId( 0 ),
686 pDoRecoverRead( true ),
687 pDoRecoverWrite( true ),
688 pFollowRedirects( true ),
689 pUseVirtRedirector( useVirtRedirector ),
690 pAllowBundledClose( false ),
691 pPlugin( plugin )
692 {
693 pFileHandle = new uint8_t[4];
694 ResetMonitoringVars();
697 pLFileHandler = new LocalFileHandler();
698 }

References XrdCl::DefaultEnv::GetFileTimer(), XrdCl::DefaultEnv::GetForkHandler(), XrdCl::FileTimer::RegisterFileObject(), and XrdCl::ForkHandler::RegisterFileObject().

+ Here is the call graph for this function:

◆ ~FileStateHandler()

XrdCl::FileStateHandler::~FileStateHandler ( )

Destructor.

Definition at line 703 of file XrdClFileStateHandler.cc.

704 {
705 //--------------------------------------------------------------------------
706 // This, in principle, should never ever happen. Except for the case
707 // when we're interfaced with ROOT that may call this desctructor from
708 // its garbage collector, from its __cxa_finalize, ie. after the XrdCl lib
709 // has been finalized by the linker. So, if we don't have the log object
710 // at this point we just give up the hope.
711 //--------------------------------------------------------------------------
712 if( DefaultEnv::GetLog() && pSessionId && !pDataServer->IsLocalFile() ) // if the file object was bound to a physical connection
713 DefaultEnv::GetPostMaster()->DecFileInstCnt( *pDataServer );
714
717
720
721 if( pFileState != Closed && DefaultEnv::GetLog() )
722 {
723 XRootDStatus st;
724 MonitorClose( &st );
725 ResetMonitoringVars();
726 }
727
728 // check if the logger is still there, this is only for root, as root might
729 // have unload us already so in this case we don't want to do anything
730 if( DefaultEnv::GetLog() && pUseVirtRedirector && pFileUrl && pFileUrl->IsMetalink() )
731 {
732 RedirectorRegistry& registry = RedirectorRegistry::Instance();
733 registry.Release( *pFileUrl );
734 }
735
736 delete pStatInfo;
737 delete pFileUrl;
738 delete pDataServer;
739 delete pLoadBalancer;
740 delete [] pFileHandle;
741 delete pLFileHandler;
742 }
static Log * GetLog()
Get default log.
static PostMaster * GetPostMaster()
Get default post master.
void UnRegisterFileObject(FileStateHandler *file)
Un-register a file state handler.
void UnRegisterFileObject(FileStateHandler *file)
void DecFileInstCnt(const URL &url)
Decrement file object instance count bound to this channel.
static RedirectorRegistry & Instance()
Returns reference to the single instance.
bool IsMetalink() const
Is it a URL to a metalink.
Definition XrdClURL.cc:465
bool IsLocalFile() const
Definition XrdClURL.cc:474

References Closed, XrdCl::PostMaster::DecFileInstCnt(), XrdCl::DefaultEnv::GetFileTimer(), XrdCl::DefaultEnv::GetForkHandler(), XrdCl::DefaultEnv::GetLog(), XrdCl::DefaultEnv::GetPostMaster(), XrdCl::RedirectorRegistry::Instance(), XrdCl::URL::IsLocalFile(), XrdCl::URL::IsMetalink(), XrdCl::RedirectorRegistry::Release(), XrdCl::FileTimer::UnRegisterFileObject(), and XrdCl::ForkHandler::UnRegisterFileObject().

+ Here is the call graph for this function:

Member Function Documentation

◆ AfterForkChild()

void XrdCl::FileStateHandler::AfterForkChild ( )

Called in the child process after the fork.

Definition at line 2744 of file XrdClFileStateHandler.cc.

2745 {
2746 Log *log = DefaultEnv::GetLog();
2747
2748 if( pFileState == Closed || pFileState == Error )
2749 return;
2750
2751 if( (IsReadOnly() && pDoRecoverRead) ||
2752 (!IsReadOnly() && pDoRecoverWrite) )
2753 {
2754 log->Debug( FileMsg, "[%p@%s] Putting the file in recovery state in "
2755 "process %d", this, pFileUrl->GetObfuscatedURL().c_str(), getpid() );
2756 pFileState = Recovering;
2757 pInTheFly.clear();
2758 pToBeRecovered.clear();
2759 }
2760 else
2761 pFileState = Error;
2762 }
std::string GetObfuscatedURL() const
Get the URL with authz information obfuscated.
Definition XrdClURL.cc:498
const uint64_t FileMsg
XrdSysError Log
Definition XrdConfig.cc:113

References Closed, XrdCl::Log::Debug(), Error, XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), XrdCl::URL::GetObfuscatedURL(), and Recovering.

+ Here is the call graph for this function:

◆ Checkpoint()

XRootDStatus XrdCl::FileStateHandler::Checkpoint ( std::shared_ptr< FileStateHandler > & self,
kXR_char code,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Create a checkpoint

Parameters
handler: handler to be notified when the response arrives, the response parameter will hold a std::vector of XAttr objects
timeout: timeout value, if 0 the environment default will be used
Returns
: status of the operation

Definition at line 2059 of file XrdClFileStateHandler.cc.

2063 {
2064 XrdSysMutexHelper scopedLock( self->pMutex );
2065
2066 if( self->pFileState == Error ) return self->pStatus;
2067
2068 if( self->pFileState != Opened && self->pFileState != Recovering )
2069 return XRootDStatus( stError, errInvalidOp );
2070
2071 Log *log = DefaultEnv::GetLog();
2072 log->Debug( FileMsg, "[%p@%s] Sending a checkpoint command for handle %#x to %s",
2073 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
2074 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
2075
2076 Message *msg;
2078 MessageUtils::CreateRequest( msg, req );
2079
2080 req->requestid = kXR_chkpoint;
2081 req->opcode = code;
2082 memcpy( req->fhandle, self->pFileHandle, 4 );
2083
2084 MessageSendParams params;
2085 params.timeout = timeout;
2086 params.followRedirects = false;
2087 params.stateful = true;
2088
2090
2092 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
2093
2094 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
2095 }
@ kXR_chkpoint
Definition XProtocol.hh:124
static void ProcessSendParams(MessageSendParams &sendParams)
Process sending params.
static void CreateRequest(Message *&msg, Request *&req, uint32_t payloadSize=0)
Create a message.
static void SetDescription(Message *msg)
Get the description of a message.
const uint16_t stError
An error occurred that could potentially be retried.
const uint16_t errInvalidOp

References XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), XrdCl::errInvalidOp, Error, ClientChkPointRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::DefaultEnv::GetLog(), kXR_chkpoint, ClientChkPointRequest::opcode, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientChkPointRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

+ Here is the call graph for this function:

◆ ChkptWrt()

XRootDStatus XrdCl::FileStateHandler::ChkptWrt ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
uint32_t size,
const void * buffer,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Checkpointed write - async

Parameters
offsetoffset from the beginning of the file
sizenumber of bytes to be written
buffera pointer to the buffer holding the data to be written
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 2108 of file XrdClFileStateHandler.cc.

2114 {
2115 XrdSysMutexHelper scopedLock( self->pMutex );
2116
2117 if( self->pFileState == Error ) return self->pStatus;
2118
2119 if( self->pFileState != Opened && self->pFileState != Recovering )
2120 return XRootDStatus( stError, errInvalidOp );
2121
2122 Log *log = DefaultEnv::GetLog();
2123 log->Debug( FileMsg, "[%p@%s] Sending a write command for handle %#x to %s",
2124 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
2125 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
2126
2127 Message *msg;
2129 MessageUtils::CreateRequest( msg, req, sizeof( ClientWriteRequest ) );
2130
2131 req->requestid = kXR_chkpoint;
2132 req->opcode = kXR_ckpXeq;
2133 req->dlen = 24; // as specified in the protocol specification
2134 memcpy( req->fhandle, self->pFileHandle, 4 );
2135
2136 ClientWriteRequest *wrtreq = (ClientWriteRequest*)msg->GetBuffer( sizeof(ClientChkPointRequest) );
2137 wrtreq->requestid = kXR_write;
2138 wrtreq->offset = offset;
2139 wrtreq->dlen = size;
2140 memcpy( wrtreq->fhandle, self->pFileHandle, 4 );
2141
2142 ChunkList *list = new ChunkList();
2143 list->push_back( ChunkInfo( 0, size, (char*)buffer ) );
2144
2145 MessageSendParams params;
2146 params.timeout = timeout;
2147 params.followRedirects = false;
2148 params.stateful = true;
2149 params.chunkList = list;
2150
2152
2154 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
2155
2156 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
2157 }
kXR_unt16 requestid
Definition XProtocol.hh:806
kXR_char fhandle[4]
Definition XProtocol.hh:807
static const int kXR_ckpXeq
Definition XProtocol.hh:216
@ kXR_write
Definition XProtocol.hh:131
std::vector< ChunkInfo > ChunkList
List of chunks.

References XrdCl::MessageSendParams::chunkList, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), ClientChkPointRequest::dlen, ClientWriteRequest::dlen, XrdCl::errInvalidOp, Error, ClientChkPointRequest::fhandle, ClientWriteRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::Buffer::GetBuffer(), XrdCl::DefaultEnv::GetLog(), kXR_chkpoint, kXR_ckpXeq, kXR_write, ClientWriteRequest::offset, ClientChkPointRequest::opcode, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientChkPointRequest::requestid, ClientWriteRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

+ Here is the call graph for this function:

◆ ChkptWrtV()

XRootDStatus XrdCl::FileStateHandler::ChkptWrtV ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
const struct iovec * iov,
int iovcnt,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Checkpointed WriteV - async

Parameters
offsetoffset from the beginning of the file
iovlist of the buffers to be written
iovcntnumber of buffers
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 then the environment default will be used
Returns
status of the operation

Write scattered buffers in one operation - async

Parameters
offsetoffset from the beginning of the file
iovlist of the buffers to be written
iovcntnumber of buffers
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 then the environment default will be used
Returns
status of the operation

Definition at line 2170 of file XrdClFileStateHandler.cc.

2176 {
2177 XrdSysMutexHelper scopedLock( self->pMutex );
2178
2179 if( self->pFileState == Error ) return self->pStatus;
2180
2181 if( self->pFileState != Opened && self->pFileState != Recovering )
2182 return XRootDStatus( stError, errInvalidOp );
2183
2184 Log *log = DefaultEnv::GetLog();
2185 log->Debug( FileMsg, "[%p@%s] Sending a write command for handle %#x to %s",
2186 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
2187 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
2188
2189 Message *msg;
2191 MessageUtils::CreateRequest( msg, req, sizeof( ClientWriteRequest ) );
2192
2193 req->requestid = kXR_chkpoint;
2194 req->opcode = kXR_ckpXeq;
2195 req->dlen = 24; // as specified in the protocol specification
2196 memcpy( req->fhandle, self->pFileHandle, 4 );
2197
2198 ChunkList *list = new ChunkList();
2199 uint32_t size = 0;
2200 for( int i = 0; i < iovcnt; ++i )
2201 {
2202 if( iov[i].iov_len == 0 ) continue;
2203 size += iov[i].iov_len;
2204 list->push_back( ChunkInfo( 0, iov[i].iov_len,
2205 (char*)iov[i].iov_base ) );
2206 }
2207
2208 ClientWriteRequest *wrtreq = (ClientWriteRequest*)msg->GetBuffer( sizeof(ClientChkPointRequest) );
2209 wrtreq->requestid = kXR_write;
2210 wrtreq->offset = offset;
2211 wrtreq->dlen = size;
2212 memcpy( wrtreq->fhandle, self->pFileHandle, 4 );
2213
2214 MessageSendParams params;
2215 params.timeout = timeout;
2216 params.followRedirects = false;
2217 params.stateful = true;
2218 params.chunkList = list;
2219
2221
2223 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
2224
2225 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
2226 }

References XrdCl::MessageSendParams::chunkList, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), ClientChkPointRequest::dlen, ClientWriteRequest::dlen, XrdCl::errInvalidOp, Error, ClientChkPointRequest::fhandle, ClientWriteRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::Buffer::GetBuffer(), XrdCl::DefaultEnv::GetLog(), kXR_chkpoint, kXR_ckpXeq, kXR_write, ClientWriteRequest::offset, ClientChkPointRequest::opcode, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientChkPointRequest::requestid, ClientWriteRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

+ Here is the call graph for this function:

◆ Close()

XRootDStatus XrdCl::FileStateHandler::Close ( std::shared_ptr< FileStateHandler > & self,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Close the file object

Parameters
handlerhandler to be notified about the status of the operation
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 874 of file XrdClFileStateHandler.cc.

877 {
878 XrdSysMutexHelper scopedLock( self->pMutex );
879
880 //--------------------------------------------------------------------------
881 // Check if we can proceed
882 //--------------------------------------------------------------------------
883 if( self->pFileState == Error )
884 return self->pStatus;
885
886 if( self->pFileState == CloseInProgress )
887 return XRootDStatus( stError, errInProgress );
888
889 if( self->pFileState == Closed )
890 return XRootDStatus( stOK, suAlreadyDone );
891
892 if( self->pFileState == OpenInProgress || self->pFileState == Recovering )
893 return XRootDStatus( stError, errInvalidOp );
894
895 if( !self->pAllowBundledClose && !self->pInTheFly.empty() )
896 return XRootDStatus( stError, errInvalidOp );
897
898 self->pFileState = CloseInProgress;
899
900 Log *log = DefaultEnv::GetLog();
901 log->Debug( FileMsg, "[%p@%s] Sending a close command for handle %#x to %s",
902 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
903 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
904
905 //--------------------------------------------------------------------------
906 // Close the file
907 //--------------------------------------------------------------------------
908 Message *msg;
910 MessageUtils::CreateRequest( msg, req );
911
912 req->requestid = kXR_close;
913 memcpy( req->fhandle, self->pFileHandle, 4 );
914
916 msg->SetSessionId( self->pSessionId );
917 CloseHandler *closeHandler = new CloseHandler( self, handler, msg );
918 MessageSendParams params;
919 params.timeout = timeout;
920 params.followRedirects = false;
921 params.stateful = true;
923
924 XRootDStatus st = self->IssueRequest( *self->pDataServer, msg, closeHandler, params );
925
926 if( !st.IsOK() )
927 {
928 // an invalid-session error means the connection to the server has been
929 // closed, which in turn means that the server closed the file already
930 if( st.code == errInvalidSession || st.code == errSocketDisconnected ||
931 st.code == errConnectionError || st.code == errSocketOptError ||
932 st.code == errPollerError || st.code == errSocketError )
933 {
934 self->pFileState = Closed;
935 ResponseJob *job = new ResponseJob( closeHandler, new XRootDStatus(),
936 nullptr, nullptr );
938 return XRootDStatus();
939 }
940
941 delete closeHandler;
942 self->pStatus = st;
943 self->pFileState = Error;
944 return st;
945 }
946 return st;
947 }
kXR_unt16 requestid
Definition XProtocol.hh:228
kXR_char fhandle[4]
Definition XProtocol.hh:229
@ kXR_close
Definition XProtocol.hh:115
void QueueJob(Job *job, void *arg=0)
Add a job to be run.
JobManager * GetJobManager()
Get the job manager object user by the post master.
const uint16_t errSocketOptError
const uint16_t errPollerError
const uint16_t errInProgress
const uint16_t stOK
Everything went OK.
const uint16_t suAlreadyDone
const uint16_t errConnectionError
const uint16_t errSocketError
const uint16_t errInvalidSession
const uint16_t errSocketDisconnected

References Closed, CloseInProgress, XrdCl::Status::code, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), XrdCl::errConnectionError, XrdCl::errInProgress, XrdCl::errInvalidOp, XrdCl::errInvalidSession, Error, XrdCl::errPollerError, XrdCl::errSocketDisconnected, XrdCl::errSocketError, XrdCl::errSocketOptError, ClientCloseRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::PostMaster::GetJobManager(), XrdCl::DefaultEnv::GetLog(), XrdCl::DefaultEnv::GetPostMaster(), XrdCl::Status::IsOK(), kXR_close, OpenInProgress, XrdCl::MessageUtils::ProcessSendParams(), XrdCl::JobManager::QueueJob(), Recovering, ClientCloseRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::Message::SetSessionId(), XrdCl::MessageSendParams::stateful, XrdCl::stError, XrdCl::stOK, XrdCl::suAlreadyDone, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::File::Close().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ DelXAttr()

XRootDStatus XrdCl::FileStateHandler::DelXAttr ( std::shared_ptr< FileStateHandler > & self,
const std::vector< std::string > & attrs,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Delete extended attributes - async

Parameters
attrs: list of extended attributes to set
handler: handler to be notified when the response arrives, the response parameter will hold a std::vector of XAttrStatus objects
timeout: timeout value, if 0 the environment default will be used
Returns
: status of the operation

Definition at line 1998 of file XrdClFileStateHandler.cc.

2002 {
2003 XrdSysMutexHelper scopedLock( self->pMutex );
2004
2005 if( self->pFileState == Error ) return self->pStatus;
2006
2007 if( self->pFileState != Opened && self->pFileState != Recovering )
2008 return XRootDStatus( stError, errInvalidOp );
2009
2010 Log *log = DefaultEnv::GetLog();
2011 log->Debug( FileMsg, "[%p@%s] Sending a fattr del command for handle %#x to %s",
2012 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
2013 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
2014
2015 //--------------------------------------------------------------------------
2016 // Issue a new fattr del request
2017 //--------------------------------------------------------------------------
2018 return XAttrOperationImpl( self, kXR_fattrDel, 0, attrs, handler, timeout );
2019 }
@ kXR_fattrDel
Definition XProtocol.hh:270

References XrdCl::Log::Debug(), XrdCl::errInvalidOp, Error, XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), kXR_fattrDel, Opened, Recovering, and XrdCl::stError.

Referenced by XrdCl::File::DelXAttr().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Fcntl()

XRootDStatus XrdCl::FileStateHandler::Fcntl ( std::shared_ptr< FileStateHandler > & self,
const Buffer & arg,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Performs a custom operation on an open file, server implementation dependent - async

Parameters
argquery argument
handlerhandler to be notified when the response arrives, the response parameter will hold a Buffer object if the procedure is successful
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 1865 of file XrdClFileStateHandler.cc.

1869 {
1870 XrdSysMutexHelper scopedLock( self->pMutex );
1871
1872 if( self->pFileState == Error ) return self->pStatus;
1873
1874 if( self->pFileState != Opened && self->pFileState != Recovering )
1875 return XRootDStatus( stError, errInvalidOp );
1876
1877 Log *log = DefaultEnv::GetLog();
1878 log->Debug( FileMsg, "[%p@%s] Sending a fcntl command for handle %#x to %s",
1879 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1880 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1881
1882 Message *msg;
1883 ClientQueryRequest *req;
1884 MessageUtils::CreateRequest( msg, req, arg.GetSize() );
1885
1886 req->requestid = kXR_query;
1887 req->infotype = kXR_Qopaqug;
1888 req->dlen = arg.GetSize();
1889 memcpy( req->fhandle, self->pFileHandle, 4 );
1890 msg->Append( arg.GetBuffer(), arg.GetSize(), 24 );
1891
1892 MessageSendParams params;
1893 params.timeout = timeout;
1894 params.followRedirects = false;
1895 params.stateful = true;
1897
1899 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1900
1901 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1902 }
kXR_unt16 requestid
Definition XProtocol.hh:630
kXR_char fhandle[4]
Definition XProtocol.hh:633
@ kXR_query
Definition XProtocol.hh:113
@ kXR_Qopaqug
Definition XProtocol.hh:625

References XrdCl::Buffer::Append(), XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), ClientQueryRequest::dlen, XrdCl::errInvalidOp, Error, ClientQueryRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::Buffer::GetBuffer(), XrdCl::DefaultEnv::GetLog(), XrdCl::Buffer::GetSize(), ClientQueryRequest::infotype, kXR_Qopaqug, kXR_query, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientQueryRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::File::Fcntl().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ GetProperty()

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

Get file property

See also
File::SetProperty for property list

Definition at line 2277 of file XrdClFileStateHandler.cc.

2279 {
2280 XrdSysMutexHelper scopedLock( pMutex );
2281 if( name == "ReadRecovery" )
2282 {
2283 if( pDoRecoverRead ) value = "true";
2284 else value = "false";
2285 return true;
2286 }
2287 else if( name == "WriteRecovery" )
2288 {
2289 if( pDoRecoverWrite ) value = "true";
2290 else value = "false";
2291 return true;
2292 }
2293 else if( name == "FollowRedirects" )
2294 {
2295 if( pFollowRedirects ) value = "true";
2296 else value = "false";
2297 return true;
2298 }
2299 else if( name == "DataServer" && pDataServer )
2300 { value = pDataServer->GetHostId(); return true; }
2301 else if( name == "LastURL" && pDataServer )
2302 { value = pDataServer->GetURL(); return true; }
2303 else if( name == "WrtRecoveryRedir" && pWrtRecoveryRedir )
2304 { value = pWrtRecoveryRedir->GetHostId(); return true; }
2305 value = "";
2306 return false;
2307 }
std::string GetHostId() const
Get the host part of the URL (user:password@host:port)
Definition XrdClURL.hh:99
std::string GetURL() const
Get the URL.
Definition XrdClURL.hh:86

References XrdCl::URL::GetHostId(), and XrdCl::URL::GetURL().

+ Here is the call graph for this function:

◆ GetXAttr()

XRootDStatus XrdCl::FileStateHandler::GetXAttr ( std::shared_ptr< FileStateHandler > & self,
const std::vector< std::string > & attrs,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Get extended attributes - async

Parameters
attrs: list of extended attributes to get
handler: handler to be notified when the response arrives, the response parameter will hold a std::vector of XAttr objects
timeout: timeout value, if 0 the environment default will be used
Returns
: status of the operation

Definition at line 1972 of file XrdClFileStateHandler.cc.

1976 {
1977 XrdSysMutexHelper scopedLock( self->pMutex );
1978
1979 if( self->pFileState == Error ) return self->pStatus;
1980
1981 if( self->pFileState != Opened && self->pFileState != Recovering )
1982 return XRootDStatus( stError, errInvalidOp );
1983
1984 Log *log = DefaultEnv::GetLog();
1985 log->Debug( FileMsg, "[%p@%s] Sending a fattr get command for handle %#x to %s",
1986 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1987 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1988
1989 //--------------------------------------------------------------------------
1990 // Issue a new fattr get request
1991 //--------------------------------------------------------------------------
1992 return XAttrOperationImpl( self, kXR_fattrGet, 0, attrs, handler, timeout );
1993 }
@ kXR_fattrGet
Definition XProtocol.hh:271

References XrdCl::Log::Debug(), XrdCl::errInvalidOp, Error, XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), kXR_fattrGet, Opened, Recovering, and XrdCl::stError.

Referenced by XrdCl::File::GetXAttr().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ IsOpen()

bool XrdCl::FileStateHandler::IsOpen ( ) const

Check if the file is open.

Definition at line 2231 of file XrdClFileStateHandler.cc.

2232 {
2233 XrdSysMutexHelper scopedLock( pMutex );
2234
2235 if( pFileState == Opened || pFileState == Recovering )
2236 return true;
2237 return false;
2238 }

References Opened, and Recovering.

◆ IsSecure()

bool XrdCl::FileStateHandler::IsSecure ( ) const
inline

Check if the file is using an encrypted connection.

Definition at line 658 of file XrdClFileStateHandler.hh.

659 {
660 return pIsChannelEncrypted;
661 }

◆ ListXAttr()

XRootDStatus XrdCl::FileStateHandler::ListXAttr ( std::shared_ptr< FileStateHandler > & self,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

List extended attributes - async

Parameters
handler: handler to be notified when the response arrives, the response parameter will hold a std::vector of XAttr objects
timeout: timeout value, if 0 the environment default will be used
Returns
: status of the operation

Definition at line 2024 of file XrdClFileStateHandler.cc.

2027 {
2028 XrdSysMutexHelper scopedLock( self->pMutex );
2029
2030 if( self->pFileState == Error ) return self->pStatus;
2031
2032 if( self->pFileState != Opened && self->pFileState != Recovering )
2033 return XRootDStatus( stError, errInvalidOp );
2034
2035 Log *log = DefaultEnv::GetLog();
2036 log->Debug( FileMsg, "[%p@%s] Sending a fattr list command for handle %#x to %s",
2037 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
2038 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
2039
2040 //--------------------------------------------------------------------------
2041 // Issue a new fattr get request
2042 //--------------------------------------------------------------------------
2043 static const std::vector<std::string> nothing;
2044 return XAttrOperationImpl( self, kXR_fattrList, ClientFattrRequest::aData,
2045 nothing, handler, timeout );
2046 }
@ kXR_fattrList
Definition XProtocol.hh:272
static const int aData
Definition XProtocol.hh:298

References ClientFattrRequest::aData, XrdCl::Log::Debug(), XrdCl::errInvalidOp, Error, XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), kXR_fattrList, Opened, Recovering, and XrdCl::stError.

Referenced by XrdCl::File::ListXAttr().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Lock()

void XrdCl::FileStateHandler::Lock ( )
inline

Lock the internal lock.

Definition at line 680 of file XrdClFileStateHandler.hh.

681 {
682 pMutex.Lock();
683 }

◆ OnClose()

void XrdCl::FileStateHandler::OnClose ( const XRootDStatus * status)

Process the results of the closing operation.

Definition at line 2453 of file XrdClFileStateHandler.cc.

2454 {
2455 Log *log = DefaultEnv::GetLog();
2456 XrdSysMutexHelper scopedLock( pMutex );
2457
2458 log->Debug(FileMsg, "[%p@%s] Close returned from %s with: %s", this,
2459 pFileUrl->GetObfuscatedURL().c_str(), pDataServer->GetHostId().c_str(),
2460 status->ToStr().c_str() );
2461
2462 log->Dump(FileMsg, "[%p@%s] Items in the fly %zu, queued for recovery %zu",
2463 this, pFileUrl->GetObfuscatedURL().c_str(), pInTheFly.size(), pToBeRecovered.size() );
2464
2465 MonitorClose( status );
2466 ResetMonitoringVars();
2467
2468 pStatus = *status;
2469 pFileState = Closed;
2470 }

References Closed, XrdCl::Log::Debug(), XrdCl::Log::Dump(), XrdCl::FileMsg, XrdCl::URL::GetHostId(), XrdCl::DefaultEnv::GetLog(), XrdCl::URL::GetObfuscatedURL(), and XrdCl::XRootDStatus::ToStr().

+ Here is the call graph for this function:

◆ OnOpen()

void XrdCl::FileStateHandler::OnOpen ( const XRootDStatus * status,
const OpenInfo * openInfo,
const HostList * hostList )

Process the results of the opening operation.

Definition at line 2312 of file XrdClFileStateHandler.cc.

2315 {
2316 Log *log = DefaultEnv::GetLog();
2317 XrdSysMutexHelper scopedLock( pMutex );
2318
2319 //--------------------------------------------------------------------------
2320 // Assign the data server and the load balancer
2321 //--------------------------------------------------------------------------
2322 std::string lastServer = pFileUrl->GetHostId();
2323 if( hostList )
2324 {
2325 delete pDataServer;
2326 delete pLoadBalancer;
2327 pLoadBalancer = 0;
2328 delete pWrtRecoveryRedir;
2329 pWrtRecoveryRedir = 0;
2330
2331 pDataServer = new URL( hostList->back().url );
2332 pDataServer->SetParams( pFileUrl->GetParams() );
2333 if( !( pUseVirtRedirector && pFileUrl->IsMetalink() ) ) pDataServer->SetPath( pFileUrl->GetPath() );
2334 lastServer = pDataServer->GetHostId();
2335 HostList::const_iterator itC;
2336 URL::ParamsMap params = pDataServer->GetParams();
2337 for( itC = hostList->begin(); itC != hostList->end(); ++itC )
2338 {
2339 MessageUtils::MergeCGI( params,
2340 itC->url.GetParams(),
2341 true );
2342 }
2343 pDataServer->SetParams( params );
2344
2345 HostList::const_reverse_iterator it;
2346 for( it = hostList->rbegin(); it != hostList->rend(); ++it )
2347 if( it->loadBalancer )
2348 {
2349 pLoadBalancer = new URL( it->url );
2350 break;
2351 }
2352
2353 for( it = hostList->rbegin(); it != hostList->rend(); ++it )
2354 if( it->flags & kXR_recoverWrts )
2355 {
2356 pWrtRecoveryRedir = new URL( it->url );
2357 break;
2358 }
2359 }
2360
2361 log->Debug(FileMsg, "[%p@%s] Open has returned with status %s",
2362 this, pFileUrl->GetObfuscatedURL().c_str(), status->ToStr().c_str() );
2363
2364 if( pDataServer && !pDataServer->IsLocalFile() )
2365 {
2366 //------------------------------------------------------------------------
2367 // Check if we are using a secure connection
2368 //------------------------------------------------------------------------
2369 XrdCl::AnyObject isencobj;
2371 QueryTransport( *pDataServer, XRootDQuery::IsEncrypted, isencobj );
2372 if( st.IsOK() )
2373 {
2374 bool *isenc;
2375 isencobj.Get( isenc );
2376 pIsChannelEncrypted = *isenc;
2377 delete isenc;
2378 }
2379 }
2380
2381 //--------------------------------------------------------------------------
2382 // We have failed
2383 //--------------------------------------------------------------------------
2384 pStatus = *status;
2385 if( !pStatus.IsOK() || !openInfo )
2386 {
2387 log->Debug(FileMsg, "[%p@%s] Error while opening at %s: %s",
2388 this, pFileUrl->GetObfuscatedURL().c_str(), lastServer.c_str(),
2389 pStatus.ToStr().c_str() );
2390 FailQueuedMessages( pStatus );
2391 pFileState = Error;
2392
2393 //------------------------------------------------------------------------
2394 // Report to monitoring
2395 //------------------------------------------------------------------------
2396 Monitor *mon = DefaultEnv::GetMonitor();
2397 if( mon )
2398 {
2399 Monitor::ErrorInfo i;
2400 i.file = pFileUrl;
2401 i.status = status;
2402 i.opCode = Monitor::ErrorInfo::ErrOpen;
2403 mon->Event( Monitor::EvErrIO, &i );
2404 }
2405 }
2406 //--------------------------------------------------------------------------
2407 // We have succeeded
2408 //--------------------------------------------------------------------------
2409 else
2410 {
2411 //------------------------------------------------------------------------
2412 // Store the response info
2413 //------------------------------------------------------------------------
2414 openInfo->GetFileHandle( pFileHandle );
2415 pSessionId = openInfo->GetSessionId();
2416 if( openInfo->GetStatInfo() )
2417 {
2418 delete pStatInfo;
2419 pStatInfo = new StatInfo( *openInfo->GetStatInfo() );
2420 }
2421
2422 log->Debug( FileMsg, "[%p@%s] successfully opened at %s, handle: %#x, "
2423 "session id: %llu", this, pFileUrl->GetObfuscatedURL().c_str(),
2424 pDataServer->GetHostId().c_str(), *((uint32_t*)pFileHandle),
2425 (unsigned long long) pSessionId );
2426
2427 //------------------------------------------------------------------------
2428 // Inform the monitoring about opening success
2429 //------------------------------------------------------------------------
2430 gettimeofday( &pOpenTime, 0 );
2431 Monitor *mon = DefaultEnv::GetMonitor();
2432 if( mon )
2433 {
2434 Monitor::OpenInfo i;
2435 i.file = pFileUrl;
2436 i.dataServer = pDataServer->GetHostId();
2437 i.oFlags = pOpenFlags;
2438 i.fSize = pStatInfo ? pStatInfo->GetSize() : 0;
2439 mon->Event( Monitor::EvOpen, &i );
2440 }
2441
2442 //------------------------------------------------------------------------
2443 // Resend the queued messages if any
2444 //------------------------------------------------------------------------
2445 ReSendQueuedMessages();
2446 pFileState = Opened;
2447 }
2448 }
#define kXR_recoverWrts
void Get(Type &object)
Retrieve the object being held.
static Monitor * GetMonitor()
Get the monitor object.
static void MergeCGI(URL::ParamsMap &cgi1, const URL::ParamsMap &cgi2, bool replace)
Merge cgi2 into cgi1.
@ EvErrIO
ErrorInfo: An I/O error occurred.
@ EvOpen
OpenInfo: File opened.
uint64_t GetSize() const
Get size (in bytes)
const std::string & GetPath() const
Get the path.
Definition XrdClURL.hh:217
std::map< std::string, std::string > ParamsMap
Definition XrdClURL.hh:33
void SetParams(const std::string &params)
Set params.
Definition XrdClURL.cc:402
void SetPath(const std::string &path)
Set the path.
Definition XrdClURL.hh:225
const ParamsMap & GetParams() const
Get the URL params.
Definition XrdClURL.hh:244
std::string ToStr() const
Convert to string.
bool IsOK() const
We're fine.
static const uint16_t IsEncrypted
returns true if the channel is encrypted

References XrdCl::Monitor::OpenInfo::dataServer, XrdCl::Log::Debug(), XrdCl::Monitor::ErrorInfo::ErrOpen, Error, XrdCl::Monitor::Event(), XrdCl::Monitor::EvErrIO, XrdCl::Monitor::EvOpen, XrdCl::Monitor::OpenInfo::file, XrdCl::Monitor::ErrorInfo::file, XrdCl::FileMsg, XrdCl::Monitor::OpenInfo::fSize, XrdCl::AnyObject::Get(), XrdCl::OpenInfo::GetFileHandle(), XrdCl::URL::GetHostId(), XrdCl::DefaultEnv::GetLog(), XrdCl::DefaultEnv::GetMonitor(), XrdCl::URL::GetObfuscatedURL(), XrdCl::URL::GetParams(), XrdCl::URL::GetPath(), XrdCl::DefaultEnv::GetPostMaster(), XrdCl::OpenInfo::GetSessionId(), XrdCl::StatInfo::GetSize(), XrdCl::OpenInfo::GetStatInfo(), XrdCl::XRootDQuery::IsEncrypted, XrdCl::URL::IsLocalFile(), XrdCl::URL::IsMetalink(), XrdCl::Status::IsOK(), kXR_recoverWrts, XrdCl::MessageUtils::MergeCGI(), XrdCl::Monitor::OpenInfo::oFlags, XrdCl::Monitor::ErrorInfo::opCode, Opened, XrdCl::URL::SetParams(), XrdCl::URL::SetPath(), XrdCl::Monitor::ErrorInfo::status, and XrdCl::XRootDStatus::ToStr().

+ Here is the call graph for this function:

◆ OnStateError()

void XrdCl::FileStateHandler::OnStateError ( std::shared_ptr< FileStateHandler > & self,
XRootDStatus * status,
Message * message,
ResponseHandler * userHandler,
MessageSendParams & sendParams )
static

Handle an error while sending a stateful message.

Definition at line 2475 of file XrdClFileStateHandler.cc.

2480 {
2481 //--------------------------------------------------------------------------
2482 // It may be a redirection
2483 //--------------------------------------------------------------------------
2484 if( !status->IsOK() && status->code == errRedirect && self->pFollowRedirects )
2485 {
2486 static const std::string root = "root", xroot = "xroot", file = "file",
2487 roots = "roots", xroots = "xroots";
2488 std::string msg = status->GetErrorMessage();
2489 if( !msg.compare( 0, root.size(), root ) ||
2490 !msg.compare( 0, xroot.size(), xroot ) ||
2491 !msg.compare( 0, file.size(), file ) ||
2492 !msg.compare( 0, roots.size(), roots ) ||
2493 !msg.compare( 0, xroots.size(), xroots ) )
2494 {
2495 FileStateHandler::OnStateRedirection( self, msg, message, userHandler, sendParams );
2496 return;
2497 }
2498 }
2499
2500 //--------------------------------------------------------------------------
2501 // Handle error
2502 //--------------------------------------------------------------------------
2503 Log *log = DefaultEnv::GetLog();
2504 XrdSysMutexHelper scopedLock( self->pMutex );
2505 self->pInTheFly.erase( message );
2506
2507 log->Dump( FileMsg, "[%p@%s] File state error encountered. Message %s "
2508 "returned with %s", self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
2509 message->GetObfuscatedDescription().c_str(), status->ToStr().c_str() );
2510
2511 //--------------------------------------------------------------------------
2512 // Report to monitoring
2513 //--------------------------------------------------------------------------
2514 Monitor *mon = DefaultEnv::GetMonitor();
2515 if( mon )
2516 {
2517 Monitor::ErrorInfo i;
2518 i.file = self->pFileUrl;
2519 i.status = status;
2520
2521 ClientRequest *req = (ClientRequest*)message->GetBuffer();
2522 switch( req->header.requestid )
2523 {
2524 case kXR_read: i.opCode = Monitor::ErrorInfo::ErrRead; break;
2525 case kXR_readv: i.opCode = Monitor::ErrorInfo::ErrReadV; break;
2526 case kXR_pgread: i.opCode = Monitor::ErrorInfo::ErrRead; break;
2527 case kXR_write: i.opCode = Monitor::ErrorInfo::ErrWrite; break;
2528 case kXR_writev: i.opCode = Monitor::ErrorInfo::ErrWriteV; break;
2529 case kXR_pgwrite: i.opCode = Monitor::ErrorInfo::ErrWrite; break;
2530 default: i.opCode = Monitor::ErrorInfo::ErrUnc;
2531 }
2532
2533 mon->Event( Monitor::EvErrIO, &i );
2534 }
2535
2536 //--------------------------------------------------------------------------
2537 // The message is not recoverable
2538 // (message using a kernel buffer is not recoverable by definition)
2539 //--------------------------------------------------------------------------
2540 if( !self->IsRecoverable( *status ) || sendParams.kbuff )
2541 {
2542 log->Error( FileMsg, "[%p@%s] Fatal file state error. Message %s "
2543 "returned with %s", self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
2544 message->GetObfuscatedDescription().c_str(), status->ToStr().c_str() );
2545
2546 self->FailMessage( RequestData( message, userHandler, sendParams ), *status );
2547 delete status;
2548 return;
2549 }
2550
2551 //--------------------------------------------------------------------------
2552 // Insert the message to the recovery queue and start the recovery
2553 // procedure if we don't have any more message in the fly
2554 //--------------------------------------------------------------------------
2555 self->pCloseReason = *status;
2556 RecoverMessage( self, RequestData( message, userHandler, sendParams ) );
2557 delete status;
2558 }
struct ClientRequestHdr header
Definition XProtocol.hh:846
kXR_unt16 requestid
Definition XProtocol.hh:157
@ kXR_read
Definition XProtocol.hh:125
@ kXR_writev
Definition XProtocol.hh:143
@ kXR_readv
Definition XProtocol.hh:137
@ kXR_pgread
Definition XProtocol.hh:142
@ kXR_pgwrite
Definition XProtocol.hh:138
static void OnStateRedirection(std::shared_ptr< FileStateHandler > &self, const std::string &redirectUrl, Message *message, ResponseHandler *userHandler, MessageSendParams &sendParams)
Handle stateful redirect.
const uint16_t errRedirect
@ ErrUnc
Unclassified operation.

References XrdCl::Status::code, XrdCl::Log::Dump(), XrdCl::Log::Error(), XrdCl::Monitor::ErrorInfo::ErrRead, XrdCl::Monitor::ErrorInfo::ErrReadV, XrdCl::errRedirect, XrdCl::Monitor::ErrorInfo::ErrUnc, XrdCl::Monitor::ErrorInfo::ErrWrite, XrdCl::Monitor::ErrorInfo::ErrWriteV, XrdCl::Monitor::Event(), XrdCl::Monitor::EvErrIO, XrdCl::Monitor::ErrorInfo::file, XrdCl::FileMsg, XrdCl::Buffer::GetBuffer(), XrdCl::XRootDStatus::GetErrorMessage(), XrdCl::DefaultEnv::GetLog(), XrdCl::DefaultEnv::GetMonitor(), XrdCl::Message::GetObfuscatedDescription(), ClientRequest::header, XrdCl::Status::IsOK(), XrdCl::MessageSendParams::kbuff, kXR_pgread, kXR_pgwrite, kXR_read, kXR_readv, kXR_write, kXR_writev, OnStateRedirection(), XrdCl::Monitor::ErrorInfo::opCode, ClientRequestHdr::requestid, XrdCl::Monitor::ErrorInfo::status, and XrdCl::XRootDStatus::ToStr().

+ Here is the call graph for this function:

◆ OnStateRedirection()

void XrdCl::FileStateHandler::OnStateRedirection ( std::shared_ptr< FileStateHandler > & self,
const std::string & redirectUrl,
Message * message,
ResponseHandler * userHandler,
MessageSendParams & sendParams )
static

Handle stateful redirect.

Definition at line 2563 of file XrdClFileStateHandler.cc.

2568 {
2569 XrdSysMutexHelper scopedLock( self->pMutex );
2570 self->pInTheFly.erase( message );
2571
2572 //--------------------------------------------------------------------------
2573 // Register the state redirect url and append the new cgi information to
2574 // the file URL
2575 //--------------------------------------------------------------------------
2576 if( !self->pStateRedirect )
2577 {
2578 std::ostringstream o;
2579 self->pStateRedirect = new URL( redirectUrl );
2580 URL::ParamsMap params = self->pFileUrl->GetParams();
2581 MessageUtils::MergeCGI( params,
2582 self->pStateRedirect->GetParams(),
2583 false );
2584 self->pFileUrl->SetParams( params );
2585 }
2586
2587 RecoverMessage( self, RequestData( message, userHandler, sendParams ) );
2588 }

References XrdCl::MessageUtils::MergeCGI().

Referenced by OnStateError().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ OnStateResponse()

void XrdCl::FileStateHandler::OnStateResponse ( std::shared_ptr< FileStateHandler > & self,
XRootDStatus * status,
Message * message,
AnyObject * response,
HostList * hostList )
static

Handle stateful response.

Definition at line 2593 of file XrdClFileStateHandler.cc.

2598 {
2599 Log *log = DefaultEnv::GetLog();
2600 XrdSysMutexHelper scopedLock( self->pMutex );
2601
2602 log->Dump( FileMsg, "[%p@%s] Got state response for message %s",
2603 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
2604 message->GetObfuscatedDescription().c_str() );
2605
2606 //--------------------------------------------------------------------------
2607 // Since this message may be the last "in-the-fly" and no recovery
2608 // is done if messages are in the fly, we may need to trigger recovery
2609 //--------------------------------------------------------------------------
2610 self->pInTheFly.erase( message );
2611 RunRecovery( self );
2612
2613 //--------------------------------------------------------------------------
2614 // Play with the actual response before returning it. This is a good
2615 // place to do caching in the future.
2616 //--------------------------------------------------------------------------
2617 ClientRequest *req = (ClientRequest*)message->GetBuffer();
2618 switch( req->header.requestid )
2619 {
2620 //------------------------------------------------------------------------
2621 // Cache the stat response
2622 //------------------------------------------------------------------------
2623 case kXR_stat:
2624 {
2625 StatInfo *info = 0;
2626 response->Get( info );
2627 delete self->pStatInfo;
2628 self->pStatInfo = new StatInfo( *info );
2629 break;
2630 }
2631
2632 //------------------------------------------------------------------------
2633 // Handle read response
2634 //------------------------------------------------------------------------
2635 case kXR_read:
2636 {
2637 ++self->pRCount;
2638 self->pRBytes += req->read.rlen;
2639 break;
2640 }
2641
2642 //------------------------------------------------------------------------
2643 // Handle read response
2644 //------------------------------------------------------------------------
2645 case kXR_pgread:
2646 {
2647 ++self->pRCount;
2648 self->pRBytes += req->pgread.rlen;
2649 break;
2650 }
2651
2652 //------------------------------------------------------------------------
2653 // Handle readv response
2654 //------------------------------------------------------------------------
2655 case kXR_readv:
2656 {
2657 ++self->pVRCount;
2658 size_t segs = req->header.dlen/sizeof(readahead_list);
2659 readahead_list *dataChunk = (readahead_list*)message->GetBuffer( 24 );
2660 for( size_t i = 0; i < segs; ++i )
2661 self->pVRBytes += dataChunk[i].rlen;
2662 self->pVSegs += segs;
2663 break;
2664 }
2665
2666 //------------------------------------------------------------------------
2667 // Handle write response
2668 //------------------------------------------------------------------------
2669 case kXR_write:
2670 {
2671 ++self->pWCount;
2672 self->pWBytes += req->write.dlen;
2673 break;
2674 }
2675
2676 //------------------------------------------------------------------------
2677 // Handle write response
2678 //------------------------------------------------------------------------
2679 case kXR_pgwrite:
2680 {
2681 ++self->pWCount;
2682 self->pWBytes += req->pgwrite.dlen;
2683 break;
2684 }
2685
2686 //------------------------------------------------------------------------
2687 // Handle writev response
2688 //------------------------------------------------------------------------
2689 case kXR_writev:
2690 {
2691 ++self->pVWCount;
2692 size_t size = req->header.dlen/sizeof(readahead_list);
2693 XrdProto::write_list *wrtList =
2694 reinterpret_cast<XrdProto::write_list*>( message->GetBuffer( 24 ) );
2695 for( size_t i = 0; i < size; ++i )
2696 self->pVWBytes += wrtList[i].wlen;
2697 break;
2698 }
2699 };
2700 }
struct ClientPgReadRequest pgread
Definition XProtocol.hh:861
struct ClientPgWriteRequest pgwrite
Definition XProtocol.hh:862
@ kXR_stat
Definition XProtocol.hh:129
struct ClientReadRequest read
Definition XProtocol.hh:867
struct ClientWriteRequest write
Definition XProtocol.hh:876

References ClientRequestHdr::dlen, ClientPgWriteRequest::dlen, ClientWriteRequest::dlen, XrdCl::Log::Dump(), XrdCl::FileMsg, XrdCl::AnyObject::Get(), XrdCl::Buffer::GetBuffer(), XrdCl::DefaultEnv::GetLog(), XrdCl::Message::GetObfuscatedDescription(), ClientRequest::header, kXR_pgread, kXR_pgwrite, kXR_read, kXR_readv, kXR_stat, kXR_write, kXR_writev, ClientRequest::pgread, ClientRequest::pgwrite, ClientRequest::read, ClientRequestHdr::requestid, ClientPgReadRequest::rlen, ClientReadRequest::rlen, readahead_list::rlen, XrdProto::write_list::wlen, and ClientRequest::write.

+ Here is the call graph for this function:

◆ Open()

XRootDStatus XrdCl::FileStateHandler::Open ( std::shared_ptr< FileStateHandler > & self,
const std::string & url,
uint16_t flags,
uint16_t mode,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Open the file pointed to by the given URL

Parameters
urlurl of the file to be opened
flagsOpenFlags::Flags
modeAccess::Mode for new files, 0 otherwise
handlerhandler to be notified about the status of the operation
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 747 of file XrdClFileStateHandler.cc.

753 {
754 XrdSysMutexHelper scopedLock( self->pMutex );
755
756 //--------------------------------------------------------------------------
757 // Check if we can proceed
758 //--------------------------------------------------------------------------
759 if( self->pFileState == Error )
760 return self->pStatus;
761
762 if( self->pFileState == OpenInProgress )
763 return XRootDStatus( stError, errInProgress );
764
765 if( self->pFileState == CloseInProgress || self->pFileState == Opened ||
766 self->pFileState == Recovering )
767 return XRootDStatus( stError, errInvalidOp );
768
769 self->pFileState = OpenInProgress;
770
771 //--------------------------------------------------------------------------
772 // Check if the parameters are valid
773 //--------------------------------------------------------------------------
774 Log *log = DefaultEnv::GetLog();
775
776 if( self->pFileUrl )
777 {
778 if( self->pUseVirtRedirector && self->pFileUrl->IsMetalink() )
779 {
780 RedirectorRegistry& registry = RedirectorRegistry::Instance();
781 registry.Release( *self->pFileUrl );
782 }
783 delete self->pFileUrl;
784 self->pFileUrl = 0;
785 }
786
787 self->pFileUrl = new URL( url );
788
789 //--------------------------------------------------------------------------
790 // Add unique uuid to each open request so replays due to error/timeout
791 // recovery can be correctly handled.
792 //--------------------------------------------------------------------------
793 URL::ParamsMap cgi = self->pFileUrl->GetParams();
794 uuid_t uuid;
795 char requuid[37]= {0};
796 uuid_generate( uuid );
797 uuid_unparse( uuid, requuid );
798 cgi["xrdcl.requuid"] = requuid;
799 self->pFileUrl->SetParams( cgi );
800
801 if( !self->pFileUrl->IsValid() )
802 {
803 log->Error( FileMsg, "[%p@%s] Trying to open invalid url: %s",
804 self.get(), self->pFileUrl->GetPath().c_str(), url.c_str() );
805 self->pStatus = XRootDStatus( stError, errInvalidArgs );
806 self->pFileState = Closed;
807 return self->pStatus;
808 }
809
810 //--------------------------------------------------------------------------
811 // Check if the recovery procedures should be enabled
812 //--------------------------------------------------------------------------
813 const URL::ParamsMap &urlParams = self->pFileUrl->GetParams();
814 URL::ParamsMap::const_iterator it;
815 it = urlParams.find( "xrdcl.recover-reads" );
816 if( (it != urlParams.end() && it->second == "false") ||
817 !self->pDoRecoverRead )
818 {
819 self->pDoRecoverRead = false;
820 log->Debug( FileMsg, "[%p@%s] Read recovery procedures are disabled",
821 self.get(), self->pFileUrl->GetObfuscatedURL().c_str() );
822 }
823
824 it = urlParams.find( "xrdcl.recover-writes" );
825 if( (it != urlParams.end() && it->second == "false") ||
826 !self->pDoRecoverWrite )
827 {
828 self->pDoRecoverWrite = false;
829 log->Debug( FileMsg, "[%p@%s] Write recovery procedures are disabled",
830 self.get(), self->pFileUrl->GetObfuscatedURL().c_str() );
831 }
832
833 //--------------------------------------------------------------------------
834 // Open the file
835 //--------------------------------------------------------------------------
836 log->Debug( FileMsg, "[%p@%s] Sending an open command", self.get(),
837 self->pFileUrl->GetObfuscatedURL().c_str() );
838
839 self->pOpenMode = mode;
840 self->pOpenFlags = flags;
841 OpenHandler *openHandler = new OpenHandler( self, handler );
842
843 Message *msg;
845 std::string path = self->pFileUrl->GetPathWithFilteredParams();
846 MessageUtils::CreateRequest( msg, req, path.length() );
847
848 req->requestid = kXR_open;
849 req->mode = mode;
850 req->options = flags | kXR_async | kXR_retstat;
851 req->dlen = path.length();
852 msg->Append( path.c_str(), path.length(), 24 );
853
855 MessageSendParams params; params.timeout = timeout;
856 params.followRedirects = self->pFollowRedirects;
858
859 XRootDStatus st = self->IssueRequest( *self->pFileUrl, msg, openHandler, params );
860
861 if( !st.IsOK() )
862 {
863 delete openHandler;
864 self->pStatus = st;
865 self->pFileState = Closed;
866 return st;
867 }
868 return st;
869 }
kXR_unt16 requestid
Definition XProtocol.hh:479
kXR_unt16 options
Definition XProtocol.hh:481
@ kXR_async
Definition XProtocol.hh:458
@ kXR_retstat
Definition XProtocol.hh:463
@ kXR_open
Definition XProtocol.hh:122
const uint16_t errInvalidArgs

References ::OpenHandler, XrdCl::Buffer::Append(), Closed, CloseInProgress, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), ClientOpenRequest::dlen, XrdCl::errInProgress, XrdCl::errInvalidArgs, XrdCl::errInvalidOp, Error, XrdCl::Log::Error(), XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::DefaultEnv::GetLog(), XrdCl::RedirectorRegistry::Instance(), XrdCl::Status::IsOK(), kXR_async, kXR_open, kXR_retstat, ClientOpenRequest::mode, Opened, OpenInProgress, ClientOpenRequest::options, XrdCl::MessageUtils::ProcessSendParams(), Recovering, XrdCl::RedirectorRegistry::Release(), ClientOpenRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::File::Open().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ PgRead()

XRootDStatus XrdCl::FileStateHandler::PgRead ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
uint32_t size,
void * buffer,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Read data pages at a given offset

Parameters
offset: offset from the beginning of the file (Note: has to 4KB aligned)
size: buffer size
buffer: a pointer to buffer big enough to hold the data
handler: handler to be notified when the response arrives, the response parameter will hold a PgReadInfo object if the procedure was successful
timeout: timeout value, if 0 environment default will be used
Returns
: status of the operation

Definition at line 1055 of file XrdClFileStateHandler.cc.

1061 {
1062 int issupported = true;
1063 AnyObject obj;
1064 XRootDStatus st1 = DefaultEnv::GetPostMaster()->QueryTransport( *self->pDataServer, XRootDQuery::ServerFlags, obj );
1065 int protver = 0;
1066 XRootDStatus st2 = Utils::GetProtocolVersion( *self->pDataServer, protver );
1067 if( st1.IsOK() && st2.IsOK() )
1068 {
1069 int *ptr = 0;
1070 obj.Get( ptr );
1071 issupported = ( *ptr & kXR_suppgrw ) && ( protver >= kXR_PROTPGRWVERSION );
1072 delete ptr;
1073 }
1074 else
1075 issupported = false;
1076
1077 if( !issupported )
1078 {
1079 DefaultEnv::GetLog()->Debug( FileMsg, "[%p@%s] PgRead not supported; substituting with Read.",
1080 self.get(), self->pFileUrl->GetObfuscatedURL().c_str() );
1081 ResponseHandler *substitHandler = new PgReadSubstitutionHandler( self, handler );
1082 auto st = Read( self, offset, size, buffer, substitHandler, timeout );
1083 if( !st.IsOK() ) delete substitHandler;
1084 return st;
1085 }
1086
1087 ResponseHandler* pgHandler = new PgReadHandler( self, handler, offset );
1088 auto st = PgReadImpl( self, offset, size, buffer, PgReadFlags::None, pgHandler, timeout );
1089 if( !st.IsOK() ) delete pgHandler;
1090 return st;
1091 }
#define kXR_suppgrw
#define kXR_PROTPGRWVERSION
Definition XProtocol.hh:73
static XRootDStatus PgReadImpl(std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, void *buffer, uint16_t flags, ResponseHandler *handler, uint16_t timeout=0)
static XRootDStatus Read(std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, uint16_t timeout=0)
void Debug(uint64_t topic, const char *format,...)
Print a debug message.
Definition XrdClLog.cc:282
Status QueryTransport(const URL &url, uint16_t query, AnyObject &result)
static XrdCl::XRootDStatus GetProtocolVersion(const XrdCl::URL url, int &protver)
static const uint16_t ServerFlags
returns server flags

References ::PgReadHandler, ::PgReadSubstitutionHandler, XrdCl::Log::Debug(), XrdCl::FileMsg, XrdCl::AnyObject::Get(), XrdCl::DefaultEnv::GetLog(), XrdCl::DefaultEnv::GetPostMaster(), XrdCl::Utils::GetProtocolVersion(), XrdCl::Status::IsOK(), kXR_PROTPGRWVERSION, kXR_suppgrw, XrdCl::PgReadFlags::None, PgReadImpl(), XrdCl::PostMaster::QueryTransport(), Read(), and XrdCl::XRootDQuery::ServerFlags.

Referenced by XrdCl::File::PgRead().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ PgReadImpl()

XRootDStatus XrdCl::FileStateHandler::PgReadImpl ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
uint32_t size,
void * buffer,
uint16_t flags,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Read data pages at a given offset (actual implementation)

Parameters
offset: offset from the beginning of the file (Note: has to 4KB aligned)
size: buffer size
buffer: a pointer to buffer big enough to hold the data
flags: PgRead flags
handler: handler to be notified when the response arrives, the response parameter will hold a PgReadInfo object if the procedure was successful
timeout: timeout value, if 0 environment default will be used
Returns
: status of the operation

Definition at line 1111 of file XrdClFileStateHandler.cc.

1118 {
1119 XrdSysMutexHelper scopedLock( self->pMutex );
1120
1121 if( self->pFileState == Error ) return self->pStatus;
1122
1123 if( self->pFileState != Opened && self->pFileState != Recovering )
1124 return XRootDStatus( stError, errInvalidOp );
1125
1126 Log *log = DefaultEnv::GetLog();
1127 log->Debug( FileMsg, "[%p@%s] Sending a pgread command for handle %#x to %s",
1128 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1129 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1130
1131 Message *msg;
1133 MessageUtils::CreateRequest( msg, req, sizeof( ClientPgReadReqArgs ) );
1134
1135 req->requestid = kXR_pgread;
1136 req->offset = offset;
1137 req->rlen = size;
1138 memcpy( req->fhandle, self->pFileHandle, 4 );
1139
1140 //--------------------------------------------------------------------------
1141 // Now adjust the message size so it can hold PgRead arguments
1142 //--------------------------------------------------------------------------
1143 req->dlen = sizeof( ClientPgReadReqArgs );
1144 void *newBuf = msg->GetBuffer( sizeof( ClientPgReadRequest ) );
1145 memset( newBuf, 0, sizeof( ClientPgReadReqArgs ) );
1146 ClientPgReadReqArgs *args = reinterpret_cast<ClientPgReadReqArgs*>(
1147 msg->GetBuffer( sizeof( ClientPgReadRequest ) ) );
1148 args->reqflags = flags;
1149
1150 ChunkList *list = new ChunkList();
1151 list->push_back( ChunkInfo( offset, size, buffer ) );
1152
1154 MessageSendParams params;
1155 params.timeout = timeout;
1156 params.followRedirects = false;
1157 params.stateful = true;
1158 params.chunkList = list;
1160 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1161
1162 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1163 }
kXR_char fhandle[4]
Definition XProtocol.hh:509

References XrdCl::MessageSendParams::chunkList, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), ClientPgReadRequest::dlen, XrdCl::errInvalidOp, Error, ClientPgReadRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::Buffer::GetBuffer(), XrdCl::DefaultEnv::GetLog(), kXR_pgread, ClientPgReadRequest::offset, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientPgReadReqArgs::reqflags, ClientPgReadRequest::requestid, ClientPgReadRequest::rlen, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by PgRead(), and PgReadRetry().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ PgReadRetry()

XRootDStatus XrdCl::FileStateHandler::PgReadRetry ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
uint32_t size,
size_t pgnb,
void * buffer,
PgReadHandler * handler,
uint16_t timeout = 0 )
static

Retry reading one page of data at a given offset

Parameters
offset: offset from the beginning of the file (Note: has to 4KB aligned)
size: buffer size
buffer: a pointer to buffer big enough to hold the data
handler: handler to be notified when the response arrives
timeout: timeout value, if 0 environment default will be used
Returns
: status of the operation

Definition at line 1093 of file XrdClFileStateHandler.cc.

1100 {
1101 if( size > (uint32_t)XrdSys::PageSize )
1102 return XRootDStatus( stError, errInvalidArgs, EINVAL,
1103 "PgRead retry size exceeded 4KB." );
1104
1105 ResponseHandler *retryHandler = new PgReadRetryHandler( handler, pgnb );
1106 XRootDStatus st = PgReadImpl( self, offset, size, buffer, PgReadFlags::Retry, retryHandler, timeout );
1107 if( !st.IsOK() ) delete retryHandler;
1108 return st;
1109 }
static const int PageSize

References ::PgReadRetryHandler, XrdCl::errInvalidArgs, XrdCl::Status::IsOK(), XrdSys::PageSize, PgReadImpl(), XrdCl::PgReadFlags::Retry, and XrdCl::stError.

+ Here is the call graph for this function:

◆ PgWrite()

XRootDStatus XrdCl::FileStateHandler::PgWrite ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
uint32_t size,
const void * buffer,
std::vector< uint32_t > & cksums,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Write number of pages at a given offset - async

Parameters
offsetoffset from the beginning of the file
sizebuffer size
buffera pointer to a buffer holding data pages
cksumsthe crc32c checksums for each 4KB page
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 1292 of file XrdClFileStateHandler.cc.

1299 {
1300 //--------------------------------------------------------------------------
1301 // Resolve timeout value
1302 //--------------------------------------------------------------------------
1303 if( timeout == 0 )
1304 {
1305 int val = DefaultRequestTimeout;
1306 XrdCl::DefaultEnv::GetEnv()->GetInt( "RequestTimeout", val );
1307 timeout = val;
1308 }
1309
1310 //--------------------------------------------------------------------------
1311 // Validate the digest vector size
1312 //--------------------------------------------------------------------------
1313 if( cksums.empty() )
1314 {
1315 const char *data = static_cast<const char*>( buffer );
1316 XrdOucPgrwUtils::csCalc( data, offset, size, cksums );
1317 }
1318 else
1319 {
1320 size_t crc32cCnt = XrdOucPgrwUtils::csNum( offset, size );
1321 if( crc32cCnt != cksums.size() )
1322 return XRootDStatus( stError, errInvalidArgs, 0, "Wrong number of crc32c digests." );
1323 }
1324
1325 //--------------------------------------------------------------------------
1326 // Create a context for PgWrite operation
1327 //--------------------------------------------------------------------------
1328 struct pgwrt_t
1329 {
1330 pgwrt_t( ResponseHandler *h ) : handler( h ), status( nullptr )
1331 {
1332 }
1333
1334 ~pgwrt_t()
1335 {
1336 if( handler )
1337 {
1338 // if all retries were successful no error status was set
1339 if( !status ) status = new XRootDStatus();
1340 handler->HandleResponse( status, nullptr );
1341 }
1342 }
1343
1344 static size_t GetPgNb( uint64_t pgoff, uint64_t offset, uint32_t fstpglen )
1345 {
1346 if( pgoff == offset ) return 0; // we need this if statement because we operate on unsigned integers
1347 return ( pgoff - ( offset + fstpglen ) ) / XrdSys::PageSize + 1;
1348 }
1349
1350 inline void SetStatus( XRootDStatus* s )
1351 {
1352 if( !status ) status = s;
1353 else delete s;
1354 }
1355
1356 ResponseHandler *handler;
1357 XRootDStatus *status;
1358 };
1359 auto pgwrt = std::make_shared<pgwrt_t>( handler );
1360
1361 int fLen, lLen;
1362 XrdOucPgrwUtils::csNum( offset, size, fLen, lLen );
1363 uint32_t fstpglen = fLen;
1364
1365 time_t start = ::time( nullptr );
1366 auto h = ResponseHandler::Wrap( [=]( XrdCl::XRootDStatus *s, XrdCl::AnyObject *r ) mutable
1367 {
1368 std::unique_ptr<AnyObject> scoped( r );
1369 // if the request failed simply pass the status to the
1370 // user handler
1371 if( !s->IsOK() )
1372 {
1373 pgwrt->SetStatus( s );
1374 return; // pgwrt destructor will call the handler
1375 }
1376 // also if the request was sucessful and there were no
1377 // corrupted pages pass the status to the user handler
1378 RetryInfo *inf = nullptr;
1379 r->Get( inf );
1380 if( !inf->NeedRetry() )
1381 {
1382 pgwrt->SetStatus( s );
1383 return; // pgwrt destructor will call the handler
1384 }
1385 delete s;
1386 // first adjust the timeout value
1387 uint16_t elapsed = ::time( nullptr ) - start;
1388 if( elapsed >= timeout )
1389 {
1390 pgwrt->SetStatus( new XRootDStatus( stError, errOperationExpired ) );
1391 return; // pgwrt destructor will call the handler
1392 }
1393 else timeout -= elapsed;
1394 // retransmit the corrupted pages
1395 for( size_t i = 0; i < inf->Size(); ++i )
1396 {
1397 auto tpl = inf->At( i );
1398 uint64_t pgoff = std::get<0>( tpl );
1399 uint32_t pglen = std::get<1>( tpl );
1400 const void *pgbuf = static_cast<const char*>( buffer ) + ( pgoff - offset );
1401 uint32_t pgdigest = cksums[pgwrt_t::GetPgNb( pgoff, offset, fstpglen )];
1402 auto h = ResponseHandler::Wrap( [=]( XrdCl::XRootDStatus *s, XrdCl::AnyObject *r ) mutable
1403 {
1404 std::unique_ptr<AnyObject> scoped( r );
1405 // if we failed simply set the status
1406 if( !s->IsOK() )
1407 {
1408 pgwrt->SetStatus( s );
1409 return; // the destructor will call the handler
1410 }
1411 delete s;
1412 // otherwise check if the data were not corrupted again
1413 RetryInfo *inf = nullptr;
1414 r->Get( inf );
1415 if( inf->NeedRetry() ) // so we failed in the end
1416 {
1417 DefaultEnv::GetLog()->Warning( FileMsg, "[%p@%s] Failed retransmitting corrupted "
1418 "page: pgoff=%llu, pglen=%u, pgdigest=%u", self.get(),
1419 self->pFileUrl->GetObfuscatedURL().c_str(), (unsigned long long) pgoff, pglen, pgdigest );
1420 pgwrt->SetStatus( new XRootDStatus( stError, errDataError, 0,
1421 "Failed to retransmit corrupted page" ) );
1422 }
1423 else
1424 DefaultEnv::GetLog()->Info( FileMsg, "[%p@%s] Succesfuly retransmitted corrupted "
1425 "page: pgoff=%llu, pglen=%u, pgdigest=%u", self.get(),
1426 self->pFileUrl->GetObfuscatedURL().c_str(), (unsigned long long) pgoff, pglen, pgdigest );
1427 } );
1428 auto st = PgWriteRetry( self, pgoff, pglen, pgbuf, pgdigest, h, timeout );
1429 if( !st.IsOK() ) pgwrt->SetStatus( new XRootDStatus( st ) );
1430 DefaultEnv::GetLog()->Info( FileMsg, "[%p@%s] Retransmitting corrupted page: "
1431 "pgoff=%llu, pglen=%u, pgdigest=%u", self.get(),
1432 self->pFileUrl->GetObfuscatedURL().c_str(), (unsigned long long) pgoff, pglen, pgdigest );
1433 }
1434 } );
1435
1436 auto st = PgWriteImpl( self, offset, size, buffer, cksums, 0, h, timeout );
1437 if( !st.IsOK() )
1438 {
1439 pgwrt->handler = nullptr;
1440 delete h;
1441 }
1442 return st;
1443 }
static Env * GetEnv()
Get default client environment.
bool GetInt(const std::string &key, int &value)
Definition XrdClEnv.cc:89
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, uint16_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, uint16_t timeout=0)
void Warning(uint64_t topic, const char *format,...)
Report a warning.
Definition XrdClLog.cc:248
void Info(uint64_t topic, const char *format,...)
Print an info.
Definition XrdClLog.cc:265
static ResponseHandler * Wrap(std::function< void(XRootDStatus &, AnyObject &)> func)
static void csCalc(const char *data, off_t offs, size_t count, uint32_t *csval)
static int csNum(off_t offs, int count)
Compute the required size of a checksum vector based on offset & length.
const uint16_t errOperationExpired
const uint16_t errDataError
data is corrupted
const int DefaultRequestTimeout

References XrdCl::RetryInfo::At(), XrdOucPgrwUtils::csCalc(), XrdOucPgrwUtils::csNum(), XrdCl::DefaultRequestTimeout, XrdCl::errDataError, XrdCl::errInvalidArgs, XrdCl::errOperationExpired, XrdCl::FileMsg, XrdCl::AnyObject::Get(), XrdCl::DefaultEnv::GetEnv(), XrdCl::Env::GetInt(), XrdCl::DefaultEnv::GetLog(), XrdCl::ResponseHandler::HandleResponse(), XrdCl::Log::Info(), XrdCl::Status::IsOK(), XrdCl::RetryInfo::NeedRetry(), XrdSys::PageSize, PgWriteImpl(), PgWriteRetry(), XrdCl::RetryInfo::Size(), XrdCl::stError, XrdCl::Log::Warning(), and XrdCl::ResponseHandler::Wrap().

Referenced by XrdCl::File::PgWrite().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ PgWriteImpl()

XRootDStatus XrdCl::FileStateHandler::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,
uint16_t timeout = 0 )
static

Write number of pages at a given offset - async

Parameters
offsetoffset from the beginning of the file
sizebuffer size
buffera pointer to a buffer holding data pages
cksumsthe crc32c checksums for each 4KB page
flagsPgWrite flags
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 1463 of file XrdClFileStateHandler.cc.

1471 {
1472 XrdSysMutexHelper scopedLock( self->pMutex );
1473
1474 if( self->pFileState == Error ) return self->pStatus;
1475
1476 if( self->pFileState != Opened && self->pFileState != Recovering )
1477 return XRootDStatus( stError, errInvalidOp );
1478
1479 Log *log = DefaultEnv::GetLog();
1480 log->Debug( FileMsg, "[%p@%s] Sending a pgwrite command for handle %#x to %s",
1481 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1482 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1483
1484 //--------------------------------------------------------------------------
1485 // Create the message
1486 //--------------------------------------------------------------------------
1487 Message *msg;
1489 MessageUtils::CreateRequest( msg, req );
1490
1491 req->requestid = kXR_pgwrite;
1492 req->offset = offset;
1493 req->dlen = size + cksums.size() * sizeof( uint32_t );
1494 req->reqflags = flags;
1495 memcpy( req->fhandle, self->pFileHandle, 4 );
1496
1497 ChunkList *list = new ChunkList();
1498 list->push_back( ChunkInfo( offset, size, (char*)buffer ) );
1499
1500 MessageSendParams params;
1501 params.timeout = timeout;
1502 params.followRedirects = false;
1503 params.stateful = true;
1504 params.chunkList = list;
1505 params.crc32cDigests.swap( cksums );
1506
1508
1510 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1511
1512 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1513 }
kXR_char fhandle[4]
Definition XProtocol.hh:531

References XrdCl::MessageSendParams::chunkList, XrdCl::MessageSendParams::crc32cDigests, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), ClientPgWriteRequest::dlen, XrdCl::errInvalidOp, Error, ClientPgWriteRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::DefaultEnv::GetLog(), kXR_pgwrite, ClientPgWriteRequest::offset, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientPgWriteRequest::reqflags, ClientPgWriteRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by PgWrite(), and PgWriteRetry().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ PgWriteRetry()

XRootDStatus XrdCl::FileStateHandler::PgWriteRetry ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
uint32_t size,
const void * buffer,
uint32_t digest,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Write number of pages at a given offset - async

Parameters
offsetoffset from the beginning of the file
sizebuffer size
buffera pointer to a buffer holding data pages
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 1448 of file XrdClFileStateHandler.cc.

1455 {
1456 std::vector<uint32_t> cksums{ digest };
1457 return PgWriteImpl( self, offset, size, buffer, cksums, PgReadFlags::Retry, handler, timeout );
1458 }

References PgWriteImpl(), and XrdCl::PgReadFlags::Retry.

Referenced by PgWrite().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Read()

XRootDStatus XrdCl::FileStateHandler::Read ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
uint32_t size,
void * buffer,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Read a data chunk at a given offset - sync

Parameters
offsetoffset from the beginning of the file
sizenumber of bytes to be read
buffera pointer to a buffer big enough to hold the data or 0 if the buffer should be allocated by the system
handlerhandler to be notified when the response arrives, the response parameter will hold a buffer object if the procedure was successful, if a preallocated buffer was specified then the buffer object will "wrap" this buffer
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 1009 of file XrdClFileStateHandler.cc.

1015 {
1016 XrdSysMutexHelper scopedLock( self->pMutex );
1017
1018 if( self->pFileState == Error ) return self->pStatus;
1019
1020 if( self->pFileState != Opened && self->pFileState != Recovering )
1021 return XRootDStatus( stError, errInvalidOp );
1022
1023 Log *log = DefaultEnv::GetLog();
1024 log->Debug( FileMsg, "[%p@%s] Sending a read command for handle %#x to %s",
1025 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1026 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1027
1028 Message *msg;
1029 ClientReadRequest *req;
1030 MessageUtils::CreateRequest( msg, req );
1031
1032 req->requestid = kXR_read;
1033 req->offset = offset;
1034 req->rlen = size;
1035 memcpy( req->fhandle, self->pFileHandle, 4 );
1036
1037 ChunkList *list = new ChunkList();
1038 list->push_back( ChunkInfo( offset, size, buffer ) );
1039
1041 MessageSendParams params;
1042 params.timeout = timeout;
1043 params.followRedirects = false;
1044 params.stateful = true;
1045 params.chunkList = list;
1047 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1048
1049 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1050 }
kXR_unt16 requestid
Definition XProtocol.hh:644
kXR_char fhandle[4]
Definition XProtocol.hh:645

References XrdCl::MessageSendParams::chunkList, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), XrdCl::errInvalidOp, Error, ClientReadRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::DefaultEnv::GetLog(), kXR_read, ClientReadRequest::offset, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientReadRequest::requestid, ClientReadRequest::rlen, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by PgRead(), and XrdCl::File::Read().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ReadV()

XRootDStatus XrdCl::FileStateHandler::ReadV ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
struct iovec * iov,
int iovcnt,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Read data into scattered buffers in one operation - async

Parameters
offsetoffset from the beginning of the file
iovlist of the buffers to be written
iovcntnumber of buffers
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 then the environment default will be used
Returns
status of the operation

Definition at line 1806 of file XrdClFileStateHandler.cc.

1812 {
1813 XrdSysMutexHelper scopedLock( self->pMutex );
1814
1815 if( self->pFileState == Error ) return self->pStatus;
1816
1817 if( self->pFileState != Opened && self->pFileState != Recovering )
1818 return XRootDStatus( stError, errInvalidOp );
1819
1820 Log *log = DefaultEnv::GetLog();
1821 log->Debug( FileMsg, "[%p@%s] Sending a read command for handle %#x to %s",
1822 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1823 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1824
1825 Message *msg;
1826 ClientReadRequest *req;
1827 MessageUtils::CreateRequest( msg, req );
1828
1829 // calculate the total read size
1830 size_t size = std::accumulate( iov, iov + iovcnt, 0, []( size_t acc, iovec &rhs )
1831 {
1832 return acc + rhs.iov_len;
1833 } );
1834 req->requestid = kXR_read;
1835 req->offset = offset;
1836 req->rlen = size;
1837 msg->SetVirtReqID( kXR_virtReadv );
1838 memcpy( req->fhandle, self->pFileHandle, 4 );
1839
1840 ChunkList *list = new ChunkList();
1841 list->reserve( iovcnt );
1842 uint64_t choff = offset;
1843 for( int i = 0; i < iovcnt; ++i )
1844 {
1845 list->emplace_back( choff, iov[i].iov_len, iov[i].iov_base );
1846 choff += iov[i].iov_len;
1847 }
1848
1850 MessageSendParams params;
1851 params.timeout = timeout;
1852 params.followRedirects = false;
1853 params.stateful = true;
1854 params.chunkList = list;
1856 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1857
1858 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1859 }
@ kXR_virtReadv
Definition XProtocol.hh:150

References XrdCl::MessageSendParams::chunkList, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), XrdCl::errInvalidOp, Error, ClientReadRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::DefaultEnv::GetLog(), kXR_read, kXR_virtReadv, ClientReadRequest::offset, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientReadRequest::requestid, ClientReadRequest::rlen, XrdCl::XRootDTransport::SetDescription(), XrdCl::Message::SetVirtReqID(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::File::ReadV().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ SetProperty()

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

Set file property

See also
File::GetProperty for propert list

Definition at line 2243 of file XrdClFileStateHandler.cc.

2245 {
2246 XrdSysMutexHelper scopedLock( pMutex );
2247 if( name == "ReadRecovery" )
2248 {
2249 if( value == "true" ) pDoRecoverRead = true;
2250 else pDoRecoverRead = false;
2251 return true;
2252 }
2253 else if( name == "WriteRecovery" )
2254 {
2255 if( value == "true" ) pDoRecoverWrite = true;
2256 else pDoRecoverWrite = false;
2257 return true;
2258 }
2259 else if( name == "FollowRedirects" )
2260 {
2261 if( value == "true" ) pFollowRedirects = true;
2262 else pFollowRedirects = false;
2263 return true;
2264 }
2265 else if( name == "BundledClose" )
2266 {
2267 if( value == "true" ) pAllowBundledClose = true;
2268 else pAllowBundledClose = false;
2269 return true;
2270 }
2271 return false;
2272 }

◆ SetXAttr()

XRootDStatus XrdCl::FileStateHandler::SetXAttr ( std::shared_ptr< FileStateHandler > & self,
const std::vector< xattr_t > & attrs,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Set extended attributes - async

Parameters
attrs: list of extended attributes to set
handler: handler to be notified when the response arrives, the response parameter will hold a std::vector of XAttrStatus objects
timeout: timeout value, if 0 the environment default will be used
Returns
: status of the operation

Definition at line 1946 of file XrdClFileStateHandler.cc.

1950 {
1951 XrdSysMutexHelper scopedLock( self->pMutex );
1952
1953 if( self->pFileState == Error ) return self->pStatus;
1954
1955 if( self->pFileState != Opened && self->pFileState != Recovering )
1956 return XRootDStatus( stError, errInvalidOp );
1957
1958 Log *log = DefaultEnv::GetLog();
1959 log->Debug( FileMsg, "[%p@%s] Sending a fattr set command for handle %#x to %s",
1960 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1961 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1962
1963 //--------------------------------------------------------------------------
1964 // Issue a new fattr get request
1965 //--------------------------------------------------------------------------
1966 return XAttrOperationImpl( self, kXR_fattrSet, 0, attrs, handler, timeout );
1967 }
@ kXR_fattrSet
Definition XProtocol.hh:273

References XrdCl::Log::Debug(), XrdCl::errInvalidOp, Error, XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), kXR_fattrSet, Opened, Recovering, and XrdCl::stError.

Referenced by XrdCl::File::SetXAttr().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Stat()

XRootDStatus XrdCl::FileStateHandler::Stat ( std::shared_ptr< FileStateHandler > & self,
bool force,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Obtain status information for this file - async

Parameters
forcedo not use the cached information, force re-stating
handlerhandler to be notified when the response arrives, the response parameter will hold a StatInfo object if the procedure is successful
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 952 of file XrdClFileStateHandler.cc.

956 {
957 XrdSysMutexHelper scopedLock( self->pMutex );
958
959 if( self->pFileState == Error ) return self->pStatus;
960
961 if( self->pFileState != Opened && self->pFileState != Recovering )
962 return XRootDStatus( stError, errInvalidOp );
963
964 //--------------------------------------------------------------------------
965 // Return the cached info
966 //--------------------------------------------------------------------------
967 if( !force )
968 {
969 AnyObject *obj = new AnyObject();
970 obj->Set( new StatInfo( *self->pStatInfo ) );
971 if (handler)
972 handler->HandleResponseWithHosts( new XRootDStatus(), obj, new HostList() );
973 return XRootDStatus();
974 }
975
976 Log *log = DefaultEnv::GetLog();
977 log->Debug( FileMsg, "[%p@%s] Sending a stat command for handle %#x to %s",
978 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
979 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
980
981 //--------------------------------------------------------------------------
982 // Issue a new stat request
983 // stating a file handle doesn't work (fixed in 3.2.0) so we need to
984 // stat the pat
985 //--------------------------------------------------------------------------
986 Message *msg;
988 std::string path = self->pFileUrl->GetPath();
989 MessageUtils::CreateRequest( msg, req );
990
991 req->requestid = kXR_stat;
992 memcpy( req->fhandle, self->pFileHandle, 4 );
993
994 MessageSendParams params;
995 params.timeout = timeout;
996 params.followRedirects = false;
997 params.stateful = true;
999
1001 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1002
1003 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1004 }
kXR_char fhandle[4]
Definition XProtocol.hh:771
kXR_unt16 requestid
Definition XProtocol.hh:768
std::vector< HostInfo > HostList

References XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), XrdCl::errInvalidOp, Error, ClientStatRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::DefaultEnv::GetLog(), XrdCl::ResponseHandler::HandleResponseWithHosts(), kXR_stat, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientStatRequest::requestid, XrdCl::AnyObject::Set(), XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::File::Stat().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Sync()

XRootDStatus XrdCl::FileStateHandler::Sync ( std::shared_ptr< FileStateHandler > & self,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Commit all pending disk writes - async

Parameters
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 1518 of file XrdClFileStateHandler.cc.

1521 {
1522 XrdSysMutexHelper scopedLock( self->pMutex );
1523
1524 if( self->pFileState == Error ) return self->pStatus;
1525
1526 if( self->pFileState != Opened && self->pFileState != Recovering )
1527 return XRootDStatus( stError, errInvalidOp );
1528
1529 Log *log = DefaultEnv::GetLog();
1530 log->Debug( FileMsg, "[%p@%s] Sending a sync command for handle %#x to %s",
1531 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1532 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1533
1534 Message *msg;
1535 ClientSyncRequest *req;
1536 MessageUtils::CreateRequest( msg, req );
1537
1538 req->requestid = kXR_sync;
1539 memcpy( req->fhandle, self->pFileHandle, 4 );
1540
1541 MessageSendParams params;
1542 params.timeout = timeout;
1543 params.followRedirects = false;
1544 params.stateful = true;
1546
1548 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1549
1550 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1551 }
kXR_char fhandle[4]
Definition XProtocol.hh:782
@ kXR_sync
Definition XProtocol.hh:128
kXR_unt16 requestid
Definition XProtocol.hh:781

References XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), XrdCl::errInvalidOp, Error, ClientSyncRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::DefaultEnv::GetLog(), kXR_sync, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientSyncRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::File::Sync().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Tick()

void XrdCl::FileStateHandler::Tick ( time_t now)

Tick.

Definition at line 2705 of file XrdClFileStateHandler.cc.

2706 {
2707 if (pMutex.CondLock())
2708 {TimeOutRequests( now );
2709 pMutex.UnLock();
2710 }
2711 }
void TimeOutRequests(time_t now)
Declare timeout on requests being recovered.

References XrdSysMutex::CondLock(), TimeOutRequests(), and XrdSysMutex::UnLock().

+ Here is the call graph for this function:

◆ TimeOutRequests()

void XrdCl::FileStateHandler::TimeOutRequests ( time_t now)

Declare timeout on requests being recovered.

Definition at line 2716 of file XrdClFileStateHandler.cc.

2717 {
2718 if( !pToBeRecovered.empty() )
2719 {
2720 Log *log = DefaultEnv::GetLog();
2721 log->Dump( FileMsg, "[%p@%s] Got a timer event", this,
2722 pFileUrl->GetObfuscatedURL().c_str() );
2723 RequestList::iterator it;
2724 JobManager *jobMan = DefaultEnv::GetPostMaster()->GetJobManager();
2725 for( it = pToBeRecovered.begin(); it != pToBeRecovered.end(); )
2726 {
2727 if( it->params.expires <= now )
2728 {
2729 jobMan->QueueJob( new ResponseJob(
2730 it->handler,
2731 new XRootDStatus( stError, errOperationExpired ),
2732 0, it->params.hostList ) );
2733 it = pToBeRecovered.erase( it );
2734 }
2735 else
2736 ++it;
2737 }
2738 }
2739 }

References XrdCl::Log::Dump(), XrdCl::errOperationExpired, XrdCl::FileMsg, XrdCl::PostMaster::GetJobManager(), XrdCl::DefaultEnv::GetLog(), XrdCl::URL::GetObfuscatedURL(), XrdCl::DefaultEnv::GetPostMaster(), XrdCl::JobManager::QueueJob(), and XrdCl::stError.

Referenced by Tick().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Truncate()

XRootDStatus XrdCl::FileStateHandler::Truncate ( std::shared_ptr< FileStateHandler > & self,
uint64_t size,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Truncate the file to a particular size - async

Parameters
sizedesired size of the file
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 1556 of file XrdClFileStateHandler.cc.

1560 {
1561 XrdSysMutexHelper scopedLock( self->pMutex );
1562
1563 if( self->pFileState == Error ) return self->pStatus;
1564
1565 if( self->pFileState != Opened && self->pFileState != Recovering )
1566 return XRootDStatus( stError, errInvalidOp );
1567
1568 Log *log = DefaultEnv::GetLog();
1569 log->Debug( FileMsg, "[%p@%s] Sending a truncate command for handle %#x to %s",
1570 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1571 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1572
1573 Message *msg;
1575 MessageUtils::CreateRequest( msg, req );
1576
1577 req->requestid = kXR_truncate;
1578 memcpy( req->fhandle, self->pFileHandle, 4 );
1579 req->offset = size;
1580
1581 MessageSendParams params;
1582 params.timeout = timeout;
1583 params.followRedirects = false;
1584 params.stateful = true;
1586
1588 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1589
1590 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1591 }
@ kXR_truncate
Definition XProtocol.hh:140

References XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), XrdCl::errInvalidOp, Error, ClientTruncateRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::DefaultEnv::GetLog(), kXR_truncate, ClientTruncateRequest::offset, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientTruncateRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::File::Truncate().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ TryOtherServer()

XRootDStatus XrdCl::FileStateHandler::TryOtherServer ( std::shared_ptr< FileStateHandler > & self,
uint16_t timeout )
static

Try other data server.

Definition at line 2767 of file XrdClFileStateHandler.cc.

2768 {
2769 XrdSysMutexHelper scopedLock( self->pMutex );
2770
2771 if( self->pFileState != Opened || !self->pLoadBalancer )
2772 return XRootDStatus( stError, errInvalidOp );
2773
2774 self->pFileState = Recovering;
2775
2776 Log *log = DefaultEnv::GetLog();
2777 log->Debug( FileMsg, "[%p@%s] Reopen file at next data server.",
2778 self.get(), self->pFileUrl->GetObfuscatedURL().c_str() );
2779
2780 // merge CGI
2781 auto lbcgi = self->pLoadBalancer->GetParams();
2782 auto dtcgi = self->pDataServer->GetParams();
2783 MessageUtils::MergeCGI( lbcgi, dtcgi, false );
2784 // update tried CGI
2785 auto itr = lbcgi.find( "tried" );
2786 if( itr == lbcgi.end() )
2787 lbcgi["tried"] = self->pDataServer->GetHostName();
2788 else
2789 {
2790 std::string tried = itr->second;
2791 tried += "," + self->pDataServer->GetHostName();
2792 lbcgi["tried"] = tried;
2793 }
2794 self->pLoadBalancer->SetParams( lbcgi );
2795
2796 return ReOpenFileAtServer( self, *self->pLoadBalancer, timeout );
2797 }

References XrdCl::Log::Debug(), XrdCl::errInvalidOp, XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), XrdCl::MessageUtils::MergeCGI(), Opened, Recovering, and XrdCl::stError.

Referenced by XrdCl::File::TryOtherServer().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ UnLock()

void XrdCl::FileStateHandler::UnLock ( )
inline

Unlock the internal lock.

Definition at line 688 of file XrdClFileStateHandler.hh.

689 {
690 pMutex.UnLock();
691 }

◆ VectorRead()

XRootDStatus XrdCl::FileStateHandler::VectorRead ( std::shared_ptr< FileStateHandler > & self,
const ChunkList & chunks,
void * buffer,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Read scattered data chunks in one operation - async

Parameters
chunkslist of the chunks to be read
buffera pointer to a buffer big enough to hold the data
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 then the environment default will be used
Returns
status of the operation

Definition at line 1596 of file XrdClFileStateHandler.cc.

1601 {
1602 //--------------------------------------------------------------------------
1603 // Sanity check
1604 //--------------------------------------------------------------------------
1605 XrdSysMutexHelper scopedLock( self->pMutex );
1606
1607 if( self->pFileState == Error ) return self->pStatus;
1608
1609 if( self->pFileState != Opened && self->pFileState != Recovering )
1610 return XRootDStatus( stError, errInvalidOp );
1611
1612 Log *log = DefaultEnv::GetLog();
1613 log->Debug( FileMsg, "[%p@%s] Sending a vector read command for handle %#x to %s",
1614 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1615 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1616
1617 //--------------------------------------------------------------------------
1618 // Build the message
1619 //--------------------------------------------------------------------------
1620 Message *msg;
1621 ClientReadVRequest *req;
1622 MessageUtils::CreateRequest( msg, req, sizeof(readahead_list)*chunks.size() );
1623
1624 req->requestid = kXR_readv;
1625 req->dlen = sizeof(readahead_list)*chunks.size();
1626
1627 ChunkList *list = new ChunkList();
1628 char *cursor = (char*)buffer;
1629
1630 //--------------------------------------------------------------------------
1631 // Copy the chunk info
1632 //--------------------------------------------------------------------------
1633 readahead_list *dataChunk = (readahead_list*)msg->GetBuffer( 24 );
1634 for( size_t i = 0; i < chunks.size(); ++i )
1635 {
1636 dataChunk[i].rlen = chunks[i].length;
1637 dataChunk[i].offset = chunks[i].offset;
1638 memcpy( dataChunk[i].fhandle, self->pFileHandle, 4 );
1639
1640 void *chunkBuffer;
1641 if( cursor )
1642 {
1643 chunkBuffer = cursor;
1644 cursor += chunks[i].length;
1645 }
1646 else
1647 chunkBuffer = chunks[i].buffer;
1648
1649 list->push_back( ChunkInfo( chunks[i].offset,
1650 chunks[i].length,
1651 chunkBuffer ) );
1652 }
1653
1654 //--------------------------------------------------------------------------
1655 // Send the message
1656 //--------------------------------------------------------------------------
1657 MessageSendParams params;
1658 params.timeout = timeout;
1659 params.followRedirects = false;
1660 params.stateful = true;
1661 params.chunkList = list;
1663
1665 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1666
1667 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1668 }
kXR_int32 rlen
Definition XProtocol.hh:660
kXR_int64 offset
Definition XProtocol.hh:661
kXR_unt16 requestid
Definition XProtocol.hh:670

References XrdCl::MessageSendParams::chunkList, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), ClientReadVRequest::dlen, XrdCl::errInvalidOp, Error, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::Buffer::GetBuffer(), XrdCl::DefaultEnv::GetLog(), kXR_readv, readahead_list::offset, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientReadVRequest::requestid, readahead_list::rlen, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::File::VectorRead().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ VectorWrite()

XRootDStatus XrdCl::FileStateHandler::VectorWrite ( std::shared_ptr< FileStateHandler > & self,
const ChunkList & chunks,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Write scattered data chunks in one operation - async

Parameters
chunkslist of the chunks to be read
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 then the environment default will be used
Returns
status of the operation

Definition at line 1673 of file XrdClFileStateHandler.cc.

1677 {
1678 //--------------------------------------------------------------------------
1679 // Sanity check
1680 //--------------------------------------------------------------------------
1681 XrdSysMutexHelper scopedLock( self->pMutex );
1682
1683 if( self->pFileState == Error ) return self->pStatus;
1684
1685 if( self->pFileState != Opened && self->pFileState != Recovering )
1686 return XRootDStatus( stError, errInvalidOp );
1687
1688 Log *log = DefaultEnv::GetLog();
1689 log->Debug( FileMsg, "[%p@%s] Sending a vector write command for handle %#x to %s",
1690 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1691 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1692
1693 //--------------------------------------------------------------------------
1694 // Determine the size of the payload
1695 //--------------------------------------------------------------------------
1696
1697 // the size of write vector
1698 uint32_t payloadSize = sizeof(XrdProto::write_list) * chunks.size();
1699
1700 //--------------------------------------------------------------------------
1701 // Build the message
1702 //--------------------------------------------------------------------------
1703 Message *msg;
1705 MessageUtils::CreateRequest( msg, req, payloadSize );
1706
1707 req->requestid = kXR_writev;
1708 req->dlen = sizeof(XrdProto::write_list) * chunks.size();
1709
1710 ChunkList *list = new ChunkList();
1711
1712 //--------------------------------------------------------------------------
1713 // Copy the chunk info
1714 //--------------------------------------------------------------------------
1715 XrdProto::write_list *writeList =
1716 reinterpret_cast<XrdProto::write_list*>( msg->GetBuffer( 24 ) );
1717
1718
1719
1720 for( size_t i = 0; i < chunks.size(); ++i )
1721 {
1722 writeList[i].wlen = chunks[i].length;
1723 writeList[i].offset = chunks[i].offset;
1724 memcpy( writeList[i].fhandle, self->pFileHandle, 4 );
1725
1726 list->push_back( ChunkInfo( chunks[i].offset,
1727 chunks[i].length,
1728 chunks[i].buffer ) );
1729 }
1730
1731 //--------------------------------------------------------------------------
1732 // Send the message
1733 //--------------------------------------------------------------------------
1734 MessageSendParams params;
1735 params.timeout = timeout;
1736 params.followRedirects = false;
1737 params.stateful = true;
1738 params.chunkList = list;
1740
1742 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1743
1744 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1745 }

References XrdCl::MessageSendParams::chunkList, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), ClientWriteVRequest::dlen, XrdCl::errInvalidOp, Error, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::Buffer::GetBuffer(), XrdCl::DefaultEnv::GetLog(), kXR_writev, XrdProto::write_list::offset, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientWriteVRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, XrdCl::MessageSendParams::timeout, and XrdProto::write_list::wlen.

Referenced by XrdCl::File::VectorWrite().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Visa()

XRootDStatus XrdCl::FileStateHandler::Visa ( std::shared_ptr< FileStateHandler > & self,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Get access token to a file - async

Parameters
handlerhandler to be notified when the response arrives, the response parameter will hold a Buffer object if the procedure is successful
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 1907 of file XrdClFileStateHandler.cc.

1910 {
1911 XrdSysMutexHelper scopedLock( self->pMutex );
1912
1913 if( self->pFileState == Error ) return self->pStatus;
1914
1915 if( self->pFileState != Opened && self->pFileState != Recovering )
1916 return XRootDStatus( stError, errInvalidOp );
1917
1918 Log *log = DefaultEnv::GetLog();
1919 log->Debug( FileMsg, "[%p@%s] Sending a visa command for handle %#x to %s",
1920 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1921 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1922
1923 Message *msg;
1924 ClientQueryRequest *req;
1925 MessageUtils::CreateRequest( msg, req );
1926
1927 req->requestid = kXR_query;
1928 req->infotype = kXR_Qvisa;
1929 memcpy( req->fhandle, self->pFileHandle, 4 );
1930
1931 MessageSendParams params;
1932 params.timeout = timeout;
1933 params.followRedirects = false;
1934 params.stateful = true;
1936
1938 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1939
1940 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1941 }
@ kXR_Qvisa
Definition XProtocol.hh:622

References XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), XrdCl::errInvalidOp, Error, ClientQueryRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::DefaultEnv::GetLog(), ClientQueryRequest::infotype, kXR_query, kXR_Qvisa, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientQueryRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::File::Visa().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Write() [1/3]

XRootDStatus XrdCl::FileStateHandler::Write ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
Buffer && buffer,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Write a data chunk at a given offset - async

Parameters
offsetoffset from the beginning of the file
bufferr-value reference to Buffer object, in this case XrdCl runtime takes ownership of the buffer
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 1216 of file XrdClFileStateHandler.cc.

1221 {
1222 //--------------------------------------------------------------------------
1223 // If the memory is not page (4KB) aligned we cannot use the kernel buffer
1224 // so fall back to normal write
1225 //--------------------------------------------------------------------------
1226 if( !XrdSys::KernelBuffer::IsPageAligned( buffer.GetBuffer() ) || self->pIsChannelEncrypted )
1227 {
1228 Log *log = DefaultEnv::GetLog();
1229 log->Info( FileMsg, "[%p@%s] Buffer for handle %#x is not page aligned (4KB), "
1230 "cannot convert it to kernel space buffer.", self.get(),
1231 self->pFileUrl->GetObfuscatedURL().c_str(), *((uint32_t*)self->pFileHandle) );
1232
1233 void *buff = buffer.GetBuffer();
1234 uint32_t size = buffer.GetSize();
1235 ReleaseBufferHandler *wrtHandler =
1236 new ReleaseBufferHandler( std::move( buffer ), handler );
1237 XRootDStatus st = self->Write( self, offset, size, buff, wrtHandler, timeout );
1238 if( !st.IsOK() )
1239 {
1240 buffer = std::move( wrtHandler->GetBuffer() );
1241 delete wrtHandler;
1242 }
1243 return st;
1244 }
1245
1246 //--------------------------------------------------------------------------
1247 // Transfer the data from user space to kernel space
1248 //--------------------------------------------------------------------------
1249 uint32_t length = buffer.GetSize();
1250 char *ubuff = buffer.Release();
1251
1252 std::unique_ptr<XrdSys::KernelBuffer> kbuff( new XrdSys::KernelBuffer() );
1253 ssize_t ret = XrdSys::Move( ubuff, *kbuff, length );
1254 if( ret < 0 )
1255 return XRootDStatus( stError, errInternal, XProtocol::mapError( errno ) );
1256
1257 //--------------------------------------------------------------------------
1258 // Now create a write request and enqueue it
1259 //--------------------------------------------------------------------------
1260 return WriteKernelBuffer( self, offset, ret, std::move( kbuff ), handler, timeout );
1261 }
static int mapError(int rc)
static bool IsPageAligned(const void *ptr)
const uint16_t errInternal
Internal error.
ssize_t Move(KernelBuffer &kbuff, char *&ubuff)

References XrdCl::errInternal, XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), XrdCl::Log::Info(), XrdCl::Status::IsOK(), XrdSys::KernelBuffer::IsPageAligned(), XProtocol::mapError(), XrdSys::Move(), and XrdCl::stError.

+ Here is the call graph for this function:

◆ Write() [2/3]

XRootDStatus XrdCl::FileStateHandler::Write ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
uint32_t size,
const void * buffer,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Write a data chunk at a given offset - async

Parameters
offsetoffset from the beginning of the file
sizenumber of bytes to be written
buffera pointer to the buffer holding the data to be written
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 1168 of file XrdClFileStateHandler.cc.

1174 {
1175 XrdSysMutexHelper scopedLock( self->pMutex );
1176
1177 if( self->pFileState == Error ) return self->pStatus;
1178
1179 if( self->pFileState != Opened && self->pFileState != Recovering )
1180 return XRootDStatus( stError, errInvalidOp );
1181
1182 Log *log = DefaultEnv::GetLog();
1183 log->Debug( FileMsg, "[%p@%s] Sending a write command for handle %#x to %s",
1184 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1185 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1186
1187 Message *msg;
1188 ClientWriteRequest *req;
1189 MessageUtils::CreateRequest( msg, req );
1190
1191 req->requestid = kXR_write;
1192 req->offset = offset;
1193 req->dlen = size;
1194 memcpy( req->fhandle, self->pFileHandle, 4 );
1195
1196 ChunkList *list = new ChunkList();
1197 list->push_back( ChunkInfo( 0, size, (char*)buffer ) );
1198
1199 MessageSendParams params;
1200 params.timeout = timeout;
1201 params.followRedirects = false;
1202 params.stateful = true;
1203 params.chunkList = list;
1204
1206
1208 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1209
1210 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1211 }

References XrdCl::MessageSendParams::chunkList, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), ClientWriteRequest::dlen, XrdCl::errInvalidOp, Error, ClientWriteRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::DefaultEnv::GetLog(), kXR_write, ClientWriteRequest::offset, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientWriteRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::File::Write(), XrdCl::File::Write(), and XrdCl::File::Write().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Write() [3/3]

XRootDStatus XrdCl::FileStateHandler::Write ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
uint32_t size,
Optional< uint64_t > fdoff,
int fd,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Write a data from a given file descriptor at a given offset - async

Parameters
offsetoffset from the beginning of the file
sizenumber of bytes to be written
fdoffoffset of the data to be written from the file descriptor (optional, if not provided will copy data from the file descriptor at the current cursor position)
fdfile descriptor open for reading
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 the environment default will be used
Returns
status of the operation

Definition at line 1266 of file XrdClFileStateHandler.cc.

1273 {
1274 //--------------------------------------------------------------------------
1275 // Read the data from the file descriptor into a kernel buffer
1276 //--------------------------------------------------------------------------
1277 std::unique_ptr<XrdSys::KernelBuffer> kbuff( new XrdSys::KernelBuffer() );
1278 ssize_t ret = fdoff ? XrdSys::Read( fd, *kbuff, size, *fdoff ) :
1279 XrdSys::Read( fd, *kbuff, size );
1280 if( ret < 0 )
1281 return XRootDStatus( stError, errInternal, XProtocol::mapError( errno ) );
1282
1283 //--------------------------------------------------------------------------
1284 // Now create a write request and enqueue it
1285 //--------------------------------------------------------------------------
1286 return WriteKernelBuffer( self, offset, ret, std::move( kbuff ), handler, timeout );
1287 }
ssize_t Read(int fd, KernelBuffer &buffer, uint32_t length, int64_t offset)

References XrdCl::errInternal, XProtocol::mapError(), XrdSys::Read(), and XrdCl::stError.

+ Here is the call graph for this function:

◆ WriteV()

XRootDStatus XrdCl::FileStateHandler::WriteV ( std::shared_ptr< FileStateHandler > & self,
uint64_t offset,
const struct iovec * iov,
int iovcnt,
ResponseHandler * handler,
uint16_t timeout = 0 )
static

Write scattered buffers in one operation - async

Parameters
offsetoffset from the beginning of the file
iovlist of the buffers to be written
iovcntnumber of buffers
handlerhandler to be notified when the response arrives
timeouttimeout value, if 0 then the environment default will be used
Returns
status of the operation

Definition at line 1750 of file XrdClFileStateHandler.cc.

1756 {
1757 XrdSysMutexHelper scopedLock( self->pMutex );
1758
1759 if( self->pFileState == Error ) return self->pStatus;
1760
1761 if( self->pFileState != Opened && self->pFileState != Recovering )
1762 return XRootDStatus( stError, errInvalidOp );
1763
1764 Log *log = DefaultEnv::GetLog();
1765 log->Debug( FileMsg, "[%p@%s] Sending a write command for handle %#x to %s",
1766 self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
1767 *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
1768
1769 Message *msg;
1770 ClientWriteRequest *req;
1771 MessageUtils::CreateRequest( msg, req );
1772
1773 ChunkList *list = new ChunkList();
1774
1775 uint32_t size = 0;
1776 for( int i = 0; i < iovcnt; ++i )
1777 {
1778 if( iov[i].iov_len == 0 ) continue;
1779 size += iov[i].iov_len;
1780 list->push_back( ChunkInfo( 0, iov[i].iov_len,
1781 (char*)iov[i].iov_base ) );
1782 }
1783
1784 req->requestid = kXR_write;
1785 req->offset = offset;
1786 req->dlen = size;
1787 memcpy( req->fhandle, self->pFileHandle, 4 );
1788
1789 MessageSendParams params;
1790 params.timeout = timeout;
1791 params.followRedirects = false;
1792 params.stateful = true;
1793 params.chunkList = list;
1794
1796
1798 StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
1799
1800 return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
1801 }

References XrdCl::MessageSendParams::chunkList, XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), ClientWriteRequest::dlen, XrdCl::errInvalidOp, Error, ClientWriteRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::DefaultEnv::GetLog(), kXR_write, ClientWriteRequest::offset, Opened, XrdCl::MessageUtils::ProcessSendParams(), Recovering, ClientWriteRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::MessageSendParams::stateful, XrdCl::stError, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::File::WriteV().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Friends And Related Symbol Documentation

◆ ::OpenHandler

friend class ::OpenHandler
friend

Definition at line 84 of file XrdClFileStateHandler.hh.

Referenced by Open().

◆ ::PgReadHandler

friend class ::PgReadHandler
friend

Definition at line 81 of file XrdClFileStateHandler.hh.

Referenced by PgRead().

◆ ::PgReadRetryHandler

friend class ::PgReadRetryHandler
friend

Definition at line 82 of file XrdClFileStateHandler.hh.

Referenced by PgReadRetry().

◆ ::PgReadSubstitutionHandler

friend class ::PgReadSubstitutionHandler
friend

Definition at line 83 of file XrdClFileStateHandler.hh.

Referenced by PgRead().


The documentation for this class was generated from the following files: