XrdCl::LocalFileHandler Class Reference

#include <XrdClLocalFileHandler.hh>

Collaboration diagram for XrdCl::LocalFileHandler:

Public Member Functions
	LocalFileHandler ()
	~LocalFileHandler ()
XRootDStatus	Close (ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	DelXAttr (const std::vector< std::string > &attrs, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	ExecRequest (const URL &url, Message *msg, ResponseHandler *handler, MessageSendParams &sendParams)
	Translate an XRootD request into LocalFileHandler call.
XRootDStatus	Fcntl (const Buffer &arg, ResponseHandler *handler, uint16_t timeout=0)
const HostList &	GetHostList ()
XRootDStatus	GetXAttr (const std::vector< std::string > &attrs, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	ListXAttr (ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	Open (const std::string &url, uint16_t flags, uint16_t mode, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	Open (const URL *url, const Message *req, AnyObject *&resp)
	Handle local redirect to given URL triggered by the given request.
XRootDStatus	QueueTask (XRootDStatus *st, AnyObject *obj, ResponseHandler *handler)
XRootDStatus	Read (uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	ReadV (uint64_t offset, struct iovec *iov, int iovcnt, ResponseHandler *handler, uint16_t timeout=0)
void	SetHostList (const HostList &hostList)
XRootDStatus	SetXAttr (const std::vector< xattr_t > &attrs, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	Stat (ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	Sync (ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	Truncate (uint64_t size, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	VectorRead (const ChunkList &chunks, void *buffer, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	VectorWrite (const ChunkList &chunks, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	Visa (ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	Write (uint64_t offset, uint32_t size, const void *buffer, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus	WriteV (uint64_t offset, ChunkList *chunks, ResponseHandler *handler, uint16_t timeout=0)

Static Public Member Functions
static XRootDStatus	MkdirPath (const std::string &path)

Detailed Description

Definition at line 32 of file XrdClLocalFileHandler.hh.

Constructor & Destructor Documentation

LocalFileHandler()

XrdCl::LocalFileHandler::LocalFileHandler

(

)

Definition at line 230 of file XrdClLocalFileHandler.cc.

                                     :
      fd( -1 )
  {
  }

~LocalFileHandler()

XrdCl::LocalFileHandler::~LocalFileHandler

(

)

Definition at line 238 of file XrdClLocalFileHandler.cc.

  {
 
  }

Member Function Documentation

Close()

XRootDStatus XrdCl::LocalFileHandler::Close	(	ResponseHandler *	handler,
		uint16_t	timeout = 0 )

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 269 of file XrdClLocalFileHandler.cc.

  {
    if( close( fd ) == -1 )
    {
      Log *log = DefaultEnv::GetLog();
      log->Error( FileMsg, "Close: file fd: %i %s", fd, XrdSysE2T( errno ) );
      XRootDStatus *error = new XRootDStatus( stError, errLocalError, errno );
      return QueueTask( error, 0, handler );
    }
 
    return QueueTask( new XRootDStatus(), 0, handler );
  }

References close, XrdCl::errLocalError, XrdCl::Log::Error(), XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), QueueTask(), XrdCl::stError, and XrdSysE2T().

Referenced by ExecRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

DelXAttr()

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

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 696 of file XrdClLocalFileHandler.cc.

  {
    XrdSysXAttr *xattr = XrdSysFAttr::Xat;
    std::vector<XAttrStatus> response;
 
    auto itr = attrs.begin();
    for( ; itr != attrs.end(); ++itr )
    {
      std::string name = *itr;
      int err = xattr->Del( name.c_str(), 0, fd );
      XRootDStatus status = err < 0 ? XRootDStatus( stError, errLocalError, -err ) :
                                      XRootDStatus();
 
      response.push_back( XAttrStatus( name, status ) );
    }
 
    AnyObject *resp = new AnyObject();
    resp->Set( new std::vector<XAttrStatus>( std::move( response ) ) );
 
    return QueueTask( new XRootDStatus(), resp, handler );
  }

References XrdSysXAttr::Del(), XrdCl::errLocalError, QueueTask(), XrdCl::AnyObject::Set(), XrdCl::stError, and XrdSysFAttr::Xat.

Here is the call graph for this function:

ExecRequest()

XRootDStatus XrdCl::LocalFileHandler::ExecRequest	(	const URL &	url,
		Message *	msg,
		ResponseHandler *	handler,
		MessageSendParams &	sendParams )

Translate an XRootD request into LocalFileHandler call.

Definition at line 1003 of file XrdClLocalFileHandler.cc.

  {
    ClientRequest *req = reinterpret_cast<ClientRequest*>( msg->GetBuffer() );
 
    switch( req->header.requestid )
    {
      case kXR_open:
      {
        XRootDStatus st = Open( url.GetURL(), req->open.options,
                                req->open.mode, handler, sendParams.timeout );
        delete msg; // in case of other operations msg is owned by the handler
        return st;
      }
 
      case kXR_close:
      {
        return Close( handler, sendParams.timeout );
      }
 
      case kXR_stat:
      {
        return Stat( handler, sendParams.timeout );
      }
 
      case kXR_read:
      {
        if( msg->GetVirtReqID() == kXR_virtReadv )
        {
          auto &chunkList = *sendParams.chunkList;
          struct iovec iov[chunkList.size()];
          for( size_t i = 0; i < chunkList.size() ; ++i )
          {
            iov[i].iov_base = chunkList[i].buffer;
            iov[i].iov_len  = chunkList[i].length;
          }
          return ReadV( chunkList.front().offset, iov, chunkList.size(),
                        handler, sendParams.timeout );
        }
 
        return Read( req->read.offset, req->read.rlen,
                     sendParams.chunkList->front().buffer,
                     handler, sendParams.timeout );
      }
 
      case kXR_write:
      {
        ChunkList *chunks = sendParams.chunkList;
        if( chunks->size() == 1 )
        {
          // it's an ordinary write
          return Write( req->write.offset, req->write.dlen,
                        chunks->front().buffer, handler,
                        sendParams.timeout );
        }
        // it's WriteV call
        return WriteV( req->write.offset, sendParams.chunkList,
                       handler, sendParams.timeout );
      }
 
      case kXR_sync:
      {
        return Sync( handler, sendParams.timeout );
      }
 
      case kXR_truncate:
      {
        return Truncate( req->truncate.offset, handler, sendParams.timeout );
      }
 
      case kXR_writev:
      {
        return VectorWrite( *sendParams.chunkList, handler,
                            sendParams.timeout );
      }
 
      case kXR_readv:
      {
        return VectorRead( *sendParams.chunkList, 0,
                           handler, sendParams.timeout );
      }
 
      case kXR_fattr:
      {
        return XAttrImpl( req->fattr.subcode, req->fattr.numattr, req->fattr.dlen,
                          msg->GetBuffer( sizeof(ClientRequestHdr ) ), handler );
      }
 
      default:
      {
        return XRootDStatus( stError, errNotSupported );
      }
    }
  }

References XrdCl::MessageSendParams::chunkList, Close(), ClientFattrRequest::dlen, ClientWriteRequest::dlen, XrdCl::errNotSupported, ClientRequest::fattr, XrdCl::Buffer::GetBuffer(), XrdCl::URL::GetURL(), XrdCl::Message::GetVirtReqID(), ClientRequest::header, kXR_close, kXR_fattr, kXR_open, kXR_read, kXR_readv, kXR_stat, kXR_sync, kXR_truncate, kXR_virtReadv, kXR_write, kXR_writev, ClientOpenRequest::mode, ClientFattrRequest::numattr, ClientReadRequest::offset, ClientTruncateRequest::offset, ClientWriteRequest::offset, Open(), ClientRequest::open, ClientOpenRequest::options, Read(), ClientRequest::read, ReadV(), ClientRequestHdr::requestid, ClientReadRequest::rlen, XrdOucIOVec::size, Stat, XrdCl::stError, ClientFattrRequest::subcode, Sync(), XrdCl::MessageSendParams::timeout, Truncate(), ClientRequest::truncate, VectorRead(), VectorWrite(), Write(), ClientRequest::write, and WriteV().

Here is the call graph for this function:

Fcntl()

XRootDStatus XrdCl::LocalFileHandler::Fcntl	(	const Buffer &	arg,
		ResponseHandler *	handler,
		uint16_t	timeout = 0 )

Performs a custom operation on an open file - async

Parameters

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 607 of file XrdClLocalFileHandler.cc.

  {
    return XRootDStatus( stError, errNotSupported );
  }

References XrdCl::errNotSupported, and XrdCl::stError.

GetHostList()

const HostList & XrdCl::LocalFileHandler::GetHostList ( )

inline

Definition at line 306 of file XrdClLocalFileHandler.hh.

      {
        return pHostList;
      }

GetXAttr()

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

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 653 of file XrdClLocalFileHandler.cc.

  {
    XrdSysXAttr *xattr = XrdSysFAttr::Xat;
    std::vector<XAttr> response;
 
    auto itr = attrs.begin();
    for( ; itr != attrs.end(); ++itr )
    {
      std::string name  = *itr;
      std::unique_ptr<char[]> buffer;
 
      int size = xattr->Get( name.c_str(), 0, 0, 0, fd );
      if( size < 0 )
      {
        XRootDStatus status( stError, errLocalError, -size );
        response.push_back( XAttr( *itr, "", status ) );
        continue;
      }
      buffer.reset( new char[size] );
      int ret = xattr->Get( name.c_str(), buffer.get(), size, 0, fd );
 
      XRootDStatus status;
      std::string  value;
 
      if( ret >= 0 )
        value.append( buffer.get(), ret );
      else if( ret < 0 )
        status = XRootDStatus( stError, errLocalError, -ret );
 
      response.push_back( XAttr( *itr, value, status ) );
    }
 
    AnyObject *resp = new AnyObject();
    resp->Set( new std::vector<XAttr>( std::move( response ) ) );
 
    return QueueTask( new XRootDStatus(), resp, handler );
  }

References XrdCl::errLocalError, XrdSysXAttr::Get(), XrdCl::NullRef< Response >::value, QueueTask(), XrdCl::AnyObject::Set(), XrdCl::stError, and XrdSysFAttr::Xat.

Here is the call graph for this function:

ListXAttr()

XRootDStatus XrdCl::LocalFileHandler::ListXAttr	(	ResponseHandler *	handler,
		uint16_t	timeout = 0 )

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 723 of file XrdClLocalFileHandler.cc.

  {
    XrdSysXAttr *xattr = XrdSysFAttr::Xat;
    std::vector<XAttr> response;
 
    XrdSysXAttr::AList *alist = 0;
    int err = xattr->List( &alist, 0, fd, 1 );
 
    if( err < 0 )
    {
      XRootDStatus *status = new XRootDStatus( stError, XProtocol::mapError( -err ) );
      return QueueTask( status, 0, handler );
    }
 
    XrdSysXAttr::AList *ptr = alist;
    while( ptr )
    {
      std::string name( ptr->Name, ptr->Nlen );
      int vlen = ptr->Vlen;
      ptr = ptr->Next;
 
      std::unique_ptr<char[]> buffer( new char[vlen] );
      int ret = xattr->Get( name.c_str(),
                            buffer.get(), vlen, 0, fd );
 
      std::string value = ret >= 0 ? std::string( buffer.get(), ret ) :
                                     std::string();
      XRootDStatus status = ret >= 0 ? XRootDStatus() :
                                       XRootDStatus( stError, errLocalError, -ret );
      response.push_back( XAttr( name, value, status ) );
    }
    xattr->Free( alist );
 
    AnyObject *resp = new AnyObject();
    resp->Set( new std::vector<XAttr>( std::move( response ) ) );
 
    return QueueTask( new XRootDStatus(), resp, handler );
  }

References XrdCl::errLocalError, XrdSysXAttr::Free(), XrdSysXAttr::Get(), XrdSysXAttr::List(), XProtocol::mapError(), XrdSysXAttr::AList::Name, XrdSysXAttr::AList::Next, XrdSysXAttr::AList::Nlen, XrdCl::NullRef< Response >::value, QueueTask(), XrdCl::AnyObject::Set(), XrdCl::stError, XrdSysXAttr::AList::Vlen, and XrdSysFAttr::Xat.

Here is the call graph for this function:

MkdirPath()

XRootDStatus XrdCl::LocalFileHandler::MkdirPath ( const std::string & path )

static

creates the directories specified in path

Parameters

path	specifies which directories are to be created

Returns

status of the mkdir system call

Definition at line 791 of file XrdClLocalFileHandler.cc.

  {
    // first find the most up-front component that exists
    size_t pos = path.rfind( '/' );
    while( pos != std::string::npos && pos != 0 )
    {
      std::string tmp = path.substr( 0, pos );
      struct stat st;
      int rc = lstat( tmp.c_str(), &st );
      if( rc == 0 ) break;
      if( errno != ENOENT )
        return XRootDStatus( stError, errLocalError, errno );
      pos = path.rfind( '/', pos - 1 );
    }
 
    pos = path.find( '/', pos + 1 );
    while( pos != std::string::npos && pos != 0 )
    {
      std::string tmp = path.substr( 0, pos );
      if( mkdir( tmp.c_str(), 0755 ) )
      {
        if( errno != EEXIST )
          return XRootDStatus( stError, errLocalError, errno );
      }
      pos = path.find( '/', pos + 1 );
    }
    return XRootDStatus();
  }

References XrdCl::errLocalError, lstat(), mkdir, stat, and XrdCl::stError.

Here is the call graph for this function:

Open() [1/2]

XRootDStatus XrdCl::LocalFileHandler::Open	(	const std::string &	url,
		uint16_t	flags,
		uint16_t	mode,
		ResponseHandler *	handler,
		uint16_t	timeout = 0 )

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 246 of file XrdClLocalFileHandler.cc.

  {
    AnyObject *resp = 0;
    XRootDStatus st = OpenImpl( url, flags, mode, resp );
    if( !st.IsOK() && st.code != errLocalError )
      return st;
 
    return QueueTask( new XRootDStatus( st ), resp, handler );
  }

References XrdCl::Status::code, XrdCl::errLocalError, XrdCl::Status::IsOK(), and QueueTask().

Referenced by ExecRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

Open() [2/2]

XRootDStatus XrdCl::LocalFileHandler::Open	(	const URL *	url,
		const Message *	req,
		AnyObject *&	resp )

Handle local redirect to given URL triggered by the given request.

Definition at line 257 of file XrdClLocalFileHandler.cc.

  {
    const ClientOpenRequest* request =
        reinterpret_cast<const ClientOpenRequest*>( req->GetBuffer() );
    uint16_t flags = ntohs( request->options );
    uint16_t mode  = ntohs( request->mode );
    return OpenImpl( url->GetURL(), flags, mode, resp );
  }

References XrdCl::Buffer::GetBuffer(), XrdCl::URL::GetURL(), ClientOpenRequest::mode, and ClientOpenRequest::options.

Here is the call graph for this function:

QueueTask()

XRootDStatus XrdCl::LocalFileHandler::QueueTask	(	XRootDStatus *	st,
		AnyObject *	obj,
		ResponseHandler *	handler )

Queues a task to the jobmanager

Parameters

st	the status of the file operation
obj	the object holding data like open-, chunk- or vreadinfo
handler	handler to be notified when the response arrives

Returns

status of the operation

Definition at line 768 of file XrdClLocalFileHandler.cc.

  {
    // if it is simply the sync handler we can release the semaphore
    // and return there is no need to execute this in the thread-pool
    SyncResponseHandler *syncHandler =
        dynamic_cast<SyncResponseHandler*>( handler );
    if( syncHandler || DefaultEnv::GetPostMaster() == nullptr )
    {
      syncHandler->HandleResponse( st, resp );
      return XRootDStatus();
    }
 
    HostList *hosts = pHostList.empty() ? 0 : new HostList( pHostList );
    LocalFileTask *task = new LocalFileTask( st, resp, hosts, handler );
    DefaultEnv::GetPostMaster()->GetJobManager()->QueueJob( task );
    return XRootDStatus();
  }

References XrdCl::PostMaster::GetJobManager(), XrdCl::DefaultEnv::GetPostMaster(), XrdCl::SyncResponseHandler::HandleResponse(), and XrdCl::JobManager::QueueJob().

Referenced by Close(), DelXAttr(), GetXAttr(), ListXAttr(), Open(), Read(), ReadV(), SetXAttr(), Stat(), Sync(), Truncate(), VectorRead(), VectorWrite(), Write(), and WriteV().

Here is the call graph for this function:

Here is the caller graph for this function:

Read()

XRootDStatus XrdCl::LocalFileHandler::Read	(	uint64_t	offset,
		uint32_t	size,
		void *	buffer,
		ResponseHandler *	handler,
		uint16_t	timeout = 0 )

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 320 of file XrdClLocalFileHandler.cc.

  {
#if defined(__APPLE__)
    Log *log = DefaultEnv::GetLog();
    int read = 0;
    if( ( read = pread( fd, buffer, size, offset ) ) == -1 )
    {
      log->Error( FileMsg, "Read: failed %s", XrdSysE2T( errno ) );
      XRootDStatus *error = new XRootDStatus( stError, errLocalError, errno );
      return QueueTask( error, 0, handler );
    }
    ChunkInfo *chunk = new ChunkInfo( offset, read, buffer );
    AnyObject *resp = new AnyObject();
    resp->Set( chunk );
    return QueueTask( new XRootDStatus(), resp, handler );
#else
    AioCtx *ctx = new AioCtx( pHostList, handler );
    ctx->SetRead( fd, offset, size, buffer );
 
    int rc = aio_read( *ctx );
 
    if( rc < 0 )
    {
      Log *log = DefaultEnv::GetLog();
      log->Error( FileMsg, "Read: failed %s", XrdSysE2T( errno ) );
      return XRootDStatus( stError, errLocalError, errno );
    }
 
    return XRootDStatus();
#endif
  }

References XrdCl::errLocalError, XrdCl::Log::Error(), XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), pread, QueueTask(), read, XrdCl::AnyObject::Set(), XrdCl::stError, and XrdSysE2T().

Referenced by ExecRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

ReadV()

XRootDStatus XrdCl::LocalFileHandler::ReadV	(	uint64_t	offset,
		struct iovec *	iov,
		int	iovcnt,
		ResponseHandler *	handler,
		uint16_t	timeout = 0 )

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 357 of file XrdClLocalFileHandler.cc.

  {
    Log *log = DefaultEnv::GetLog();
#if defined(__APPLE__)
    ssize_t ret = lseek( fd, offset, SEEK_SET );
    if( ret >= 0 )
      ret = readv( fd, iov, iovcnt );
#else
    ssize_t ret = preadv( fd, iov, iovcnt, offset );
#endif
    if( ret == -1 )
    {
      log->Error( FileMsg, "ReadV: failed %s", XrdSysE2T( errno ) );
      XRootDStatus *error = new XRootDStatus( stError, errLocalError, errno );
      return QueueTask( error, 0, handler );
    }
    VectorReadInfo *info = new VectorReadInfo();
    info->SetSize( ret );
    uint64_t choff = offset;
    uint32_t left  = ret;
    for( int i = 0; i < iovcnt; ++i )
    {
      uint32_t chlen = iov[i].iov_len;
      if( chlen > left ) chlen = left;
      info->GetChunks().emplace_back( choff, chlen, iov[i].iov_base);
      left  -= chlen;
      choff += chlen;
    }
    AnyObject *resp = new AnyObject();
    resp->Set( info );
    return QueueTask( new XRootDStatus(), resp, handler );
  }

References XrdCl::errLocalError, XrdCl::Log::Error(), XrdCl::FileMsg, XrdCl::VectorReadInfo::GetChunks(), XrdCl::DefaultEnv::GetLog(), lseek, QueueTask(), readv, XrdCl::AnyObject::Set(), XrdCl::VectorReadInfo::SetSize(), XrdCl::stError, and XrdSysE2T().

Referenced by ExecRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

SetHostList()

void XrdCl::LocalFileHandler::SetHostList ( const HostList & hostList )

inline

Definition at line 301 of file XrdClLocalFileHandler.hh.

      {
        pHostList = hostList;
      }

SetXAttr()

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

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 625 of file XrdClLocalFileHandler.cc.

  {
    XrdSysXAttr *xattr = XrdSysFAttr::Xat;
    std::vector<XAttrStatus> response;
 
    auto itr = attrs.begin();
    for( ; itr != attrs.end(); ++itr )
    {
      std::string name  = std::get<xattr_name>( *itr );
      std::string value = std::get<xattr_value>( *itr );
      int err = xattr->Set( name.c_str(), value.c_str(), value.size(), 0, fd );
      XRootDStatus status = err < 0 ? XRootDStatus( stError, errLocalError, -err ) :
                                  XRootDStatus();
 
      response.push_back( XAttrStatus( name, status ) );
    }
 
    AnyObject *resp = new AnyObject();
    resp->Set( new std::vector<XAttrStatus>( std::move( response ) ) );
 
    return QueueTask( new XRootDStatus(), resp, handler );
  }

References XrdCl::errLocalError, XrdCl::NullRef< Response >::value, QueueTask(), XrdCl::AnyObject::Set(), XrdSysXAttr::Set(), XrdCl::stError, and XrdSysFAttr::Xat.

Here is the call graph for this function:

Stat()

XRootDStatus XrdCl::LocalFileHandler::Stat	(	ResponseHandler *	handler,
		uint16_t	timeout = 0 )

Obtain status information for this file - async

Parameters

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 286 of file XrdClLocalFileHandler.cc.

  {
    Log *log = DefaultEnv::GetLog();
 
    struct stat ssp;
    if( fstat( fd, &ssp ) == -1 )
    {
      log->Error( FileMsg, "Stat: failed fd: %i %s", fd, XrdSysE2T( errno ) );
      XRootDStatus *error = new XRootDStatus( stError, errLocalError, errno );
      return QueueTask( error, 0, handler );
    }
    std::ostringstream data;
    data << ssp.st_dev << " " << ssp.st_size << " " << ssp.st_mode << " "
        << ssp.st_mtime;
    log->Debug( FileMsg, "%s", data.str().c_str() );
 
    StatInfo *statInfo = new StatInfo();
    if( !statInfo->ParseServerResponse( data.str().c_str() ) )
    {
      log->Error( FileMsg, "Stat: ParseServerResponse failed." );
      delete statInfo;
      return QueueTask( new XRootDStatus( stError, errLocalError, kXR_FSError ),
                        0, handler );
    }
 
    AnyObject *resp = new AnyObject();
    resp->Set( statInfo );
    return QueueTask( new XRootDStatus(), resp, handler );
  }

References XrdCl::Log::Debug(), XrdCl::errLocalError, XrdCl::Log::Error(), XrdCl::FileMsg, fstat, XrdCl::DefaultEnv::GetLog(), kXR_FSError, XrdCl::StatInfo::ParseServerResponse(), QueueTask(), XrdCl::AnyObject::Set(), stat, XrdCl::stError, and XrdSysE2T().

Here is the call graph for this function:

Sync()

XRootDStatus XrdCl::LocalFileHandler::Sync	(	ResponseHandler *	handler,
		uint16_t	timeout = 0 )

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 438 of file XrdClLocalFileHandler.cc.

  {
#if defined(__APPLE__)
    if( fsync( fd ) )
    {
      Log *log = DefaultEnv::GetLog();
      log->Error( FileMsg, "Sync: failed %s", XrdSysE2T( errno ) );
      XRootDStatus *error = new XRootDStatus( stError, errOSError,
                                              XProtocol::mapError( errno ),
                                              XrdSysE2T( errno ) );
      return QueueTask( error, 0, handler );
    }
    return QueueTask( new XRootDStatus(), 0, handler );
#else
    AioCtx *ctx = new AioCtx( pHostList, handler );
    ctx->SetFsync( fd );
    int rc = aio_fsync( O_SYNC, *ctx );
    if( rc < 0 )
    {
      Log *log = DefaultEnv::GetLog();
      log->Error( FileMsg, "Sync: failed %s", XrdSysE2T( errno ) );
      return XRootDStatus( stError, errLocalError, errno );
    }
#endif
    return XRootDStatus();
  }

References XrdCl::errLocalError, XrdCl::Log::Error(), XrdCl::errOSError, XrdCl::FileMsg, fsync, XrdCl::DefaultEnv::GetLog(), XProtocol::mapError(), QueueTask(), XrdCl::stError, and XrdSysE2T().

Referenced by ExecRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

Truncate()

XRootDStatus XrdCl::LocalFileHandler::Truncate	(	uint64_t	size,
		ResponseHandler *	handler,
		uint16_t	timeout = 0 )

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 469 of file XrdClLocalFileHandler.cc.

  {
    if( ftruncate( fd, size ) )
    {
      Log *log = DefaultEnv::GetLog();
      log->Error( FileMsg, "Truncate: failed, file descriptor: %i, %s", fd,
                  XrdSysE2T( errno ) );
      XRootDStatus *error = new XRootDStatus( stError, errLocalError, errno );
      return QueueTask( error, 0, handler );
    }
 
    return QueueTask( new XRootDStatus( stOK ), 0, handler );
  }

References XrdCl::errLocalError, XrdCl::Log::Error(), XrdCl::FileMsg, ftruncate, XrdCl::DefaultEnv::GetLog(), QueueTask(), XrdCl::stError, XrdCl::stOK, and XrdSysE2T().

Referenced by ExecRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

VectorRead()

XRootDStatus XrdCl::LocalFileHandler::VectorRead	(	const ChunkList &	chunks,
		void *	buffer,
		ResponseHandler *	handler,
		uint16_t	timeout = 0 )

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 487 of file XrdClLocalFileHandler.cc.

  {
    std::unique_ptr<VectorReadInfo> info( new VectorReadInfo() );
    size_t totalSize = 0;
    bool useBuffer( buffer );
 
    for( auto itr = chunks.begin(); itr != chunks.end(); ++itr )
    {
      auto &chunk = *itr;
      if( !useBuffer )
        buffer = chunk.buffer;
      ssize_t bytesRead = pread( fd, buffer, chunk.length,
                                 chunk.offset );
      if( bytesRead < 0 )
      {
        Log *log = DefaultEnv::GetLog();
        log->Error( FileMsg, "VectorRead: failed, file descriptor: %i, %s",
                    fd, XrdSysE2T( errno ) );
        XRootDStatus *error = new XRootDStatus( stError, errLocalError, errno );
        return QueueTask( error, 0, handler );
      }
      totalSize += bytesRead;
      info->GetChunks().push_back( ChunkInfo( chunk.offset, bytesRead, buffer ) );
      if( useBuffer )
        buffer = reinterpret_cast<char*>( buffer ) + bytesRead;
    }
 
    info->SetSize( totalSize );
    AnyObject *resp = new AnyObject();
    resp->Set( info.release() );
    return QueueTask( new XRootDStatus(), resp, handler );
  }

References XrdCl::errLocalError, XrdCl::Log::Error(), XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), pread, QueueTask(), XrdCl::AnyObject::Set(), XrdCl::stError, and XrdSysE2T().

Referenced by ExecRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

VectorWrite()

XRootDStatus XrdCl::LocalFileHandler::VectorWrite	(	const ChunkList &	chunks,
		ResponseHandler *	handler,
		uint16_t	timeout = 0 )

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 524 of file XrdClLocalFileHandler.cc.

  {
 
    for( auto itr = chunks.begin(); itr != chunks.end(); ++itr )
    {
      auto &chunk = *itr;
      ssize_t bytesWritten = pwrite( fd, chunk.buffer, chunk.length,
                                     chunk.offset );
      if( bytesWritten < 0 )
      {
        Log *log = DefaultEnv::GetLog();
        log->Error( FileMsg, "VectorWrite: failed, file descriptor: %i, %s",
                    fd, XrdSysE2T( errno ) );
        XRootDStatus *error = new XRootDStatus( stError, errLocalError, errno );
        return QueueTask( error, 0, handler );
      }
    }
 
    return QueueTask( new XRootDStatus(), 0, handler );
  }

References XrdCl::errLocalError, XrdCl::Log::Error(), XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), pwrite, QueueTask(), XrdCl::stError, and XrdSysE2T().

Referenced by ExecRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

Visa()

XRootDStatus XrdCl::LocalFileHandler::Visa	(	ResponseHandler *	handler,
		uint16_t	timeout = 0 )

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 616 of file XrdClLocalFileHandler.cc.

  {
    return XRootDStatus( stError, errNotSupported );
  }

References XrdCl::errNotSupported, and XrdCl::stError.

Write()

XRootDStatus XrdCl::LocalFileHandler::Write	(	uint64_t	offset,
		uint32_t	size,
		const void *	buffer,
		ResponseHandler *	handler,
		uint16_t	timeout = 0 )

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 397 of file XrdClLocalFileHandler.cc.

  {
#if defined(__APPLE__)
    const char *buff = reinterpret_cast<const char*>( buffer );
    size_t bytesWritten = 0;
    while( bytesWritten < size )
    {
      ssize_t ret = pwrite( fd, buff, size, offset );
      if( ret < 0 )
      {
        Log *log = DefaultEnv::GetLog();
        log->Error( FileMsg, "Write: failed %s", XrdSysE2T( errno ) );
        XRootDStatus *error = new XRootDStatus( stError, errLocalError, errno );
        return QueueTask( error, 0, handler );
      }
      offset += ret;
      buff += ret;
      bytesWritten += ret;
    }
    return QueueTask( new XRootDStatus(), 0, handler );
#else
    AioCtx *ctx = new AioCtx( pHostList, handler );
    ctx->SetWrite( fd, offset, size, buffer );
 
    int rc = aio_write( *ctx );
 
    if( rc < 0 )
    {
      Log *log = DefaultEnv::GetLog();
      log->Error( FileMsg, "Write: failed %s", XrdSysE2T( errno ) );
      return XRootDStatus( stError, errLocalError, errno );
    }
 
    return XRootDStatus();
#endif
  }

References XrdCl::errLocalError, XrdCl::Log::Error(), XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), pwrite, QueueTask(), XrdCl::stError, and XrdSysE2T().

Referenced by ExecRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

WriteV()

XRootDStatus XrdCl::LocalFileHandler::WriteV	(	uint64_t	offset,
		ChunkList *	chunks,
		ResponseHandler *	handler,
		uint16_t	timeout = 0 )

Write scattered buffers in one operation - async

Parameters

offset	offset from the beginning of the file
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 549 of file XrdClLocalFileHandler.cc.

  {
    size_t iovcnt = chunks->size();
    iovec iovcp[iovcnt];
    ssize_t size = 0;
    for( size_t i = 0; i < iovcnt; ++i )
    {
      iovcp[i].iov_base = (*chunks)[i].buffer;
      iovcp[i].iov_len  = (*chunks)[i].length;
      size += (*chunks)[i].length;
    }
    iovec *iovptr = iovcp;
 
    ssize_t bytesWritten = 0;
    while( bytesWritten < size )
    {
#ifdef __APPLE__
      ssize_t ret = lseek( fd, offset, SEEK_SET );
      if( ret >= 0 )
        ret = writev( fd, iovptr, iovcnt );
#else
      ssize_t ret = pwritev( fd, iovptr, iovcnt, offset );
#endif
      if( ret < 0 )
      {
        Log *log = DefaultEnv::GetLog();
        log->Error( FileMsg, "WriteV: failed %s", XrdSysE2T( errno ) );
        XRootDStatus *error = new XRootDStatus( stError, errLocalError, errno );
        return QueueTask( error, 0, handler );
      }
 
      bytesWritten += ret;
      while( ret )
      {
        if( size_t( ret ) > iovptr[0].iov_len )
        {
          ret -= iovptr[0].iov_len;
          --iovcnt;
          ++iovptr;
        }
        else
        {
          iovptr[0].iov_len -= ret;
          iovptr[0].iov_base = reinterpret_cast<char*>( iovptr[0].iov_base ) + ret;
          ret = 0;
        }
      }
    }
 
    return QueueTask( new XRootDStatus(), 0, handler );
  }

References XrdCl::errLocalError, XrdCl::Log::Error(), XrdCl::FileMsg, XrdCl::DefaultEnv::GetLog(), lseek, QueueTask(), XrdCl::stError, writev, and XrdSysE2T().

Referenced by ExecRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• XrdClLocalFileHandler.hh
• XrdClLocalFileHandler.cc