#include <DavixFile.h>

Inheritance diagram for DavixFile:

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)

	DavixFile (void)

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

	DavixFile (const std::string &name, int flags=IOFlags::OpenRead, 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

IOSize	read (void *into, IOSize n) override

IOSize	readv (IOBuffer *into, IOSize buffers) override

IOSize	readv (IOPosBuffer *into, IOSize buffers) override

void	resize (IOOffset size) override

IOSize	write (const void *from, IOSize n) override

	~DavixFile (void) override

Public Member Functions inherited from Storage
virtual bool	eof (void) const

virtual void	flush (void)

virtual IOOffset	position (void) const

virtual bool	prefetch (const IOPosBuffer *what, IOSize n)

virtual IOSize	read (void *into, IOSize n, IOOffset pos)

IOSize	read (IOBuffer into, IOOffset pos)

virtual void	rewind (void)

virtual IOOffset	size (void) const

	Storage (void)

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

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...

Static Public Member Functions
static void	configureDavixLogLevel ()

Private Attributes
std::unique_ptr< Davix::DavPosix >	m_davixPosix

Davix_fd *	m_fd

std::string	m_name

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

Detailed Description

Definition at line 8 of file DavixFile.h.

Constructor & Destructor Documentation

DavixFile::DavixFile ( void )

Definition at line 18 of file DavixFile.cc.

18 {}

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

Definition at line 20 of file DavixFile.cc.

                                                                {
   open(name, flags, perms);
 }

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

Definition at line 24 of file DavixFile.cc.

References flags.

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

DavixFile::~DavixFile ( void )

override

Definition at line 29 of file DavixFile.cc.

                           {
   close();
   return;
 }

Member Function Documentation

void DavixFile::abort ( void )

virtual

Definition at line 52 of file DavixFile.cc.

References cms::Exception::addContext().

                           {
   if (m_davixPosix && m_fd) {
     DavixError *err = nullptr;
     m_davixPosix->close(m_fd, &err);
     if (err) {
       std::unique_ptr<DavixError> davixErrManaged(err);
       cms::Exception ex("FileAbortError");
       ex << "Davix::abort(name='" << m_name << ") failed with error "
          << err->getErrMsg().c_str() << " and error code " << err->getStatus();
       ex.addContext("Calling DavixFile::abort()");
       throw ex;
     }
   }
   return;
 }

void DavixFile::close ( void )

overridevirtual

Reimplemented from Storage.

Definition at line 34 of file DavixFile.cc.

References cms::Exception::addContext(), and eostools::move().

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_davixPosix && m_fd) {
     auto davixPosix = std::move(m_davixPosix);
     DavixError *err = nullptr;
     davixPosix->close(m_fd, &err);
     m_fd = nullptr;
     if (err) {
       std::unique_ptr<DavixError> davixErrManaged(err);
       cms::Exception ex("FileCloseError");
       ex << "Davix::close(name='" << m_name << ") failed with error "
          << err->getErrMsg().c_str() << " and error code " << err->getStatus();
       ex.addContext("Calling DavixFile::close()");
       throw ex;
     }
   }
   return;
 }

void DavixFile::configureDavixLogLevel ( )

static

Definition at line 68 of file DavixFile.cc.

