bool cond::MigrateGTUtilities::getGTList( const std::string& gt,
std::vector<std::tuple<std::string,std::string,std::string,std::string,std::string> >&tagList ){
cond::DbSession gtSession = openDbSession("sourceConnect",cond::Auth::COND_READER_ROLE,true);
gtSession.transaction().start(true);
coral::ISchema& schema = gtSession.nominalSchema();
std::string gtTable("TAGTREE_TABLE_");
gtTable += gt;
if( !schema.existsTable( gtTable ) ){
std::cout <<"ERROR: The specified Global Tag \"" << gt <<"\" has not been found in the database." <<std::endl;
return false;
}
bool ret = false;
GT::tname = gtTable;
TAGINV::tname = "TAGINVENTORY_TABLE";
persistency::Query< TAGINV::tagname, TAGINV::objectname, TAGINV::recordname, TAGINV::labelname, TAGINV::pfn > q( schema );
q.addCondition<GT::tagid, TAGINV::tagid>();
q.addOrderClause<TAGINV::tagname>();
for ( auto row : q ) {
tagList.push_back( row );
ret = true;
}
gtSession.transaction().commit();
return ret;
}
int cond::ListIOVUtilities::execute(){
initializePluginManager();
bool listAll = hasOptionValue("all");
cond::DbSession session = openDbSession( "connect", true );
if( listAll ){
cond::MetaData metadata_svc(session);
std::vector<std::string> alltags;
cond::DbScopedTransaction transaction(session);
transaction.start(true);
metadata_svc.listAllTags(alltags);
transaction.commit();
std::copy (alltags.begin(),
alltags.end(),
std::ostream_iterator<std::string>(std::cout,"\n")
);
}else{
std::string tag = getOptionValue<std::string>("tag");
cond::MetaData metadata_svc(session);
std::string token;
cond::DbScopedTransaction transaction(session);
transaction.start(true);
token=metadata_svc.getToken(tag);
transaction.commit();
{
bool verbose = hasOptionValue("verbose");
bool details = hasOptionValue("summary");
TFile * xml=0;
if (details) {
xml = TFile::Open(std::string(tag+".xml").c_str(),"recreate");
}
cond::IOVProxy iov( session, token, !details, details);
unsigned int counter=0;
std::string payloadContainer=iov.payloadContainerName();
std::cout<<"Tag "<<tag;
if (verbose) std::cout << "\nStamp: " << iov.iov().comment()
<< "; time " << cond::time::to_boost(iov.iov().timestamp())
<< "; revision " << iov.iov().revision();
std::cout <<"\nTimeType " << cond::timeTypeSpecs[iov.timetype()].name
<<"\nPayloadContainerName "<<payloadContainer<<"\n"
<<"since \t till \t payloadToken"<<std::endl;
for (cond::IOVProxy::const_iterator ioviterator=iov.begin(); ioviterator!=iov.end(); ioviterator++) {
std::cout<<ioviterator->since() << " \t "<<ioviterator->till() <<" \t "<<ioviterator->wrapperToken();
if (details) {
ora::Object obj = session.getObject(ioviterator->wrapperToken());
std::ostringstream ss; ss << tag << '_' << ioviterator->since();
xml->WriteObjectAny(obj.address(),obj.typeName().c_str(), ss.str().c_str());
obj.destruct();
}
std::cout<<std::endl;
++counter;
}
if (xml) xml->Close();
std::cout<<"Total # of payload objects: "<<counter<<std::endl;
}
}
return 0;
}
std::string getToken(cond::DbSession & s, std::string & tag) {
s = openDbSession("connect", true);
cond::MetaData metadata_svc(s);
cond::DbScopedTransaction transaction(s);
transaction.start(true);
std::string token = metadata_svc.getToken(tag);
transaction.commit();
std::cout << "Source iov token: " << token << "\n";
return token;
}
int cond::SchemaManager::execute(){
bool drop= hasOptionValue("drop");
bool dropAll= hasOptionValue("dropAll");
bool create= hasOptionValue("create");
std::string payloadName("");
if( hasOptionValue("payload") ) payloadName = getOptionValue<std::string>("payload");
std::string typeName("");
if( hasOptionValue("type") ) typeName = getOptionValue<std::string>("type");
cond::DbSession session = openDbSession("connect", Auth::COND_ADMIN_ROLE);
cond::IOVSchemaUtility util( session, std::cout );
cond::DbScopedTransaction trans( session );
if( dropAll ){
trans.start(false);
util.dropAll();
trans.commit();
return 0;
}
if( drop || create ){
trans.start(false);
if( drop ){
if(payloadName.empty()){
throw cond::Exception("Payload name not provided.");
}
util.dropPayloadContainer( payloadName );
}
if( create ){
util.createIOVContainer();
if(!payloadName.empty()) util.createPayloadContainer( payloadName, typeName );
}
trans.commit();
return 0;
}
throw cond::Exception("Option create or drop not provided.");
}
int cond::SchemaIOVUtilities::execute(){
bool dropSchema= hasOptionValue("drop");
bool createSchema= hasOptionValue("create");
cond::DbSession session = openDbSession("connect", Auth::COND_ADMIN_ROLE );
cond::IOVSchemaUtility util( session, std::cout );
cond::DbScopedTransaction trans( session );
if( dropSchema || createSchema ){
trans.start(false);
if( dropSchema ){
util.dropIOVContainer();
}
if( createSchema ){
util.createIOVContainer();
}
trans.commit();
return 0;
}
throw cond::Exception("Option create or drop not provided.");
}
int cond::ValidateUtilities::execute(){
initializeForDbConnection();
std::string tag("");
if( hasOptionValue("tag") ) tag = getOptionValue<std::string>("tag");
std::string dir("");
if( hasOptionValue("dir") ) dir = getOptionValue<std::string>("dir");
bool debug = hasDebug();
std::string refConnect = getOptionValue<std::string>("reference");
std::string candidate = getOptionValue<std::string>("candidate" );
std::tuple<std::string,std::string,std::string> connPars = persistency::parseConnectionString( refConnect );
if( std::get<0>( connPars ) == "frontier" ) throwException("Cannot validate data from FronTier cache.","ValidateUtilities::execute");
std::string refDbName = std::get<1>( connPars )+"_"+std::get<2>( connPars );
if(debug){
std::cout << "tag " << tag << std::endl;
}
std::vector<std::string> tagToProcess;
if( !tag.empty() ){
tagToProcess.push_back( tag );
} else {
cond::DbSession refdb = openDbSession( "reference", cond::Auth::COND_READER_ROLE, true );
refdb.transaction().start( true );
cond::MetaData metadata(refdb);
metadata.listAllTags( tagToProcess );
refdb.transaction().commit();
}
persistency::ConnectionPool connPool;
std::cout <<"# Opening session on reference database..."<<std::endl;
persistency::Session session0 = connPool.createSession( refConnect );
std::cout <<"# Opening session on candidates database..."<<std::endl;
persistency::Session session1 = connPool.createSession( candidate );
session1.transaction().start();
if( !session1.existsDatabase() ) throwException( "Candidate DB \""+candidate+" does not exist.",
"MigrateUtilities::execute" );
std::cout <<"# "<<tagToProcess.size()<<" tag(s) to process."<<std::endl;
std::cout <<std::endl;
size_t nt = 0;
size_t tid = 0;
for( auto t : tagToProcess ){
tid++;
std::cout <<"--> Processing tag["<<tid<<"]: "<<t<<std::endl;
std::string refFileName("");
std::string candFileName("");
try{
std::cout <<" Writing reference db"<<std::endl;
refFileName = writeTag( t, "ref", session0, dir );
std::string destTag("");
cond::MigrationStatus status;
if( !session1.checkMigrationLog( refConnect, t, destTag, status ) ) {
std::cout << " ERROR: Tag "<< t <<" has not been migrated in database " << candidate <<std::endl;
boost::filesystem::remove( boost::filesystem::path(refFileName) );
} else {
std::cout <<" Writing candidate db"<<std::endl;
candFileName = writeTag( destTag, "cand", session1, dir );
bool cmp = compareFiles( refFileName, candFileName );
if(!cmp){
std::cout <<" ERROR: Comparison found differences."<<std::endl;
flushFile( refDbName, t, refFileName );
flushFile( refDbName, t, candFileName );
} else {
std::cout <<" Comparison OK."<<std::endl;
}
nt++;
}
} catch ( const std::exception& e ){
std::cout <<" ERROR:"<<e.what()<<std::endl;
std::cout <<" Tag "<<t<<" will be skipped."<<std::endl;
}
cleanUp( refFileName );
cleanUp( candFileName );
}
std::cout <<std::endl<<"# "<<nt<<" tag(s) checked for validation."<<std::endl;
return 0;
}
int cond::MigrateUtilities::execute(){
std::string newTag("");
std::string tag("");
if( hasOptionValue("tag")) {
tag = getOptionValue<std::string>("tag");
if( hasOptionValue("newTag")) newTag = getOptionValue<std::string>("newTag");
}
bool debug = hasDebug();
std::string destConnect = getOptionValue<std::string>("destConnect" );
std::string sourceConnect = getOptionValue<std::string>("sourceConnect");
std::tuple<std::string,std::string,std::string> connPars = parseConnectionString( sourceConnect );
if( std::get<0>( connPars ) == "frontier" ) throwException("Cannot migrate data from FronTier cache.","MigrateUtilities::execute");
std::cout <<"# Connecting to source database on "<<sourceConnect<<std::endl;
cond::DbSession sourcedb = openDbSession( "sourceConnect", cond::Auth::COND_READER_ROLE, true );
if(debug){
std::cout << "tag " << tag << std::endl;
}
sourcedb.transaction().start( true );
cond::MetaData metadata(sourcedb);
std::vector<std::string> tagToProcess;
if( !tag.empty() ){
tagToProcess.push_back( tag );
} else {
metadata.listAllTags( tagToProcess );
}
persistency::ConnectionPool connPool;
std::cout <<"# Opening session on destination database..."<<std::endl;
persistency::Session session = connPool.createSession( destConnect, true );
session.transaction().start( false );
if( !session.existsDatabase() ) session.createDatabase();
session.transaction().commit();
std::cout <<"# "<<tagToProcess.size()<<" tag(s) to process."<<std::endl;
std::cout <<std::endl;
size_t nt = 0;
size_t tid = 0;
for( auto t : tagToProcess ){
tid++;
std::cout <<"--> Processing tag["<<tid<<"]: "<<t<<std::endl;
session.transaction().start( false );
std::string destTag("");
if( session.checkMigrationLog( sourceConnect, t, destTag ) ){
std::cout <<" Tag already migrated." << std::endl;
session.transaction().rollback();
continue;
}
destTag = t;
if( !newTag.empty() ){
destTag = newTag;
} else {
if( session.existsIov( destTag ) ){
destTag = destTag+"["+std::get<1>( connPars )+"/"+std::get<2>( connPars )+"]";
std::cout <<" Tag "<<t<<" already existing, renamed to "<<destTag<<std::endl;
}
}
if( session.existsIov( destTag ) ){
session.transaction().rollback();
throwException("Tag \""+destTag+"\" already exists.","MigrateUtilities::execute");
}
std::cout <<" Resolving source tag oid..."<<std::endl;
std::string iovTok = metadata.getToken(t);
if(iovTok.empty()){
session.transaction().rollback();
throw std::runtime_error(std::string("tag ")+t+std::string(" not found") );
}
std::map<std::string,Hash> tokenToHash;
size_t niovs = 0;
std::set<Hash> pids;
persistency::IOVEditor editor;
std::cout <<" Loading source tag..."<<std::endl;
try{
cond::IOVProxy sourceIov(sourcedb, iovTok);
int tt = (int) sourceIov.timetype();
if( sourceIov.size() == 0 ) {
std::cout <<" No iov found. Skipping tag."<<std::endl;
session.transaction().rollback();
continue;
}
std::string payloadType("");
if( sourceIov.payloadClasses().size() > 0 ) {
payloadType = *(sourceIov.payloadClasses().begin());
} else {
std::string tk = sourceIov.begin()->token();
payloadType = sourcedb.classNameForItem( tk );
}
std::cout <<" Importing tag. Size:"<<sourceIov.size()<<" timeType:"<<cond::timeTypeNames(tt)<<" payloadObjectType=\""<<payloadType<<"\""<<std::endl;
editor = session.createIov( payloadType, destTag, (cond::TimeType)tt );
editor.setDescription( "Tag "+t+" migrated from "+sourceConnect );
for( auto iov : sourceIov ){
Time_t s = iov.since();
std::string tok = iov.token();
Hash pid("");
auto f = tokenToHash.find( tok );
if( f == tokenToHash.end() ){
if(hasDebug() ) std::cout <<"Debug: fetching object for iov ["<<niovs+1<<"] oid: \""<<t<<"\" from source database"<<std::endl;
ora::Object obj = sourcedb.getObject( tok );
if(hasDebug() ) std::cout <<"Debug: importing object into destination database"<<std::endl;
pid = import( obj.typeName(), obj.address(), session );
tokenToHash.insert( std::make_pair( tok, pid ) );
obj.destruct();
} else {
pid= f->second;
}
pids.insert( pid );
editor.insert( s, pid );
niovs++;
if( niovs && (niovs%1000==0) ) std::cout <<" Total of iov inserted: "<<niovs<<std::endl;
}
std::cout <<" Total of iov inserted: "<<niovs<<std::endl;
std::cout <<" Flushing changes..."<<std::endl;
editor.flush();
session.addToMigrationLog( sourceConnect, t, destTag );
session.transaction().commit();
std::cout <<" Tag \""<<t<<"\" imported. Payloads:"<<pids.size()<<" IOVs:"<<niovs<<std::endl;
nt++;
} catch ( const std::exception& e ){
std::cout <<" ERROR:"<<e.what()<<std::endl;
std::cout <<" Tag "<<t<<" will be skipped."<<std::endl;
session.transaction().rollback();
continue;
}
}
std::cout <<"# "<<nt<<" tag(s) migrated."<<std::endl;
sourcedb.transaction().commit();
return 0;
}
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;
}
