---

DbBaseConverter.cpp

Go to the documentation of this file.

//====================================================================
//      DbBaseConverter implementation
//--------------------------------------------------------------------
//
//      Package    : System ( The LHCb Offline System)
//
//  Description: Generic Db data converter
//
//      Author     : M.Frank
//====================================================================
#define DBCNV_DBBASECONVERTER_CPP
// $Header: /nfs/slac/g/glast/ground/cvs/GaudiDb/src/Base/DbBaseConverter.cpp,v 1.1.1.1 2001/04/18 21:13:34 tlindner Exp $

// Framework include files
#include "GaudiKernel/System.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/RegistryEntry.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IAddressCreator.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IObjManager.h"

#include "GaudiDb/IOODataBase.h"
#include "GaudiDb/IDataBaseMgr.h"
#include "GaudiDb/DbVArray.h"
#include "GaudiDb/DbDataBase.h"
#include "GaudiDb/DbBaseConverter.h"
#include "GaudiDb/DbAddress.h"

DbBaseConverter::DbBaseConverter(const CLID& clid, IOODataBase* db, ISvcLocator* svc)
: Converter(db->type(), clid, svc), m_db(db), m_type(0)
{
  std::string typName = System::typeinfoName(typeid(DbObject));
  m_type = db->typeInfo(typName);
  m_cnvSvcName  = db->name().substr(0,db->name().rfind("."));
  m_helperServices.clear();
  m_persSvcName = "EventPersistencySvc";
  m_dataSvcName = "EventDataSvc";
}

DbBaseConverter::~DbBaseConverter()     {
}

const DbTypeInfo* DbBaseConverter::typeInfo()  const    {
  return m_type;
}

StatusCode DbBaseConverter::initialize()   {
  StatusCode status = Converter::initialize();
  MsgStream log(msgSvc(),"DbBaseConverter");
  if ( !status.isSuccess() )   {
    log << MSG::ERROR << "Cannot initialize base class \"Converter\"" << endreq;
    return status;
  }
  m_helperServices.clear();

  status = serviceLocator()->getService(m_cnvSvcName,IID_IDataBaseMgr,(IInterface*&)m_helperServices.DbaseMgr);
  if ( !status.isSuccess() )    {
    log << MSG::ERROR << "Cannot connect to \"" << m_cnvSvcName << "\"" << endreq;
    return status;
  }
  status = serviceLocator()->getService(m_persSvcName,IID_IConversionSvc,(IInterface*&)m_helperServices.PersSvc);
  if ( !status.isSuccess() )    {
    log << MSG::ERROR << "Cannot connect to \"" << m_persSvcName << "\"" << endreq;
    return status;
  }
  status = serviceLocator()->getService(m_dataSvcName,IID_IDataProviderSvc,(IInterface*&)m_helperServices.DataSvc);
  if ( !status.isSuccess() )    {
    log << MSG::ERROR << "Cannot connect to \"" << m_dataSvcName << "\"" << endreq;
    return status;
  }
  status = serviceLocator()->queryInterface(IID_IObjManager, (void**)&m_helperServices.ObjManager);
  if ( !status.isSuccess() )    {
    log << MSG::ERROR << "Cannot connect to \"ObjManager\"" << endreq;
    return status;
  }
  m_helperServices.PersSvc->queryInterface(IID_IAddressCreator, (void**)&m_helperServices.AddrCreator);
  m_helperServices.DbaseMgr->queryInterface(IID_IConversionSvc, (void**)&m_helperServices.CnvSvc);
  m_helperServices.SvcLocator = serviceLocator();
  m_helperServices.MessageSvc = messageService();
  if ( 0 == m_type )    {
    log << MSG::ERROR << "No type information availible...." << endreq;
    return StatusCode::FAILURE;
  }
  return status;
}

StatusCode DbBaseConverter::finalize()   {
  StatusCode status = Converter::finalize();     // Just call the base class
  m_helperServices.clear();
  return status;
}

DataObject* DbBaseConverter::createTransient()   {
  return new DataObject();
}

const std::string DbBaseConverter::containerName(IDataDirectory* pDir)  const {
  return pDir->fullpath();
}

dbHandle<DbObject> DbBaseConverter::createPersistent(dbHandle<DbContainer>& cntH)  {
  dbHandle<DbObject> handle = new(cntH, *m_type) DbObject();
  return handle;
}

StatusCode DbBaseConverter::createObj(IOpaqueAddress* /* pAddress */ , DataObject*& refpObject)   {
  refpObject = createTransient();
  return StatusCode::SUCCESS;
}

StatusCode DbBaseConverter::fillObjRefs(IOpaqueAddress* pAddress, DataObject* pObject )   {
  return updateObjRefs(pAddress, pObject);
}

StatusCode DbBaseConverter::updateObj(IOpaqueAddress* /* pAddress */ , DataObject* /* pObject */ )   {
  return StatusCode::SUCCESS;
}

StatusCode DbBaseConverter::updateObjRefs(IOpaqueAddress* pAddress, DataObject* pObject)   {
  try     {
    DbAddress* pAddr = dynamic_cast<DbAddress*>(pAddress);
    if ( 0 != pObject && 0 != pAddr )   {
      // OK. Data are read, now update the transient representation(s)
      dbHandle<DbDefObject> objH = pAddr->objectHdl();
      dbHandle<DbLink>      lnkH = *pAddr;
      if ( objH.open(pAddr->containerHdl(), lnkH) )   {
        StatusCode status = updateTransientDirectoryLinks( objH, pObject );
        if ( status.isSuccess() )   {
          status = updateTransientSymbolicLinks( objH, pObject );
          if ( status.isSuccess() )   {
            status = beginTransientUpdate( objH, pObject );
            if ( status.isSuccess() )   {
              status = doTransientUpdate( objH, pObject );
              if ( status.isSuccess() )   {
                status = endTransientUpdate( objH, pObject );
                if ( status.isSuccess() )   {
                  return afterTransientUpdate( objH, pObject );
                }
              }
            }
          }
        }
      }
    }
  }
  catch (...)   {
  }
  MsgStream log(messageService(),"DbBaseConverter");
  log << MSG::INFO << "updateObjRefs: Cannot load object data from persistent medium..." << endreq;
  return StatusCode::FAILURE;
}

StatusCode DbBaseConverter::createRep(DataObject* pObject, IOpaqueAddress*& refpAddress)   {
  refpAddress = 0;
  if ( 0 != pObject )   {
    try   {
      dbHandle<DbContainer> cntH;
      dbHandle<DbDataBase>  dbH = m_helperServices.DbaseMgr->defaultDbHdl();
      std::string cntName = containerName(pObject->directory());
      if ( cntH.open(dbH, cntName, *m_type, DbOOMs::UPDATE|DbOOMs::CREATE) )   {
        dbHandle<DbObject> objH = createPersistent(cntH);
        if ( objH.isValid() )   {
          refpAddress = new DbAddress(objH, pObject->clID());
          if ( updateRep(refpAddress, pObject).isSuccess() )   {
            return StatusCode::SUCCESS;
          }
        }
      }
    }
    catch (...)   {
    }
  }
  if ( 0 != refpAddress )   {
    refpAddress->release();
    refpAddress = 0;
  }
  MsgStream log(messageService(),"DbBaseConverter");
  log << MSG::FATAL << "Fatal Error in createRep:" << __FILE__ << " line " << __LINE__ << endreq;
  return StatusCode::FAILURE;
}

StatusCode DbBaseConverter::fillRepRefs(IOpaqueAddress* pAddress, DataObject* pObject)  {
  try   {
    DbAddress* pAddr = dynamic_cast<DbAddress*>(pAddress);
    StatusCode status = doUpdateRepRefs(pAddress, pObject);
    if ( status.isSuccess() && 0 != pAddr )   {
      dbHandle<DbObject>& objH = pAddr->objectHdl();
      // All fine: now is actually the time to add the entry to the container
      if ( pAddr->containerHdl().addEntry(objH) )    {
        dbHandle<DbDefObject> dobjH = objH;
        status = afterPersistentUpdate(dobjH, pObject);
        if ( status.isSuccess() )   {
          return StatusCode::SUCCESS;
        }
      }
    }
  }
  catch (...)   {
  }
  return StatusCode::FAILURE;
}

StatusCode DbBaseConverter::updateRepRefs(IOpaqueAddress* pAddress, DataObject* pObject)     {
  try   {
    DbAddress* pAddr = dynamic_cast<DbAddress*>(pAddress);
    StatusCode status = doUpdateRepRefs(pAddress, pObject);
    if ( status.isSuccess() && 0 != pAddr )   {
      dbHandle<DbObject>& objH = pAddr->objectHdl();
      // All fine: now is actually the time to add the entry to the container
      if ( pAddr->containerHdl().updateEntry(objH) )    {
        dbHandle<DbDefObject> dobjH = objH;
        status = afterPersistentUpdate(dobjH, pObject);
        if ( status.isSuccess() )   {
          return StatusCode::SUCCESS;
        }
      }
    }
  }
  catch (...)   {
  }
  return StatusCode::FAILURE;
}

StatusCode DbBaseConverter::updateRep(IOpaqueAddress* pAddress, DataObject* pObject)     {
  StatusCode status = StatusCode::FAILURE;
  try   {
    DbAddress* pAddr = dynamic_cast<DbAddress*>(pAddress);
    if ( 0 != pObject && 0 != pAddr && pAddr->isValid() )    {
      dbHandle<DbObject>& oH = pAddr->objectHdl();
      if ( !oH.isValid() )   {
        dbHandle<DbLink> lnkH = *pAddr;
        oH.open(pAddr->containerHdl(), lnkH);
      }
      dbHandle<DbDefObject> objH = oH;
      if ( objH.isValid() )   {
        status = preparePersistentUpdate( objH, pObject );
        if ( status.isSuccess() )   {
          return beginPersistentUpdate( objH, pObject );
        }
      }
    }
  }
  catch (...)   {
  }
  MsgStream log(messageService(),"DbBaseConverter");
  log << MSG::FATAL << "Fatal Error in updateRep:" << __FILE__ << " line " << __LINE__ << endreq;
  return StatusCode::FAILURE;
}

StatusCode DbBaseConverter::doUpdateRepRefs(IOpaqueAddress* pAddress, DataObject* pObj)   {
  std::string error = "Unknown exception";
  try   {
    DbAddress* pAddr = dynamic_cast<DbAddress*>(pAddress);
    if ( 0 != pObj && 0 != pAddr )    {
      dbHandle<DbDefObject> objH = pAddr->objectHdl();
      if ( objH.isValid() )   {
        // Add the directory leafs of the DataObject
        objH->links().remove_all();
        StatusCode status = doPersistentUpdate( objH, pObj );
        if ( status.isSuccess() )   {
          status = endPersistentUpdate(objH, pObj);
          if ( status.isSuccess() )     {
            status = addPersistentDirectoryLinks(objH, pObj);
            if ( status.isSuccess() )   {
              return addPersistentSymbolicLinks(objH, pObj);
            }
            else  {
              error = "addPersistentDirectoryLinks";
            }
          }
          else  {
            error = "endPersistentUpdate";
          }
        }
        else  {
          error = "doPersistentUpdate";
        }
      }
      else    {
        error = "Invalid Obj handle";
      }
    }
    else    {
      error = "invalid address/object";
    }
  }
  catch (...)   {
  }
  MsgStream log(messageService(),"DbBaseConverter");
  log << MSG::FATAL << "Fatal Error in doUpdateRepRefs:" << __FILE__ << " line " << __LINE__ 
      << " Obj:" << pObj->fullpath() 
      << " Error: " << error
      << endreq;
  return StatusCode::FAILURE;
}

StatusCode DbBaseConverter::addPersistentLink(IOpaqueAddress* pA, dbHandle<DbDefObject>& /* objH */, const DataObject* pObj)   {
  StatusCode iret = StatusCode::FAILURE;
  /*
  // If the address does not exist, it means that the object
  // is not written to disk; we do not have to store the persistent reference.
  iret = StatusCode::SUCCESS;
  // Now store the persistent address (if possible)
  if ( 0 != pA )   {    
    dbHandle<DbLink> to(*pA->genericLink());
    //std::cout << "Add leaf:" << obj << " #Links:" << m_objLinks.size() << " #Leafs:" << m_objSymLinks.size() << std::endl;
    dbHandle<DbDataBase> dbH = objH.containedIn().containedIn();
    if ( dbH.addAssocEntry(pA->dbName(), pA->containerName(), pA->objectName(), to) )  {
      iret = objH->links().extend(to);
    }
  }
  */
  if ( !iret.isSuccess() )   {
    MsgStream err(messageService(),"DbBaseConverter");
    err << MSG::FATAL << "Entry:" << pObj->fullpath() 
                      << " Cannot add persistent Reference ";
    if ( 0 != pA )err << pA->dbName() 
                      << ":" << pA->containerName() 
                      << "#" << pA->objectName();
    err << endreq;
  }
  return iret;
}

StatusCode DbBaseConverter::addPersistentDirectoryLinks(dbHandle<DbDefObject>& objH, const DataObject* pObj)   {
  StatusCode status = StatusCode::SUCCESS, iret;
  for( DataObject::DirIterator i = pObj->dirBegin(), iend = pObj->dirEnd(); i != iend; i++ )   {
    IOpaqueAddress* pA = (*i)->address();
    iret = StatusCode::FAILURE;
    if ( 0 != pA )   {    
      dbHandle<DbLink> to(*pA->genericLink());
      //std::cout << "Add leaf:" << obj << " #Links:" << m_objLinks.size() << " #Leafs:" << m_objSymLinks.size() << std::endl;
      dbHandle<DbDataBase> dbH = objH.containedIn().containedIn();
      if ( dbH.addAssocEntry(pA->dbName(), pA->containerName(), pA->objectName(), to) )  {
        iret = objH->links().extend(to);
      }
    }
    else    {
      // This is not really an error, it only means that the object
      // pointed to is not persistent. Hence, this link cannot be followed
      // from the data written.
      iret = objH->addInvalidLink();
    }
    if ( !iret.isSuccess() )   {
      status = iret;
      MsgStream err(messageService(),"DbBaseConverter");
      err << MSG::FATAL << "Entry:" << pObj->fullpath() 
                        << " Cannot add persistent directory reference ";
      if ( 0 != pA )err << pA->dbName() 
                        << ":" << pA->containerName() 
                        << "#" << pA->objectName();
      err << endreq;
    }
  }
  return status;
}

StatusCode DbBaseConverter::addPersistentSymbolicLinks(dbHandle<DbDefObject>& objH, const DataObject* pObj)   {
  StatusCode status = StatusCode::SUCCESS, iret;
  int cnt = 0;
  // Add the internal link hints of the DataObject
  for( DataObject::ConstLinkIterator j = pObj->linkBegin(), jend = pObj->linkEnd(); j != jend; j++ )   {
    IOpaqueAddress* pA = (*j)->address();
    iret = StatusCode::FAILURE;
    cnt++;
    if ( 0 != pA )   {
      dbHandle<DbLink> to(*pA->genericLink(), true);
      //std::cout << "Add leaf:" << obj << " #Links:" << m_objLinks.size() << " #Leafs:" << m_objSymLinks.size() << std::endl;
      dbHandle<DbDataBase> dbH = objH.containedIn().containedIn();
      if ( dbH.addAssocEntry(pA->dbName(), pA->containerName(), (*j)->path(), to) )  {
        iret = objH->links().extend(to);
      }
    }
    else    {
      // This is not really an error, it only means that 
      // if ( pA==0 ) : The object pointed to is not persistent. 
      //                Hence, this link cannot be followed
      //                from the data written.
      iret = objH->addInvalidLink();
    }
    if ( !iret.isSuccess() )   {
      status = iret;
      MsgStream err(messageService(),"DbBaseConverter");
      err << MSG::FATAL << "Entry:" << pObj->fullpath() 
                        << " Cannot add persistent symbolic reference ";
      if ( 0 != pA )err << pA->dbName() 
                        << ":" << pA->containerName() 
                        << "#" << pA->objectName();
      err << endreq;
    }
  }
  objH->setNumSymLink(cnt);
  return status;
}

StatusCode DbBaseConverter::preparePersistentUpdate( dbHandle<DbDefObject>& /* objH */ , const DataObject* pObject)   {
  bool needsUpdate  = false;
  DataObject* pPtr  = 0;
  // We need the links been properly done....
  // Add the internal link hints of the DataObject first 
  // by forcing a load request and then update the object 
  // to be written out.
  for( DataObject::ConstLinkIterator j = pObject->linkBegin(), jend = pObject->linkEnd(); j != jend; j++ )   {
    if ( 0 == (*j)->object() )    {
      StatusCode iret = dataProvider()->retrieveObject((*j)->path(), pPtr);
      if ( iret.isSuccess() )   {
        needsUpdate = true;
      }
    }
  }
  if ( needsUpdate )    {
    dataProvider()->updateObject(const_cast<IDataDirectory*>(pObject->directory()));
  }
  return StatusCode::SUCCESS;
}

StatusCode DbBaseConverter::beginPersistentUpdate( dbHandle<DbDefObject>& objH, const DataObject* pObject)   {
  return objH->beginPersistentUpdate(m_helperServices, pObject);
}

StatusCode DbBaseConverter::doPersistentUpdate( dbHandle<DbDefObject>& objH, const DataObject* pObject)   {
  return objH->doPersistentUpdate( m_helperServices, pObject );
}

StatusCode DbBaseConverter::endPersistentUpdate( dbHandle<DbDefObject>& objH, const DataObject* pObject)   {
  return objH->endPersistentUpdate(m_helperServices, pObject);
}

StatusCode DbBaseConverter::afterPersistentUpdate(dbHandle<DbDefObject>& /* objH */ , const DataObject* /* pObject */ )   {
  return StatusCode::SUCCESS;
}

StatusCode DbBaseConverter::beginTransientUpdate(dbHandle<DbDefObject>& /* objH */ , DataObject* pObject)   {
  pObject->clearLinks();
  return StatusCode::SUCCESS;
}

StatusCode DbBaseConverter::endTransientUpdate(dbHandle<DbDefObject>& /* objH */ , DataObject* /* pObject */ )   {
  return StatusCode::SUCCESS;
}

StatusCode DbBaseConverter::afterTransientUpdate(dbHandle<DbDefObject>& /* objH */ , DataObject* /* pObject */ )   {
  return StatusCode::SUCCESS;
}

StatusCode DbBaseConverter::doTransientUpdate(dbHandle<DbDefObject>& objH, DataObject* pObject)   {
  return objH->doTransientUpdate( m_helperServices, pObject );
}

static inline bool isInvalidLink(const GenericLinkBase& link) {
  if ( 0 == link.svcType() && 0 == link.clID() &&
       0xFFFFFFFF == link.genericInfo()->m_info[0] &&
       0xFFFFFFFF == link.genericInfo()->m_info[1] ) {
    return true;
  }
  return false;
}

StatusCode DbBaseConverter::updateTransientDirectoryLinks(dbHandle<DbDefObject>& objH, DataObject* pObject)   {
  long numLinks = objH->numLink();
  long numSymLinks = objH->numSymLink();
  IOpaqueAddress* pA;
  std::string fname, cname, oname;
  StatusCode iret, status = StatusCode::SUCCESS;
  RegistryEntry* pEntry = dynamic_cast<RegistryEntry*>(pObject->directory());
  dbVarray< dbHandle<DbLink> >& links = objH->links();

  // First add the directory entries of the DataObject
  for ( long i = 0, num = numLinks-numSymLinks; i < num; i++ )   {
    dbHandle<DbLink>& link = links[i];
    iret = objH.validateAssoc(link, fname, cname, oname);
    if ( iret.isSuccess() )   {
      iret = m_helperServices.AddrCreator->createAddress(link, fname, cname, oname, pA);
      if ( iret.isSuccess() )   {
        int loc = oname.rfind(IDataDirectory::SEPARATOR);
        std::string objname(oname, loc>0 ? loc : 0, oname.length());
        iret = pEntry->add( objname, pA);
        if ( !iret.isSuccess() )   { // This means the entry is already present
          pA->release();
        }
      }
      else    {
        MsgStream err(messageService(),"DbBaseConverter");
        err << MSG::DEBUG << "Entry:" << fname << ":" << cname << "->" << oname
            << " Cannot add transient directory reference "
            << endreq;
        //        status = iret;
      }
    }
    else if ( isInvalidLink(link) )   {
      MsgStream err(messageService(),"DbBaseConverter");
      err << MSG::DEBUG << "Entry:" << pEntry->fullpath()
          << " Cannot vaidate transient directory reference "
          << "Reference is invalid...maybe an error" << endreq;
      //        status = iret;
    }
    else {
      MsgStream err(messageService(),"DbBaseConverter");
      err << MSG::DEBUG << "Entry:" << pEntry->fullpath()
          << " Cannot vaidate transient symbolic reference "
          << " Typ:"  << long(link.svcType()) 
          << " CLID:" << long(link.clID()) 
          << " [1]="  << (unsigned long)link.genericInfo()->m_info[0] << " "
          << " [2]="  << (unsigned long)link.genericInfo()->m_info[1] << " "
          << endreq;
      // status = iret;
    }
  }
  return status;
}

StatusCode DbBaseConverter::updateTransientSymbolicLinks(dbHandle<DbDefObject>& objH, DataObject* pObject)   {
  long numLinks = objH->numLink();
  long numSymLinks = objH->numSymLink();
  std::string fname, cname, oname;
  StatusCode iret, status = StatusCode::SUCCESS;
  dbVarray< dbHandle<DbLink> >& links = objH->links();

  // Add the internal link hints of the DataObject
  for ( long j = numLinks-numSymLinks; j < numLinks; j++ )   {
    dbHandle<DbLink>& link = links[j];
    link.makeSymbolic();
    iret = objH.validateAssoc(link, fname, cname, oname);
    if ( iret.isSuccess() )   {
      pObject->addLink(oname, 0);
    }
    else if ( isInvalidLink(link) )   {
      IDataDirectory* pEntry = pObject->directory();
      MsgStream err(messageService(),"DbBaseConverter");
      err << MSG::DEBUG << "Entry:" << pEntry->fullpath()
          << " Cannot vaidate transient symbolic reference "
          << "Reference is invalid...maybe an error" << endreq;
      // status = iret;
    }
    else {
      IDataDirectory* pEntry = pObject->directory();
      MsgStream err(messageService(),"DbBaseConverter");
      err << MSG::DEBUG << "Entry:" << pEntry->fullpath()
          << " Cannot vaidate transient symbolic reference "
          << " Typ:"  << long(link.svcType()) 
          << " CLID:" << long(link.clID()) 
          << " [1]="  << (unsigned long)link.genericInfo()->m_info[0] << " "
          << " [2]="  << (unsigned long)link.genericInfo()->m_info[1] << " "
          << endreq;
      //status = iret;
    }
  }
  return status;
}

---