XrdFile Class Reference

#include <XrdFile.h>

Inheritance diagram for XrdFile:

Public Member Functions
virtual void	abort (void)
void	close (void) override
virtual void	create (const char *name, bool exclusive=false, int perms=0666)
virtual void	create (const std::string &name, bool exclusive=false, int perms=0666)
virtual void	open (const char *name, int flags=IOFlags::OpenRead, int perms=0666)
virtual void	open (const std::string &name, int flags=IOFlags::OpenRead, int perms=0666)
IOOffset	position (IOOffset offset, Relative whence=SET) override
bool	prefetch (const IOPosBuffer *what, IOSize n) override
IOSize	read (void *into, IOSize n) override
IOSize	read (void *into, IOSize n, IOOffset pos) override
IOSize	readv (IOBuffer *into, IOSize n) override
IOSize	readv (IOPosBuffer *into, IOSize n) override
void	resize (IOOffset size) override
IOSize	write (const void *from, IOSize n) override
IOSize	write (const void *from, IOSize n, IOOffset pos) override
	XrdFile (void)
	XrdFile (IOFD fd)
	XrdFile (const char *name, int flags=IOFlags::OpenRead, int perms=0666)
	XrdFile (const std::string &name, int flags=IOFlags::OpenRead, int perms=0666)
	~XrdFile (void) override
Public Member Functions inherited from Storage
virtual bool	eof (void) const
virtual void	flush (void)
virtual IOOffset	position (void) const
IOSize	read (IOBuffer into, IOOffset pos)
virtual void	rewind (void)
virtual IOOffset	size (void) const
	Storage (void)
IOSize	write (IOBuffer from, IOOffset pos)
virtual IOSize	writev (const IOPosBuffer *from, IOSize buffers)
	~Storage (void) override
Public Member Functions inherited from IOInput
int	read (void)
IOSize	read (IOBuffer into)
IOSize	xread (IOBuffer into)
IOSize	xread (void *into, IOSize n)
IOSize	xreadv (IOBuffer *into, IOSize buffers)
virtual	~IOInput (void)
	Destruct the stream. A no-op. More...
Public Member Functions inherited from IOOutput
IOSize	write (unsigned char byte)
IOSize	write (IOBuffer from)
virtual IOSize	writev (const IOBuffer *from, IOSize buffers)
IOSize	xwrite (const void *from, IOSize n)
IOSize	xwrite (IOBuffer from)
IOSize	xwritev (const IOBuffer *from, IOSize buffers)
virtual	~IOOutput (void)
	Destruct the stream. A no-op. More...

Private Member Functions
void	addConnection (cms::Exception &)
std::shared_ptr< XrdCl::File >	getActiveFile ()

Private Attributes
bool	m_close
std::string	m_name
IOOffset	m_offset
std::atomic< unsigned int >	m_op_count
edm::propagate_const< std::shared_ptr< XrdAdaptor::RequestManager > >	m_requestmanager
IOOffset	m_size

Additional Inherited Members
Public Types inherited from Storage
enum	Relative { SET, CURRENT, END }

Detailed Description

Definition at line 17 of file XrdFile.h.

Constructor & Destructor Documentation

XrdFile::XrdFile

(

void

)

Definition at line 22 of file XrdFile.cc.

  :  m_offset (0),
    m_size(-1),
    m_close (false),
    m_name(),
    m_op_count(0)
{
}

XrdFile::XrdFile

(

IOFD

fd

)

XrdFile::XrdFile	(	const char *	name,
		int	flags = IOFlags::OpenRead,
		int	perms = 0666
	)

Definition at line 31 of file XrdFile.cc.

References open().

  : m_offset (0),
    m_size(-1),
    m_close (false),
    m_name(),
    m_op_count(0)
{
  open (name, flags, perms);
}

XrdFile::XrdFile	(	const std::string &	name,
		int	flags = IOFlags::OpenRead,
		int	perms = 0666
	)

Definition at line 43 of file XrdFile.cc.

References flags, and open().

  : m_offset (0),
    m_size(-1),
    m_close (false),
    m_name(),
    m_op_count(0)
{
  open (name.c_str (), flags, perms);
}

XrdFile::~XrdFile ( void  )

override

Definition at line 55 of file XrdFile.cc.

References m_close, and m_name.

{
  if (m_close)
    edm::LogError("XrdFileError")
      << "Destructor called on XROOTD file '" << m_name
      << "' but the file is still open";
}

