#include <src/FileMgr/FileMgr.h>

Inheritance diagram for FileMgr:

Collaboration diagram for FileMgr:

Public Member Functions
	FileMgr (const std::string &name, ISvcLocator *svc)

	~FileMgr () override

StatusCode	initialize () override

StatusCode	finalize () override

void	handle (const Incident &) override

StatusCode	regHandler (FileHdlr) override

StatusCode	hasHandler (const IoTech &) const override

StatusCode	deregHandler (const IoTech &) override

StatusCode	getHandler (const IoTech &, FileHdlr &) const override

StatusCode	getHandler (const std::string &, FileHdlr &) const override

int	getFileAttr (const std::string &, std::vector< const FileAttr * > &) const override

StatusCode	getFileAttr (const Fd, const FileAttr *&) const override

StatusCode	getFileAttr (void , const FileAttr &) const override

void	listHandlers () const override

void	listFiles () const override

virtual void	listActions () const

virtual void	listSuppression () const

int	getFiles (std::vector< std::string > &, bool onlyOpen=true) const override

int	getFiles (std::vector< const Io::FileAttr * > &, bool onlyOpen=true) const override

int	getFiles (const Io::IoTech &, std::vector< std::string > &, bool onlyOpen=true) const override

int	getFiles (const Io::IoTech &, std::vector< const Io::FileAttr * > &, bool onlyOpen=true) const override

int	getFiles (const Io::IoTech &, const Io::IoFlags &, std::vector< std::string > &, bool onlyOpen=true) const override

int	getFiles (const Io::IoTech &, const Io::IoFlags &, std::vector< const Io::FileAttr * > &, bool onlyOpen=true) const override

int	getFd (std::vector< Fd > &) const override

int	getFd (const Io::IoTech &, std::vector< Io::Fd > &) const override

int	getFd (const Io::IoTech &, const Io::IoFlags &, std::vector< Io::Fd > &) const override

const std::string &	fname (const Io::Fd &) const override

const std::string &	fname (void *) const override

Io::Fd	fd (const std::string &) const override

Io::Fd	fd (void *) const override

void *	fptr (const std::string &) const override

void *	fptr (const Io::Fd &) const override

int	getLastError (std::string &) const override

Io::open_t	open (const Io::IoTech &, const std::string &caller, const std::string &fname, const Io::IoFlags &, Io::Fd &fd, void *&ptr, const std::string &desc="", const bool shared=false) override

Io::open_t	open (const Io::IoTech &, const std::string &caller, const std::string &fname, const Io::IoFlags &, Io::Fd &, const std::string &desc="", const bool shared=false) override

Io::open_t	open (const Io::IoTech &, const std::string &caller, const std::string &fname, const Io::IoFlags &, void *&, const std::string &desc="", const bool shared=false) override

Io::close_t	close (const Fd, const std::string &caller) override

Io::close_t	close (void *, const std::string &caller) override

Io::reopen_t	reopen (const Fd, const IoFlags &, const std::string &caller) override

Io::reopen_t	reopen (void *, const IoFlags &, const std::string &caller) override

StatusCode	regAction (Io::bfcn_action_t, const Io::Action &, const std::string &desc="") override

StatusCode	regAction (Io::bfcn_action_t, const Io::Action &, const Io::IoTech &, const std::string &desc="") override

void	suppressAction (const std::string &) override

void	suppressAction (const std::string &, const Io::Action &) override

Public Member Functions inherited from extends< BASE, Interfaces >
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...

StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...

std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...

	~extends () override=default
	Virtual destructor. More...

void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...

StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...

std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...

	~extends () override=default
	Virtual destructor. More...

Public Member Functions inherited from extend_interfaces< Interfaces...>
	~extend_interfaces () override=default
	Virtual destructor. More...

	~extend_interfaces () override=default
	Virtual destructor. More...

Private Types
typedef std::pair< Io::bfcn_action_t, std::string >	bfcn_desc_t

typedef std::map< Io::Action, std::list< bfcn_desc_t > >	actionMap

typedef std::multimap< std::string, FileAttr * >	fileMap

typedef std::map< std::string, int >	supMap

Private Member Functions
virtual Io::open_t	open (const IoTech &, const std::string &caller, const std::string &fname, const std::string &desc, const IoFlags &, Fd &, void *&, const bool shared)

StatusCode	execAction (Io::FileAttr *, const std::string &, const Io::Action &) const

StatusCode	execActs (Io::FileAttr *, const std::string &, const Io::Action &, const actionMap &m) const

bool	accessMatch (const Io::IoFlags &, const Io::IoFlags &, bool strict=false) const

bool	isShareable (const std::string &filename, const Io::IoFlags &) const

Private Attributes
StringProperty	m_logfile

BooleanProperty	m_printSummary

BooleanProperty	m_loadRootHandler

BooleanProperty	m_loadPosixHandler

StringProperty	m_ssl_proxy

StringProperty	m_ssl_cert

fileMap	m_files

std::map< IoTech, FileHdlr >	m_handlers

std::map< Fd, FileAttr * >	m_descriptors

std::vector< std::unique_ptr< FileAttr > >	m_attr

std::vector< FileAttr * >	m_oldFiles

std::map< IoTech, actionMap >	m_actions

supMap	m_supMap

std::string	m_lastErrS

int	m_lastErr

std::unique_ptr< RootFileHandler >	m_rfh

std::unique_ptr< POSIXFileHandler >	m_pfh

MsgStream	m_log

