XrdCl::FileStateHandler Class Reference

Handle the stateful operations. More...

#include <XrdClFileStateHandler.hh>

Collaboration diagram for XrdCl::FileStateHandler:

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

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

Static Public Member Functions
static XRootDStatus	Checkpoint (std::shared_ptr< FileStateHandler > &self, kXR_char code, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	ChkptWrt (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, const void *buffer, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	ChkptWrtV (std::shared_ptr< FileStateHandler > &self, uint64_t offset, const struct iovec *iov, int iovcnt, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	Clone (std::shared_ptr< FileStateHandler > &self, const CloneLocations &locs, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	Close (std::shared_ptr< FileStateHandler > &self, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	DelXAttr (std::shared_ptr< FileStateHandler > &self, const std::vector< std::string > &attrs, ResponseHandler *handler, time_t timeout=0)
static std::unique_ptr< ExportedFileTemplate >	ExportTemplate (std::shared_ptr< FileStateHandler > &self)
static XRootDStatus	Fcntl (std::shared_ptr< FileStateHandler > &self, QueryCode::Code queryCode, const Buffer &arg, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	GetXAttr (std::shared_ptr< FileStateHandler > &self, const std::vector< std::string > &attrs, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	ListXAttr (std::shared_ptr< FileStateHandler > &self, ResponseHandler *handler, time_t timeout=0)
static void	OnStateError (std::shared_ptr< FileStateHandler > &self, XRootDStatus *status, Message *message, ResponseHandler *userHandler, MessageSendParams &sendParams)
	Handle an error while sending a stateful message.
static void	OnStateRedirection (std::shared_ptr< FileStateHandler > &self, const std::string &redirectUrl, Message *message, ResponseHandler *userHandler, MessageSendParams &sendParams)
	Handle stateful redirect.
static void	OnStateResponse (std::shared_ptr< FileStateHandler > &self, XRootDStatus *status, Message *message, AnyObject *response, HostList *hostList)
	Handle stateful response.
static XRootDStatus	Open (std::shared_ptr< FileStateHandler > &self, const std::string &url, OpenFlags::Flags flags, uint16_t mode, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	OpenUsingTemplate (std::shared_ptr< FileStateHandler > &self, ExportedFileTemplate *templ, const std::string &url, OpenFlags::Flags flags, uint16_t mode, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	PgRead (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	PgReadImpl (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, void *buffer, uint16_t flags, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	PgReadRetry (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, size_t pgnb, void *buffer, PgReadHandler *handler, time_t timeout=0)
static XRootDStatus	PgWrite (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, const void *buffer, std::vector< uint32_t > &cksums, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	PgWriteImpl (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, const void *buffer, std::vector< uint32_t > &cksums, kXR_char flags, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	PgWriteRetry (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, const void *buffer, uint32_t digest, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	PreRead (std::shared_ptr< FileStateHandler > &self, const TractList &tracts, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	Read (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	ReadV (std::shared_ptr< FileStateHandler > &self, uint64_t offset, struct iovec *iov, int iovcnt, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	SetXAttr (std::shared_ptr< FileStateHandler > &self, const std::vector< xattr_t > &attrs, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	Stat (std::shared_ptr< FileStateHandler > &self, bool force, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	Sync (std::shared_ptr< FileStateHandler > &self, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	Truncate (std::shared_ptr< FileStateHandler > &self, uint64_t size, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	TryOtherServer (std::shared_ptr< FileStateHandler > &self, time_t timeout)
	Try other data server.
static XRootDStatus	VectorRead (std::shared_ptr< FileStateHandler > &self, const ChunkList &chunks, void *buffer, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	VectorWrite (std::shared_ptr< FileStateHandler > &self, const ChunkList &chunks, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	Visa (std::shared_ptr< FileStateHandler > &self, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	Write (std::shared_ptr< FileStateHandler > &self, uint64_t offset, Buffer &&buffer, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	Write (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, const void *buffer, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	Write (std::shared_ptr< FileStateHandler > &self, uint64_t offset, uint32_t size, Optional< uint64_t > fdoff, int fd, ResponseHandler *handler, time_t timeout=0)
static XRootDStatus	WriteV (std::shared_ptr< FileStateHandler > &self, uint64_t offset, const struct iovec *iov, int iovcnt, ResponseHandler *handler, time_t timeout=0)

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

Detailed Description

Handle the stateful operations.

Definition at line 95 of file XrdClFileStateHandler.hh.

Member Enumeration Documentation

FileStatus

enum XrdCl::FileStateHandler::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 106 of file XrdClFileStateHandler.hh.

      {
        Closed,           
        Opened,           
        Error,            
        Recovering,       
        OpenInProgress,   
        CloseInProgress   
      };

Constructor & Destructor Documentation

FileStateHandler() [1/2]

XrdCl::FileStateHandler::FileStateHandler

(

FilePlugIn *&

plugin

)

Constructor.

Definition at line 657 of file XrdClFileStateHandler.cc.

                                                          :
    pFileState( Closed ),
    pStatInfo( 0 ),
    pFileUrl( 0 ),
    pDataServer( 0 ),
    pLoadBalancer( 0 ),
    pStateRedirect( 0 ),
    pWrtRecoveryRedir( 0 ),
    pFileHandle( 0 ),
    pOpenMode( 0 ),
    pOpenFlags( OpenFlags::None ),
    pSessionId( 0 ),
    pDoRecoverRead( true ),
    pDoRecoverWrite( true ),
    pFollowRedirects( true ),
    pUseVirtRedirector( true ),
    pIsChannelEncrypted( false ),
    pAllowBundledClose( false ),
    pPlugin( plugin )
  {
    pFileHandle = new uint8_t[4];
    ResetMonitoringVars();
    DefaultEnv::GetForkHandler()->RegisterFileObject( this );
    DefaultEnv::GetFileTimer()->RegisterFileObject( this );
    pLFileHandler = new LocalFileHandler();
  }

References Closed, 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

useVirtRedirector

if true Metalink files will be treated as a VirtualRedirectors

Definition at line 690 of file XrdClFileStateHandler.cc.

                                                                                  :
    pFileState( Closed ),
    pStatInfo( 0 ),
    pFileUrl( 0 ),
    pDataServer( 0 ),
    pLoadBalancer( 0 ),
    pStateRedirect( 0 ),
    pWrtRecoveryRedir( 0 ),
    pFileHandle( 0 ),
    pOpenMode( 0 ),
    pOpenFlags( OpenFlags::None ),
    pSessionId( 0 ),
    pDoRecoverRead( true ),
    pDoRecoverWrite( true ),
    pFollowRedirects( true ),
    pUseVirtRedirector( useVirtRedirector ),
    pAllowBundledClose( false ),
    pPlugin( plugin )
  {
    pFileHandle = new uint8_t[4];
    ResetMonitoringVars();
    DefaultEnv::GetForkHandler()->RegisterFileObject( this );
    DefaultEnv::GetFileTimer()->RegisterFileObject( this );
    pLFileHandler = new LocalFileHandler();
  }

References Closed, 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 719 of file XrdClFileStateHandler.cc.

  {
    //--------------------------------------------------------------------------
    // This, in principle, should never ever happen. Except for the case
    // when we're interfaced with ROOT that may call this desctructor from
    // its garbage collector, from its __cxa_finalize, ie. after the XrdCl lib
    // has been finalized by the linker. So, if we don't have the log object
    // at this point we just give up the hope.
    //--------------------------------------------------------------------------
    if( DefaultEnv::GetLog() && pSessionId && !pDataServer->IsLocalFile() ) // if the file object was bound to a physical connection
      DefaultEnv::GetPostMaster()->DecFileInstCnt( *pDataServer );
 
    if( DefaultEnv::GetFileTimer() )
      DefaultEnv::GetFileTimer()->UnRegisterFileObject( this );
 
    if( DefaultEnv::GetForkHandler() )
      DefaultEnv::GetForkHandler()->UnRegisterFileObject( this );
 
    if( pFileState != Closed && DefaultEnv::GetLog() )
    {
      XRootDStatus st;
      MonitorClose( &st );
      ResetMonitoringVars();
    }
 
    // check if the logger is still there, this is only for root, as root might
    // have unload us already so in this case we don't want to do anything
    if( DefaultEnv::GetLog() && pUseVirtRedirector && pFileUrl && pFileUrl->IsMetalink() )
    {
      RedirectorRegistry& registry = RedirectorRegistry::Instance();
      registry.Release( *pFileUrl );
    }
 
    delete pStatInfo;
    delete pFileUrl;
    delete pDataServer;
    delete pLoadBalancer;
    delete [] pFileHandle;
    delete pLFileHandler;
  }

References Closed, XrdCl::PostMaster::DecFileInstCnt(), XrdCl::DefaultEnv::GetFileTimer(), XrdCl::DefaultEnv::GetForkHandler(), XrdCl::DefaultEnv::GetLog(), XrdCl::DefaultEnv::GetPostMaster(), XrdCl::RedirectorRegistry::Instance(), 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 2882 of file XrdClFileStateHandler.cc.

  {
    Log *log = DefaultEnv::GetLog();
 
    if( pFileState == Closed || pFileState == Error )
      return;
 
    if( (IsReadOnly() && pDoRecoverRead) ||
        (!IsReadOnly() && pDoRecoverWrite) )
    {
      log->Debug( FileMsg, "[%p@%s] Putting the file in recovery state in "
                  "process %d", (void*)this, pFileUrl->GetObfuscatedURL().c_str(), getpid() );
      pFileState = Recovering;
      pInTheFly.clear();
      pToBeRecovered.clear();
    }
    else
      pFileState = Error;
  }

References Closed, XrdCl::Log::Debug(), Error, XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), 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, time_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 2191 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a checkpoint command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message               *msg;
    ClientChkPointRequest *req;
    MessageUtils::CreateRequest( msg, req );
 
    req->requestid  = kXR_chkpoint;
    req->opcode     = code;
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
 
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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, time_t timeout = 0 )

static

Checkpointed write - async

Parameters

offset	offset from the beginning of the file
size	number of bytes to be written
buffer	a pointer to the buffer holding the data to be written
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 2240 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a write command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message               *msg;
    ClientChkPointRequest *req;
    MessageUtils::CreateRequest( msg, req, sizeof( ClientWriteRequest ) );
 
    req->requestid = kXR_chkpoint;
    req->opcode    = kXR_ckpXeq;
    req->dlen      = 24; // as specified in the protocol specification
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    ClientWriteRequest *wrtreq = (ClientWriteRequest*)msg->GetBuffer( sizeof(ClientChkPointRequest) );
    wrtreq->requestid = kXR_write;
    wrtreq->offset    = offset;
    wrtreq->dlen      = size;
    memcpy( wrtreq->fhandle, self->pFileHandle, 4 );
 
    ChunkList *list   = new ChunkList();
    list->push_back( ChunkInfo( 0, size, (char*)buffer ) );
 
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    params.chunkList       = list;
 
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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, time_t timeout = 0 )

static

Checkpointed WriteV - async

Parameters

offset	offset from the beginning of the file
iov	list of the buffers to be written
iovcnt	number of buffers
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Write scattered buffers in one operation - async

Parameters

offset	offset from the beginning of the file
iov	list of the buffers to be written
iovcnt	number of buffers
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 2302 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a write command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message               *msg;
    ClientChkPointRequest *req;
    MessageUtils::CreateRequest( msg, req, sizeof( ClientWriteRequest ) );
 
    req->requestid = kXR_chkpoint;
    req->opcode    = kXR_ckpXeq;
    req->dlen      = 24; // as specified in the protocol specification
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    ChunkList *list   = new ChunkList();
    uint32_t size = 0;
    for( int i = 0; i < iovcnt; ++i )
    {
      if( iov[i].iov_len == 0 ) continue;
      size += iov[i].iov_len;
      list->push_back( ChunkInfo( 0, iov[i].iov_len,
                       (char*)iov[i].iov_base ) );
    }
 
    ClientWriteRequest *wrtreq = (ClientWriteRequest*)msg->GetBuffer( sizeof(ClientChkPointRequest) );
    wrtreq->requestid = kXR_write;
    wrtreq->offset    = offset;
    wrtreq->dlen      = size;
    memcpy( wrtreq->fhandle, self->pFileHandle, 4 );
 
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    params.chunkList       = list;
 
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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:

Clone()

XRootDStatus XrdCl::FileStateHandler::Clone ( std::shared_ptr< FileStateHandler > & self, const CloneLocations & locs, ResponseHandler * handler, time_t timeout = 0 )

static

Clone ranges of files into the current file

Parameters

handler	: handler to be notified when the response arrives.
timeout	: timeout value, if 0 the environment default will be used

Returns

: status of the operation

Definition at line 3497 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    if( !Utils::HasKSameFS( *self->pDataServer ) )
      return XRootDStatus( stError, errNotSupported );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a clone command for handle %#x to %s",
                self.get(), self->pFileUrl->GetURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message           *msg;
    ClientReadRequest *req;
 
    size_t nrange = locs.locations.size();
 
    MessageUtils::CreateRequest( msg, req, sizeof(XrdProto::clone_list)*nrange );
 
    req->requestid  = kXR_clone;
    req->dlen       = sizeof(XrdProto::clone_list)*nrange;
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    XrdProto::clone_list *cl = (XrdProto::clone_list*)msg->GetBuffer( 24 );
    int idx=0;
    for(auto &loc: locs.locations)
    {
      if( !loc.file )
        return XRootDStatus( stError, errInvalidOp, 0,
                             "Template file not available" );
 
      FileStateHandlerTemplate *fht = dynamic_cast<FileStateHandlerTemplate*>(loc.file.get());
      if( !fht )
        return XRootDStatus( stError, errInvalidOp, 0,
                             "Template file invalid" );
 
      std::shared_ptr<FileStateHandler> tfp = fht->pTemplateFileWp.lock();
      if( !tfp )
        return XRootDStatus( stError, errInvalidOp, 0,
                             "Template file object does not exist" );
 
      XrdSysMutexHelper scopedLock( tfp->pMutex );
      if( tfp->pFileState != Opened )
        return XRootDStatus( stError, errInvalidOp, 0,
                             "Template file not open" );
 
      if( tfp->pSessionId != self->pSessionId )
        return XRootDStatus( stError, errInvalidOp, 0,
                             "Clone source not at same location as destination" );
 
      memcpy( cl[idx].srcFH, tfp->pFileHandle, 4 );
      cl[idx].srcOffs = loc.srcOffs;
      cl[idx].srcLen  = loc.srcLen;
      cl[idx].dstOffs = loc.dstOffs;
      ++idx;
    }
 
    XRootDTransport::SetDescription( msg );
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    MessageUtils::ProcessSendParams( params );
    StatefulHandler  *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

References XrdCl::MessageUtils::CreateRequest(), XrdCl::Log::Debug(), ClientReadRequest::dlen, XrdProto::clone_list::dstOffs, XrdCl::errInvalidOp, XrdCl::errNotSupported, Error, ClientReadRequest::fhandle, XrdCl::FileMsg, XrdCl::MessageSendParams::followRedirects, XrdCl::Buffer::GetBuffer(), XrdCl::DefaultEnv::GetLog(), XrdCl::Utils::HasKSameFS(), kXR_clone, XrdCl::CloneLocations::locations, Opened, XrdCl::MessageUtils::ProcessSendParams(), XrdCl::FileStateHandlerTemplate::pTemplateFileWp, Recovering, ClientReadRequest::requestid, XrdCl::XRootDTransport::SetDescription(), XrdProto::clone_list::srcLen, XrdProto::clone_list::srcOffs, 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, time_t timeout = 0 )

static

Close the file object

Parameters

handler	handler to be notified about the status of the operation
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 937 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    //--------------------------------------------------------------------------
    // Check if we can proceed
    //--------------------------------------------------------------------------
    if( self->pFileState == Error )
      return self->pStatus;
 
    if( self->pFileState == CloseInProgress )
      return XRootDStatus( stError, errInProgress );
 
    if( self->pFileState == Closed )
      return XRootDStatus( stOK, suAlreadyDone );
 
    if( self->pFileState == OpenInProgress || self->pFileState == Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    if( !self->pAllowBundledClose && !self->pInTheFly.empty() )
      return XRootDStatus( stError, errInvalidOp );
 
    self->pFileState = CloseInProgress;
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a close command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    //--------------------------------------------------------------------------
    // Close the file
    //--------------------------------------------------------------------------
    Message            *msg;
    ClientCloseRequest *req;
    MessageUtils::CreateRequest( msg, req );
 
    req->requestid = kXR_close;
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    XRootDTransport::SetDescription( msg );
    msg->SetSessionId( self->pSessionId );
    CloseHandler *closeHandler = new CloseHandler( self, handler, msg );
    MessageSendParams params;
    params.timeout = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    MessageUtils::ProcessSendParams( params );
 
    XRootDStatus st = self->IssueRequest( *self->pDataServer, msg, closeHandler, params );
 
    if( !st.IsOK() )
    {
      // an invalid-session error means the connection to the server has been
      // closed, which in turn means that the server closed the file already
      if( st.code == errInvalidSession  || st.code == errSocketDisconnected ||
          st.code == errConnectionError || st.code == errSocketOptError     ||
          st.code == errPollerError     || st.code == errSocketError           )
      {
        self->pFileState = Closed;
        ResponseJob *job = new ResponseJob( closeHandler, new XRootDStatus(),
                                            nullptr, nullptr );
        DefaultEnv::GetPostMaster()->GetJobManager()->QueueJob( job );
        return XRootDStatus();
      }
 
      delete closeHandler;
      self->pStatus    = st;
      self->pFileState = Error;
      return st;
    }
    return st;
  }

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, time_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 2130 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a fattr del command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    //--------------------------------------------------------------------------
    // Issue a new fattr del request
    //--------------------------------------------------------------------------
    return XAttrOperationImpl( self, kXR_fattrDel, 0, attrs, handler, timeout );
  }

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:

ExportTemplate()

static std::unique_ptr< ExportedFileTemplate > XrdCl::FileStateHandler::ExportTemplate ( std::shared_ptr< FileStateHandler > & self )

inlinestatic

Provides an object that carries the infromation required by another FileStateHandler to clone the file.

Definition at line 788 of file XrdClFileStateHandler.hh.

      {
        return std::make_unique<FileStateHandlerTemplate>(self);
      }

Fcntl()

XRootDStatus XrdCl::FileStateHandler::Fcntl ( std::shared_ptr< FileStateHandler > & self, QueryCode::Code queryCode, const Buffer & arg, ResponseHandler * handler, time_t timeout = 0 )

static

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

Parameters

queryCode	query code
arg	query argument
handler	handler to be notified when the response arrives, the response parameter will hold a Buffer object if the procedure is successful
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1996 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a fcntl command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message            *msg;
    ClientQueryRequest *req;
    MessageUtils::CreateRequest( msg, req, arg.GetSize() );
 
    req->requestid = kXR_query;
    req->infotype  = queryCode;
    req->dlen      = arg.GetSize();
    memcpy( req->fhandle, self->pFileHandle, 4 );
    msg->Append( arg.GetBuffer(), arg.GetSize(), sizeof(ClientQueryRequest) );
 
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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_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(), and 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 2409 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( pMutex );
    if( name == "ReadRecovery" )
    {
      if( pDoRecoverRead ) value = "true";
      else value = "false";
      return true;
    }
    else if( name == "WriteRecovery" )
    {
      if( pDoRecoverWrite ) value = "true";
      else value = "false";
      return true;
    }
    else if( name == "FollowRedirects" )
    {
      if( pFollowRedirects ) value = "true";
      else value = "false";
      return true;
    }
    else if( name == "DataServer" && pDataServer )
      { value = pDataServer->GetHostId(); return true; }
    else if( name == "LastURL" && pDataServer )
      { value =  pDataServer->GetURL(); return true; }
    else if( name == "WrtRecoveryRedir" && pWrtRecoveryRedir )
      { value = pWrtRecoveryRedir->GetHostId(); return true; }
    value = "";
    return false;
  }

GetXAttr()

XRootDStatus XrdCl::FileStateHandler::GetXAttr ( std::shared_ptr< FileStateHandler > & self, const std::vector< std::string > & attrs, ResponseHandler * handler, time_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 2104 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a fattr get command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    //--------------------------------------------------------------------------
    // Issue a new fattr get request
    //--------------------------------------------------------------------------
    return XAttrOperationImpl( self, kXR_fattrGet, 0, attrs, handler, timeout );
  }

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 2363 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( pMutex );
 
    if( pFileState == Opened || pFileState == Recovering )
      return true;
    return false;
  }

References Opened, and Recovering.

IsSecure()

bool XrdCl::FileStateHandler::IsSecure ( ) const

inline

Check if the file is using an encrypted connection.

Definition at line 728 of file XrdClFileStateHandler.hh.

      {
        return pIsChannelEncrypted;
      }

ListXAttr()

XRootDStatus XrdCl::FileStateHandler::ListXAttr ( std::shared_ptr< FileStateHandler > & self, ResponseHandler * handler, time_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 2156 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a fattr list command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    //--------------------------------------------------------------------------
    // Issue a new fattr get request
    //--------------------------------------------------------------------------
    static const std::vector<std::string> nothing;
    return XAttrOperationImpl( self, kXR_fattrList, ClientFattrRequest::aData,
                               nothing, handler, timeout );
  }

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 750 of file XrdClFileStateHandler.hh.

      {
        pMutex.Lock();
      }

NeedFileTempl()

bool XrdCl::FileStateHandler::NeedFileTempl ( ) const

inline

Checks if we need to set a file template.

Definition at line 797 of file XrdClFileStateHandler.hh.

      {
        if( (pOpenFlags & OpenFlags::Dup) || (pOpenFlags & OpenFlags::Samefs) )
          return true;
        return false;
      }

References XrdCl::OpenFlags::Dup, and XrdCl::OpenFlags::Samefs.

OnClose()

void XrdCl::FileStateHandler::OnClose

(

const XRootDStatus *

status

)

Process the results of the closing operation.

Definition at line 2591 of file XrdClFileStateHandler.cc.

  {
    Log *log = DefaultEnv::GetLog();
    XrdSysMutexHelper scopedLock( pMutex );
 
    log->Debug(FileMsg, "[%p@%s] Close returned from %s with: %s", (void*)this,
               pFileUrl->GetObfuscatedURL().c_str(), pDataServer->GetHostId().c_str(),
               status->ToStr().c_str() );
 
    log->Dump(FileMsg, "[%p@%s] Items in the fly %zu, queued for recovery %zu",
              (void*)this, pFileUrl->GetObfuscatedURL().c_str(), pInTheFly.size(), pToBeRecovered.size() );
 
    MonitorClose( status );
    ResetMonitoringVars();
 
    pStatus    = *status;
    pFileState = Closed;
  }

References Closed, XrdCl::Log::Debug(), XrdCl::Log::Dump(), XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), 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 2444 of file XrdClFileStateHandler.cc.

  {
    Log *log = DefaultEnv::GetLog();
    XrdSysMutexHelper scopedLock( pMutex );
 
    //--------------------------------------------------------------------------
    // Assign the data server and the load balancer
    //--------------------------------------------------------------------------
    std::string lastServer = pFileUrl->GetHostId();
    if( hostList )
    {
      delete pDataServer;
      delete pLoadBalancer;
      pLoadBalancer = 0;
      delete pWrtRecoveryRedir;
      pWrtRecoveryRedir = 0;
 
      pDataServer = new URL( hostList->back().url );
      pDataServer->SetParams( pFileUrl->GetParams() );
      if( !( pUseVirtRedirector && pFileUrl->IsMetalink() ) ) pDataServer->SetPath( pFileUrl->GetPath() );
      lastServer = pDataServer->GetHostId();
      HostList::const_iterator itC;
      URL::ParamsMap params = pDataServer->GetParams();
      for( itC = hostList->begin(); itC != hostList->end(); ++itC )
      {
        MessageUtils::MergeCGI( params,
                                itC->url.GetParams(),
                                true );
      }
      pDataServer->SetParams( params );
 
      HostList::const_reverse_iterator it;
      for( it = hostList->rbegin(); it != hostList->rend(); ++it )
        if( it->loadBalancer )
        {
          pLoadBalancer = new URL( it->url );
          break;
        }
 
      for( it = hostList->rbegin(); it != hostList->rend(); ++it )
        if( it->flags & kXR_recoverWrts )
        {
          pWrtRecoveryRedir = new URL( it->url );
          break;
        }
    }
 
    log->Debug(FileMsg, "[%p@%s] Open has returned with status %s",
               (void*)this, pFileUrl->GetObfuscatedURL().c_str(), status->ToStr().c_str() );
 
    if( pDataServer && !pDataServer->IsLocalFile() )
    {
      //------------------------------------------------------------------------
      // Check if we are using a secure connection
      //------------------------------------------------------------------------
      XrdCl::AnyObject isencobj;
      XrdCl::XRootDStatus st = XrdCl::DefaultEnv::GetPostMaster()->
                QueryTransport( *pDataServer, XRootDQuery::IsEncrypted, isencobj );
      if( st.IsOK() )
      {
        bool *isenc;
        isencobj.Get( isenc );
        pIsChannelEncrypted = isenc ? *isenc : false;
        delete isenc;
      }
    }
 
    //--------------------------------------------------------------------------
    // We have failed
    //--------------------------------------------------------------------------
    pStatus = *status;
    if( !pStatus.IsOK() || !openInfo )
    {
      log->Debug(FileMsg, "[%p@%s] Error while opening at %s: %s",
                 (void*)this, pFileUrl->GetObfuscatedURL().c_str(), lastServer.c_str(),
                 pStatus.ToStr().c_str() );
      FailQueuedMessages( pStatus );
      pFileState = Error;
 
      //------------------------------------------------------------------------
      // Report to monitoring
      //------------------------------------------------------------------------
      Monitor *mon = DefaultEnv::GetMonitor();
      if( mon )
      {
        Monitor::ErrorInfo i;
        i.file   = pFileUrl;
        i.status = status;
        i.opCode = Monitor::ErrorInfo::ErrOpen;
        mon->Event( Monitor::EvErrIO, &i );
      }
    }
    //--------------------------------------------------------------------------
    // We have succeeded
    //--------------------------------------------------------------------------
    else
    {
       //------------------------------------------------------------------------
       // if requested file colocation or dup was done, don't do again on reopen
       //------------------------------------------------------------------------
       pOpenFlags &= ~(OpenFlags::Dup | OpenFlags::Samefs);
 
      //------------------------------------------------------------------------
      // Store the response info
      //------------------------------------------------------------------------
      openInfo->GetFileHandle( pFileHandle );
      pSessionId = openInfo->GetSessionId();
      if( openInfo->GetStatInfo() )
      {
        delete pStatInfo;
        pStatInfo = new StatInfo( *openInfo->GetStatInfo() );
      }
 
      log->Debug( FileMsg, "[%p@%s] successfully opened at %s, handle: %#x, "
                  "session id: %llu", (void*)this, pFileUrl->GetObfuscatedURL().c_str(),
                  pDataServer->GetHostId().c_str(), *((uint32_t*)pFileHandle),
                  (unsigned long long) pSessionId );
 
      //------------------------------------------------------------------------
      // Inform the monitoring about opening success
      //------------------------------------------------------------------------
      gettimeofday( &pOpenTime, 0 );
      Monitor *mon = DefaultEnv::GetMonitor();
      if( mon )
      {
        Monitor::OpenInfo i;
        i.file       = pFileUrl;
        i.dataServer = pDataServer->GetHostId();
        i.oFlags     = pOpenFlags;
        i.oFlags2    = pOpenFlags>>16;
        i.fSize      = pStatInfo ? pStatInfo->GetSize() : 0;
        mon->Event( Monitor::EvOpen, &i );
      }
 
      //------------------------------------------------------------------------
      // Resend the queued messages if any
      //------------------------------------------------------------------------
      ReSendQueuedMessages();
      pFileState  = Opened;
    }
  }

References XrdCl::Monitor::OpenInfo::dataServer, XrdCl::Log::Debug(), XrdCl::OpenFlags::Dup, XrdCl::Monitor::ErrorInfo::ErrOpen, Error, XrdCl::Monitor::Event(), XrdCl::Monitor::EvErrIO, XrdCl::Monitor::EvOpen, XrdCl::Monitor::ErrorInfo::file, XrdCl::Monitor::OpenInfo::file, XrdCl::FileMsg, XrdCl::Monitor::OpenInfo::fSize, XrdCl::AnyObject::Get(), XrdCl::OpenInfo::GetFileHandle(), XrdCl::DefaultEnv::GetLog(), XrdCl::DefaultEnv::GetMonitor(), XrdCl::DefaultEnv::GetPostMaster(), XrdCl::OpenInfo::GetSessionId(), XrdCl::OpenInfo::GetStatInfo(), XrdCl::XRootDQuery::IsEncrypted, XrdCl::Status::IsOK(), kXR_recoverWrts, XrdCl::MessageUtils::MergeCGI(), XrdCl::Monitor::OpenInfo::oFlags, XrdCl::Monitor::OpenInfo::oFlags2, XrdCl::Monitor::ErrorInfo::opCode, Opened, XrdCl::OpenFlags::Samefs, 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 2613 of file XrdClFileStateHandler.cc.

  {
    //--------------------------------------------------------------------------
    // It may be a redirection
    //--------------------------------------------------------------------------
    if( !status->IsOK() && status->code == errRedirect && self->pFollowRedirects )
    {
      static const std::string root  = "root",  xroot  = "xroot", file = "file",
                               roots = "roots", xroots = "xroots";
      std::string msg = status->GetErrorMessage();
      if( !msg.compare( 0, root.size(),   root )  ||
          !msg.compare( 0, xroot.size(),  xroot ) ||
          !msg.compare( 0, file.size(),   file )  ||
          !msg.compare( 0, roots.size(),  roots ) ||
          !msg.compare( 0, xroots.size(), xroots ) )
      {
        FileStateHandler::OnStateRedirection( self, msg, message, userHandler, sendParams );
        return;
      }
    }
 
    //--------------------------------------------------------------------------
    // Handle error
    //--------------------------------------------------------------------------
    Log *log = DefaultEnv::GetLog();
    XrdSysMutexHelper scopedLock( self->pMutex );
    self->pInTheFly.erase( message );
 
    log->Dump( FileMsg, "[%p@%s] File state error encountered. Message %s "
               "returned with %s", (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
               message->GetObfuscatedDescription().c_str(), status->ToStr().c_str() );
 
    //--------------------------------------------------------------------------
    // Report to monitoring
    //--------------------------------------------------------------------------
    Monitor *mon = DefaultEnv::GetMonitor();
    if( mon )
    {
      Monitor::ErrorInfo i;
      i.file   = self->pFileUrl;
      i.status = status;
 
      ClientRequest *req = (ClientRequest*)message->GetBuffer();
      switch( req->header.requestid )
      {
        case kXR_read:    i.opCode = Monitor::ErrorInfo::ErrRead;   break;
        case kXR_readv:   i.opCode = Monitor::ErrorInfo::ErrReadV;  break;
        case kXR_pgread:  i.opCode = Monitor::ErrorInfo::ErrRead;   break;
        case kXR_write:   i.opCode = Monitor::ErrorInfo::ErrWrite;  break;
        case kXR_writev:  i.opCode = Monitor::ErrorInfo::ErrWriteV; break;
        case kXR_pgwrite: i.opCode = Monitor::ErrorInfo::ErrWrite;  break;
        default: i.opCode = Monitor::ErrorInfo::ErrUnc;
      }
 
      mon->Event( Monitor::EvErrIO, &i );
    }
 
    //--------------------------------------------------------------------------
    // The message is not recoverable
    // (message using a kernel buffer is not recoverable by definition)
    //--------------------------------------------------------------------------
    if( !self->IsRecoverable( *status ) || sendParams.kbuff )
    {
      log->Error( FileMsg, "[%p@%s] Fatal file state error. Message %s "
                 "returned with %s", (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                 message->GetObfuscatedDescription().c_str(), status->ToStr().c_str() );
 
      self->FailMessage( RequestData( message, userHandler, sendParams ), *status );
      delete status;
      return;
    }
 
    //--------------------------------------------------------------------------
    // Insert the message to the recovery queue and start the recovery
    // procedure if we don't have any more message in the fly
    //--------------------------------------------------------------------------
    self->pCloseReason = *status;
    RecoverMessage( self, RequestData( message, userHandler, sendParams ) );
    delete status;
  }

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 2701 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
    self->pInTheFly.erase( message );
 
    //--------------------------------------------------------------------------
    // Register the state redirect url and append the new cgi information to
    // the file URL
    //--------------------------------------------------------------------------
    if( !self->pStateRedirect )
    {
      std::ostringstream o;
      self->pStateRedirect = new URL( redirectUrl );
      URL::ParamsMap params = self->pFileUrl->GetParams();
      MessageUtils::MergeCGI( params,
                              self->pStateRedirect->GetParams(),
                              false );
      self->pFileUrl->SetParams( params );
    }
 
    RecoverMessage( self, RequestData( message, userHandler, sendParams ) );
  }

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 2731 of file XrdClFileStateHandler.cc.

  {
    Log    *log = DefaultEnv::GetLog();
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    log->Dump( FileMsg, "[%p@%s] Got state response for message %s",
               (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
               message->GetObfuscatedDescription().c_str() );
 
    //--------------------------------------------------------------------------
    // Since this message may be the last "in-the-fly" and no recovery
    // is done if messages are in the fly, we may need to trigger recovery
    //--------------------------------------------------------------------------
    self->pInTheFly.erase( message );
    RunRecovery( self );
 
    //--------------------------------------------------------------------------
    // Play with the actual response before returning it. This is a good
    // place to do caching in the future.
    //--------------------------------------------------------------------------
    ClientRequest *req = (ClientRequest*)message->GetBuffer();
    switch( req->header.requestid )
    {
      //------------------------------------------------------------------------
      // Cache the stat response
      //------------------------------------------------------------------------
      case kXR_stat:
      {
        StatInfo *info = 0;
        response->Get( info );
        delete self->pStatInfo;
        self->pStatInfo = new StatInfo( *info );
        break;
      }
 
      //------------------------------------------------------------------------
      // Handle read response
      //------------------------------------------------------------------------
      case kXR_read:
      {
        ++self->pRCount;
        self->pRBytes += req->read.rlen;
        break;
      }
 
      //------------------------------------------------------------------------
      // Handle read response
      //------------------------------------------------------------------------
      case kXR_pgread:
      {
        ++self->pRCount;
        self->pRBytes += req->pgread.rlen;
        break;
      }
 
      //------------------------------------------------------------------------
      // Handle readv response
      //------------------------------------------------------------------------
      case kXR_readv:
      {
        ++self->pVRCount;
        size_t segs = req->header.dlen/sizeof(readahead_list);
        readahead_list *dataChunk = (readahead_list*)message->GetBuffer( 24 );
        for( size_t i = 0; i < segs; ++i )
          self->pVRBytes += dataChunk[i].rlen;
        self->pVSegs += segs;
        break;
      }
 
      //------------------------------------------------------------------------
      // Handle write response
      //------------------------------------------------------------------------
      case kXR_write:
      {
        ++self->pWCount;
        self->pWBytes += req->write.dlen;
        break;
      }
 
      //------------------------------------------------------------------------
      // Handle write response
      //------------------------------------------------------------------------
      case kXR_pgwrite:
      {
        ++self->pWCount;
        self->pWBytes += req->pgwrite.dlen;
        break;
      }
 
      //------------------------------------------------------------------------
      // Handle writev response
      //------------------------------------------------------------------------
      case kXR_writev:
      {
        ++self->pVWCount;
        size_t size = req->header.dlen/sizeof(readahead_list);
        XrdProto::write_list *wrtList =
            reinterpret_cast<XrdProto::write_list*>( message->GetBuffer( 24 ) );
        for( size_t i = 0; i < size; ++i )
          self->pVWBytes += wrtList[i].wlen;
        break;
      }
    };
  }

References ClientPgWriteRequest::dlen, ClientRequestHdr::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, OpenFlags::Flags flags, uint16_t mode, ResponseHandler * handler, time_t timeout = 0 )

static

Open the file pointed to by the given URL

Parameters

url	url of the file to be opened
flags	OpenFlags::Flags
mode	Access::Mode for new files, 0 otherwise
handler	handler to be notified about the status of the operation
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 787 of file XrdClFileStateHandler.cc.

  {
    self->pTemplateFileWp.reset();
    return OpenImpl( self, url, flags, mode, handler, timeout );
  }

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

Here is the caller graph for this function:

OpenUsingTemplate()

XRootDStatus XrdCl::FileStateHandler::OpenUsingTemplate ( std::shared_ptr< FileStateHandler > & self, ExportedFileTemplate * templ, const std::string & url, OpenFlags::Flags flags, uint16_t mode, ResponseHandler * handler, time_t timeout = 0 )

static

Open the file pointed to by the given URL Alows one to specify template file. Required if using Dup or Samefs flags.

Parameters

url	url of the file to be opened
templ	Template of file to colocate with or duplicate
flags	OpenFlags::Flags
mode	Access::Mode for new files, 0 otherwise
handler	handler to be notified about the status of the operation
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 763 of file XrdClFileStateHandler.cc.

  {
    if( !templ )
      return XRootDStatus( stError, errInvalidArgs, 0, "Template file not available" );
 
    FileStateHandlerTemplate *fht = dynamic_cast<FileStateHandlerTemplate*>( templ );
    if( !fht )
      return XRootDStatus( stError, errInvalidArgs, 0, "Template file invalid" );
 
    self->pTemplateFileWp = fht->pTemplateFileWp;
 
    return OpenImpl( self, url, flags, mode, handler, timeout );
  }

References XrdCl::errInvalidArgs, XrdCl::FileStateHandlerTemplate::pTemplateFileWp, and XrdCl::stError.

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

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, time_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 1185 of file XrdClFileStateHandler.cc.

  {
    int issupported = true;
    AnyObject obj;
    XRootDStatus st1 = DefaultEnv::GetPostMaster()->QueryTransport( *self->pDataServer, XRootDQuery::ServerFlags, obj );
    int protver = 0;
    XRootDStatus st2 = Utils::GetProtocolVersion( *self->pDataServer, protver );
    if( st1.IsOK() && st2.IsOK() )
    {
      int *ptr = 0;
      obj.Get( ptr );
      issupported = ( ptr && (*ptr & kXR_suppgrw) ) && ( protver >= kXR_PROTPGRWVERSION );
      delete ptr;
    }
    else
      issupported = false;
 
    if( !issupported )
    {
      DefaultEnv::GetLog()->Debug( FileMsg, "[%p@%s] PgRead not supported; substituting with Read.",
                                  (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str() );
      ResponseHandler *substitHandler = new PgReadSubstitutionHandler( self, handler );
      auto st = Read( self, offset, size, buffer, substitHandler, timeout );
      if( !st.IsOK() ) delete substitHandler;
      return st;
    }
 
    ResponseHandler* pgHandler = new PgReadHandler( self, handler, offset );
    auto st = PgReadImpl( self, offset, size, buffer, PgReadFlags::None, pgHandler, timeout );
    if( !st.IsOK() ) delete pgHandler;
    return st;
  }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

PgReadImpl()

XRootDStatus XrdCl::FileStateHandler::PgReadImpl ( std::shared_ptr< FileStateHandler > & self, uint64_t offset, uint32_t size, void * buffer, uint16_t flags, ResponseHandler * handler, time_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 1241 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a pgread command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message             *msg;
    ClientPgReadRequest *req;
    MessageUtils::CreateRequest( msg, req, sizeof( ClientPgReadReqArgs ) );
 
    req->requestid  = kXR_pgread;
    req->offset     = offset;
    req->rlen       = size;
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    //--------------------------------------------------------------------------
    // Now adjust the message size so it can hold PgRead arguments
    //--------------------------------------------------------------------------
    req->dlen = sizeof( ClientPgReadReqArgs );
    void *newBuf = msg->GetBuffer( sizeof( ClientPgReadRequest ) );
    memset( newBuf, 0, sizeof( ClientPgReadReqArgs ) );
    ClientPgReadReqArgs *args = reinterpret_cast<ClientPgReadReqArgs*>(
        msg->GetBuffer( sizeof( ClientPgReadRequest ) ) );
    args->reqflags = flags;
 
    ChunkList *list   = new ChunkList();
    list->push_back( ChunkInfo( offset, size, buffer ) );
 
    XRootDTransport::SetDescription( msg );
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    params.chunkList       = list;
    MessageUtils::ProcessSendParams( params );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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, time_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 1223 of file XrdClFileStateHandler.cc.

  {
    if( size > (uint32_t)XrdSys::PageSize )
      return XRootDStatus( stError, errInvalidArgs, EINVAL,
                          "PgRead retry size exceeded 4KB." );
 
    ResponseHandler *retryHandler = new PgReadRetryHandler( handler, pgnb );
    XRootDStatus st = PgReadImpl( self, offset, size, buffer, PgReadFlags::Retry, retryHandler, timeout );
    if( !st.IsOK() ) delete retryHandler;
    return st;
  }

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

Here is the call graph for this function:

PgWrite()

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

static

Write number of pages at a given offset - async

Parameters

offset	offset from the beginning of the file
size	buffer size
buffer	a pointer to a buffer holding data pages
cksums	the crc32c checksums for each 4KB page
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1422 of file XrdClFileStateHandler.cc.

  {
    //--------------------------------------------------------------------------
    // Resolve timeout value
    //--------------------------------------------------------------------------
    if( timeout == 0 )
    {
      int val = DefaultRequestTimeout;
      XrdCl::DefaultEnv::GetEnv()->GetInt( "RequestTimeout", val );
      timeout = val;
    }
 
    //--------------------------------------------------------------------------
    // Validate the digest vector size
    //--------------------------------------------------------------------------
    if( cksums.empty() )
    {
      const char *data = static_cast<const char*>( buffer );
      XrdOucPgrwUtils::csCalc( data, offset, size, cksums );
    }
    else
    {
      size_t crc32cCnt = XrdOucPgrwUtils::csNum( offset, size );
      if( crc32cCnt != cksums.size() )
        return XRootDStatus( stError, errInvalidArgs, 0, "Wrong number of crc32c digests." );
    }
 
    //--------------------------------------------------------------------------
    // Create a context for PgWrite operation
    //--------------------------------------------------------------------------
    struct pgwrt_t
    {
      pgwrt_t( ResponseHandler *h ) : handler( h ), status( nullptr )
      {
      }
 
      ~pgwrt_t()
      {
        if( handler )
        {
          // if all retries were successful no error status was set
          if( !status ) status = new XRootDStatus();
          handler->HandleResponse( status, nullptr );
        }
      }
 
      static size_t GetPgNb( uint64_t pgoff, uint64_t offset, uint32_t fstpglen )
      {
        if( pgoff == offset ) return 0; // we need this if statement because we operate on unsigned integers
        return ( pgoff - ( offset + fstpglen ) ) / XrdSys::PageSize + 1;
      }
 
      inline void SetStatus( XRootDStatus* s )
      {
        if( !status ) status = s;
        else delete s;
      }
 
      ResponseHandler *handler;
      XRootDStatus    *status;
    };
    auto pgwrt = std::make_shared<pgwrt_t>( handler );
 
    int fLen, lLen;
    XrdOucPgrwUtils::csNum( offset, size, fLen, lLen );
    uint32_t fstpglen = fLen;
 
    time_t start = ::time( nullptr );
    auto h = ResponseHandler::Wrap( [=]( XrdCl::XRootDStatus *s, XrdCl::AnyObject *r ) mutable
        {
          std::unique_ptr<AnyObject> scoped( r );
          // if the request failed simply pass the status to the
          // user handler
          if( !s->IsOK() )
          {
            pgwrt->SetStatus( s );
            return; // pgwrt destructor will call the handler
          }
          // also if the request was sucessful and there were no
          // corrupted pages pass the status to the user handler
          RetryInfo *inf = nullptr;
          r->Get( inf );
          if( !inf->NeedRetry() )
          {
            pgwrt->SetStatus( s );
            return; // pgwrt destructor will call the handler
          }
          delete s;
          // first adjust the timeout value
          time_t elapsed = ::time( nullptr ) - start;
          if( elapsed >= timeout )
          {
            pgwrt->SetStatus( new XRootDStatus( stError, errOperationExpired ) );
            return; // pgwrt destructor will call the handler
          }
          else timeout -= elapsed;
          // retransmit the corrupted pages
          for( size_t i = 0; i < inf->Size(); ++i )
          {
            auto tpl = inf->At( i );
            uint64_t    pgoff = std::get<0>( tpl );
            uint32_t    pglen = std::get<1>( tpl );
            const void *pgbuf = static_cast<const char*>( buffer ) + ( pgoff - offset );
            uint32_t pgdigest = cksums[pgwrt_t::GetPgNb( pgoff, offset, fstpglen )];
            auto h = ResponseHandler::Wrap( [=]( XrdCl::XRootDStatus *s, XrdCl::AnyObject *r ) mutable
                {
                  std::unique_ptr<AnyObject> scoped( r );
                  // if we failed simply set the status
                  if( !s->IsOK() )
                  {
                    pgwrt->SetStatus( s );
                    return; // the destructor will call the handler
                  }
                  delete s;
                  // otherwise check if the data were not corrupted again
                  RetryInfo *inf = nullptr;
                  r->Get( inf );
                  if( inf->NeedRetry() ) // so we failed in the end
                  {
                    DefaultEnv::GetLog()->Warning( FileMsg, "[%p@%s] Failed retransmitting corrupted "
                                                   "page: pgoff=%llu, pglen=%u, pgdigest=%u", (void*)self.get(),
                                                   self->pFileUrl->GetObfuscatedURL().c_str(), (unsigned long long) pgoff, pglen, pgdigest );
                    pgwrt->SetStatus( new XRootDStatus( stError, errDataError, 0,
                                      "Failed to retransmit corrupted page" ) );
                  }
                  else
                    DefaultEnv::GetLog()->Info( FileMsg, "[%p@%s] Succesfuly retransmitted corrupted "
                                                "page: pgoff=%llu, pglen=%u, pgdigest=%u", (void*)self.get(),
                                                self->pFileUrl->GetObfuscatedURL().c_str(), (unsigned long long) pgoff, pglen, pgdigest );
                } );
            auto st = PgWriteRetry( self, pgoff, pglen, pgbuf, pgdigest, h, timeout );
            if( !st.IsOK() ) pgwrt->SetStatus( new XRootDStatus( st ) );
            DefaultEnv::GetLog()->Info( FileMsg, "[%p@%s] Retransmitting corrupted page: "
                                        "pgoff=%llu, pglen=%u, pgdigest=%u", (void*)self.get(),
                                        self->pFileUrl->GetObfuscatedURL().c_str(), (unsigned long long) pgoff, pglen, pgdigest );
          }
        } );
 
    auto st = PgWriteImpl( self, offset, size, buffer, cksums, 0, h, timeout );
    if( !st.IsOK() )
    {
      pgwrt->handler = nullptr;
      delete h;
    }
    return st;
  }

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, time_t timeout = 0 )

static

Write number of pages at a given offset - async

Parameters

offset	offset from the beginning of the file
size	buffer size
buffer	a pointer to a buffer holding data pages
cksums	the crc32c checksums for each 4KB page
flags	PgWrite flags
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1593 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a pgwrite command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    //--------------------------------------------------------------------------
    // Create the message
    //--------------------------------------------------------------------------
    Message              *msg;
    ClientPgWriteRequest *req;
    MessageUtils::CreateRequest( msg, req );
 
    req->requestid  = kXR_pgwrite;
    req->offset     = offset;
    req->dlen       = size + cksums.size() * sizeof( uint32_t );
    req->reqflags   = flags;
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    ChunkList *list   = new ChunkList();
    list->push_back( ChunkInfo( offset, size, (char*)buffer ) );
 
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    params.chunkList       = list;
    params.crc32cDigests.swap( cksums );
 
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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, time_t timeout = 0 )

static

Write number of pages at a given offset - async

Parameters

offset	offset from the beginning of the file
size	buffer size
buffer	a pointer to a buffer holding data pages
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1578 of file XrdClFileStateHandler.cc.

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

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:

PreRead()

XRootDStatus XrdCl::FileStateHandler::PreRead ( std::shared_ptr< FileStateHandler > & self, const TractList & tracts, ResponseHandler * handler, time_t timeout = 0 )

static

Preread data tracts at given offsets - async

Parameters

tracts	A vector of offset/lengths of data tracts to preread.
handler	handler to be notified when the response arrives. Since no data is transmitted, there is no response parameter.
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1072 of file XrdClFileStateHandler.cc.

  {
    //--------------------------------------------------------------------------
    // Sanity check
    //--------------------------------------------------------------------------
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending an read+preread command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    //--------------------------------------------------------------------------
    // Build the message
    //--------------------------------------------------------------------------
    Message            *msg;
    ClientReadRequest  *req;
    MessageUtils::CreateRequest( msg, req, sizeof(readahead_list)*tracts.size() + 8 );
 
    req->requestid = kXR_read;
    req->offset    = 0;
    req->rlen      = 0;
    memcpy( req->fhandle, self->pFileHandle, 4 );
    req->dlen      = sizeof(readahead_list)*tracts.size() + 8;
 
    static char dummyBuff[8];
    ChunkList *list   = new ChunkList();
    list->push_back( ChunkInfo( 0, 0,  dummyBuff ) );
 
    //--------------------------------------------------------------------------
    // Copy the tract info
    //--------------------------------------------------------------------------
    readahead_list *dataTract = (readahead_list*)msg->GetBuffer( 24 + 8 );
    for( size_t i = 0; i < tracts.size(); ++i )
    {
      dataTract[i].rlen   = tracts[i].length;
      dataTract[i].offset = tracts[i].offset;
      memcpy( dataTract[i].fhandle, req->fhandle, 4 );
    }
 
    //--------------------------------------------------------------------------
    // Send the message
    //--------------------------------------------------------------------------
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    params.chunkList       = list;
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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

Here is the call graph for this function:

Read()

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

static

Read a data chunk at a given offset - sync

Parameters

offset	offset from the beginning of the file
size	number of bytes to be read
buffer	a pointer to a buffer big enough to hold the data or 0 if the buffer should be allocated by the system
handler	handler 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
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1139 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a read command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message           *msg;
    ClientReadRequest *req;
    MessageUtils::CreateRequest( msg, req );
 
    req->requestid  = kXR_read;
    req->offset     = offset;
    req->rlen       = size;
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    ChunkList *list   = new ChunkList();
    list->push_back( ChunkInfo( offset, size, buffer ) );
 
    XRootDTransport::SetDescription( msg );
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    params.chunkList       = list;
    MessageUtils::ProcessSendParams( params );
    StatefulHandler  *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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, time_t timeout = 0 )

static

Read data into scattered buffers in one operation - async

Parameters

offset	offset from the beginning of the file
iov	list of the buffers to be written
iovcnt	number of buffers
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 1936 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a read command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message           *msg;
    ClientReadRequest *req;
    MessageUtils::CreateRequest( msg, req );
 
    // calculate the total read size
    size_t size = std::accumulate( iov, iov + iovcnt, 0, []( size_t acc, iovec &rhs )
                                                         {
                                                           return acc + rhs.iov_len;
                                                         } );
    req->requestid  = kXR_read;
    req->offset     = offset;
    req->rlen       = size;
    msg->SetVirtReqID( kXR_virtReadv );
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    ChunkList *list = new ChunkList();
    list->reserve( iovcnt );
    uint64_t choff = offset;
    for( int i = 0; i < iovcnt; ++i )
    {
      list->emplace_back( choff, iov[i].iov_len, iov[i].iov_base );
      choff += iov[i].iov_len;
    }
 
    XRootDTransport::SetDescription( msg );
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    params.chunkList       = list;
    MessageUtils::ProcessSendParams( params );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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 2375 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( pMutex );
    if( name == "ReadRecovery" )
    {
      if( value == "true" ) pDoRecoverRead = true;
      else pDoRecoverRead = false;
      return true;
    }
    else if( name == "WriteRecovery" )
    {
      if( value == "true" ) pDoRecoverWrite = true;
      else pDoRecoverWrite = false;
      return true;
    }
    else if( name == "FollowRedirects" )
    {
      if( value == "true" ) pFollowRedirects = true;
      else pFollowRedirects = false;
      return true;
    }
    else if( name == "BundledClose" )
    {
      if( value == "true" ) pAllowBundledClose = true;
      else pAllowBundledClose = false;
      return true;
    }
    return false;
  }

SetXAttr()

XRootDStatus XrdCl::FileStateHandler::SetXAttr ( std::shared_ptr< FileStateHandler > & self, const std::vector< xattr_t > & attrs, ResponseHandler * handler, time_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 2078 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a fattr set command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    //--------------------------------------------------------------------------
    // Issue a new fattr get request
    //--------------------------------------------------------------------------
    return XAttrOperationImpl( self, kXR_fattrSet, 0, attrs, handler, timeout );
  }

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, time_t timeout = 0 )

static

Obtain status information for this file - async

Parameters

force	do not use the cached information, force re-stating
handler	handler to be notified when the response arrives, the response parameter will hold a StatInfo object if the procedure is successful
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1015 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    //--------------------------------------------------------------------------
    // Return the cached info
    //--------------------------------------------------------------------------
    if( !force )
    {
      AnyObject *obj = new AnyObject();
      obj->Set( new StatInfo( *self->pStatInfo ) );
      if (handler)
        handler->HandleResponseWithHosts( new XRootDStatus(), obj, new HostList() );
      return XRootDStatus();
    }
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a stat command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    //--------------------------------------------------------------------------
    // Issue a new stat request
    // stating a file handle doesn't work (fixed in 3.2.0) so we need to
    // stat the pat
    //--------------------------------------------------------------------------
    Message           *msg;
    ClientStatRequest *req;
    std::string        path = self->pFileUrl->GetPath();
    MessageUtils::CreateRequest( msg, req );
 
    req->requestid = kXR_stat;
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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, time_t timeout = 0 )

static

Commit all pending disk writes - async

Parameters

handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1648 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a sync command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message           *msg;
    ClientSyncRequest *req;
    MessageUtils::CreateRequest( msg, req );
 
    req->requestid = kXR_sync;
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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 2843 of file XrdClFileStateHandler.cc.

  {
    if (pMutex.CondLock())
       {TimeOutRequests( now );
        pMutex.UnLock();
       }
  }

References TimeOutRequests().

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 2854 of file XrdClFileStateHandler.cc.

  {
    if( !pToBeRecovered.empty() )
    {
      Log *log = DefaultEnv::GetLog();
      log->Dump( FileMsg, "[%p@%s] Got a timer event", (void*)this,
                 pFileUrl->GetObfuscatedURL().c_str() );
      RequestList::iterator it;
      JobManager *jobMan = DefaultEnv::GetPostMaster()->GetJobManager();
      for( it = pToBeRecovered.begin(); it != pToBeRecovered.end(); )
      {
        if( it->params.expires <= now )
        {
          jobMan->QueueJob( new ResponseJob(
                              it->handler,
                              new XRootDStatus( stError, errOperationExpired ),
                              0, it->params.hostList ) );
          it = pToBeRecovered.erase( it );
        }
        else
          ++it;
      }
    }
  }

References XrdCl::Log::Dump(), XrdCl::errOperationExpired, XrdCl::FileMsg, XrdCl::PostMaster::GetJobManager(), XrdCl::DefaultEnv::GetLog(), 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, time_t timeout = 0 )

static

Truncate the file to a particular size - async

Parameters

size	desired size of the file
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1686 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a truncate command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message               *msg;
    ClientTruncateRequest *req;
    MessageUtils::CreateRequest( msg, req );
 
    req->requestid = kXR_truncate;
    memcpy( req->fhandle, self->pFileHandle, 4 );
    req->offset = size;
 
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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, time_t timeout )

static

Try other data server.

Definition at line 2905 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState != Opened || !self->pLoadBalancer )
      return XRootDStatus( stError, errInvalidOp );
 
    self->pFileState = Recovering;
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Reopen file at next data server.",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str() );
 
    // merge CGI
    auto lbcgi = self->pLoadBalancer->GetParams();
    auto dtcgi = self->pDataServer->GetParams();
    MessageUtils::MergeCGI( lbcgi, dtcgi, false );
    // update tried CGI
    auto itr = lbcgi.find( "tried" );
    if( itr == lbcgi.end() )
      lbcgi["tried"] = self->pDataServer->GetHostName();
    else
    {
     std::string tried = itr->second;
     tried += "," + self->pDataServer->GetHostName();
     lbcgi["tried"] = tried;
    }
    self->pLoadBalancer->SetParams( lbcgi );
 
    return ReOpenFileAtServer( self, *self->pLoadBalancer, timeout );
  }

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 758 of file XrdClFileStateHandler.hh.

      {
        pMutex.UnLock();
      }

VectorRead()

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

static

Read scattered data chunks in one operation - async

Parameters

chunks	list of the chunks to be read
buffer	a pointer to a buffer big enough to hold the data
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 1726 of file XrdClFileStateHandler.cc.

  {
    //--------------------------------------------------------------------------
    // Sanity check
    //--------------------------------------------------------------------------
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a vector read command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    //--------------------------------------------------------------------------
    // Build the message
    //--------------------------------------------------------------------------
    Message            *msg;
    ClientReadVRequest *req;
    MessageUtils::CreateRequest( msg, req, sizeof(readahead_list)*chunks.size() );
 
    req->requestid = kXR_readv;
    req->dlen      = sizeof(readahead_list)*chunks.size();
 
    ChunkList *list   = new ChunkList();
    char      *cursor = (char*)buffer;
 
    //--------------------------------------------------------------------------
    // Copy the chunk info
    //--------------------------------------------------------------------------
    readahead_list *dataChunk = (readahead_list*)msg->GetBuffer( 24 );
    for( size_t i = 0; i < chunks.size(); ++i )
    {
      dataChunk[i].rlen   = chunks[i].length;
      dataChunk[i].offset = chunks[i].offset;
      memcpy( dataChunk[i].fhandle, self->pFileHandle, 4 );
 
      void *chunkBuffer;
      if( cursor )
      {
        chunkBuffer  = cursor;
        cursor      += chunks[i].length;
      }
      else
        chunkBuffer = chunks[i].buffer;
 
      list->push_back( ChunkInfo( chunks[i].offset,
                                  chunks[i].length,
                                  chunkBuffer ) );
    }
 
    //--------------------------------------------------------------------------
    // Send the message
    //--------------------------------------------------------------------------
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    params.chunkList       = list;
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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, time_t timeout = 0 )

static

Write scattered data chunks in one operation - async

Parameters

chunks	list of the chunks to be read
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 1803 of file XrdClFileStateHandler.cc.

  {
    //--------------------------------------------------------------------------
    // Sanity check
    //--------------------------------------------------------------------------
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a vector write command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    //--------------------------------------------------------------------------
    // Determine the size of the payload
    //--------------------------------------------------------------------------
 
    // the size of write vector
    uint32_t payloadSize = sizeof(XrdProto::write_list) * chunks.size();
 
    //--------------------------------------------------------------------------
    // Build the message
    //--------------------------------------------------------------------------
    Message             *msg;
    ClientWriteVRequest *req;
    MessageUtils::CreateRequest( msg, req, payloadSize );
 
    req->requestid = kXR_writev;
    req->dlen      = sizeof(XrdProto::write_list) * chunks.size();
 
    ChunkList *list   = new ChunkList();
 
    //--------------------------------------------------------------------------
    // Copy the chunk info
    //--------------------------------------------------------------------------
    XrdProto::write_list *writeList =
        reinterpret_cast<XrdProto::write_list*>( msg->GetBuffer( 24 ) );
 
 
 
    for( size_t i = 0; i < chunks.size(); ++i )
    {
      writeList[i].wlen   = chunks[i].length;
      writeList[i].offset = chunks[i].offset;
      memcpy( writeList[i].fhandle, self->pFileHandle, 4 );
 
      list->push_back( ChunkInfo( chunks[i].offset,
                                  chunks[i].length,
                                  chunks[i].buffer ) );
    }
 
    //--------------------------------------------------------------------------
    // Send the message
    //--------------------------------------------------------------------------
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    params.chunkList       = list;
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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, time_t timeout = 0 )

static

Get access token to a file - async

Parameters

handler	handler to be notified when the response arrives, the response parameter will hold a Buffer object if the procedure is successful
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 2039 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a visa command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message            *msg;
    ClientQueryRequest *req;
    MessageUtils::CreateRequest( msg, req );
 
    req->requestid = kXR_query;
    req->infotype  = kXR_Qvisa;
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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, time_t timeout = 0 )

static

Write a data chunk at a given offset - async

Parameters

offset	offset from the beginning of the file
buffer	r-value reference to Buffer object, in this case XrdCl runtime takes ownership of the buffer
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1346 of file XrdClFileStateHandler.cc.

  {
    //--------------------------------------------------------------------------
    // If the memory is not page (4KB) aligned we cannot use the kernel buffer
    // so fall back to normal write
    //--------------------------------------------------------------------------
    if( !XrdSys::KernelBuffer::IsPageAligned( buffer.GetBuffer() ) || self->pIsChannelEncrypted )
    {
      Log *log = DefaultEnv::GetLog();
      log->Info( FileMsg, "[%p@%s] Buffer for handle %#x is not page aligned (4KB), "
                 "cannot convert it to kernel space buffer.", (void*)self.get(),
                 self->pFileUrl->GetObfuscatedURL().c_str(), *((uint32_t*)self->pFileHandle) );
 
      void     *buff = buffer.GetBuffer();
      uint32_t  size = buffer.GetSize();
      ReleaseBufferHandler *wrtHandler =
          new ReleaseBufferHandler( std::move( buffer ), handler );
      XRootDStatus st = self->Write( self, offset, size, buff, wrtHandler, timeout );
      if( !st.IsOK() )
      {
        buffer = std::move( wrtHandler->GetBuffer() );
        delete wrtHandler;
      }
      return st;
    }
 
    //--------------------------------------------------------------------------
    // Transfer the data from user space to kernel space
    //--------------------------------------------------------------------------
    uint32_t  length = buffer.GetSize();
    char     *ubuff  = buffer.Release();
 
    std::unique_ptr<XrdSys::KernelBuffer> kbuff( new XrdSys::KernelBuffer() );
    ssize_t ret = XrdSys::Move( ubuff, *kbuff, length );
    if( ret < 0 )
      return XRootDStatus( stError, errInternal, XProtocol::mapError( errno ) );
 
    //--------------------------------------------------------------------------
    // Now create a write request and enqueue it
    //--------------------------------------------------------------------------
    return WriteKernelBuffer( self, offset, ret, std::move( kbuff ), handler, timeout );
  }

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, time_t timeout = 0 )

static

Write a data chunk at a given offset - async

Parameters

offset	offset from the beginning of the file
size	number of bytes to be written
buffer	a pointer to the buffer holding the data to be written
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1298 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a write command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message            *msg;
    ClientWriteRequest *req;
    MessageUtils::CreateRequest( msg, req );
 
    req->requestid  = kXR_write;
    req->offset     = offset;
    req->dlen       = size;
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    ChunkList *list   = new ChunkList();
    list->push_back( ChunkInfo( 0, size, (char*)buffer ) );
 
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    params.chunkList       = list;
 
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

Write() [3/3]

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

static

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

Parameters

offset	offset from the beginning of the file
size	number of bytes to be written
fdoff	offset 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)
fd	file descriptor open for reading
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1396 of file XrdClFileStateHandler.cc.

  {
    //--------------------------------------------------------------------------
    // Read the data from the file descriptor into a kernel buffer
    //--------------------------------------------------------------------------
    std::unique_ptr<XrdSys::KernelBuffer> kbuff( new XrdSys::KernelBuffer() );
    ssize_t ret = fdoff ? XrdSys::Read( fd, *kbuff, size, *fdoff ) :
                          XrdSys::Read( fd, *kbuff, size );
    if( ret < 0 )
      return XRootDStatus( stError, errInternal, XProtocol::mapError( errno ) );
 
    //--------------------------------------------------------------------------
    // Now create a write request and enqueue it
    //--------------------------------------------------------------------------
    return WriteKernelBuffer( self, offset, ret, std::move( kbuff ), handler, timeout );
  }

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, time_t timeout = 0 )

static

Write scattered buffers in one operation - async

Parameters

offset	offset from the beginning of the file
iov	list of the buffers to be written
iovcnt	number of buffers
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 1880 of file XrdClFileStateHandler.cc.

  {
    XrdSysMutexHelper scopedLock( self->pMutex );
 
    if( self->pFileState == Error ) return self->pStatus;
 
    if( self->pFileState != Opened && self->pFileState != Recovering )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
    log->Debug( FileMsg, "[%p@%s] Sending a write command for handle %#x to %s",
                (void*)self.get(), self->pFileUrl->GetObfuscatedURL().c_str(),
                *((uint32_t*)self->pFileHandle), self->pDataServer->GetHostId().c_str() );
 
    Message            *msg;
    ClientWriteRequest *req;
    MessageUtils::CreateRequest( msg, req );
 
    ChunkList *list   = new ChunkList();
 
    uint32_t size = 0;
    for( int i = 0; i < iovcnt; ++i )
    {
      if( iov[i].iov_len == 0 ) continue;
      size += iov[i].iov_len;
      list->push_back( ChunkInfo( 0, iov[i].iov_len,
                       (char*)iov[i].iov_base ) );
    }
 
    req->requestid  = kXR_write;
    req->offset     = offset;
    req->dlen       = size;
    memcpy( req->fhandle, self->pFileHandle, 4 );
 
    MessageSendParams params;
    params.timeout         = timeout;
    params.followRedirects = false;
    params.stateful        = true;
    params.chunkList       = list;
 
    MessageUtils::ProcessSendParams( params );
 
    XRootDTransport::SetDescription( msg );
    StatefulHandler *stHandler = new StatefulHandler( self, handler, msg, params );
 
    return SendOrQueue( self, *self->pDataServer, msg, stHandler, params );
  }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

::OpenHandler

friend class ::OpenHandler

friend

Definition at line 100 of file XrdClFileStateHandler.hh.

::PgReadHandler

friend class ::PgReadHandler

friend

Definition at line 97 of file XrdClFileStateHandler.hh.

Referenced by PgRead(), and PgReadRetry().

::PgReadRetryHandler

friend class ::PgReadRetryHandler

friend

Definition at line 98 of file XrdClFileStateHandler.hh.

Referenced by PgReadRetry().

::PgReadSubstitutionHandler

friend class ::PgReadSubstitutionHandler

friend

Definition at line 99 of file XrdClFileStateHandler.hh.

Referenced by PgRead().

---

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

• XrdClFileStateHandler.hh
• XrdClFileStateHandler.cc