int cond::DuplicateIOVUtilities::execute(){
std::string sourceTag = getOptionValue<std::string>("tag");
std::string destTag(sourceTag);
if(hasOptionValue("destTag")) destTag = getOptionValue<std::string>("destTag");
cond::Time_t from = getOptionValue<cond::Time_t>("fromTime");
cond::Time_t since = getOptionValue<cond::Time_t>("sinceTime");
bool doLog = hasOptionValue("logDB");
bool debug = hasDebug();
std::string destConnect = getOptionValue<std::string>("connect" );
std::string usertext("no user comments");
if( hasOptionValue("usertext")) usertext = getOptionValue<std::string>("usertext");
cond::DbSession destDb = openDbSession( "connect", Auth::COND_WRITER_ROLE );
std::string iovToken("");
std::string destIovToken("");
cond::TimeType iovType;
std::string timetypestr("");
if(debug){
std::cout << "source tag " << sourceTag << std::endl;
std::cout << "dest tag " << destTag << std::endl;
}
cond::IOVProxy sourceIov(destDb);
cond::IOVEditor destIov(destDb);
// find tag
cond::DbScopedTransaction transaction(destDb);
transaction.start(false);
destDb.storage().lockContainer( IOVNames::container() );
cond::MetaData metadata(destDb);
iovToken = metadata.getToken(sourceTag);
if(iovToken.empty())
throw std::runtime_error(std::string("tag ")+sourceTag+std::string(" not found") );
sourceIov.load( iovToken );
iovType=sourceIov.timetype();
timetypestr = cond::timeTypeSpecs[iovType].name;
if( metadata.hasTag(destTag) ){
destIovToken=metadata.getToken(destTag);
destIov.load( destIovToken );
if (iovType!=destIov.proxy().timetype()) {
throw std::runtime_error("iov type in source and dest differs");
}
} else {
destIovToken = destIov.create( iovType );
metadata.addMapping(destTag,destIovToken,iovType);
}
if(debug){
std::cout<<"source iov token "<< iovToken<<std::endl;
std::cout<<"dest iov token "<< destIovToken<<std::endl;
std::cout<<"iov type "<< timetypestr<<std::endl;
}
cond::IOVProxy::const_iterator iElem = sourceIov.find( from );
if( iElem == sourceIov.end() ){
std::cerr <<"[Error] no payload found for time " << from << std::endl;
return 1;
}
std::string payload = iElem->token();
std::string payloadClass = destDb.classNameForItem( payload );
destIov.append(since,payload);
destIov.stamp(cond::userInfo(),false);
transaction.commit();
::sleep(1);
// setup logDB and write on it...
if (doLog){
std::auto_ptr<cond::Logger> logdb;
cond::DbSession logSession = openDbSession( "logDB", Auth::COND_WRITER_ROLE );
logdb.reset(new cond::Logger( logSession ));
logdb->createLogDBIfNonExist();
cond::UserLogInfo a;
a.provenance=destConnect+"/"+destTag;
a.usertext="duplicateIOV V1.0;";
std::ostringstream ss;
ss << "From="<< from <<"; Since="<< since <<"; " << usertext;
a.usertext +=ss.str();
logdb->logOperationNow(a,destConnect,payloadClass,payload,destTag,timetypestr,0,since);
}
return 0;
}
int main(int csize, char** cline ) {
seal::PluginManager::get()->initialise();
seal::TimingReport timRep;
try {
// Loads the seal message stream
LockMutex::Mutex mutex;
pool::POOLContext::loadComponent( "SEAL/Services/MessageService" );
pool::POOLContext::loadComponent( "POOL/Services/EnvironmentAuthenticationService" );
pool::URIParser p;
p.parse();
pool::IFileCatalog lcat;
pool::IFileCatalog * cat = &lcat;
cat->setWriteCatalog(p.contactstring());
cat->connect();
cat->start();
own_ptr<pool::IPersistencySvc> oriper;
own_ptr<pool::IPersistencySvc> safeper;
own_ptr<pool::IDataSvc> datasvc;
// Persil::TCPGetter tcpGetter;
Persil::TCPGetterFactory tcpGetter;
pool::IPersistencySvcFactory* psfactory = pool::IPersistencySvcFactory::get();
oriper.reset(psfactory->create( "PersistencySvc", lcat ));
safeper.reset(new StreamPersistencySvc(*oriper.get(), tcpGetter, mutex));
datasvc.reset(pool::DataSvcFactory::instance(safeper.get()));
pool::IDataSvc *svc = datasvc.get();
Persil::currentCache() = &svc->cacheSvc();
svc->transaction().start(pool::ITransaction::READ);
if (csize==2) {
// peds
std::string iovToken(cline[1]);
svc->transaction().start(pool::ITransaction::READ);
pool::Ref<CalibTests::IOV> iov(svc,iovToken);
std::cout << "first iov " << (*iov->iov.begin()).first << " "
<< (*iov->iov.begin()).second << std::endl;
std::cout << "last iov " << (*iov->iov.rbegin()).first << " "
<< (*iov->iov.rbegin()).second << std::endl;
for (int t=253; t<290; t+=15) {
std::cout << "at time " << t << " used " << (*iov->iov.lower_bound(t)).first << std::endl;
std::string pedCid = (*iov->iov.lower_bound(t)).second;
std::cout << "ped Cid " << pedCid << std::endl;
pool::Ref<CalibTests::SimplePedestals> peds(svc,pedCid);
std::cout << "peds size " << peds->m_pedestals.size() << std::endl;
int l=2000; int le=2050;
std::cout << "peds from " << l;
for (CalibTests::SimplePedestals::ItemIterator p= peds->m_pedestals.begin()+l; p!= peds->m_pedestals.begin()+le;p++)
std::cout << " " << (*p).m_mean << "," << (*p).m_variance;
std::cout << std::endl;
}
/*
std::string iovToken(cline[1]);
pool::Ref<CalibTests::IOV> iov(svc,iovToken);
std::string pedCid = (*iov->iov.lower_bound(253)).second;
std::cout << "ped Cid " << pedCid << std::endl;
pool::Ref<CalibTests::Pedestals> peds(svc,pedCid);
int l=2000;
CalibTests::Pedestals::ItemRange r=peds->get(l);
std::cout << "peds from " << l;
for (CalibTests::Pedestals::ItemIterator p=r.first; p!=r.second;p++)
std::cout << " " << (*p).m_mean << "," << (*p).m_variance;
std::cout << std::endl;
*/
}
if (csize==3) {
// align
std::string iovAToken(cline[1]);
std::string iovIToken(cline[2]);
pool::Ref<CalibTests::IOV> iovA(svc,iovAToken);
pool::Ref<CalibTests::IOV> iovI(svc,iovIToken);
std::cout << "iov size " << iovA->iov.size() << std::endl;
std::string alignCid = (*iovA->iov.lower_bound(25)).second;
std::string indexCid = (*iovI->iov.lower_bound(25)).second;
std::cout << "align Cid " << alignCid << std::endl;
std::cout << "index Cid " << indexCid << std::endl;
pool::Ref<Alignments> align(svc,alignCid);
pool::Ref<Geom2Index> index(svc,indexCid);
Geom2Index::GeomId id=500+20+7;
std::cout << "align for " << id;
int i= index->m_indexTable[id];
std::cout << " " << (*align).m_align[i].translation() << ","
<< (*align).m_align[i].eulerAngles();
std::cout << std::endl;
}
svc->transaction().commit();
svc->session().disconnectAll();
std::cout << "committed" << std::endl;
std::cout << "commit catalog" << std::endl;
cat->commit();
}
catch ( seal::Exception& e ) {
std::cout << "seal error " << e.what() << std::endl;
return 1;
}
catch ( std::exception& e ) {
std::cout << "std error " << e.what() << std::endl;
return 1;
}
catch ( ... ) {
std::cout << "Funny error" << std::endl;
return 1;
}
return 0;
}