Additional Inherited Members
Public Types inherited from extends< BASE, Interfaces >
using	base_class = extends
	Typedef to this class. More...

using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...

using	base_class = extends
	Typedef to this class. More...

using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...

Public Types inherited from extend_interfaces< Interfaces...>
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...

using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...

Detailed Description

Definition at line 32 of file FileMgr.h.

Member Typedef Documentation

typedef std::map<Io::Action, std::list<bfcn_desc_t> > FileMgr::actionMap

private

Definition at line 142 of file FileMgr.h.

typedef std::pair<Io::bfcn_action_t,std::string> FileMgr::bfcn_desc_t

private

Definition at line 141 of file FileMgr.h.

typedef std::multimap<std::string, FileAttr*> FileMgr::fileMap

private

Definition at line 152 of file FileMgr.h.

typedef std::map<std::string, int> FileMgr::supMap

private

Definition at line 163 of file FileMgr.h.

Constructor & Destructor Documentation

FileMgr::FileMgr	(	const std::string &	name,
		ISvcLocator *	svc
	)

Definition at line 78 of file FileMgr.cpp.

   : base_class( name, svc ), 
     m_log(msgSvc(), name )
  {
 
    declareProperty("LogFile",m_logfile="");
    declareProperty("PrintSummary",m_printSummary=false);
    declareProperty("LoadROOTHandler", m_loadRootHandler=true);
    declareProperty("LoadPOSIXHandler", m_loadPosixHandler=true);
 
    declareProperty("TSSL_UserProxy", m_ssl_proxy="X509");
    declareProperty("TSSL_CertDir", m_ssl_cert="X509");
 
    m_lastErrS = "";
 
 }

FileMgr::~FileMgr ( )

override

Definition at line 97 of file FileMgr.cpp.

                   {
     // Where do the new-ed FileAttr get deleted? 
     // they get pushed into m_descriptors, but m_attr is presumably 
     // where they _also_ should be pushed in order to track ownership...
 }

Member Function Documentation

bool FileMgr::accessMatch	(	const Io::IoFlags &	fold,
		const Io::IoFlags &	fnew,
		bool	strict = `false`
	)		const

private

Definition at line 1499 of file FileMgr.cpp.

                            {
 
     ON_VERBOSE
       m_log << MSG::VERBOSE << "accessMatch  old: " << fold
         << "  new: " << fnew
         << endmsg;
 
   return  ( ((fold == Io::READ)  &&  (fnew == Io::READ)) ||
           ( (fold & Io::WRITE) != 0  &&  (fnew & Io::WRITE) != 0) ||
           ( (fold & Io::RDWR)  != 0  &&  (fnew & Io::RDWR)  != 0) ) ;
 
 }

Io::close_t FileMgr::close	(	const Fd	,
		const std::string &	caller
	)

override

close_t FileMgr::close	(	void *	vp,
		const std::string &	caller
	)

override

Definition at line 685 of file FileMgr.cpp.

                                                 {
 
   // return codes:
   //   < 0 : error condition
   //     0 : actual close of one file
   //   > 0 : shared file, removed from list, no actual close, returns
   //         number of shared files still open.
 
   ON_VERBOSE
     m_log << MSG::VERBOSE << "close(" << vp << ")"
       << endmsg;
 
   close_t r = -1;
 
   auto itr = std::find_if( std::begin(m_files), std::end(m_files),
                            [&](fileMap::const_reference i ) { return i.second->fptr()==vp; } );
 
   if (itr == m_files.end()) {
     m_log << MSG::ERROR << "unknown file ptr \"" << vp
       << "\" when calling close()"
       << endmsg;
     return r;
   }
 
   IoTech tech = itr->second->tech();
 
   FileHdlr fh;
 
   if (getHandler(tech,fh).isFailure()) {
     return r;
   }
   if (! fh.b_closeP_fcn) {
     m_log << MSG::ERROR << "no close(" << tech << ",void*) function registered"
       << endmsg;
     return -1;
   }
 
   FileAttr *fa = itr->second;
 
   // find how many times this file is open
   pair<fileMap::const_iterator, fileMap::const_iterator> fitr =
     m_files.equal_range(fa->name());
 
   int i = std::count_if( fitr.first, fitr.second, [&](fileMap::const_reference f)
                          { return f.second->fptr()==vp; } );
 
   ON_VERBOSE
     m_log << MSG::VERBOSE << "   ref count: "  << i
       << endmsg;
 
   if (i > 1 && fa->isShared()) {
     // file open multiple times in shared access. don't do the actual close
     ON_DEBUG
       m_log << MSG::DEBUG << "closing file " << fa->name() << " opened "
         << i << " times with fptr " << vp << endmsg;
     m_files.erase(itr);
 
     r = i-1;
 
   } else if (i == 1 || (i>1 && !fa->isShared()) ) {
     ON_DEBUG
       m_log << MSG::DEBUG << "closing: " << *fa << endmsg;
 
     try {
       r = fh.b_closeP_fcn(vp);
     } catch (const std::bad_function_call& err) {
       m_log << MSG::ERROR << "when calling close handler for " << tech
         << " on file " << fa->name()
         << " caught " << err.what() << endmsg;
       execAction(fa, caller, CLOSE_ERR ).ignore();
       return -1;
     } catch (...) {
       m_log << MSG::ERROR << "when calling close handler for " << tech
         << " on file " << fa->name()
         << " caught an unknown exception." << endmsg;
       execAction(fa, caller, CLOSE_ERR ).ignore();
       return -1;
     }
 
     if (r < 0) {
       m_log << MSG::WARNING
         << "close of file with ptr \"" << vp
         << "\", name: \"" << fa->name()
         << "\", tech: \"" << tech << "\" failed"
         << endmsg;
 
       return r;
     }
 
     m_files.erase(itr);
 
   } else {
     // this should never happen!
     m_log << MSG::ERROR
       << "ref count: " << i << " < 0 when closing " << fa
       << ". This should never happen"
       << endmsg;
     return -1;
 
   }
 
   fa->fd(-1);
   fa->flags(INVALID);
   fa->isOpen(false);
   fa->fptr(0);
   m_oldFiles.push_back( fa );
 
 
   // exec all callbacks
   if (execAction(fa, caller, CLOSE).isFailure()) {
     m_log << MSG::WARNING
       << "at least one close callback action failed"
       << endmsg;
   }
 
   return r;
 
 }

StatusCode FileMgr::deregHandler ( const IoTech & )

override

Definition at line 325 of file FileMgr.cpp.

                                           {
   FileHdlr hdlr;
 
   auto itr = m_handlers.find(tech);
   if (itr == m_handlers.end()) {
     m_log << MSG::ERROR << "Can't de-register tech " << tech
       << " as it hasn't been registered!"
       << endmsg;
     return StatusCode::FAILURE;
   } 
 
   m_handlers.erase(itr);
   return StatusCode::SUCCESS;
 
 }

StatusCode FileMgr::execAction	(	Io::FileAttr *	fa,
		const std::string &	caller,
		const Io::Action &	a
	)		const

private

Definition at line 1420 of file FileMgr.cpp.

                                        {
 
   Io::IoTech tech = fa->tech();
 
   StatusCode s1,s2;
 
   auto itr = m_actions.find(Io::UNKNOWN);
 
   if (itr != m_actions.end() && !itr->second.empty() ) {
     s1 = execActs(fa, caller, a, itr->second);
   }
 
   itr = m_actions.find(tech);
   if (itr != m_actions.end() && !itr->second.empty() ) {
     s2 = execActs(fa, caller, a, itr->second);
   }
 
   return (s1.isFailure() || s2.isFailure()) ? StatusCode::FAILURE 
                                             : StatusCode::SUCCESS;
 }

StatusCode FileMgr::execActs	(	Io::FileAttr *	fa,
		const std::string &	caller,
		const Io::Action &	a,
		const actionMap &	m
	)		const

private

Definition at line 1445 of file FileMgr.cpp.

                                                          {
 
   auto mitr = m.find(a);
 
   if (mitr == m.end() || mitr->second.empty()) {
     return StatusCode::SUCCESS;
   }
 
   ON_DEBUG
     m_log << MSG::DEBUG
       << "executing " << mitr->second.size()  << " " << a
       << " actions on "
       << *fa << " from "
       << caller
       << endmsg;
 
 
   bool fail(false);
 
   auto it2 = m_supMap.find(fa->name());
   if (it2 != m_supMap.end()) {
     if (get_bit(it2->second,a) || get_bit(it2->second,Io::INVALID_ACTION)) {
       ON_DEBUG
     m_log << MSG::DEBUG << "     --> suppressing callback action for "
           << a
           << endmsg;
       return StatusCode::SUCCESS;
     }
   }
 
   for (const auto& itr : mitr->second ) {
 
     ON_DEBUG
       m_log << MSG::DEBUG << "executing "
         << itr.second << endmsg;
 
     if ( (((itr.first))(fa,caller)).isFailure() ) {
       m_log << MSG::WARNING << "execution of "
         << itr.second << " on " << *fa
         << " failed during " << a << " action"
         << endmsg;
       fail = true;
     }
 
   }
 
   return  fail ? StatusCode::FAILURE : StatusCode::SUCCESS;
 
 }

Io::Fd FileMgr::fd ( const std::string & fname ) const

override

Definition at line 1235 of file FileMgr.cpp.

                                         {
 
   auto fitr = m_files.equal_range(fname);
   auto itr = std::find_if( fitr.first, fitr.second, [](fileMap::const_reference f) {
       return f.second->fd() != -1;
   } );
   return itr!=fitr.second ? itr->second->fd() : -1 ;
 }

Io::Fd FileMgr::fd ( void * fptr ) const

override

Definition at line 1247 of file FileMgr.cpp.

                             {
 
   auto itr = std::find_if(m_files.begin(),m_files.end(),[&](fileMap::const_reference f) {
       return f.second->fptr() == fptr;
   } );
   return itr!=m_files.end() ? itr->second->fd() : -1 ;
 }

StatusCode FileMgr::finalize ( )

override

Definition at line 202 of file FileMgr.cpp.

                   {
   ON_VERBOSE
     m_log << MSG::VERBOSE << "FileMgr::finalize()" << endmsg;
 
 
   if (m_printSummary || outputLevel() <= MSG::DEBUG) {
     listHandlers();
     listFiles();
     listActions();
     listSuppression();
   }
 
 
   if (!m_files.empty()) {
     m_log << MSG::WARNING
       << "At finalize, the following files remained open:"
       << endl;
     for (const auto& itr : m_files) m_log << *(itr.second) << endl;
     m_log << endmsg;
   }
 
   if (m_logfile.value() != "") {
     std::ofstream ofs;
     ofs.open(m_logfile.value().c_str());
     if (!ofs) {
       m_log << MSG::ERROR << "Unable to open output file \"" << m_logfile.value()
         << "\" for writing"
         << endmsg;
     } else {
       ON_DEBUG
       m_log << MSG::DEBUG << "Saving log to \"" << m_logfile.value() << "\""
             << endmsg;
       for (const auto& itr : m_files) {
         ofs << itr.second->name() << "  " << itr.second->tech() << "  "
             << itr.second->desc() << "  " << itr.second->iflags() << endl;
       }
 
       set<FileAttr> fs;
       for (const auto& it2 : m_oldFiles) fs.insert(*it2);
       for (const auto& it3 : fs ) {
         ofs << it3.name() << "  " << it3.tech() << "  " << it3.desc()
             << "  " << it3.iflags()
             << ( it3.isShared() ? "  SHARED" : "" )
             << endl;
       }
       ofs.close();
     }
   }
 
   // cleanup FileAttrs
   m_attr.clear();
 
   m_rfh.reset();
   m_pfh.reset();
 
 
   StatusCode status = Service::finalize();
 
   ON_DEBUG
   if ( status.isSuccess() )
       m_log << MSG::DEBUG << "Service finalised successfully" << endmsg;
 
   return status;
 
 }

const std::string & FileMgr::fname ( const Io::Fd & fd ) const

override

Definition at line 1212 of file FileMgr.cpp.

                                    {
 
   auto itr = std::find_if( std::begin(m_files), std::end(m_files), 
                            [&](fileMap::const_reference f) { return f.second->fd() == fd; } );
   return (itr!=std::end(m_files)) ? itr->second->name() : s_empty; 
 
 }

const std::string & FileMgr::fname ( void * vp ) const

override

Definition at line 1223 of file FileMgr.cpp.

                              {
 
   auto itr = std::find_if( m_files.begin(), m_files.end(), 
                           [&](fileMap::const_reference f) {
     return  f.second->fptr() == vp;
   });
   return itr!=m_files.end() ? itr->second->name() : s_empty;
 }

void * FileMgr::fptr ( const std::string & fname ) const

override

Definition at line 1258 of file FileMgr.cpp.

                                           {
   auto fitr = m_files.equal_range(fname);
   auto itr = std::find_if( fitr.first, fitr.second, [](fileMap::const_reference f) -> bool {
                 return f.second->fptr();
   } );
   return itr!=fitr.second ? itr->second->fptr() : nullptr;
 }

void * FileMgr::fptr ( const Io::Fd & fd ) const

override

Definition at line 1269 of file FileMgr.cpp.

                                   {
 
   auto itr = std::find_if(m_files.begin(),m_files.end(),[&](fileMap::const_reference f) {
         return f.second->fd() == fd;
   } );
   return itr!=m_files.end() ?  itr->second->fptr() : nullptr;
 }

int FileMgr::getFd ( std::vector< Fd > & ) const

override

int FileMgr::getFd	(	const Io::IoTech &	tech,
		std::vector< Io::Fd > &	fd
	)		const

override

Definition at line 1179 of file FileMgr.cpp.

                                                        {
 
   if (tech == UNKNOWN) return getFd( fd );
 
   fd.clear();
   transform_if( std::begin(m_descriptors), std::end(m_descriptors), std::back_inserter(fd),
                 select1st,
                 [&](const std::pair<Fd,FileAttr*>& d) { return d.second->tech()==tech; } );
 
   return fd.size();
 
 }

int FileMgr::getFd	(	const Io::IoTech &	tech,
		const Io::IoFlags &	flags,
		std::vector< Io::Fd > &	fd
	)		const

override

Definition at line 1197 of file FileMgr.cpp.

                                                                              {
 
   fd.clear();
   transform_if( m_descriptors.begin(), m_descriptors.end(),
                 std::back_inserter(fd), select1st,
                 [&](const std::pair<Fd,FileAttr*>& d) { 
                       return (d.second->tech() == tech || tech == UNKNOWN) &&
                              ( d.second->flags() == flags ); 
   } );
   return fd.size();
 }

int FileMgr::getFileAttr	(	const std::string &	fname,
		std::vector< const FileAttr * > &	fa
	)		const

override

Definition at line 974 of file FileMgr.cpp.

                                                                               {
 
   fa.clear();
 
   auto fitr = m_files.equal_range(fname);
   std::transform( fitr.first, fitr.second, std::back_inserter(fa), select2nd );
 
   std::copy_if( std::begin(m_oldFiles), std::end(m_oldFiles),
                 std::back_inserter(fa), [&](const FileAttr* f ) { return f->name() == fname; } );
 
   return fa.size();
 
 }

StatusCode FileMgr::getFileAttr	(	const Fd	,
		const FileAttr *&
	)		const

override

StatusCode FileMgr::getFileAttr	(	void *	vp,
		const FileAttr *&	fa
	)		const

override

Definition at line 1014 of file FileMgr.cpp.

                                                         {
 
   auto i = std::find_if( std::begin(m_files), std::end(m_files),
                          [&](fileMap::const_reference f) { return f.second->fptr() == vp; } );
   if (i != std::end(m_files)) {
       fa = i->second;
       return StatusCode::SUCCESS;
   }
 
   auto j = std::find_if( std::begin(m_oldFiles), std::end(m_oldFiles),
                          [&](const FileAttr* f) { return f->fptr() == vp; } );
   if (j != std::end(m_oldFiles)) {
       fa = *j;
       return StatusCode::SUCCESS;
   }
 
   return StatusCode::FAILURE;
 
 }

int FileMgr::getFiles	(	std::vector< std::string > &	files,
		bool	onlyOpen = `true`
	)		const

override

Definition at line 1037 of file FileMgr.cpp.

                                                             {
 
   files.clear();
   auto not_in_files = [&](const std::string& i) { return std::none_of( std::begin(files), std::end(files), 
                                                                        [&](const std::string& j) { return j==i; } ); };
   transform_copy_if( std::begin(m_files), std::end(m_files), std::back_inserter(files),
                      to_name,
                      not_in_files );
   if (!op) {
     transform_copy_if( std::begin(m_oldFiles), std::end(m_oldFiles), std::back_inserter(files),
                        to_name,
                        not_in_files );
   }
   return files.size();
 }

int FileMgr::getFiles	(	std::vector< const Io::FileAttr * > &	files,
		bool	onlyOpen = `true`
	)		const

override

Definition at line 1056 of file FileMgr.cpp.

                                                                  {
 
   files.clear();
   std::transform(std::begin(m_files), std::end(m_files), std::back_inserter(files),
                  select2nd );
   if (!op) {
     std::copy(std::begin(m_oldFiles), std::end(m_oldFiles), std::back_inserter(files));
   }
   return files.size();
 
 }

int FileMgr::getFiles	(	const Io::IoTech &	tech,
		std::vector< std::string > &	files,
		bool	onlyOpen = `true`
	)		const

override

Definition at line 1071 of file FileMgr.cpp.

                                                                           {
 
   if (tech == UNKNOWN) return getFiles(files,op);
 
   files.clear();
   transform_if( std::begin(m_files), std::end(m_files), std::back_inserter(files),
                 to_name,
                 [&](fileMap::const_reference f) { return f.second->tech() == tech && 
                                                   std::none_of( std::begin(files), std::end(files), [&](const std::string& j) { return j==f.first; } ); } );
 
   if (!op) {
     transform_if( std::begin(m_oldFiles), std::end(m_oldFiles), std::back_inserter(files),
                   to_name,
                   [&](const FileAttr* f) { return f->tech() == tech &&
                                                   std::none_of( std::begin(files), std::end(files), [&](const std::string& j) { return j == f->name(); } ) ; } ); 
   }
   return files.size();
 
 }

int FileMgr::getFiles	(	const Io::IoTech &	tech,
		std::vector< const Io::FileAttr * > &	files,
		bool	onlyOpen = `true`
	)		const

override

Definition at line 1094 of file FileMgr.cpp.

                                  {
 
   if (tech == UNKNOWN) return getFiles(files,op);
 
   auto matches_tech = [&](const FileAttr* f) { return f->tech()==tech; } ;
 
   files.clear();
   transform_copy_if( std::begin(m_files), std::end(m_files), std::back_inserter(files),
                      select2nd, matches_tech );
   if (!op) {
     std::copy_if( std::begin(m_oldFiles), std::end(m_oldFiles), std::back_inserter(files),
                   matches_tech );
   }
 
   return files.size();
 
 }

int FileMgr::getFiles	(	const Io::IoTech &	tech,
		const Io::IoFlags &	flags,
		std::vector< std::string > &	files,
		bool	onlyOpen = `true`
	)		const

override

Definition at line 1116 of file FileMgr.cpp.

                                                 {
 
   files.clear();
 
   auto not_in_files = [&](const std::string& n) { return std::none_of( std::begin(files), std::end(files),
                                                                        [&](const std::string& f) { return f==n; } ); };
   auto matches_tech_and_flags = [&](const FileAttr* f) { return ( f->tech() == tech || tech == UNKNOWN ) && f->flags() == flags ; } ;
 
   transform_if( std::begin(m_files), std::end(m_files), std::back_inserter(files),
                 to_name,
                 [&](fileMap::const_reference f) { return matches_tech_and_flags( f.second ) && not_in_files( f.first ); } );
   if (!op) {
     transform_if( std::begin(m_oldFiles), std::end(m_oldFiles), std::back_inserter(files),
                   to_name,
                   [&](const FileAttr* f) { return matches_tech_and_flags(f) && not_in_files(f->name()); } );
   }
 
   return files.size();
 
 }

int FileMgr::getFiles	(	const Io::IoTech &	tech,
		const Io::IoFlags &	flags,
		std::vector< const Io::FileAttr * > &	files,
		bool	onlyOpen = `true`
	)		const

override

Definition at line 1140 of file FileMgr.cpp.

                                                            {
 
   files.clear();
 
   auto matches_tech_and_flags = [&](const FileAttr* f) { return ( f->tech() == tech || tech == UNKNOWN ) 
                                                              && f->flags() == flags ; } ;
 
   transform_copy_if( std::begin(m_files), std::end(m_files), std::back_inserter(files),
                      select2nd,
                      matches_tech_and_flags );
   if (!op) {
     std::copy_if( std::begin(m_oldFiles), std::end(m_oldFiles), std::back_inserter(files),
                   matches_tech_and_flags );
   }
 
   return files.size();
 }

StatusCode FileMgr::getHandler	(	const IoTech &	,
		FileHdlr &
	)		const

override

StatusCode FileMgr::getHandler	(	const std::string &	fname,
		Io::FileHdlr &	hdlr
	)		const

override

Definition at line 1321 of file FileMgr.cpp.

                                                                   {
 
   auto fitr = m_files.equal_range(fname);
   if (fitr.first == fitr.second) {
     m_log << MSG::ERROR
       << "no file \"" << fname << "\" registered. Cannot determine tech"
       << endmsg;
     return StatusCode::FAILURE;
   }
 
   auto itr = fitr.first;
   IoTech tech = itr->second->tech();
 
   ++itr;
   while( itr != fitr.second ) {
     if ( itr->second->tech() != tech ) {
       m_log << MSG::ERROR
         << "multiple technologies registered for file \"" << fname
         << "\". Cannot determine handler" << endmsg;
       return StatusCode::FAILURE;
     }
     ++itr;
   }
 
   return getHandler(tech,hdlr);
 
 }

int FileMgr::getLastError ( std::string & err ) const

override

Definition at line 1295 of file FileMgr.cpp.

                                           {
 
   err = m_lastErrS;
   return m_lastErr;
 
 }

void FileMgr::handle ( const Incident & )

override

Definition at line 271 of file FileMgr.cpp.

                                  {
 
 }

StatusCode FileMgr::hasHandler ( const IoTech & ) const

override

Definition at line 343 of file FileMgr.cpp.

                                               {
 
   auto itr = m_handlers.find(tech);
   return (itr != m_handlers.end()) ? StatusCode::SUCCESS : StatusCode::FAILURE;
 
 }

StatusCode FileMgr::initialize ( )

override

Definition at line 106 of file FileMgr.cpp.

                     {
 
   // Super ugly hack to make sure we have the OutputLevel set first, so we
   // can see DEBUG printouts in update handlers.
   auto jos = serviceLocator()->service<IJobOptionsSvc>( "JobOptionsSvc", true );
   const auto *props = ( jos ? jos->getProperties( name() ) : nullptr );
   if (props) {
     auto prop = std::find_if( std::begin(*props), std::end(*props),
                               [&](const Property* p) { 
                                   return p->name() == "OutputLevel";
     });
     if (prop!=std::end(*props)) {
       setProperty( **prop ).ignore();
       m_log.setLevel( m_outputLevel.value() );
     }
   }
 
   StatusCode status = Service::initialize();
   m_log.setLevel( m_outputLevel.value() );
 
   if (status.isFailure()) {
 
     ON_DEBUG
       m_log << MSG::DEBUG << "Failed to initialize the base class (Service)"
         << endmsg;
     return status;
   }
 
   ON_VERBOSE
     m_log << MSG::VERBOSE << "Initializing FileMgr" << endmsg;
 
   if (m_loadRootHandler.value()) {
 
     // setup file handler for ROOT
 
     msgSvc()->setOutputLevel( "RootFileHandler", m_outputLevel.value());
     m_rfh.reset(  new RootFileHandler(msgSvc(), m_ssl_proxy, m_ssl_cert) );
 
     auto rfh = m_rfh.get(); // used in the lambdas to avoid capturing 'this'
     Io::FileHdlr hdlr(Io::ROOT,
                       [rfh](const std::string& n, const Io::IoFlags& f,
                          const std::string& desc, Io::Fd& fd,
                          void*& ptr) -> Io::open_t {
                            return rfh->openRootFile(n, f, desc, fd, ptr);
                       },
                       [rfh](void* ptr) -> Io::close_t {
                         return rfh->closeRootFile(ptr);
                       },
                       [rfh](void* ptr, const Io::IoFlags& f) -> Io::reopen_t {
                         return rfh->reopenRootFile(ptr, f);
                       });
 
     if (regHandler(hdlr).isFailure()) {
       m_log << MSG::ERROR
         << "unable to register ROOT file handler with FileMgr"
         << endmsg;
     }
   }
 
   if (m_loadPosixHandler.value()) {
 
     // setup file handler for POSIX
 
     msgSvc()->setOutputLevel( "POSIXFileHandler", m_outputLevel.value());
     m_pfh.reset( new POSIXFileHandler(msgSvc()) );
 
     auto pfh = m_pfh.get(); // used in the lambdas to avoid capturing 'this'
     Io::FileHdlr hdlp(Io::POSIX,
                       [pfh](const std::string& n, const Io::IoFlags& f,
                             const std::string& desc, Io::Fd& fd,
                             void*& ptr) -> Io::open_t {
                         return pfh->openPOSIXFile(n, f, desc, fd, ptr);
                       },
                       [pfh](Io::Fd fd) -> Io::close_t {
                         return pfh->closePOSIXFile(fd);
                       },
                       [pfh](Io::Fd fd, const Io::IoFlags& f) -> Io::reopen_t {
                          return pfh->reopenPOSIXFile(fd, f);
                       });
 
     if (regHandler(hdlp).isFailure()) {
       m_log << MSG::ERROR
         << "unable to register ROOT file handler with FileMgr"
         << endmsg;
     }
   }
 
 
 
   return StatusCode::SUCCESS;
 
 }

bool FileMgr::isShareable	(	const std::string &	filename,
		const Io::IoFlags &
	)		const

private

void FileMgr::listActions ( ) const

virtual

Definition at line 1391 of file FileMgr.cpp.

                            {
 
   m_log << MSG::INFO << "listing registered actions" << endl;
 
   for (const auto& iit : m_actions) {
     Io::IoTech t = iit.first;
     const actionMap& m = iit.second;
 
     if (!m.empty()) {
       m_log << " --- Tech: ";
       if (t == Io::UNKNOWN) {
         m_log << "ALL ---" << endl;
       } else {
         m_log << t << " ---" << endl;
       }
       for (const auto& iia : m ) {
         for (const auto& it2 : iia.second ) {
             m_log << "   " << iia.first << "  "
                   << it2.second << endl;
         }
       }
     }
   }
   m_log << endmsg;
 }

void FileMgr::listFiles ( ) const

override

Definition at line 1280 of file FileMgr.cpp.

                          {
 
   m_log << MSG::INFO << "listing registered files ["
     << (m_files.size() + m_oldFiles.size() )
     << "]:" << endl;
 
   for (auto& itr : m_files    ) m_log << itr.second << endl;
   for (auto& it2 : m_oldFiles ) m_log << *it2 << endl;
 
   m_log << endmsg;
 }

void FileMgr::listHandlers ( ) const

override

Definition at line 1352 of file FileMgr.cpp.

                             {
 
   m_log << MSG::INFO
     << "Listing registered handlers:" << endl;
 
   for (const auto& itr : m_handlers ) m_log << "    " << itr.first << endl;
   m_log << endmsg;
 
 }

void FileMgr::listSuppression ( ) const

virtual

Definition at line 1541 of file FileMgr.cpp.

                                {
 
   if (m_supMap.empty())  return;
 
   m_log << MSG::INFO << "listing suppressed file actions" << endl;
 
   for (auto it2=m_supMap.begin(); it2 != m_supMap.end(); ++it2) {
     m_log << "  " << it2->first;
     if (get_bit(it2->second, Io::INVALID_ACTION)) {
       m_log << " ALL" << endl;
     } else {
       for (int i=0; i<Io::INVALID_ACTION; ++i) {
     if (get_bit(it2->second,i)) { m_log << " " << (Io::Action)i; }
       }
       m_log << endl;
     }
   }
 
   m_log << endmsg;
 }

open_t FileMgr::open	(	const Io::IoTech &	tech,
		const std::string &	caller,
		const std::string &	fname,
		const Io::IoFlags &	flags,
		Io::Fd &	fd,
		void *&	ptr,
		const std::string &	desc = `""`,
		const bool	shared = `false`
	)

override

Definition at line 353 of file FileMgr.cpp.

                                            {
 
   return open(tech, caller, fname, desc, flags, fd, ptr, sh);
 
 }

open_t FileMgr::open	(	const Io::IoTech &	tech,
		const std::string &	caller,
		const std::string &	fname,
		const Io::IoFlags &	flags,
		Io::Fd &	fd,
		const std::string &	desc = `""`,
		const bool	shared = `false`
	)

override

Definition at line 364 of file FileMgr.cpp.

                     {
 
   void* dummy(0);
   return open(tech, caller, fname, desc, flags, fd, dummy, sh);
 
 }

open_t FileMgr::open	(	const Io::IoTech &	tech,
		const std::string &	caller,
		const std::string &	fname,
		const Io::IoFlags &	flags,
		void *&	ptr,
		const std::string &	desc = `""`,
		const bool	shared = `false`
	)

override

Definition at line 376 of file FileMgr.cpp.

                     {
 
   Fd dummy(-1);
   return open(tech, caller, fname, desc, flags, dummy, ptr, sh);
 
 }

virtual Io::open_t FileMgr::open	(	const IoTech &	,
		const std::string &	caller,
		const std::string &	fname,
		const std::string &	desc,
		const IoFlags &	,
		Fd &	,
		void *&	,
		const bool	shared
	)

privatevirtual

StatusCode FileMgr::regAction	(	Io::bfcn_action_t	bf,
		const Io::Action &	a,
		const std::string &	desc = `""`
	)

override

Definition at line 1365 of file FileMgr.cpp.

                                                                           {
 
   return regAction(bf,a,Io::UNKNOWN,d);
 
 }

StatusCode FileMgr::regAction	(	Io::bfcn_action_t	bf,
		const Io::Action &	a,
		const Io::IoTech &	t,
		const std::string &	desc = `""`
	)

override

Definition at line 1374 of file FileMgr.cpp.

                                {
 
   ON_DEBUG
     m_log << MSG::DEBUG << "registering " << a << " action "
       << System::typeinfoName(bf.target_type())
       << " for tech " << t << endmsg;
 
   m_actions[t][a].emplace_back(bf, (!d.empty()) ? d 
                                                 : System::typeinfoName(bf.target_type()));
   return StatusCode::SUCCESS;
 
 }

StatusCode FileMgr::regHandler ( FileHdlr fh )

override

Definition at line 278 of file FileMgr.cpp.

                                {
 
   IoTech tech = fh.tech;
 
   if (m_handlers.find(tech) != m_handlers.end()) {
     m_log << MSG::WARNING
       << "Handler for IoTech " << tech << " already registered. Ignoring."
       << endmsg;
     return StatusCode::SUCCESS;
   }
 
   if ( ! fh.b_open_fcn ) {
     m_log << MSG::ERROR
       << "open handler for tech " << tech << " is NULL"
       << endmsg;
     return StatusCode::FAILURE;
   }
 
   if ( ! fh.b_close_fcn && ! fh.b_closeP_fcn ) {
     m_log << MSG::ERROR
       << "no close handler for tech " << tech << " registered"
       << endmsg;
     return StatusCode::FAILURE;
   }
 
   if ( ! fh.b_reopen_fcn && ! fh.b_reopenP_fcn) {
     m_log << MSG::ERROR
       << "no reopen handler for tech " << tech << " registered"
       << endmsg;
     return StatusCode::FAILURE;
   }
 
 
   ON_DEBUG
     m_log << MSG::DEBUG
       << "Successfully registered handler for tech \"" << tech << "\""
       << endmsg;
 
   m_handlers[tech] = fh;
 
   return StatusCode::SUCCESS;
 
 }

Io::reopen_t FileMgr::reopen	(	const Fd	,
		const IoFlags &	,
		const std::string &	caller
	)

override

reopen_t FileMgr::reopen	(	void *	vp,
		const IoFlags &	flags,
		const std::string &	caller
	)

override

Definition at line 894 of file FileMgr.cpp.

                                                                        {
   ON_VERBOSE
     m_log << MSG::VERBOSE << "reopen("  << vp << "," << flags
       << "," << caller << ")"
       << endmsg;
 
   reopen_t r = -1;
 
   auto itr = std::find_if( std::begin(m_files), std::end(m_files), 
                            [&](fileMap::const_reference f) {
                                return f.second->fptr() == vp ; } );
   if (itr == m_files.end()) {
     m_log << MSG::ERROR
       << "unregistered file ptr \"" << vp
       << "\" when calling reopen()"
       << endmsg;
     return r;
   }
 
   FileAttr *fa = itr->second;
   FileHdlr fh;
   IoTech tech = fa->tech();
 
   if (getHandler(tech,fh).isFailure()) {
     return r;
   }
 
   if ( ! fh.b_reopenP_fcn ) {
     m_log << MSG::ERROR << "no reopen(" << tech << ",void*) function registered"
       << endmsg;
     return -1;
   }
 
   try {
     r = fh.b_reopenP_fcn(vp,flags);
   } catch (const std::bad_function_call& err) {
     m_log << MSG::ERROR << "when calling reopen handler for " << tech
       << " on file " << fa->name() << " with flags "
       << flags
       << " caught " << err.what() << endmsg;
     return -1;
   } catch (...) {
     m_log << MSG::ERROR << "when calling reopen handler for " << tech
       << " on file " << fa->name() << " with flags "
       << flags
       << " caught an unknown exception." << endmsg;
     return -1;
   }
 
   if (r < 0) {
     m_log << MSG::WARNING
       << "reopen of file with ptr \"" << vp
       << "\", name: \"" << fa->name()
       << "\", tech: \"" << tech
       << "\", flags: \"" << flags << "\" failed"
       << endmsg;
 
     execAction(fa, caller, Io::REOPEN_ERR ).ignore();
 
     return r;
 
   }
 
   fa->isOpen(true);
   fa->flags(flags);
 
   // exec all callbacks
   if (execAction(fa, caller, Io::REOPEN).isFailure()) {
     m_log << MSG::WARNING
       << "at least one reopen callback action failed"
       << endmsg;
   }
 
   return r;
 
 }

void FileMgr::suppressAction ( const std::string & f )

override

Definition at line 1516 of file FileMgr.cpp.

                                           {
 
   return suppressAction(f,Io::INVALID_ACTION);
 
 }

void FileMgr::suppressAction	(	const std::string &	f,
		const Io::Action &	a
	)

override

Definition at line 1525 of file FileMgr.cpp.

                                                              {
 
   auto it2 = m_supMap.find(f);
   if (it2 == m_supMap.end()) {
     int b(0);
     set_bit(b,a);
     m_supMap[f] = b;
   } else {
     set_bit(it2->second, a);
   }
 
 }

Member Data Documentation

std::map< IoTech, actionMap > FileMgr::m_actions

private

Definition at line 161 of file FileMgr.h.

std::vector<std::unique_ptr<FileAttr> > FileMgr::m_attr

private

Definition at line 157 of file FileMgr.h.

std::map<Fd, FileAttr*> FileMgr::m_descriptors

private

Definition at line 156 of file FileMgr.h.

fileMap FileMgr::m_files

private

Definition at line 154 of file FileMgr.h.

std::map<IoTech, FileHdlr> FileMgr::m_handlers

private

Definition at line 155 of file FileMgr.h.

int FileMgr::m_lastErr

private

Definition at line 167 of file FileMgr.h.

std::string FileMgr::m_lastErrS

private

Definition at line 166 of file FileMgr.h.

BooleanProperty FileMgr::m_loadPosixHandler

private

Definition at line 133 of file FileMgr.h.

BooleanProperty FileMgr::m_loadRootHandler

private

Definition at line 133 of file FileMgr.h.

MsgStream FileMgr::m_log

mutableprivate

Definition at line 171 of file FileMgr.h.

StringProperty FileMgr::m_logfile

private

Definition at line 132 of file FileMgr.h.

std::vector<FileAttr*> FileMgr::m_oldFiles

private

Definition at line 159 of file FileMgr.h.

std::unique_ptr<POSIXFileHandler> FileMgr::m_pfh

private

Definition at line 170 of file FileMgr.h.

BooleanProperty FileMgr::m_printSummary

private

Definition at line 133 of file FileMgr.h.

std::unique_ptr<RootFileHandler> FileMgr::m_rfh

private

Definition at line 169 of file FileMgr.h.

StringProperty FileMgr::m_ssl_cert

private

Definition at line 134 of file FileMgr.h.

StringProperty FileMgr::m_ssl_proxy

private

Definition at line 134 of file FileMgr.h.

supMap FileMgr::m_supMap

private

Definition at line 164 of file FileMgr.h.

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

GaudiSvc/src/FileMgr/FileMgr.h
GaudiSvc/src/FileMgr/FileMgr.cpp

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation