#include <LStoreFile.h>

Inheritance diagram for LStoreFile:

Classes
class	MutexWrapper

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)

	LStoreFile (void)

	LStoreFile (void *fd)

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

	LStoreFile (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

void	resize (IOOffset size) override

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

	~LStoreFile (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 IOSize	readv (IOPosBuffer *into, IOSize buffers)

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)

virtual IOSize	readv (IOBuffer *into, IOSize buffers)

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 Attributes
static pthread_mutex_t	m_dlopen_lock = PTHREAD_MUTEX_INITIALIZER

Private Member Functions
void	closeLibrary ()

void	loadLibrary ()

Private Attributes
bool	m_close

void *	m_fd

bool	m_is_loaded

void *	m_library_handle

std::string	m_name

int32_t(*	redd_close )(void *)

int32_t(*	redd_errno )()

int32_t(*	redd_init )()

int64_t(*	redd_lseek )(void *, int64_t, uint32_t)

void (	redd_open )(const char *, int32_t, int32_t)

int64_t(*	redd_read )(void , char , int64_t)

const std::string &(*	redd_strerror )()

int32_t(*	redd_term )()

int64_t(*	redd_write )(void , const char , int64_t)

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

Detailed Description

Definition at line 8 of file LStoreFile.h.

Constructor & Destructor Documentation

LStoreFile::LStoreFile ( void )

Definition at line 16 of file LStoreFile.cc.

References loadLibrary().

     : m_fd(nullptr),
       m_close(false),
       m_name(),
       m_library_handle(nullptr),
       m_is_loaded(false),
       redd_init(nullptr),
       redd_read(nullptr),
       redd_close(nullptr),
       redd_lseek(nullptr),
       redd_open(nullptr),
       redd_write(nullptr),
       redd_term(nullptr),
       redd_errno(nullptr),
       redd_strerror(nullptr) {
   loadLibrary();
 }

LStoreFile::LStoreFile ( void * fd )

Definition at line 34 of file LStoreFile.cc.

References loadLibrary().

     : m_fd(fd),
       m_close(true),
       m_name(),
       m_library_handle(nullptr),
       m_is_loaded(false),
       redd_init(nullptr),
       redd_read(nullptr),
       redd_close(nullptr),
       redd_lseek(nullptr),
       redd_open(nullptr),
       redd_write(nullptr),
       redd_term(nullptr),
       redd_errno(nullptr),
       redd_strerror(nullptr) {
   loadLibrary();
 }

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

Definition at line 52 of file LStoreFile.cc.

References loadLibrary(), and open().

     : m_fd(nullptr), m_close(false), m_is_loaded(false) {
   loadLibrary();
   open(name, flags, perms);
 }

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

Definition at line 58 of file LStoreFile.cc.

References HLT_2018_cff::flags, loadLibrary(), and open().

     : m_fd(nullptr), m_close(false), m_is_loaded(false) {
   loadLibrary();
   open(name.c_str(), flags, perms);
 }

LStoreFile::~LStoreFile ( void )

override

Definition at line 64 of file LStoreFile.cc.

References closeLibrary(), m_close, and m_name.

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

Member Function Documentation

void LStoreFile::abort ( void )

virtual

Definition at line 226 of file LStoreFile.cc.

References m_close, and m_fd.

                            {
   if (m_fd != nullptr)
     (*redd_close)(m_fd);
 
   m_close = false;
   m_fd = nullptr;
 }

void LStoreFile::close ( void )

overridevirtual

Reimplemented from Storage.

Definition at line 208 of file LStoreFile.cc.

References m_close, m_fd, m_name, redd_close, and redd_errno.

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

                            {
   if (m_fd == nullptr) {
     edm::LogError("LStoreFileError") << "LStoreFile::close(name='" << m_name << "') called but the file is not open";
     m_close = false;
     return;
   }
   edm::LogInfo("LStoreFile::close()") << "closing " << m_name << std::endl;
   if ((*redd_close)(m_fd) == -1)
     edm::LogWarning("LStoreFileWarning") << "redd_close(name='" << m_name << "') failed with error '"
                                          << (*redd_strerror)() << "' (redd_errno=" << (*redd_errno)() << ")";
 
   m_close = false;
   m_fd = nullptr;
 
   // Caused hang.  Will be added back after problem is fixed.
   // edm::LogInfo("LStoreFileInfo") << "Closed " << m_name;
 }

void LStoreFile::closeLibrary ( )

private

Definition at line 116 of file LStoreFile.cc.

References MillePedeFileConverter_cfg::e, Exception, m_dlopen_lock, m_is_loaded, m_library_handle, and redd_term.

Referenced by ~LStoreFile().

                               {
   try {
     LStoreFile::MutexWrapper lockObj(&this->m_dlopen_lock);
 
     // What is the correct idiom for propagating error messages
     // in functions that are exclusively called in destructors?
     // Seriously. I have no idea
     // melo
     if (m_is_loaded) {
       if ((*redd_term)()) {
         throw cms::Exception("LStoreFile::closeLibrary()") << "Error in redd_term: " << (*redd_strerror)();
       }
     }
     if (m_library_handle != nullptr) {
       if (dlclose(m_library_handle)) {
         throw cms::Exception("LStoreFile::closeLibrary()") << "Error on dlclose(): " << dlerror();
       }
     }
   } catch (cms::Exception &e) {
     edm::LogError("LStoreFileError") << "LStoreFile had an error in its destructor: " << e;
   }
   m_is_loaded = false;
 }

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

virtual

Definition at line 141 of file LStoreFile.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 LStoreFile::create	(	const std::string &	name,
		bool	exclusive = `false`,
		int	perms = `0666`
	)

virtual

Definition at line 147 of file LStoreFile.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);
 }