References davixDebugInit.

                                        {
   long logLevel = 0;
   char *logptr = nullptr;
   char const * const davixDebug = getenv("Davix_Debug");
   if (davixDebug != nullptr) {
     logLevel = strtol(davixDebug, &logptr, 0);
     if (errno) {
       edm::LogWarning("DavixFile") << "Got error while converting "
                                    << "Davix_Debug env variable to integer. "
                                       "Will use default log level 0";
       logLevel = 0;
     }
     if (logptr == davixDebug) {
       edm::LogWarning("DavixFile") << "Failed to convert to integer "
                                    << "Davix_Debug env variable; Will use default log level 0";
       logLevel = 0;
     } else if (*logptr != '\0') {
       edm::LogWarning("DavixFile") << "Failed to parse extra junk "
                                    << "from Davix_Debug env variable. Will use default log level 0";
       logLevel = 0;
     }
   }
   switch (logLevel) {
   case 0:
     std::call_once(davixDebugInit, davix_set_log_level, 0);
     break;
   case 1:
     std::call_once(davixDebugInit, davix_set_log_level, DAVIX_LOG_WARNING);
     break;
   case 2:
     std::call_once(davixDebugInit, davix_set_log_level, DAVIX_LOG_VERBOSE);
     break;
   case 3:
     std::call_once(davixDebugInit, davix_set_log_level, DAVIX_LOG_DEBUG);
     break;
   default:
     std::call_once(davixDebugInit, davix_set_log_level, DAVIX_LOG_ALL);
     break;
   }
 }

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

virtual

Definition at line 146 of file DavixFile.cc.

References IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenTruncate, and IOFlags::OpenWrite.

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

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

virtual

Definition at line 152 of file DavixFile.cc.

References IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenTruncate, and IOFlags::OpenWrite.

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

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

virtual

Definition at line 164 of file DavixFile.cc.

References cms::Exception::addContext(), edm::errors::FileOpenError, dataset::name, IOFlags::OpenRead, and X509Authentication().

                                                                {
   // Actual open
   if ((name == nullptr) || (*name == 0)) {
     edm::Exception ex(edm::errors::FileOpenError);
     ex << "Cannot open a file without name";
     ex.addContext("Calling DavixFile::open()");
     throw ex;
   }
   m_name = name;
 
   if ((flags & IOFlags::OpenRead) == 0) {
     edm::Exception ex(edm::errors::FileOpenError);
     ex << "Must open file '" << name << "' at least for read";
     ex.addContext("Calling DavixFile::open()");
     throw ex;
   }
 
   if (m_davixPosix && m_fd) {
     edm::Exception ex(edm::errors::FileOpenError);
     ex << "Davix::open(name='" << m_name << "') failed on already open file";
     ex.addContext("Calling DavixFile::open()");
     throw ex;
   }
   configureDavixLogLevel();
   // Translate our flags to system flags
   int openflags = 0;
 
   if (flags & IOFlags::OpenRead)
     openflags |= O_RDONLY;
 
   DavixError *davixErr = nullptr;
   RequestParams davixReqParams;
   // Set up X509 authentication
   davixReqParams.setClientCertCallbackX509(&X509Authentication, nullptr);
   // Set also CERT_DIR if it is set in envinroment, otherwise use default
   const char *cert_dir = nullptr;
   if ((cert_dir = getenv("X509_CERT_DIR")) == nullptr)
     cert_dir = "/etc/grid-security/certificates";
   davixReqParams.addCertificateAuthorityPath(cert_dir);
 
   m_davixPosix = std::make_unique<DavPosix>(new Context());
   m_fd = m_davixPosix->open(&davixReqParams, name, openflags, &davixErr);
 
   // Check Davix Error
   if (davixErr) {
     std::unique_ptr<DavixError> davixErrManaged(davixErr);
     edm::Exception ex(edm::errors::FileOpenError);
     ex << "Davix::open(name='" << m_name << "') failed with "
        << "error '" << davixErr->getErrMsg().c_str() << " and error code " << davixErr->getStatus();
     ex.addContext("Calling DavixFile::open()");
     throw ex;
   }
   if (!m_fd) {
     edm::Exception ex(edm::errors::FileOpenError);
     ex << "Davix::open(name='" << m_name << "') failed as fd is NULL";
     ex.addContext("Calling DavixFile::open()");
     throw ex;
   }
 }

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

virtual

Definition at line 159 of file DavixFile.cc.

References flags.

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

IOOffset DavixFile::position	(	IOOffset	offset,
		Relative	whence = `SET`
	)

overridevirtual

Implements Storage.

Definition at line 354 of file DavixFile.cc.

References cms::Exception::addContext(), and mps_fire::result.

                                                                {
   DavixError *davixErr = nullptr;
   if (whence != CURRENT && whence != SET && whence != END) {
     cms::Exception ex("FilePositionError");
     ex << "DavixFile::position() called with incorrect 'whence' parameter";
     ex.addContext("Calling DavixFile::position()");
     throw ex;
   }
   IOOffset result;
   size_t mywhence = (whence == SET ? SEEK_SET : whence == CURRENT ? SEEK_CUR : SEEK_END);
 
   if ((result = m_davixPosix->lseek(m_fd, offset, mywhence, &davixErr)) == -1) {
     cms::Exception ex("FilePositionError");
     ex << "Davix::lseek(name='" << m_name << "', offset=" << offset
        << ", whence=" << mywhence << ") failed with error " << davixErr->getErrMsg().c_str()
        << " and error code " << davixErr->getStatus() << " and "
        << "call returned " << result;
     ex.addContext("Calling DavixFile::position()");
     throw ex;
   }
 
   return result;
 }

IOSize DavixFile::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 317 of file DavixFile.cc.

References cms::Exception::addContext(), edm::errors::FileReadError, and alignCSCRings::s.

                                            {
   DavixError *davixErr = nullptr;
   m_davixPosix->fadvise(m_fd, 0, n, AdviseRandom);
   IOSize done = 0;
   while (done < n) {
     ssize_t s = m_davixPosix->read(m_fd, (char *)into + done, n - done, &davixErr);
     if (davixErr) {
       std::unique_ptr<DavixError> davixErrManaged(davixErr);
       edm::Exception ex(edm::errors::FileReadError);
       ex << "Davix::read(name='" << m_name << "', n=" << (n - done)
          << ") failed with error " << davixErr->getErrMsg().c_str() << " and error code "
          << davixErr->getStatus() << " and call returned " << s << " bytes";
       ex.addContext("Calling DavixFile::read()");
       throw ex;
     }
     if (s < 0) {
       edm::Exception ex(edm::errors::FileReadError);
       ex << "Davix::read(name='" << m_name << "', n=" << (n - done)
          << ") failed and call returned " << s;
       ex.addContext("Calling DavixFile::read()");
       throw ex;
     } else if (s == 0) {
       // end of file
       break;
     }
     done += s;
   }
   return done;
 }

IOSize DavixFile::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 224 of file DavixFile.cc.

References cms::Exception::addContext(), IOBuffer::data(), edm::errors::FileReadError, mps_fire::i, alignCSCRings::s, IOBuffer::size(), and pileupDistInMC::total.

                                                       {
   assert(!buffers || into);
 
   // Davix does not support 0 buffers;
   if (buffers == 0)
     return 0;
 
   DavixError *davixErr = nullptr;
 
   std::vector<DavIOVecInput> input_vector(buffers);
   std::vector<DavIOVecOuput> output_vector(buffers);
   IOSize total = 0; // Total requested bytes
   for (IOSize i = 0; i < buffers; ++i) {
     input_vector[i].diov_size = into[i].size();
     input_vector[i].diov_buffer = static_cast<char *>(into[i].data());
     total += into[i].size();
   }
 
   ssize_t s = m_davixPosix->preadVec(m_fd, input_vector.data(), output_vector.data(), buffers, &davixErr);
   if (davixErr) {
     std::unique_ptr<DavixError> davixErrManaged(davixErr);
     edm::Exception ex(edm::errors::FileReadError);
     ex << "Davix::readv(name='" << m_name << "', buffers=" << (buffers)
        << ") failed with error " << davixErr->getErrMsg().c_str() << " and error code "
        << davixErr->getStatus() << " and call returned " << s << " bytes";
     ex.addContext("Calling DavixFile::readv()");
     throw ex;
   }
   // Davix limits number of requests sent to the server
   // to improve performance and it does range coalescing.
   // So we can`t check what preadVec returns with what was requested.
   // Example: If two ranges are overlapping, [10, 20] and [20, 30] which is
   // coalesced into [10, 30] and it will contain one less byte than was requested.
   // Only check if returned val <= 0 and make proper actions.
   if (s < 0) {
     edm::Exception ex(edm::errors::FileReadError);
     ex << "Davix::readv(name='" << m_name << "') failed and call returned " << s;
     ex.addContext("Calling DavixFile::readv()");
     throw ex;
   } else if (s == 0) {
     // end of file
     return 0;
   }
   return total;
 }

IOSize DavixFile::readv	(	IOPosBuffer *	into,
		IOSize	buffers
	)

overridevirtual

Reimplemented from Storage.

Definition at line 270 of file DavixFile.cc.

References cms::Exception::addContext(), IOPosBuffer::data(), edm::errors::FileReadError, mps_fire::i, IOPosBuffer::offset(), alignCSCRings::s, IOPosBuffer::size(), and pileupDistInMC::total.

                                                          {
   assert(!buffers || into);
 
   // Davix does not support 0 buffers;
   if (buffers == 0)
     return 0;
 
   DavixError *davixErr = nullptr;
 
   std::vector<DavIOVecInput> input_vector(buffers);
   std::vector<DavIOVecOuput> output_vector(buffers);
   IOSize total = 0;
   for (IOSize i = 0; i < buffers; ++i) {
     input_vector[i].diov_offset = into[i].offset();
     input_vector[i].diov_size = into[i].size();
     input_vector[i].diov_buffer = static_cast<char *>(into[i].data());
     total += into[i].size();
   }
   ssize_t s = m_davixPosix->preadVec(m_fd, input_vector.data(), output_vector.data(), buffers, &davixErr);
   if (davixErr) {
     std::unique_ptr<DavixError> davixErrManaged(davixErr);
     edm::Exception ex(edm::errors::FileReadError);
     ex << "Davix::readv(name='" << m_name << "', n=" << buffers << ") failed with error "
        << davixErr->getErrMsg().c_str() << " and error code " << davixErr->getStatus()
        << " and call returned " << s << " bytes";
     ex.addContext("Calling DavixFile::readv()");
     throw ex;
   }
   // Davix limits number of requests sent to the server
   // to improve performance and it does range coalescing.
   // So we can`t check what preadVec returns with what was requested.
   // Example: If two ranges are overlapping, [10, 20] and [20, 30] which is
   // coalesced into [10, 30] and it will contain one less byte than was requested.
   // Only check if returned val <= 0 and make proper actions.
   if (s < 0) {
     edm::Exception ex(edm::errors::FileReadError);
     ex << "Davix::readv(name='" << m_name << "', n=" << buffers
        << ") failed and call returned " << s;
     ex.addContext("Calling DavixFile::readv()");
     throw ex;
   } else if (s == 0) {
     // end of file
     return 0;
   }
   return total;
 }

void DavixFile::resize ( IOOffset size )

overridevirtual

Implements Storage.

Definition at line 378 of file DavixFile.cc.

References cms::Exception::addContext().

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 << "DavixFile::resize(name='" << m_name << "') not implemented";
   ex.addContext("Calling DavixFile::resize()");
   throw ex;
 }

IOSize DavixFile::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 347 of file DavixFile.cc.

References cms::Exception::addContext(), and edm::errors::FileWriteError.

                                                   {
   edm::Exception ex(edm::errors::FileWriteError);
   ex << "DavixFile::write(name='" << m_name << "') not implemented";
   ex.addContext("Calling DavixFile::write()");
   throw ex;
 }

Member Data Documentation

std::unique_ptr<Davix::DavPosix> DavixFile::m_davixPosix

private

Definition at line 45 of file DavixFile.h.

Davix_fd* DavixFile::m_fd

private

Definition at line 44 of file DavixFile.h.

std::string DavixFile::m_name

private

Definition at line 46 of file DavixFile.h.

Public Member Functions

Static Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation