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

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. More...
 
static void OnStateRedirection (std::shared_ptr< FileStateHandler > &self, const std::string &redirectUrl, Message *message, ResponseHandler *userHandler, MessageSendParams &sendParams)
 Handle stateful redirect. More...
 
static void OnStateResponse (std::shared_ptr< FileStateHandler > &self, XRootDStatus *status, Message *message, AnyObject *response, HostList *hostList)
 Handle stateful response. More...
 
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. More...
 
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,
95  Recovering,
98  };
@ OpenInProgress
Opening is in progress.
@ CloseInProgress
Closing operation is in progress.
@ Closed
The file is closed.
@ Opened
Opening has succeeded.
@ Error
Opening has failed.
@ 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  {
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.
Singleton access to URL to virtual redirector mapping.
static RedirectorRegistry & Instance()
Returns reference to the single instance.
void Release(const URL &url)
Release the virtual redirector associated with the given URL.
bool IsMetalink() const
Is it a URL to a metalink.
Definition: XrdClURL.cc:458
bool IsLocalFile() const
Definition: XrdClURL.cc:467

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  }
Handle diagnostics.
Definition: XrdClLog.hh:101
void Debug(uint64_t topic, const char *format,...)
Print a debug message.
Definition: XrdClLog.cc:282
std::string GetObfuscatedURL() const
Get the URL with authz information obfuscated.
Definition: XrdClURL.cc:491
const uint64_t FileMsg

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;
2077  ClientChkPointRequest *req;
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
kXR_char fhandle[4]
Definition: XProtocol.hh:204
static void ProcessSendParams(MessageSendParams &sendParams)
Process sending params.
static void CreateRequest(Message *&msg, Request *&req, uint32_t payloadSize=0)
Create a message.
The message representation used throughout the system.
Definition: XrdClMessage.hh:32
static void SetDescription(Message *msg)
Get the description of a message.
const uint16_t stError
An error occurred that could potentially be retried.
Definition: XrdClStatus.hh:32
const uint16_t errInvalidOp
Definition: XrdClStatus.hh:51

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;
2128  ClientChkPointRequest *req;
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 
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
kXR_int64 offset
Definition: XProtocol.hh:808
const char * GetBuffer(uint32_t offset=0) const
Get the message buffer.
Definition: XrdClBuffer.hh:72
std::vector< ChunkInfo > ChunkList
List of chunks.
Describe a data chunk for vector read.

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;
2190  ClientChkPointRequest *req;
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 
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 )
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;
909  ClientCloseRequest *req;
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 ||
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.
void SetSessionId(uint64_t sessionId)
Set the session ID which this message is meant for.
JobManager * GetJobManager()
Get the job manager object user by the post master.
Call the user callback.
const uint16_t errSocketOptError
Definition: XrdClStatus.hh:76
const uint16_t errPollerError
Definition: XrdClStatus.hh:75
const uint16_t errInProgress
Definition: XrdClStatus.hh:59
const uint16_t stOK
Everything went OK.
Definition: XrdClStatus.hh:31
const uint16_t suAlreadyDone
Definition: XrdClStatus.hh:42
const uint16_t errConnectionError
Definition: XrdClStatus.hh:78
const uint16_t errSocketError
Definition: XrdClStatus.hh:72
const uint16_t errInvalidSession
Definition: XrdClStatus.hh:79
const uint16_t errSocketDisconnected
Definition: XrdClStatus.hh:74
uint16_t code
Error type, or additional hints on what to do.
Definition: XrdClStatus.hh:147
bool IsOK() const
We're fine.
Definition: XrdClStatus.hh:124

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_unt16 infotype
Definition: XProtocol.hh:631
kXR_char fhandle[4]
Definition: XProtocol.hh:633
@ kXR_query
Definition: XProtocol.hh:113
@ kXR_Qopaqug
Definition: XProtocol.hh:625
void Append(const char *buffer, uint32_t size)
Append data at the position pointed to by the append cursor.
Definition: XrdClBuffer.hh:164
uint32_t GetSize() const
Get the size of the message.
Definition: XrdClBuffer.hh:132

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  }
void Dump(uint64_t topic, const char *format,...)
Print a dump message.
Definition: XrdClLog.cc:299
std::string ToStr() const
Convert to string.

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  //------------------------------------------------------------------------
2397  if( mon )
2398  {
2400  i.file = pFileUrl;
2401  i.status = status;
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 );
2432  if( mon )
2433  {
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
Definition: XProtocol.hh:1166
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.
An abstract class to describe the client-side monitoring plugin interface.
Definition: XrdClMonitor.hh:56
@ EvErrIO
ErrorInfo: An I/O error occurred.
@ EvOpen
OpenInfo: File opened.
virtual void Event(EventCode evCode, void *evData)=0
void GetFileHandle(uint8_t *fileHandle) const
Get the file handle (4bytes)
const StatInfo * GetStatInfo() const
Get the stat info.
uint64_t GetSessionId() const
Object stat info.
uint64_t GetSize() const
Get size (in bytes)
URL representation.
Definition: XrdClURL.hh:31
std::map< std::string, std::string > ParamsMap
Definition: XrdClURL.hh:33
void SetParams(const std::string &params)
Set params.
Definition: XrdClURL.cc:395
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
const std::string & GetPath() const
Get the path.
Definition: XrdClURL.hh:217
Describe an encountered file-based error.
const XRootDStatus * status
Status code.
const URL * file
The file in question.
Operation opCode
The associated operation.
Describe a file open event to the monitor.
uint64_t fSize
File size in bytes.
const URL * file
File in question.
std::string dataServer
Actual fata server.
uint16_t oFlags
OpenFlags.
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  //--------------------------------------------------------------------------
2515  if( mon )
2516  {
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;
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.
void Error(uint64_t topic, const char *format,...)
Report an error.
Definition: XrdClLog.cc:231
const std::string & GetObfuscatedDescription() const
Get the description of the message with authz parameter obfuscated.
const std::string & GetErrorMessage() const
Get error message.
const uint16_t errRedirect
Definition: XrdClStatus.hh:106
XrdSys::KernelBuffer * kbuff
@ 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
kXR_int32 rlen
Definition: XProtocol.hh:647
kXR_int32 dlen
Definition: XProtocol.hh:159

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 )
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  {
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;
844  ClientOpenRequest *req;
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
kXR_int32 dlen
Definition: XProtocol.hh:483
kXR_unt16 mode
Definition: XProtocol.hh:480
const uint16_t errInvalidArgs
Definition: XrdClStatus.hh:58

References 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;
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
Definition: XProtocol.hh:1174
#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)
Status QueryTransport(const URL &url, uint16_t query, AnyObject &result)
Handle an async response.
static XrdCl::XRootDStatus GetProtocolVersion(const XrdCl::URL url, int &protver)
Definition: XrdClUtils.hh:235
static const uint16_t ServerFlags
returns server flags

References 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;
1132  ClientPgReadRequest *req;
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
kXR_unt16 requestid
Definition: XProtocol.hh:508

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 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)
virtual void HandleResponse(XRootDStatus *status, AnyObject *response)
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
Definition: XrdClStatus.hh:90
const uint16_t errDataError
data is corrupted
Definition: XrdClStatus.hh:63
const int DefaultRequestTimeout
std::tuple< uint64_t, uint32_t > At(size_t i)

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;
1488  ClientPgWriteRequest *req;
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
std::vector< uint32_t > crc32cDigests

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_int64 offset
Definition: XProtocol.hh:646
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
void SetVirtReqID(uint16_t virtReqID)
Set virtual request ID for the message.

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;
987  ClientStatRequest *req;
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
void Set(Type object, bool own=true)
virtual void HandleResponseWithHosts(XRootDStatus *status, AnyObject *response, HostList *hostList)
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;
2725  for( it = pToBeRecovered.begin(); it != pToBeRecovered.end(); )
2726  {
2727  if( it->params.expires <= now )
2728  {
2729  jobMan->QueueJob( new ResponseJob(
2730  it->handler,
2732  0, it->params.hostList ) );
2733  it = pToBeRecovered.erase( it );
2734  }
2735  else
2736  ++it;
2737  }
2738  }
2739  }
A synchronized queue.

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;
1574  ClientTruncateRequest *req;
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
kXR_char fhandle[4]
Definition: XProtocol.hh:794

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;
1704  ClientWriteVRequest *req;
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  }
kXR_unt16 requestid
Definition: XProtocol.hh:820

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)
Definition: XProtocol.hh:1361
char * Release()
Release the buffer.
Definition: XrdClBuffer.hh:238
static bool IsPageAligned(const void *ptr)
const uint16_t errInternal
Internal error.
Definition: XrdClStatus.hh:56
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().

+ 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 Function Documentation

◆ ::OpenHandler

friend class ::OpenHandler
friend

Definition at line 84 of file XrdClFileStateHandler.hh.

◆ ::PgReadHandler

friend class ::PgReadHandler
friend

Definition at line 81 of file XrdClFileStateHandler.hh.

◆ ::PgReadRetryHandler

friend class ::PgReadRetryHandler
friend

Definition at line 82 of file XrdClFileStateHandler.hh.

◆ ::PgReadSubstitutionHandler

friend class ::PgReadSubstitutionHandler
friend

Definition at line 83 of file XrdClFileStateHandler.hh.


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