void LStoreFile::loadLibrary ( )

private

Definition at line 84 of file LStoreFile.cc.

References Exception, m_dlopen_lock, m_is_loaded, m_library_handle, redd_errno, redd_init, REDD_LOAD_SYMBOL, redd_lseek, redd_open, redd_read, redd_strerror, redd_term, redd_write, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by LStoreFile().

                              {
   edm::LogError("LStoreFile::loadLibrary()") << "Loading library\n";
   LStoreFile::MutexWrapper lockObj(&this->m_dlopen_lock);
   // until ACCRE removes the java dependency from their client libs,
   // we'll dlopen() them so they don't need to be brought along with cmssw
   // if you're running LStore at your site, you will have the libs anyway
   // TODO add wrappers to make this work in OSX as well (CMSSW's getting ported?)
   // TODO   should be easy, just need to know the "proper" way to do #if OSX
   // -Melo
 
   m_library_handle = dlopen("libreddnet.so", RTLD_LAZY);
   if (m_library_handle == nullptr) {
     throw cms::Exception("LStoreFile::loadLibrary()") << "Can't dlopen() LStore libraries: " << dlerror();
   }
 
   char *retval = nullptr;
   // Explicitly state the size of these values, keeps weird 64/32 bit stuff away
   REDD_LOAD_SYMBOL(redd_init, int32_t(*)());
   REDD_LOAD_SYMBOL(redd_read, int64_t(*)(void *, char *, int64_t));
   REDD_LOAD_SYMBOL(redd_lseek, int64_t(*)(void *, int64_t, uint32_t));
   REDD_LOAD_SYMBOL(redd_open, void *(*)(const char *, int, int));
   REDD_LOAD_SYMBOL(redd_write, int64_t(*)(void *, const char *, int64_t));
   REDD_LOAD_SYMBOL(redd_term, int32_t(*)());
   REDD_LOAD_SYMBOL(redd_errno, int32_t(*)());
   REDD_LOAD_SYMBOL(redd_strerror, const std::string &(*)());
 
   if ((*redd_init)()) {
     throw cms::Exception("LStoreFile::loadLibrary()") << "Error in redd_init: " << (*redd_strerror)();
   }
   m_is_loaded = true;
 }

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

virtual

Definition at line 157 of file LStoreFile.cc.

References close(), TauDecayModes::dec, Exception, m_close, m_fd, m_name, Skims_PA_cff::name, O_NONBLOCK, IOFlags::OpenAppend, IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenNonBlock, IOFlags::OpenRead, IOFlags::OpenTruncate, IOFlags::OpenWrite, redd_errno, and redd_open.

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

                                                                 {
   // Actual open
   if ((name == nullptr) || (*name == 0))
     throw cms::Exception("LStoreFile::open()") << "Cannot open a file without a name";
 
   if ((flags & (IOFlags::OpenRead | IOFlags::OpenWrite)) == 0)
     throw cms::Exception("LStoreFile::open()") << "Must open file '" << name << "' at least for read or write";
 
   // If I am already open, close old file first
   if (m_fd != nullptr && m_close)
     close();
 
   // Translate our flags to system flags
   int openflags = 0;
 
   if ((flags & IOFlags::OpenRead) && (flags & IOFlags::OpenWrite))
     openflags |= O_RDWR;
   else if (flags & IOFlags::OpenRead)
     openflags |= O_RDONLY;
   else if (flags & IOFlags::OpenWrite)
     openflags |= O_WRONLY;
 
   if (flags & IOFlags::OpenNonBlock)
     openflags |= O_NONBLOCK;
 
   if (flags & IOFlags::OpenAppend)
     openflags |= O_APPEND;
 
   if (flags & IOFlags::OpenCreate)
     openflags |= O_CREAT;
 
   if (flags & IOFlags::OpenExclusive)
     openflags |= O_EXCL;
 
   if (flags & IOFlags::OpenTruncate)
     openflags |= O_TRUNC;
 
   void *newfd = nullptr;
   if ((newfd = (*redd_open)(name, openflags, perms)) == nullptr)
     throw cms::Exception("LStoreFile::open()")
         << "redd_open(name='" << name << "', flags=0x" << std::hex << openflags << ", permissions=0" << std::oct
         << perms << std::dec << ") => error '" << (*redd_strerror)() << "' (redd_errno=" << (*redd_errno)() << ")";
 
   m_name = name;
   m_fd = newfd;
 
   m_close = true;
 
   edm::LogInfo("LStoreFileInfo") << "Opened " << m_name;
 }

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

virtual

Definition at line 153 of file LStoreFile.cc.

References HLT_2018_cff::flags, and open().

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

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

overridevirtual

Implements Storage.

Definition at line 263 of file LStoreFile.cc.

References Storage::CURRENT, Storage::END, Exception, m_fd, m_name, redd_errno, redd_lseek, mps_fire::result, and Storage::SET.

Referenced by LStoreStorageMaker::check().

                                                                 {
   if (m_fd == nullptr)
     throw cms::Exception("LStoreFile::position()") << "LStoreFile::position() called on a closed file";
   if (whence != CURRENT && whence != SET && whence != END)
     throw cms::Exception("LStoreFile::position()") << "LStoreFile::position() called with incorrect 'whence' parameter";
 
   IOOffset result;
   uint32_t mywhence = (whence == SET ? SEEK_SET : whence == CURRENT ? SEEK_CUR : SEEK_END);
   if ((result = (*redd_lseek)(m_fd, (off_t)offset, (uint32_t)mywhence)) == -1)
     throw cms::Exception("LStoreFile::position()")
         << "redd_lseek64(name='" << m_name << "', offset=" << offset << ", whence=" << mywhence
         << ") failed with error '" << (*redd_strerror)() << "' (redd_errno=" << (*redd_errno)() << ")";
   return result;
 }

IOSize LStoreFile::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 234 of file LStoreFile.cc.

References fileCollector::done, Exception, m_fd, m_name, redd_errno, redd_strerror, and alignCSCRings::s.

                                             {
   IOSize done = 0;
   while (done < n) {
     ssize_t s = (*redd_read)(m_fd, (char *)into + done, n - done);
     if (s == -1)
       throw cms::Exception("LStoreFile::read()")
           << "redd_read(name='" << m_name << "', n=" << (n - done) << ") failed with error '" << (*redd_strerror)()
           << "' (redd_errno=" << (*redd_errno)() << ")";
     done += s;
   }
   return done;
 }

void LStoreFile::resize ( IOOffset size )

overridevirtual

Implements Storage.

Definition at line 278 of file LStoreFile.cc.

References Exception, 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().

                                   {
   throw cms::Exception("LStoreFile::resize()") << "LStoreFile::resize(name='" << m_name << "') not implemented";
 }

IOSize LStoreFile::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 247 of file LStoreFile.cc.

References fileCollector::done, Exception, m_fd, m_name, redd_errno, redd_strerror, and alignCSCRings::s.

                                                    {
   IOSize done = 0;
   while (done < n) {
     ssize_t s = (*redd_write)(m_fd, (const char *)from + done, n - done);
     if (s == -1)
       throw cms::Exception("LStoreFile::write()")
           << "redd_write(name='" << m_name << "', n=" << (n - done) << ") failed with error '" << (*redd_strerror)()
           << "' (redd_errno=" << (*redd_errno)() << ")";
     done += s;
   }
 
   return done;
 }