Member Function Documentation

void XrdFile::abort ( void  )

virtual

Definition at line 216 of file XrdFile.cc.

References m_close, m_offset, m_requestmanager, and m_size.

{
  m_requestmanager = nullptr; // propagate_const<T> has no reset() function
  m_close = false;
  m_offset = 0;
  m_size = -1;
}

void XrdFile::addConnection ( cms::Exception &  ex )

private

Definition at line 615 of file XrdFile.cc.

References edm::propagate_const< T >::get(), and m_requestmanager.

Referenced by open(), position(), read(), resize(), and write().

{
  if (m_requestmanager.get())
  {
    m_requestmanager->addConnections(ex);
  }
}

void XrdFile::close ( void  )

overridevirtual

Reimplemented from Storage.

Definition at line 196 of file XrdFile.cc.

References edm::propagate_const< T >::get(), m_close, m_name, m_offset, m_requestmanager, and m_size.

Referenced by lumiQTWidget.ApplicationWindow::fileQuit(), esMonitoring.AsyncLineReaderMixin::handle_close(), esMonitoring.FDJsonServer::handle_close(), Vispa.Gui.BoxContentDialog.BoxContentDialog::keyPressEvent(), and Vispa.Gui.FindDialog.FindDialog::keyPressEvent().

{
  if (! m_requestmanager.get())
  {
    edm::LogError("XrdFileError")
      << "XrdFile::close(name='" << m_name
      << "') called but the file is not open";
    m_close = false;
    return;
  }

  m_requestmanager = nullptr; // propagate_const<T> has no reset() function

  m_close = false;
  m_offset = 0;
  m_size = -1;
  edm::LogInfo("XrdFileInfo") << "Closed " << m_name;
}

void XrdFile::create ( const char *  name, bool  exclusive = false, int  perms = 0666  )

virtual

Definition at line 65 of file XrdFile.cc.

References open(), IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenTruncate, and IOFlags::OpenWrite.

{
  open (name,
        (IOFlags::OpenCreate | IOFlags::OpenWrite | IOFlags::OpenTruncate
         | (exclusive ? IOFlags::OpenExclusive : 0)),
        perms);
}

void XrdFile::create ( const std::string &  name, bool  exclusive = false, int  perms = 0666  )

virtual

Definition at line 76 of file XrdFile.cc.

References open(), IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenTruncate, and IOFlags::OpenWrite.

{
  open (name.c_str (),
        (IOFlags::OpenCreate | IOFlags::OpenWrite | IOFlags::OpenTruncate
         | (exclusive ? IOFlags::OpenExclusive : 0)),
        perms);
}

std::shared_ptr< XrdCl::File > XrdFile::getActiveFile ( void  )

private

Returns a file handle from one of the active sources. Verifies the file is open and throws an exception as necessary.

Definition at line 600 of file XrdFile.cc.

References cms::Exception::addContext(), edm::propagate_const< T >::get(), m_close, m_name, and m_requestmanager.

Referenced by open(), and write().

{ 
  if (!m_requestmanager.get())
  { 
    cms::Exception ex("XrdFileLogicError");
    ex << "Xrd::getActiveFile(name='" << m_name << "') no active request manager";
    ex.addContext("Calling XrdFile::getActiveFile()");
    m_requestmanager->addConnections(ex);
    m_close = false;
    throw ex;
  }
  return m_requestmanager->getActiveFile();
}

void XrdFile::open ( const char *  name, int  flags = IOFlags::OpenRead, int  perms = 0666  )

virtual

Definition at line 93 of file XrdFile.cc.

References addConnection(), cms::Exception::addContext(), FrontierConditions_GlobalTag_cff::file, edm::errors::FileOpenError, getActiveFile(), m_close, m_name, m_offset, m_requestmanager, m_size, dataset::name, None, IOFlags::OpenAppend, IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenRead, IOFlags::OpenTruncate, IOFlags::OpenWrite, and mps_update::status.

Referenced by create(), open(), and XrdFile().

