#include "PoolFileCatalogConnection.h"
 
 // Includes from POOL
 #include "CollectionBase/ICollectionQuery.h"
 #include "CollectionBase/ICollectionCursor.h"
 #include "CollectionBase/CollectionFactory.h"
 #include "CollectionBase/ICollection.h"
 #include "CollectionBase/CollectionDescription.h"
 
 #include "DataSvc/DataSvcFactory.h"
 #include "DataSvc/IDataSvc.h"
 #include "DataSvc/ICacheSvc.h"
 #include "DataSvc/CacheEntry.h"
 #include "DataSvc/AnyPtr.h"
 
 #include "PersistencySvc/Placement.h"
 #include "PersistencySvc/DatabaseConnectionPolicy.h"
 #include "PersistencySvc/ITransaction.h"
 #include "PersistencySvc/ISession.h"
 #include "PersistencySvc/ITokenIterator.h"
 #include "PersistencySvc/IContainer.h"
 #include "PersistencySvc/IDatabase.h"
 #include "PersistencySvc/IPersistencySvc.h"
 #include "PersistencySvc/IPersistencySvcFactory.h"
 
 #include "StorageSvc/DbType.h"
 
 #include "FileCatalog/IFileCatalog.h"
 #include "FileCatalog/IFCContainer.h"
 #include "FileCatalog/URIParser.h"
 #include "FileCatalog/FCEntry.h"
 #include "FileCatalog/IFCAction.h"
 #include "FileCatalog/FCLeaf.h"
 #include "FileCatalog/FCImpl.h"
 #include "FileCatalog/FCMetaImpl.h"
 
 #include "DataSvc/RefBase.h"
 
 #include "StorageSvc/DbReflex.h"
 
 #include "AttributeList/AttributeList.h"
 #include "POOLCore/POOLContext.h"
 
 // Includes from SEAL
 #include "PluginManager/PluginManager.h"
 #include "SealBase/UUID.h"
 
 // Tilec includes
 #include "TileCalibKernel/IMainContext.h"
 
 #include "TileCalibUtil/Timer.h"
 
 #include "TileCalibDatasrc/IDataSourceManager.h"
 #include "TileCalibDatasrc/DataHandle.h"
 
 #include "PoolCatalogEntry.h"
 #include "TileCalibPoolPlugin/AttributeListFuncs.h"
 
 #include <iostream>
 #include <sstream>
 #include <ctype.h>
 
 #include <TSystem.h>
 
 const std::string c_empty = std::string("");
 
 using namespace tilec::plugin::lcgpool;
 using namespace tilec::datasrc;
 using namespace tilec;
 
 using ROOT::Reflex::Type;
 
 // ---- Implementation of PoolFileCatalog ----
 
 PoolFileCatalogConnection::PoolFileCatalogConnection(const std::string &id, 
                                                      IContext *ctx):
   AbstractComponent(id,ctx),
   m_isOpen(false),
   m_writeLeaf(0),
   m_readOnly(false),
   m_persistSvc(0),
   m_entryCache(0),
   m_objectCache(0), 
   m_sealMsgLevel(4) {    
   init();
   IDataSourceManager *dataMan = IDataSourceManager::instance(); // QQQ: g_main->get<IDataSourceManager>();
   if(dataMan != 0) {
     m_entryCache = dataMan->getCache(ClassTool::getName(typeid(ICatalogEntry)), ClassTool::getName(typeid(CatalogKey)));
     if(m_entryCache == 0) MsgError("PoolFileCatalogConnection() Error getting cache InstanceCache<ICatalogEntry,ObjectKey>");
     m_objectCache = dataMan->getCache("tilec::datasrc::IObject","tilec::datasrc::ObjectKey");
     if(m_objectCache == 0) MsgError("PoolFileCatalogConnection() Error getting cache InstanceCache");
   }
   else MsgError("PoolFileCatalogConnection() Can't get IOVObjectManager");
   // setClassName<PoolFileCatalogConnection>();
   // addInterface<IConnection>();
   // addInterface<IFileCatalogConnection>();
   m_props.bind("SealMessageLevel",&m_sealMsgLevel);
   m_props.bind("readOnly",&m_readOnly);
 }
 
 void
 PoolFileCatalogConnection::init() {
   MsgDebug("init() Initializing");
   pool::POOLContext::loadComponent( "SEAL/Services/MessageService" );
 
   pool::POOLContext::loadComponent( "CORAL/RelationalPlugins/mysql" );
   pool::POOLContext::loadComponent( "CORAL/mysql/TypeConverter" );
   pool::POOLContext::loadComponent( "CORAL/Services/EnvironmentAuthenticationService" );
   
   pool::POOLContext::setMessageVerbosityLevel( (seal::Msg::Level)m_sealMsgLevel );  // seal::Msg::Verbose); //(
   pool::ObjectDeletePolicy::GLOBAL_DEFAULT = pool::ObjectDeletePolicy::DONOT_DELETE;
 }
 
 PoolFileCatalogConnection::~PoolFileCatalogConnection() {
   MsgDebug("Deleting");
 }
 
 // ---- Implementation of data provider ----
 
 void 
 PoolFileCatalogConnection::getData(DataHandle &pt) {
   const std::type_info &dataType(pt.type());
   if(pt.key() == 0) {
     MsgError("getData() The pointer has no key!");
     return;
   }
   if(dataType == typeid(ICatalogEntry)) {
     try {
       const CatalogKey *key(dynamic_cast<const CatalogKey*>(pt.key()));
       if(key == 0) {
         MsgError("getData() Can't get key "<<pt.key()<<" as CatalogKey");
         return;
       }
       MsgDebug("getData() Getting data for key: "<<*key);
       if(key->getEntryType() == CatalogKey::FID) pt.setPtr(getEntryByFID(key->getID()),typeid(ICatalogEntry));
       else if(key->getEntryType() == CatalogKey::PFN) pt.setPtr(getEntryByPFN(key->getID()),typeid(ICatalogEntry));
       else MsgWarning("getData() get by LFN not implemented");
     }
     catch(std::exception &e) {
       MsgError("getData() Exception while getting data : "<<e.what());
     }
   }
   else {
     RawObject ro(getRawObject(pt.key()->getID()));
     pt.setPtr(ro.ptr(),ro.type());
   }
 }
 
 void 
 PoolFileCatalogConnection::eraseData(DataHandle &pt) {
   const std::type_info &dataType(pt.type());
   if(pt.key() == 0) {
     MsgError("eraseData() The key is 0");
     return;
   }
   if(dataType == typeid(ICatalogEntry)) {
     try {
       ICatalogEntry *entry = reinterpret_cast<ICatalogEntry*>(pt.ptr());
       if(entry != 0) {
         if(entry->getType() == ICatalogEntry::PFNEntry) {
           MsgDebug("eraseData() Deleting PFN entry: "<<entry->getPFN()<<" with FID='"<<entry->getGUID()<<"'");
           deleteFID(entry->getGUID());
         }
         else MsgWarning("eraseData() Not implemented for LFN and FID");
       }
       else MsgError("eraseData() Entry to delete is 0");
     }
     catch(std::exception &e) {
       MsgError("eraseData() std::exception caught: "<<e.what());
     }
   }
   else MsgWarning("eraseData() not implemented for type='"<<ClassTool::getName(dataType)<<"' with key='"<<pt.key()<<"'");
 }
 
 void 
 PoolFileCatalogConnection::writeData(DataHandle &pt) {
   const std::type_info &dataType(pt.type());
   if(pt.key() == 0) {
     MsgError("writeData() The key is 0");
     return;
   }
   if(dataType == typeid(ICatalogEntry)) {
     try {
       const CatalogKey *key(dynamic_cast<const CatalogKey*>(pt.key()));
       if(key == 0) {
         MsgError("writeData() The key if not a CatalogKey");
         return;
       }
       MsgDebug("writeData() Writing with key: "<<*key);
       if(key->getEntryType() == CatalogKey::PFN) {
         std::string fid;
         // try to get enrtry
         PoolCatalogEntry *entr = getEntryByPFN(key->getID(),true);
         if(entr == 0) {
           MsgDebug("writeData() Entry for PFN='"<<key->getID()<<"' not found, creating");
           pt.setPtr(registerPFN(key->getID(),"",fid),typeid(ICatalogEntry));
           // QQQ: pt = registerPFN(key->getID(),"",fid);
         }
         else {
           // QQQ: pt = entr;
           pt.setPtr(entr,typeid(ICatalogEntry));
         }
         // ZZZ: write meta data
       
       }
       else MsgError("writeData() Writing by FID or LFN not supported");
     }
     catch(std::exception &e) {
       MsgError("writeData() Exception while writing : "<<e.what());
     }
   }
   else MsgError("writeData() not implemented for "<<ClassTool::getName(dataType));
 }
 
 bool 
 PoolFileCatalogConnection::hasData(DataHandle &) {
   MsgWarning("hasData() not implemented");
   return true;
 }
 
 void 
 PoolFileCatalogConnection::returnData(DataHandle &pt) {
   MsgWarning("returnData() I don't want any returned pointers, but I got "<<pt);
 }
 
 void 
 PoolFileCatalogConnection::newInstance(DataHandle &) {
   MsgWarning("newInstance() Not supported");
 }
 
 // ----- Implementation of FileCatalogConnection -----
 
 bool
 PoolFileCatalogConnection::listByPFN(const std::string& query, std::vector<CatalogEntry> &dst) {
   try {
     MsgDebug("listByPFN() Getting PFN list by query '"<<query<<"' # read cats:"<<m_catalog->nReadCatalogs());    
     
     pool::FClookup action;
     m_catalog->setAction(action);
     pool::PFNContainer pfnCnt(m_catalog);
     m_catalog->start();
     action.lookupPFNByQuery(query,pfnCnt);
     ICatalogEntry *poolEntry(0);
     CatalogKey key("");
     while(pfnCnt.hasNext()) {
       pool::PFNEntry pentry = pfnCnt.Next();
       key = CatalogKey(pentry.guid());
       if(m_entryCache->hasInstance(key)) poolEntry = m_entryCache->get<ICatalogEntry>(key);
       else {
         poolEntry = new PoolCatalogEntry(const_cast<PoolFileCatalogConnection*>(this),pentry.guid(),pentry.pfname(),pentry.filetype());
         // get meta data
         try {
           // if(m_writeLeaf != 0) {
 //          pool::FCMetaImpl *metai = m_writeLeaf->getMetaImpl();
 //          pool::FCBuf<pool::MetaDataEntry> buffer(10);
 //          metai->retrieveMetaData("FID='"+poolEntry->getGUID()+"'",buffer,10);
 //          if(buffer.size() > 0) {
 //            buffer.getData()[0].attrs().print(std::cout);
 //          }
 //          else MsgDebug("listByPFN() No meta data");
 //        }
 //        else MsgDebug("listByPFN() No write leaf");
 
          //  pool::MetaDaataContainer metac(m_catalog,1000);
 //        action.lookupMetaDataByQuery(std::string("guid='"+poolEntry->getGUID()+"'"),metac);
 //        if(metac.hasNext()) {
 //          pool::MetaDataEntry attr = metac.Next();
 //          attr.attrs().print(std::cout);
 //          AttributeListFuncs::getProperties(attr.attrs(),dynamic_cast<PoolCatalogEntry*>(poolEntry)->metaData());
 //        }
 //        else MsgDebug("listByPFN() No meta data found for fid="<<poolEntry->getGUID());
         }
         catch(std::exception &ex) {
           MsgError("listByPFN() Exception: "<<ex.what());
         }
       }
       MsgDebug("listByPFN() got file "<<*poolEntry);
       dst.push_back(m_entryCache->addInstance<ICatalogEntry,CatalogKey>(poolEntry,key,this));
     }
     m_catalog->commit();
     return true;
   }
   catch (std::exception &er) {
     MsgError("listByPFN() Error: SEAL exception: " << er.what() );
     try {
       m_catalog->rollback();
     }
     catch(std::exception &ex) {
       MsgError("listByPFN() Error rolling back transaction: "<<ex.what());
     }
     return false;
   }
 }
 
 bool 
 PoolFileCatalogConnection::registerPFN(const std::string &pfn, const std::string &guid) {
   std::string guidStr;
   if(guid.empty()) {
     // ZZZ: This generation seems to be unnecessary, but include it anyway
     seal::UUID ui = seal::UUID::generate();
     char uuidBuff[37];
     ui.format(uuidBuff);
     for(int i=0;i<37;i++) uuidBuff[i] = toupper(uuidBuff[i]);
     guidStr = uuidBuff;
     MsgVerbose("registerPFN() GUID is empty, generating '"<<guidStr<<"'");
   }
   else guidStr = guid;
   MsgDebug("registerPFN() Registering PFN='"<<pfn<<"' with UUID='"<<guidStr<<"'");
   std::string ftype("ROOT_All");
   return (registerPFN(pfn,ftype,guidStr) != 0);
 }
 
 CatalogEntry 
 PoolFileCatalogConnection::getByPFN(const std::string &pfn) {
   PoolCatalogEntry *entry = getEntryByPFN(pfn);
   if(entry != 0) return m_entryCache->addInstance<ICatalogEntry,CatalogKey>(entry,entry->getGUID(),this);
   else return 0;
 }
 
 bool
 PoolFileCatalogConnection::isPFNRegistered(const std::string &pfn) {
   return getByPFN(pfn);
 }
 
 // ----- Implementation of connection -----
 bool 
 PoolFileCatalogConnection::isOpen() {
   return m_isOpen;
 }
 
 bool 
 PoolFileCatalogConnection::open() {
   if(isOpen()) {
     MsgWarning("open() Connection with id='"<<getID()<<"' is already open");
     return false;
   }
   try {
     //m_rootDirectory = m_props["rootDirectory"];
     MsgInfo("open() Opening connection with id='"<<getID()<<"'");
 
     m_catalog = new pool::IFileCatalog;
 
     // env authentication
     g_main->setEnv("CORAL_AUTH_USER",getProperty("UserName"));
     // ZZZ: ask for password
     g_main->setEnv("CORAL_AUTH_PASSWORD",getProperty("Password"));
 
     // determine connstring
     std::ostringstream connStrOut;
     connStrOut<<getProperty("Technology")<<"://";
 
     if(m_props.hasProperty("HostName")) connStrOut<<getProperty("HostName")<<"/";
     connStrOut<<getProperty("DBName");
     
     std::string catalogConnStr(connStrOut.str());
     pool::URIParser p(catalogConnStr);
     MsgDebug("open() Connecting to catalog '"<<catalogConnStr<<"' read only='"<<m_readOnly<<"'");
     p.parse();
     
     if(m_readOnly) m_catalog->addReadCatalog( p.contactstring() );
     else m_catalog->setWriteCatalog( p.contactstring() );
 
     m_writeLeaf = static_cast<pool::FCLeaf*>(m_catalog->getWriteCatalog());
     m_catalog->connect();
         
     // create data svc, use given catalog
     m_dataSvc = pool::DataSvcFactory::instance(m_catalog);
     
     // set policies
     pool::DatabaseConnectionPolicy policy;
     policy.setWriteModeForNonExisting( pool::DatabaseConnectionPolicy::CREATE );
     policy.setWriteModeForExisting( pool::DatabaseConnectionPolicy::UPDATE );
     policy.setReadMode( pool::DatabaseConnectionPolicy::UPDATE );
     m_dataSvc->session().setDefaultConnectionPolicy( policy );
     
     // get IPersistencySvc
     pool::IPersistencySvcFactory *pfact = pool::IPersistencySvcFactory::get();
     if(pfact != 0) {
       m_persistSvc = pfact->create("PersistencySvc",*m_catalog);
       
       if(m_persistSvc != 0) {
         m_persistSvc->session().setDefaultConnectionPolicy( policy );
         
         // pool::ITransaction::Type accType(m_readOnly ? pool::ITransaction::READ: pool::ITransaction::UPDATE);
         //      if(m_persistSvc->session().transaction().start(accType)) {
         //        MsgDebug("open() transaction started");
         //      }
         //else MsgError("open() couldn't start transaction for persistency svc");
       }
       else MsgError("open() no IPersistencySvc created");
     }
     else MsgError("open() couldn't get IPersistencySvcFactory");
   }
   catch (std::exception &e) {
     MsgError("open() Exception:"<< e.what());
     throw ConnectionException(std::string("Could not make connection ")+e.what(),getID());
   }
   m_isOpen = true;
   return true;
 }
 
 void 
 PoolFileCatalogConnection::finalize() {
   if(m_isOpen) close();
 }
 
 bool 
 PoolFileCatalogConnection::close() {
   MsgInfo("close() Closing connection with id='"<<getID()<<"'");
   try { 
     //m_dataSvc->transaction().commit();
     // m_persistSvc->session().transaction().commit();
     m_dataSvc->session().disconnectAll();
     m_catalog->disconnect(); 
   }
   catch(std::exception &e) {
     MsgError("close() Exception while closing: "<<e.what());
   }
   delete m_persistSvc;
   m_persistSvc = 0;
   delete m_dataSvc;
   m_dataSvc = 0;
   delete m_catalog;
   m_catalog = 0;
   m_isOpen = false;
   return true;
 }
 
 DataPointer
 PoolFileCatalogConnection::getObject(const std::string &token) const {
   MsgDebug("getObject() Getting obj with token "<<token);
   ObjectKey tKey(token);
   if(m_objectCache->has(tKey)) {
     return m_objectCache->getInstance(tKey);
   }
   else {
     // QQQ: DataPointer pt(getRawObject(token).getTracker());
     // QQQ: m_objectCache->registerInstance(pt.getPtr(),ObjectKey(token),const_cast<PoolFileCatalogConnection*>(this));
     RawObject ro(getRawObject(token));
     return m_objectCache->registerInstance(ro.ptr(),ObjectKey(token),const_cast<PoolFileCatalogConnection*>(this));
     // QQQ: return pt;
   }
 }
 
 // ---- Private utility functions ----
 
 RawObject
 PoolFileCatalogConnection::getRawObject(const std::string &token) const {
   TileCStartTimer("PoolFileCatalogConnection::getRawObject");
   try {
     MsgDebug("getRawObject() Getting object with token '"<<token<<"'");
     
     pool::Token tok;
     tok.fromString(token);
     MsgDebug("getRawObject() classid="<<tok.classID().toString());
 
     ROOT::Reflex::Type cltype(getClassForToken(&tok));
     if(!cltype) {
       MsgError("getRawObject() No class found for GUID="<<tok.classID().toString());
       TileCStopTimer("PoolFileCatalogConnection::getRawObject");
       return RawObject(0,typeid(void));
     }
 
     // start read transaction
     m_catalog->start();
 
     // QQQ: m_dataSvc->transaction().start(pool::ITransaction::READ);    
     // QQQ: pool::RefBase objRef(m_dataSvc,tok,cltype.TypeInfo());
     // QQQ: void *obj = objRef.object().ptr();
 
     m_persistSvc->session().transaction().start(pool::ITransaction::READ);
     std::pair<void*,ROOT::Reflex::Type> data(m_persistSvc->readObject(cltype,tok));
     void *obj = data.first;
     MsgDebug("getRawObject() got object @"<<obj<<" of type "<<data.second.Name());
     m_persistSvc->session().transaction().commit();
 
     // QQQ: m_dataSvc->transaction().commit();
     m_catalog->commit();
 
     TileCStopTimer("PoolFileCatalogConnection::getRawObject");
     return RawObject(obj,cltype.TypeInfo());
   }
   catch(std::exception &e) {
     MsgError("getRawObject() Seal exception caught: "<<e.what());
     try {
       m_catalog->rollback();
       m_dataSvc->transaction().rollback();
     }
     catch(std::exception &ex) {
       MsgError("getRawObject() Error rolling back transaction: "<<ex.what());
     }
   }
   TileCStopTimer("PoolFileCatalogConnection::getRawObject");
   return RawObject(0,typeid(void));
 }
 
 void 
 PoolFileCatalogConnection::renamePFN(const std::string &src, const std::string &dst) {
     try {
       MsgVerbose("renamePFN() Renaming Src PFN='"<<src<<"' to Dst PFN='"<<dst<<"'");
       pool::FCregister a;
       m_catalog->setAction(a);
       m_catalog->start();
       a.renamePFN(src,dst);
       m_catalog->commit();
       MsgVerbose("renamePFN() Done renaming");
   }
   catch(std::exception &e) {
     MsgError("renamePFN() Exception while renaming PFN: "<<e.what());
     try {
       m_catalog->rollback();
     }
     catch(std::exception &ex) {
       MsgError("renamePFN() Error rolling back transaction: "<<ex.what());
     }
   }
 }
 
 PoolCatalogEntry*
 PoolFileCatalogConnection::registerPFN(const std::string &pfn, 
                                        const std::string &ft, 
                                        std::string &fid) {
   try {
     std::string fileType(ft);
     if(fileType.empty()) fileType="ROOT_All";
 
     MsgVerbose("registerPFN() Registering PFN='"<<pfn<<"' with type='"<<fileType<<"' and FID='"<<fid<<"'");
     // normal operation
     if(fid.empty() && m_writeLeaf) {
       pool::IFCAction a;
       m_catalog->setAction(a);
       m_catalog->start();
       a.registerPFN(pfn,fileType,fid);
       m_catalog->commit();
       return new PoolCatalogEntry(const_cast<PoolFileCatalogConnection*>(this),fid,pfn,fileType);
     }
     // FID specified
     else {
       pool::FCImpl* fcImpl = m_writeLeaf->getImpl();
       
       if(!fcImpl) {
         MsgError("registerPFN() No FCImpl found");
         return false;
       }
       m_catalog->start();
       pool::PFNEntry pentry(pfn,fid,fileType);
       fcImpl->insertPFN(pentry);
       m_catalog->commit();
       return new PoolCatalogEntry(const_cast<PoolFileCatalogConnection*>(this),fid,pfn,fileType);
     }
   }
   catch(std::exception &e) {
     MsgError("registerPFN() Exception while registering PFN: "<<e.what());
     try {
       m_catalog->rollback();
     }
     catch(std::exception &ex) {
       MsgError("registerPFN() Error rolling back transaction: "<<ex.what());
     }
     return 0;
   }
 }
 
 PoolCatalogEntry* 
 PoolFileCatalogConnection::getEntryByFID(const std::string &fileId) const {
   MsgVerbose("getEntryByFID() Getting by fid '"<<fileId<<"'");    
   PoolCatalogEntry *poolEntry = 0;
   try {
     pool::FClookup action;
     m_catalog->setAction(action);
     m_catalog->start();
     std::string pfn;
     std::string fileType;
     action.lookupBestPFN(fileId, pool::FileCatalog::READ,pool::FileCatalog::RANDOM, pfn,fileType);
     m_catalog->commit();
     poolEntry = new PoolCatalogEntry(const_cast<PoolFileCatalogConnection*>(this),fileId,pfn,fileType);
     // get meta data
    //  pool::MetaDataContainer metac(m_catalog);
 //     action.lookupMetaDataByQuery(std::string("FID='"+fileId+"'"),metac);
 //     if(metac.hasNext()) {
 //       pool::MetaDataEntry attr(metac.Next());
 //       AttributeListFuncs::getProperties(attr.attrs(),poolEntry->metaData());
 //     }
 //     else MsgDebug("getEntryByFID() No meta data found for fid="<<fileId);
     return poolEntry;
   }
   catch (std::exception &er) {
     MsgError("getEntryByFID() Error: SEAL exception: " << er.what() );
     try {
       m_catalog->rollback();
     }
     catch(std::exception &ex) {
       MsgError("getEntryByFID() Error rolling back transaction: "<<ex.what());
     }
     if(poolEntry != 0) delete poolEntry;
     return 0;
   }
 }
 
 PoolCatalogEntry* 
 PoolFileCatalogConnection::getEntryByPFN(const std::string &pfn, bool silent) const {
   try {
     MsgDebug("getEntryByPFN() Getting entry for PFN='"<<pfn<<"'");
     pool::FClookup action;
     m_catalog->setAction(action);
     m_catalog->start();
     
     pool::FileCatalog::FileID fid;
     std::string ftype;
     action.lookupFileByPFN(pfn,fid,ftype);
     
     // get meta data
    //  pool::MetaDataContainer metac(m_catalog);
 //     action.lookupMetaDataByQuery("FID='"+fid+"'",metac);
 //     Properties metaData;
 //     if(metac.hasNext()) {
 //       pool::MetaDataEntry attr(metac.Next());
 //       AttributeListFuncs::getProperties(attr.attrs(),metaData);
 //     }
 //     else MsgDebug("getEntryByPFN() No meta data found for fid="<<fid);
 
     m_catalog->commit();
     if(fid.empty() || ftype.empty()) {
       if(!silent) MsgWarning("getEntryByPFN() No valid fid or ftype found for PFN='"<<pfn<<"'");
       return 0;
     }
     else {
       MsgDebug("getEntryByPFN() Got FID='"<<fid<<"' File type='"<<ftype<<"' for PFN='"<<pfn<<"'");
       // ZZZ: register by PFN too??
       PoolCatalogEntry *poolEntry = new PoolCatalogEntry(const_cast<PoolFileCatalogConnection*>(this),fid,pfn,ftype);
       //poolEntry->metaData() = metaData;
       return poolEntry;
     }
   }
   catch (std::exception &er) {
     MsgError("getEntryByPFN() Error while quering for PFN: SEAL exception: " << er.what() );
     try {
       m_catalog->rollback();
     }
     catch(std::exception &er2) {
       MsgError("getEntryByPFN() Error committing transaction: "<<er2.what());
     }
     return 0;
   }
 }
 
 // ------------------------
 // ---- public methods ----
 
 bool 
 PoolFileCatalogConnection::getCollection(const PoolCatalogEntry *entr,
                                          const std::string &collName,
                                          std::vector<DataPointer> &dst) {
    if(entr == 0) {
       MsgError("getCollection() Given CatalogEntry is 0");
       return false;
    }
    try {
       // determine data location
       std::string dataLoc(entr->getDataLocation());
       MsgDebug("getCollection() Getting collection named '"<<collName<<"' with location '"<<dataLoc<<"' from entry:"<<*entr);
       m_catalog->start();
       m_dataSvc->transaction().start( pool::ITransaction::READ );
     
       pool::CollectionFactory *fact = pool::CollectionFactory::get();
       if(fact == 0) {
          MsgError("getCollection() No CollectionFactory found");
          return false;
       }
 
       pool::CollectionDescription       desc( collName, "ImplicitCollection", dataLoc );
       pool::ICollection *coll = fact->create(
          "ImplicitCollection",
          desc,
          pool::ICollection::READ,
          &m_dataSvc->session() );
       if(coll == 0) {
          MsgError("getCollection() No collection with name '"<<collName<<"' connection='"<<dataLoc<<"' found");
          return false;
       }
       std::auto_ptr<pool::ICollectionQuery> query ( coll->newQuery() );
       pool::ICollectionCursor   &cursor = query->execute();
       std::string token;
       void *obj;
 
       while( cursor.next() ) {
          const pool::Token &ref = cursor.eventRef();
          token = ref.toString();
          ROOT::Reflex::Type cltype( getClassForToken( &ref ) );
          if(cltype) {
             pool::RefBase condObj( m_dataSvc, &ref, cltype.TypeInfo() );
             obj = condObj.object().ptr();
             // QQQ: m_objectCache->registerInstance(obj,ObjectKey(token),const_cast<PoolFileCatalogConnection*>(this));
             // QQQ: dst.push_back(DataPointer(obj,cltype.TypeInfo()));
             dst.push_back(m_objectCache->registerInstance(obj,ObjectKey(token),const_cast<PoolFileCatalogConnection*>(this),cltype.TypeInfo()));
             MsgVerbose("getCollection() Found object: @"<<obj<<" with token "<<token);
          }
          else MsgError("getCollection() Can't find class for GUID='"<< ref.classID().toString());
       }
       m_catalog->commit();
       m_dataSvc->transaction().commit();
       return true;
    }
    catch (std::exception &er) {
       MsgError("getCollection() Error: SEAL exception: " << er.what());
       try {
          m_catalog->rollback();
          m_dataSvc->transaction().rollback();
       }
       catch(std::exception &ex) {
          MsgError("getCollection() Error rolling back transaction: "<<ex.what());
       }
       return false;
    }
 }
 
 void
 PoolFileCatalogConnection::writeObject(DataPointer obj,
                                        const std::string &container,
                                        const PoolCatalogEntry *entry,
                                        std::string &tokenOut) {
   if(!obj.isValid()) {
     MsgError("writeObject() Object is invalid");
     return;
   }
   if(entry == 0) {
     MsgError("writeObject() The entry is 0");
     return;
   }
   try {
     // create container/collection
     
     // get class for object to store
     ROOT::Reflex::Type ctype(ROOT::Reflex::Type::ByTypeInfo(obj.getClassType()));
     MsgDebug("writeObject() Writing obj '"<<obj
              <<"' into container '"<<container
              <<"' in entry '"<<*entry
              <<"' with class='"<<ctype.Name()<<"'");
     // check if the file exists, if it doesn't, delete the entry
     if(!entry->fileExists()) {
       MsgDebug("writeObject() The file '"<<*entry<<"' doesn't exist but is registered, removing");
       deleteFID(entry->getGUID());
     }
     // create placement
     pool::Placement place;
     if(entry->getType() == ICatalogEntry::PFNEntry) {
       place.setDatabase(entry->getPFN(),pool::DatabaseSpecification::PFN);
     }
     else {
       place.setDatabase(entry->getLFN(),pool::DatabaseSpecification::LFN);
     }
     place.setShapeID(ctype);
     place.setContainerName(container);
     // QQQ:place.setTechnology(pool::ROOTKEY_StorageType.type());
     place.setTechnology(pool::ROOTTREE_StorageType.type());
 
     m_catalog->start();
     // QQQ: m_dataSvc->transaction().start(pool::ITransaction::UPDATE);
 
     MsgVerbose("writeObject() Placement created: dbname='"<<place.databaseName()
                <<"' conainer='"<<place.containerName()
                <<"' shapeID='"<<place.shapeID().Name()<<"'");
     // create ref
     // QQQ: pool::RefBase objRef(m_dataSvc,pool::AnyPtr(obj.getPtr(),&obj.getClassType()),obj.getClassType());
     // QQQ: objRef.markWrite(place);
     
     m_persistSvc->session().transaction().start(pool::ITransaction::UPDATE);
     pool::Token *token = m_persistSvc->registerForWrite(place,obj.getPtr(),ctype);
     m_persistSvc->session().transaction().commit();
     if(token != 0) {
       tokenOut = token->toString();
       delete token;
     }
     else MsgError("writeObject() no token returned");
     
     // QQQ: m_dataSvc->transaction().commit();
     m_catalog->commit();
     
     // QQQ: const pool::Token *token = objRef.token();
     if(!token) {
       MsgError("writeObject() No token found for new object!");
       return;
     }
     // QQQ: tokenOut = token->toString();
     MsgVerbose("writeObject() Written object token '"<<tokenOut<<"'");
     m_objectCache->registerInstance(obj.getPtr(),ObjectKey(tokenOut),const_cast<PoolFileCatalogConnection*>(this));
   }
   catch(std::exception &e) {
     MsgError("writeObject() SealException caught: "<<e.what());
     try {
       m_catalog->rollback();
       m_dataSvc->transaction().rollback();
     }
     catch(std::exception &ex) {
       MsgError("writeObject() Error rolling back transaction: "<<ex.what());
     }
   }
 }
 
 void
 PoolFileCatalogConnection::writeObjects(std::vector<DataPointer> objVec,
                                         const std::string &container,
                                         const PoolCatalogEntry *entry,
                                         std::vector<std::string> &tokens) {
   if(entry == 0) {
     MsgError("writeObjects() The entry is 0");
     return;
   }
   if(objVec.empty()) {
     MsgError("writeObjects() obj vector empty");
     return;
   }
   try {
     ROOT::Reflex::Type ctype(ROOT::Reflex::Type::ByTypeInfo(objVec[0].getClassType()));
     MsgDebug("writeObjects() Writing #"<<objVec.size()
              <<" objects into container '"<<container
              <<"' in entry '"<<*entry<<"' class='"
              <<ctype.Name()<<"'");
 
     // check if the file exists, if it doesn't, delete the entry
     if(!entry->fileExists()) {
       MsgDebug("writeObjects() The file '"<<*entry<<"' doesn't exist but is registered, removing");
       deleteFID(entry->getGUID());
     }
 
     // create placement
     pool::Placement place;
     if(entry->getType() == ICatalogEntry::PFNEntry) {
       place.setDatabase(entry->getPFN(),pool::DatabaseSpecification::PFN);
     }
     else {
       place.setDatabase(entry->getLFN(),pool::DatabaseSpecification::LFN);
     }
     place.setShapeID(ctype);
     place.setContainerName(container);
     // QQQ: place.setTechnology(pool::ROOTKEY_StorageType.type());
     place.setTechnology(pool::ROOTTREE_StorageType.type());
 
     m_catalog->start();
     m_persistSvc->session().transaction().start(pool::ITransaction::UPDATE);
     // QQQ: m_dataSvc->transaction().start(pool::ITransaction::UPDATE);
 
     MsgVerbose("writeObjects() Placement created: dbname='"<<place.databaseName()
                <<"' conainer='"<<place.containerName()
                <<"' shapeID='"<<place.shapeID().Name()<<"'");
     unsigned int size(objVec.size());
     tokens.resize(size);
     for(unsigned int i=0;i<size;i++) {
       // create ref
       if(objVec[i].isValid()) {
         MsgVerbose("writeObjects() Writing object: "<<objVec[i]);
         
         // QQQ: pool::RefBase objRef(m_dataSvc,pool::AnyPtr(objVec[i].getPtr(),&objVec[i].getClassType()),objVec[i].getClassType());
         // QQQ: objRef.markWrite(place);
         // QQQ: const pool::Token *token = objRef.token();
         
         pool::Token *token = m_persistSvc->registerForWrite(place,objVec[i].getPtr(),ctype);
         if(token != 0) {
           tokens[i] = token->toString();
           delete token;
           MsgDebug("writeObjects() Written object '"<<objVec[i]<<"' token '"<<tokens[i]<<"'");
           m_objectCache->registerInstance(objVec[i].getPtr(),ObjectKey(tokens[i]),const_cast<PoolFileCatalogConnection*>(this));
         }
         else MsgError("writeObjects() No token found for new object!");
       }
       else MsgError("writeObject() Object is invalid");
     }
     // QQQ: m_dataSvc->transaction().commit();
     m_persistSvc->session().transaction().commit();
     m_catalog->commit();
   }
   catch(std::exception &e) {
     MsgError("writeObjects() SealException caught: "<<e.what());
     try {
       m_catalog->rollback();
       m_dataSvc->transaction().rollback();
     }
     catch(std::exception &ex) {
       MsgError("writeObjects() Error rolling back transaction: "<<ex.what());
     }
   }
 }
 
 std::string 
 PoolFileCatalogConnection::getAddress(DataPointer vec) {
   // QQQ: const IObjectKey *key = m_objectCache->getInstanceID(vec.getPtr());
   const IObjectKey *key = vec.getKey();
   if(key != 0) return key->getID();
   else {
     MsgError("getAddress() No key found for ptr: "<<vec);
     return "";
   }
 }
 
 void 
 PoolFileCatalogConnection::getContainers(std::vector<ICatalogEntry::IContainer> &dst,const PoolCatalogEntry *entry) {
   try {
     MsgDebug("getContainers() Getting for entry: "<<*entry);
 
     m_catalog->start();
     m_dataSvc->transaction().start(pool::ITransaction::READ);
     
     pool::IDatabase *db(0);
     if(entry->getType() == ICatalogEntry::PFNEntry) {
       db = m_dataSvc->session().databaseHandle(entry->getPFN() ,pool::DatabaseSpecification::PFN);
     }
     else {
       db = m_dataSvc->session().databaseHandle(entry->getLFN() ,pool::DatabaseSpecification::LFN);
     }
     if(db == 0) {
       MsgError("getContainers() No database service for entry: "<<*entry);
       return;
     }
     db->setTechnology( pool::DbType::getType(entry->getFileType()).type() );
     db->connectForRead();
     
     std::vector< std::string > cnts = db->containers();
     dst.reserve(cnts.size());
     std::vector< std::string >::const_iterator begin(cnts.begin());
     std::vector< std::string >::const_iterator end(cnts.end());
     pool::IContainer* cnt(0);
     pool::ITokenIterator * tokenIter(0);
     pool::Token *token(0);
 
     for(;begin != end;++begin) {
       cnt = db->containerHandle( *begin );
       if(cnt != 0) {
         MsgDebug("getContainers() Container '"<<cnt->name()<<"'");
         dst.push_back(ICatalogEntry::IContainer(cnt->name()));
         tokenIter = cnt->tokens( "" );
         if(tokenIter != 0) {
           while ((token = tokenIter->next()) != 0 ) {
             ROOT::Reflex::Type cltype(getClassForToken(token));
             if(cltype) {
               dst.back().m_objects.push_back(m_objectCache->registerForFetch(ObjectKey(token->toString()),cltype.TypeInfo(),this));
             }
             else MsgError("getContainers() No SEAL class found for GUID '"<<token->classID().toString()<<"'");
             token->release();
           }
         }
       }
     }
     db->disconnect();
     m_dataSvc->transaction().commit();
     m_catalog->commit();
   }
   catch(std::exception &e) {
     MsgError("getContainers() SealException caught: "<<e.what());
     try {
       m_catalog->rollback();
       m_dataSvc->transaction().rollback();
     }
     catch(std::exception &ex) {
       MsgError("getContainers() Error rolling back transaction: "<<ex.what());
     }
   }
 }
 
 void 
 PoolFileCatalogConnection::updateMeta(PoolCatalogEntry *entry) {
   try {
     pool::MetaDataEntry spec;
     {
       pool::FCAdmin adm;
       m_catalog->setAction(adm);
       m_catalog->start();
       adm.getMetaDataSpec(spec);
       AttributeListFuncs::updateAttributeSpec(entry->metaData(),spec.spec());
       adm.updateMetaDataSpec(spec);
       m_catalog->commit();
     }
     {
       pool::FCregister reg;
       m_catalog->setAction(reg);
       m_catalog->start();
       AttributeListFuncs::getAttributeList(entry->metaData(),spec.attrs());
       reg.registerMetaData(entry->getGUID(),spec);
       m_catalog->commit();
     }
   }
   catch(std::exception &e) {
     MsgError("updateMeta() SealException caught: "<<e.what());
     try {
       m_catalog->rollback();
     }
     catch(std::exception &ex) {
       MsgError("updateMeta() Error rolling back transaction: "<<ex.what());
     }
   }
 }
 
 void 
 PoolFileCatalogConnection::printAttributes(const std::string &db) {
   try {
     m_catalog->start();
     m_persistSvc->session().transaction().start(pool::ITransaction::READ);
     pool::ISession &session(m_persistSvc->session());
     pool::IDatabase *database(session.databaseHandle(db,pool::DatabaseSpecification::PFN));
     
     if(database == 0) {
       MsgError("printAttributes() no database");
       m_persistSvc->session().transaction().commit();
       return;
     }
 
     if(database->openMode() == pool::IDatabase::CLOSED) {
       database->connectForRead();
     }
 
     long tech(database->technology());
     pool::ITechnologySpecificAttributes &sessAttr(session.technologySpecificAttributes(tech));
     pool::ITechnologySpecificAttributes &dbAttrs(database->technologySpecificAttributes());
 
     MsgDebug("-------------------------------------------");
     MsgDebug("db='"<<db<<"' technology="<<tech);
 
     printTechAttr<int>("DEFAULT_COMPRESSION",sessAttr);
     printTechAttr<int>("DEFAULT_SPLITLEVEL",sessAttr);
     printTechAttr<int>("DEFAULT_AUTOSAVE",sessAttr);
     printTechAttr<int>("DEFAULT_BUFFERSIZE",sessAttr);
     printTechAttr<int>("NUM_CLASSES",sessAttr);
     printTechAttr<int>("NUM_TYPES",sessAttr);
     printTechAttr<int>("ERRNO",sessAttr);
     printTechAttr<int>("TREE_MAX_SIZE",sessAttr);
 
     MsgDebug(">Database attributes:");
     printTechAttr<int>("DEFAULT_COMPRESSION", dbAttrs);
     printTechAttr<int>("DEFAULT_SPLITLEVEL", dbAttrs);
     printTechAttr<int>("DEFAULT_AUTOSAVE", dbAttrs);
     printTechAttr<int>("DEFAULT_BUFFERSIZE", dbAttrs);
     printTechAttr<int>("COMPRESSION_LEVEL", dbAttrs);
     printTechAttr<double>("COMPRESSION_FACTOR", dbAttrs);
     printTechAttr<int>("BEST_BUFFER", dbAttrs);
     printTechAttr<double>("BYTES_WRITTEN", dbAttrs);
     printTechAttr<double>("BYTES_READ", dbAttrs);
     printTechAttr<int>("BYTES_FREE", dbAttrs);
     printTechAttr<int>("BYTES_INFO", dbAttrs);
     printTechAttr<int>("BYTES_KEYS", dbAttrs);
     printTechAttr<int>("NKEYS", dbAttrs);
     printTechAttr<double>("FILEBYTES_WRITTEN", dbAttrs);
     printTechAttr<double>("FILEBYTES_READ", dbAttrs);
     printTechAttr<int>("FILE_DESCRIPTOR", dbAttrs);
     printTechAttr<int>("FILE_VERSION", dbAttrs);
     printTechAttr<long>("FILE_SIZE", dbAttrs);
     printTechAttr<int>("FILE_ERROR", dbAttrs);
     printTechAttr<long>("FILE_END", dbAttrs);
     printTechAttr<void*>("FILE_KEYS", dbAttrs);
     printTechAttr<void*>("TFILE", dbAttrs);
     printTechAttr<long>("TREE_MAX_SIZE", dbAttrs);
 
     MsgDebug("-------------------------------------------");
 
     std::vector<std::string> conts(database->containers());
     std::vector<std::string>::iterator begin(conts.begin());
     std::vector<std::string>::iterator end(conts.end());
     for(; begin != end; ++begin) {
       pool::IContainer *cont = database->containerHandle(*begin);
       pool::ITechnologySpecificAttributes &contAttrs(cont->technologySpecificAttributes());
 
       MsgDebug("--- Container '"<<*begin<<"' technology="<<cont->technology());
       if(cont->technology() == pool::ROOTTREE_StorageType.type()) {
         MsgDebug("Container of type ROOTTree");
         printTechAttr<void*>("TREE", contAttrs);
         printTechAttr<int>("TREE_ENTRIES", contAttrs);
         printTechAttr<int>("TREE_NBRANCHES", contAttrs);
         printTechAttr<double>("TREE_TOTAL_BYTES", contAttrs);
         printTechAttr<double>("TREE_ZIP_BYTES", contAttrs);
         printTechAttr<int>("TREE_FILE_NUMBER", contAttrs);
         printTechAttr<int>("TREE_MAX_SIZE", contAttrs);
         printTechAttr<int>("TREE_MAX_VIRTUAL_SIZE", contAttrs);
         
         unsigned int branches = cont->technologySpecificAttributes().attribute<int>("TREE_NBRANCHES");
         for(unsigned int iBranches = 0; iBranches < branches; ++iBranches) {
           std::string branch(begin->substr(begin->find('_') + 1));
           MsgDebug("----- Branch '"<<branch<<"'");
           printTechAttr<void*>("BRANCH", contAttrs, branch);
           printTechAttr<int>("BRANCH_ENTRIES", contAttrs, branch);
           printTechAttr<int>("BRANCH_MAX_BASKETS", contAttrs, branch);
           printTechAttr<int>("BRANCH_BASKET_SIZE", contAttrs, branch);
           printTechAttr<double>("BRANCH_TOTAL_SIZE", contAttrs, branch);
           printTechAttr<double>("BRANCH_TOTAL_BYTES", contAttrs, branch);
           printTechAttr<double>("BRANCH_ZIP_BYTES", contAttrs, branch);
           printTechAttr<int>("BRANCH_COMPRESSION_LEVEL", contAttrs, branch);
           printTechAttr<int>("BRANCH_NLEAVES", contAttrs, branch);
           printTechAttr<int>("BRANCH_SPLIT_LEVEL", contAttrs, branch);
         }
       } 
       else if(cont->technology() == pool::ROOTKEY_StorageType.type()) {
         MsgDebug("Container of type ROOTKey");
 
         printTechAttr<void*>("DIRECTORY", contAttrs);
         printTechAttr<void*>("DIR_MOTHER", contAttrs);
         printTechAttr<void*>("DIR_FILE", contAttrs);
         printTechAttr<void*>("DIR_LIST_KEYS", contAttrs);
         printTechAttr<int>("DIR_NKEYS", contAttrs);
         printTechAttr<int>("DIR_PRINT", contAttrs);
         printTechAttr<int>("DIR_WRITABLE", contAttrs);
         printTechAttr<int>("DIR_MODIFIED", contAttrs);
       }
       else {
         MsgWarning("Unknown technology for container");
       }
     }
     MsgDebug("-------------------------------------------");
     m_persistSvc->session().transaction().commit();
     m_catalog->commit();
   }
   catch(std::exception &e) {
     MsgError("printAttributes() Exception: "<<e.what());
     try {
       m_catalog->commit();
     }
     catch(std::exception &e) {
       MsgError("printAttributes() Exception: "<<e.what());
     }
   }
 }
 
 // -------------------------
 // ---- Private methods ----
 
 void 
 PoolFileCatalogConnection::deletePFN(const CatalogKey &key) {
   try {
     MsgDebug("deletePFN() PFN="<<key.getID());
     pool::FCAdmin a;
     m_catalog->setAction(a);
     m_catalog->start();
     a.deletePFN(key.getID());
     m_catalog->commit();
     // remove cache entry and delete instance
     m_entryCache->eraseInstance(key);
   }
   catch(std::exception &e) {
     MsgError("deletePFN() Exception caught: "<<e.what());
   }
 }
 
 void 
 PoolFileCatalogConnection::deleteFID(const std::string &fid) {
   try {
     MsgDebug("deleteFID() FID="<<fid);
     pool::FCAdmin a;
     m_catalog->setAction(a);
     m_catalog->start();
     a.deleteEntry(fid);
     m_catalog->commit();
     // remove cache entry and delete instance
     m_entryCache->eraseInstance(CatalogKey(fid));
   }
   catch(std::exception &e) {
     MsgError("deleteFID() Exception caught: "<<e.what());
   }
 }
 
 // ---- Static methods ----
 
 ROOT::Reflex::Type
 PoolFileCatalogConnection::getClassForToken( const pool::Token *token ) {
   const pool::Guid &classId(token->classID());
   return pool::DbReflex::forGuid(classId);
 }

This page was automatically generated by the LXR engine.