{
  // Actual open
  if ((name == nullptr) || (*name == 0)) {
    edm::Exception ex(edm::errors::FileOpenError);
    ex << "Cannot open a file without a name";
    ex.addContext("Calling XrdFile::open()");
    throw ex;
  }
  if ((flags & (IOFlags::OpenRead | IOFlags::OpenWrite)) == 0) {
    edm::Exception ex(edm::errors::FileOpenError);
    ex << "Must open file '" << name << "' at least for read or write";
    ex.addContext("Calling XrdFile::open()");
    throw ex;
  }

  // Translate our flags to system flags
  XrdCl::OpenFlags::Flags openflags = XrdCl::OpenFlags::None;

  if (flags & IOFlags::OpenWrite)
    openflags |= XrdCl::OpenFlags::Update;
  else if (flags & IOFlags::OpenRead)
    openflags |= XrdCl::OpenFlags::Read;

  if (flags & IOFlags::OpenAppend) {
    edm::Exception ex(edm::errors::FileOpenError);
    ex << "Opening file '" << name << "' in append mode not supported";
    ex.addContext("Calling XrdFile::open()");
    throw ex;
  }

  if (flags & IOFlags::OpenCreate)
  {
    if (! (flags & IOFlags::OpenExclusive))
      openflags |= XrdCl::OpenFlags::Delete;
    openflags |= XrdCl::OpenFlags::New;
    openflags |= XrdCl::OpenFlags::MakePath;
  }

  if ((flags & IOFlags::OpenTruncate) && (flags & IOFlags::OpenWrite))
    openflags |= XrdCl::OpenFlags::Delete;

  // Translate mode flags
  XrdCl::Access::Mode modeflags = XrdCl::Access::None;
  modeflags |= (perms & S_IRUSR) ? XrdCl::Access::UR : XrdCl::Access::None;
  modeflags |= (perms & S_IWUSR) ? XrdCl::Access::UW : XrdCl::Access::None;
  modeflags |= (perms & S_IXUSR) ? XrdCl::Access::UX : XrdCl::Access::None;
  modeflags |= (perms & S_IRGRP) ? XrdCl::Access::GR : XrdCl::Access::None;
  modeflags |= (perms & S_IWGRP) ? XrdCl::Access::GW : XrdCl::Access::None;
  modeflags |= (perms & S_IXGRP) ? XrdCl::Access::GX : XrdCl::Access::None;
  modeflags |= (perms & S_IROTH) ? XrdCl::Access::GR : XrdCl::Access::None;
  modeflags |= (perms & S_IWOTH) ? XrdCl::Access::GW : XrdCl::Access::None;
  modeflags |= (perms & S_IXOTH) ? XrdCl::Access::GX : XrdCl::Access::None;

  m_requestmanager = RequestManager::getInstance(name, openflags, modeflags);
  m_name = name;

  // Stat the file so we can keep track of the offset better.
  auto file = getActiveFile();
  XrdCl::XRootDStatus status;
  XrdCl::StatInfo *statInfo = nullptr;
  if (! (status = file->Stat(false, statInfo)).IsOK()) {
    edm::Exception ex(edm::errors::FileOpenError);
    ex << "XrdCl::File::Stat(name='" << name
       << ") => error '" << status.ToStr()
       << "' (errno=" << status.errNo << ", code=" << status.code << ")";
    ex.addContext("Calling XrdFile::open()");
    addConnection(ex);
    throw ex;
  }
  assert(statInfo);
  m_size = statInfo->GetSize();
  delete(statInfo);

  m_offset = 0;
  m_close = true;

  // Send the monitoring info, if available.
  // Note: getenv is not reentrant.
  // Commenting out until this is available in the new client.
/*
  char * crabJobId = getenv(kCrabJobIdEnv);
  if (crabJobId) {
    kXR_unt32 dictId;
    m_file->SendMonitoringInfo(crabJobId, &dictId);
    edm::LogInfo("XrdFileInfo") << "Set monitoring ID to " << crabJobId << " with resulting dictId " << dictId << ".";
  }
*/

  edm::LogInfo("XrdFileInfo") << "Opened " << m_name;

  std::vector<std::string> sources;
  m_requestmanager->getActiveSourceNames(sources);
  std::stringstream ss;
  ss << "Active sources: ";
  for (auto const& it : sources)
    ss << it << ", ";
  edm::LogInfo("XrdFileInfo") << ss.str();
}

void XrdFile::open ( const std::string &  name, int  flags = IOFlags::OpenRead, int  perms = 0666  )

virtual

Definition at line 87 of file XrdFile.cc.

References flags, and open().

{ open (name.c_str (), flags, perms); }

IOOffset XrdFile::position ( IOOffset  offset, Relative  whence = SET  )

overridevirtual

Implements Storage.

Definition at line 547 of file XrdFile.cc.

References addConnection(), cms::Exception::addContext(), Storage::CURRENT, Storage::END, edm::propagate_const< T >::get(), m_offset, m_requestmanager, m_size, PFRecoTauDiscriminationByIsolation_cfi::offset, and Storage::SET.

{
  if (! m_requestmanager.get()) {
    cms::Exception ex("FilePositionError");
    ex << "XrdFile::position() called on a closed file";
    ex.addContext("Calling XrdFile::position()");
    addConnection(ex);
    throw ex;
  }
  switch (whence)
  {
  case SET:
    m_offset = offset;
    break;

  case CURRENT:
    m_offset += offset;
    break;

  // TODO: None of this works with concurrent writers to the file.
  case END:
    assert(m_size != -1);
    m_offset = m_size + offset;
    break;

  default:
    cms::Exception ex("FilePositionError");
    ex << "XrdFile::position() called with incorrect 'whence' parameter";
    ex.addContext("Calling XrdFile::position()");
    addConnection(ex);
    throw ex;
  }

  if (m_offset < 0)
    m_offset = 0;
  assert(m_size != -1);
  if (m_offset > m_size)
    m_size = m_offset;

  return m_offset;
}

bool XrdFile::prefetch ( const IOPosBuffer *  what, IOSize  n  )

overridevirtual

Reimplemented from Storage.

Definition at line 536 of file XrdFile.cc.

{
  // The new Xrootd client does not contain any internal buffers.
  // Hence, prefetching is disabled completely.
  return false;
}

IOSize XrdFile::read ( void *  into, IOSize  n  )

overridevirtual

Read into into at most n number of bytes.

If this is a blocking stream, the call will block until some data can be read, end of input is reached, or an exception is thrown. For a non-blocking stream the available input is returned. If none is available, an exception is thrown.

Returns

The number of bytes actually read. This is less or equal to the size of the buffer. Zero indicates that the end of the input has been reached: end of file, or remote end closing for a connected channel like a pipe or a socket. Otherwise the value can be less than requested if limited amount of input is currently available for platform or implementation reasons.

Exceptions

In	case of error, a #IOError exception is thrown. This includes the situation where the input stream is in non-blocking mode and no input is currently available (FIXME: make this simpler; clarify which exception).

Implements IOInput.

Definition at line 226 of file XrdFile.cc.

References addConnection(), cms::Exception::addContext(), edm::errors::FileReadError, edm::propagate_const< T >::get(), m_name, m_offset, and m_requestmanager.

{
  if (n > 0x7fffffff) {
    edm::Exception ex(edm::errors::FileReadError);
    ex << "XrdFile::read(name='" << m_name << "', n=" << n
       << ") too many bytes, limit is 0x7fffffff";
    ex.addContext("Calling XrdFile::read()");
    addConnection(ex);
    throw ex;
  }

  uint32_t bytesRead = m_requestmanager->handle(into, n, m_offset).get();
  m_offset += bytesRead;
  return bytesRead;
}

IOSize XrdFile::read ( void *  into, IOSize  n, IOOffset  pos  )

overridevirtual

Reimplemented from Storage.

Definition at line 243 of file XrdFile.cc.

References addConnection(), cms::Exception::addContext(), edm::errors::FileReadError, m_name, m_requestmanager, min(), eostools::move(), mps_fire::result, and XRD_CL_MAX_READ_SIZE.

{
  if (n > 0x7fffffff) {
    edm::Exception ex(edm::errors::FileReadError);
    ex << "XrdFile::read(name='" << m_name << "', n=" << n
       << ") exceeds read size limit 0x7fffffff";
    ex.addContext("Calling XrdFile::read()");
    addConnection(ex);
    throw ex;
  }
  if (n == 0) {
    return 0;
  }

  // In some cases, the IO layers above us (particularly, if lazy-download is
  // enabled) will emit very large reads.  We break this up into multiple
  // reads in order to avoid hitting timeouts.
  std::future<IOSize> prev_future, cur_future;
  IOSize bytesRead = 0, prev_future_expected = 0, cur_future_expected = 0;
  bool readReturnedShort = false;

  // Check the status of a read operation; updates bytesRead and
  // readReturnedShort.
  auto check_read = [&](std::future<IOSize> &future, IOSize expected) {
    if (!future.valid()) {
      return;
    }
    IOSize result = future.get();
    if (readReturnedShort && (result != 0)) {
      edm::Exception ex(edm::errors::FileReadError);
      ex << "XrdFile::read(name='" << m_name << "', n=" << n
         << ") remote server returned non-zero length read after EOF.";
      ex.addContext("Calling XrdFile::read()");
      addConnection(ex);
      throw ex;
    } else if (result != expected) {
        readReturnedShort = true;
    }
    bytesRead += result;
  };

  while (n) {
    IOSize chunk = std::min(n, static_cast<IOSize>(XRD_CL_MAX_READ_SIZE));

    // Save prior read state; issue new read.
    prev_future = std::move(cur_future);
    prev_future_expected = cur_future_expected;
    cur_future = m_requestmanager->handle(into, chunk, pos);
    cur_future_expected = chunk;

    // Wait for the prior read; update bytesRead.
    check_read(prev_future, prev_future_expected);

    // Update counters.
    into = static_cast<char*>(into) + chunk;
    n -= chunk;
    pos += chunk;
  }

  // Wait for the last read to finish.
  check_read(cur_future, cur_future_expected);

  return bytesRead;
}

IOSize XrdFile::readv ( IOBuffer *  into, IOSize  buffers  )

overridevirtual

Read from the input stream into multiple scattered buffers. There are buffers to fill in an array starting at into; the memory those buffers occupy does not need to be contiguous. The buffers are filled in the order given, eac buffer is filled fully before the subsequent buffers.

If this is a blocking stream, the call will block until some data can be read, end of input is reached, or an exception is thrown. For a non-blocking stream the available input is returned. If none is available, an exception is thrown.

The base class implementation uses read(void *, IOSize) method, but derived classes may implement a more efficient alternative.

Returns

The number of bytes actually read. This is less or equal to the size of the buffer. Zero indicates that the end of the input has been reached: end of file, or remote end closing for a connected channel like a pipe or a socket. Otherwise the value can be less than requested if limited amount of input is currently available for platform or implementation reasons. Note that the return value indicates the number of bytes read, not the number of buffers; it is the sum total of bytes filled into all the buffers.

Exceptions

In

case of error, a #IOError exception is thrown. However if some data has already been read, the error is swallowed and the method returns the data read so far. It is assumed that persistent errors will occur anyway on the next read and sporadic errors like stream becoming unvailable can be ignored. Use xread() if a different policy is desirable.

Reimplemented from IOInput.

Definition at line 310 of file XrdFile.cc.

References data, mps_fire::i, gen::n, IOBuffer::size(), and Storage::size().

{
  std::vector<IOPosBuffer> new_buf;
  new_buf.reserve(n);
  IOOffset off = 0;
  for (IOSize i=0; i<n; i++) {
    IOSize size = into[i].size();
    new_buf[i] = IOPosBuffer(off, into[i].data(), size);
    off += size;
  }
  return readv(&(new_buf[0]), n);
}

IOSize XrdFile::readv ( IOPosBuffer *  into, IOSize  n  )

overridevirtual

Reimplemented from Storage.

Definition at line 328 of file XrdFile.cc.

References cms::Exception::addContext(), edmScanValgrind::buffer, GetRecoTauVFromDQM_MC_cff::cl, KineDebug3::count(), IOPosBuffer::data(), data, end, cppFunctionSkipper::exception, edm::propagate_const< T >::get(), XrdAdaptor::XrootdException::getCode(), training_settings::idx, m_op_count, m_requestmanager, cmsPerfSuiteHarvest::now, IOPosBuffer::offset(), PFRecoTauDiscriminationByIsolation_cfi::offset, IOInput::read(), mps_fire::result, IOPosBuffer::set_data(), IOPosBuffer::set_offset(), IOPosBuffer::set_size(), IOPosBuffer::size(), Storage::size(), command_line::start, edm::errors::StdException, UNLIKELY, cms::Exception::what(), XRD_CL_MAX_CHUNK, and XRD_CL_MAX_SIZE.

{
  // A trivial vector read - unlikely, considering ROOT data format.
  if (UNLIKELY(n == 0)) {
    return 0;
  }
  if (UNLIKELY(n == 1)) {
    return read(into[0].data(), into[0].size(), into[0].offset());
  }

  auto cl = std::make_shared<std::vector<IOPosBuffer>>();

  // CMSSW may issue large readv's; Xrootd is only able to handle
  // 1024.  Further, the splitting algorithm may slightly increase
  // the number of buffers.
  IOSize adjust = XRD_CL_MAX_SIZE - 2;
  cl->reserve(n > adjust ? adjust : n);
  IOSize idx = 0, last_idx = 0;
  IOSize final_result = 0;
  std::vector<std::pair<std::future<IOSize>, IOSize>> readv_futures;
  while (idx < n)
  {
    cl->clear();
    IOSize size = 0;
    while (idx < n) {
      unsigned rollback_count = 1;
      IOSize current_size = size;
      IOOffset offset = into[idx].offset();
      IOSize length = into[idx].size();
      size += length;
      char * buffer = static_cast<char *>(into[idx].data());
      while (length > XRD_CL_MAX_CHUNK) {
        IOPosBuffer ci;
        ci.set_size(XRD_CL_MAX_CHUNK);
        length -= XRD_CL_MAX_CHUNK;
        ci.set_offset(offset);
        offset += XRD_CL_MAX_CHUNK;
        ci.set_data(buffer);
        buffer += XRD_CL_MAX_CHUNK;
        cl->emplace_back(ci);
        rollback_count ++;
      }
      IOPosBuffer ci;
      ci.set_size(length);
      ci.set_offset(offset);
      ci.set_data(buffer);
      cl->emplace_back(ci);

      if (cl->size() > adjust)
      {
        while (rollback_count--) cl->pop_back();
        size = current_size;
        break;
      }
      else
      {
        idx++;
      }
    }
    try
    {
      readv_futures.emplace_back(m_requestmanager->handle(cl), size);
    }
    catch (edm::Exception& ex)
    {
      ex.addContext("Calling XrdFile::readv()");
      throw;
    }

    // Assure that we have made some progress.
    assert(last_idx < idx);
    last_idx = idx;

  }
  std::chrono::time_point<std::chrono::high_resolution_clock> start, end;
  start = std::chrono::high_resolution_clock::now();

    // If there are multiple readv calls, wait until all return until looking
    // at the results of any.  This guarantees that all readv's have finished
    // by time we call .get() for the first time (in case one of the readv's
    // result in an exception).
    //
    // We cannot have outstanding readv's on function exit as the XrdCl may
    // write into the corresponding buffer at the same time as ROOT.
  if (readv_futures.size() > 1)
  {
    for (auto & readv_result : readv_futures)
    {
      if (readv_result.first.valid())
      {
        readv_result.first.wait();
      }
    }
  }

  for (auto & readv_result : readv_futures)
  {
    IOSize result = 0;
    try
    {
      const int retry_count = 5;
      for (int retries=0; retries<retry_count; retries++)
      {
        try
        {
          if (readv_result.first.valid())
          {
            result = readv_result.first.get();
          }
        }
        catch (XrootdException& ex)
        {
          if ((retries != retry_count-1) && (ex.getCode() == XrdCl::errInvalidResponse))
          {
            edm::LogWarning("XrdAdaptorInternal") << "Got an invalid response from Xrootd server; retrying" << std::endl;
            result = m_requestmanager->handle(cl).get();
          }
          else
          {
            throw;
          }
        }
        assert(result == readv_result.second);
      }
    }
    catch (edm::Exception& ex)
    {
      ex.addContext("Calling XrdFile::readv()");
      throw;
    }
    catch (std::exception& ex)
    {
      edm::Exception newex(edm::errors::StdException);
      newex << "A std::exception was thrown when processing an xrootd request: " << ex.what();
      newex.addContext("Calling XrdFile::readv()");
      throw newex;
    }
    final_result += result;
  }
  end = std::chrono::high_resolution_clock::now();

  edm::LogVerbatim("XrdAdaptorInternal") << "[" << m_op_count.fetch_add(1) << "] Time for readv: " << static_cast<int>(std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count()) << " (sub-readv requests: " << readv_futures.size() << ")" << std::endl;

  return final_result;
}

void XrdFile::resize ( IOOffset  size )

overridevirtual

Implements Storage.

Definition at line 590 of file XrdFile.cc.

References addConnection(), cms::Exception::addContext(), and m_name.

Referenced by Vispa.Gui.TextDialog.TextDialog::__init__(), Vispa.Plugins.ConfigEditor.ToolDialog.ToolDialog::__init__(), Vispa.Main.MainWindow.MainWindow::_loadIni(), and Vispa.Gui.PortConnection.PointToPointConnection::updateConnection().

{
  cms::Exception ex("FileResizeError");
  ex << "XrdFile::resize(name='" << m_name << "') not implemented";
  ex.addContext("Calling XrdFile::resize()");
  addConnection(ex);
  throw ex;
}

IOSize XrdFile::write ( const void *  from, IOSize  n  )

overridevirtual

Write n bytes of data starting at address from.

Returns

The number of bytes written. Normally this will be n, but can be less, even zero, for example if the stream is non-blocking mode and cannot accept input at this time.

Exceptions

In	case of error, an exception is thrown. However if the stream is in non-blocking mode and cannot accept output, it will not throw an exception – the return value will be less than requested.

Implements IOOutput.

Definition at line 475 of file XrdFile.cc.

References addConnection(), cms::Exception::addContext(), FrontierConditions_GlobalTag_cff::file, edm::errors::FileWriteError, getActiveFile(), m_name, m_offset, m_size, gen::n, and alignCSCRings::s.

{
  if (n > 0x7fffffff) {
    edm::Exception ex(edm::errors::FileWriteError);
    ex << "XrdFile::write(name='" << m_name << "', n=" << n
       << ") too many bytes, limit is 0x7fffffff";
    ex.addContext("Calling XrdFile::write()");
    addConnection(ex);
    throw ex;
  }
  auto file = getActiveFile();

  XrdCl::XRootDStatus s = file->Write(m_offset, n, from);
  if (!s.IsOK()) {
    edm::Exception ex(edm::errors::FileWriteError);
    ex << "XrdFile::write(name='" << m_name << "', n=" << n
       << ") failed with error '" << s.ToStr()
       << "' (errno=" << s.errNo << ", code=" << s.code << ")";
    ex.addContext("Calling XrdFile::write()");
    addConnection(ex);
    throw ex;
  }
  m_offset += n;
  assert(m_size != -1);
  if (m_offset > m_size)
    m_size = m_offset;

  return n;
}

IOSize XrdFile::write ( const void *  from, IOSize  n, IOOffset  pos  )

overridevirtual

Reimplemented from Storage.

Definition at line 506 of file XrdFile.cc.

References addConnection(), cms::Exception::addContext(), FrontierConditions_GlobalTag_cff::file, edm::errors::FileWriteError, getActiveFile(), m_name, m_size, gen::n, and alignCSCRings::s.

{
  if (n > 0x7fffffff) {
    edm::Exception ex(edm::errors::FileWriteError);
    ex << "XrdFile::write(name='" << m_name << "', n=" << n
       << ") too many bytes, limit is 0x7fffffff";
    ex.addContext("Calling XrdFile::write()");
    addConnection(ex);
    throw ex;
  }
  auto file = getActiveFile();

  XrdCl::XRootDStatus s = file->Write(pos, n, from);
  if (!s.IsOK()) {
    edm::Exception ex(edm::errors::FileWriteError);
    ex << "XrdFile::write(name='" << m_name << "', n=" << n
       << ") failed with error '" << s.ToStr()
       << "' (errno=" << s.errNo << ", code=" << s.code << ")";
    ex.addContext("Calling XrdFile::write()");
    addConnection(ex);
    throw ex;
  }
  assert (m_size != -1);
  if (static_cast<IOOffset>(pos + n) > m_size)
    m_size = pos + n;

  return n;
}

Member Data Documentation

bool XrdFile::m_close

private

Definition at line 71 of file XrdFile.h.

Referenced by abort(), close(), getActiveFile(), open(), and ~XrdFile().

std::string XrdFile::m_name

private

Definition at line 72 of file XrdFile.h.

Referenced by close(), getActiveFile(), open(), read(), resize(), write(), and ~XrdFile().

IOOffset XrdFile::m_offset

private

Definition at line 69 of file XrdFile.h.

Referenced by abort(), close(), open(), position(), read(), and write().

std::atomic<unsigned int> XrdFile::m_op_count

private

Definition at line 73 of file XrdFile.h.

Referenced by readv().

edm::propagate_const<std::shared_ptr<XrdAdaptor::RequestManager> > XrdFile::m_requestmanager

private

Definition at line 68 of file XrdFile.h.

Referenced by abort(), addConnection(), close(), getActiveFile(), open(), position(), read(), and readv().

IOOffset XrdFile::m_size

private

Definition at line 70 of file XrdFile.h.

Referenced by abort(), close(), open(), position(), and write().