int cond::CreateKeyUtilities::execute(){
std::string inFile("");
if( hasOptionValue("create") ) {
inFile = getOptionValue<std::string>("create");
size_t keySize = 0;
if( hasOptionValue("generate") ) keySize = Auth::COND_AUTHENTICATION_KEY_SIZE;
if(!inFile.empty()){
DecodingKey key;
key.init( DecodingKey::FILE_NAME, Auth::COND_KEY, false );
key.createFromInputFile( inFile, keySize );
if( hasDebug() ) key.list( std::cout );
key.flush();
return 0;
}
return 1;
}
if( hasOptionValue("read") ) {
inFile = getOptionValue<std::string>("read");
if(!inFile.empty()){
DecodingKey key;
key.init( inFile, Auth::COND_KEY );
key.list( std::cout );
return 0;
}
return 1;
}
if( hasOptionValue("dump_template") ) {
std::cout <<DecodingKey::templateFile() <<std::endl;
return 0;
}
return 1;
}
int cond::RunInfoUtils::execute(){
std::string connect = getOptionValue<std::string>("connect");
std::string fromConnect = getOptionValue<std::string>("fromConnect");
// this is mandatory
std::string tag = getOptionValue<std::string>("tag");
std::cout <<"# Source tag is "<<tag<<std::endl;
size_t max_entries = 1000;
if(hasOptionValue("max_entries")) max_entries = getOptionValue<size_t>("max_entries");
persistency::ConnectionPool connPool;
if( hasOptionValue("authPath") ){
connPool.setAuthenticationPath( getOptionValue<std::string>( "authPath") );
}
if(hasDebug()) connPool.setMessageVerbosity( coral::Debug );
connPool.configure();
persistency::Session session = connPool.createSession( connect, true );
std::cout <<"# Connecting to target database on "<<connect<<std::endl;
persistency::Session sourceSession = connPool.createSession( fromConnect );
std::cout <<"# Connecting to source database on "<<fromConnect<<std::endl;
RunInfoUpdate updater( session );
persistency::TransactionScope tsc( session.transaction() );
tsc.start(false);
sourceSession.transaction().start();
updater.import( max_entries, tag, sourceSession );
sourceSession.transaction().commit();
tsc.commit();
return 0;
}
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;
}
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::KeyManager::execute(){
if( hasOptionValue("dump_template") ) {
if( hasOptionValue("textFile") ) {
std::string textFile = getOptionValue<std::string>("textFile");
std::ofstream outFile ( textFile.c_str() );
if (outFile.is_open()){
outFile <<DecodingKey::templateFile()<<std::endl;
outFile.close();
} else {
std::cout <<"ERROR: file \""<<textFile<<"\" cannot be open."<<std::endl;
outFile.close();
return 1;
}
} else {
std::cout <<DecodingKey::templateFile()<<std::endl;
}
return 0;
}
if( hasOptionValue("create") ) {
std::string textFile = getOptionValue<std::string>("textFile");
size_t keySize = Auth::COND_AUTHENTICATION_KEY_SIZE;
DecodingKey key;
key.init( DecodingKey::FILE_NAME, Auth::COND_KEY, false );
key.createFromInputFile( textFile, keySize );
if( hasDebug() ) key.list( std::cout );
key.flush();
return 0;
}
if( !hasOptionValue("dump") && !hasOptionValue("read")) {
return 0;
}
std::string path = getOptionValue<std::string>("keyPath");
boost::filesystem::path keyPath( path );
boost::filesystem::path keyFile( DecodingKey::FILE_PATH );
keyPath /= keyFile;
std::string keyFileName = keyPath.string();
if(!boost::filesystem::exists( keyFileName )){
std::cout <<"ERROR: specified key file \""<<keyFileName<<"\" does not exist."<<std::endl;
return 1;
}
if( hasOptionValue("dump") ) {
std::string textFile = getOptionValue<std::string>("textFile");
std::ofstream outFile ( textFile.c_str() );
if (outFile.is_open()){
DecodingKey key;
key.init( keyFileName, Auth::COND_KEY );
key.list( outFile );
outFile.close();
return 0;
} else {
std::cout <<"ERROR: file \""<<textFile<<"\" cannot be open."<<std::endl;
outFile.close();
return 1;
}
}
if( hasOptionValue("read") ) {
DecodingKey key;
key.init( keyFileName, Auth::COND_KEY );
key.list( std::cout );
return 0;
}
return 1;
}
bool Options::parseCommandLine(int argc, const char* const* argv)
{
bool success = true;
program_name_ = argv[0];
desc_.add_options()(
"help",
"show help message"
)(
"version,v",
"show version information"
)(
"input-filename,i",
po::value<std::string>(&input_filename_)->required(),
"input file name (.mp3, .wav, .flac, .dat)"
)(
"output-filename,o",
po::value<std::string>(&output_filename_)->required(),
"output file name (.wav, .dat, .png, .json)"
)(
"zoom,z",
po::value<int>(&samples_per_pixel_)->default_value(256),
"zoom level (samples per pixel)"
)(
"pixels-per-second",
po::value<int>(&pixels_per_second_)->default_value(100),
"zoom level (pixels per second)"
)(
"bits,b",
po::value<int>(&bits_)->default_value(16),
"bits (8 or 16)"
)(
"start,s",
po::value<double>(&start_time_)->default_value(0.0),
"start time (seconds)"
)(
"end,e",
po::value<double>(&end_time_)->default_value(0.0),
"end time (seconds)"
)(
"width,w",
po::value<int>(&image_width_)->default_value(800),
"image width (pixels)"
)(
"height,h",
po::value<int>(&image_height_)->default_value(250),
"image height (pixels)"
)(
"colors,c",
po::value<std::string>(&color_scheme_)->default_value("audacity"),
"color scheme (audition or audacity)"
)(
"border-color",
po::value<RGBA>(&border_color_),
"border color (rrggbb[aa])"
)(
"background-color",
po::value<RGBA>(&background_color_),
"background color (rrggbb[aa])"
)(
"waveform-color",
po::value<RGBA>(&waveform_color_),
"wave color (rrggbb[aa])"
)(
"axis-label-color",
po::value<RGBA>(&axis_label_color_),
"axis label color (rrggbb[aa])"
)(
"no-axis-labels",
"render waveform image without axis labels"
)(
"with-axis-labels",
"render waveform image with axis labels (default)"
);
po::variables_map variables_map;
try {
po::command_line_parser parser(argc, argv);
parser.options(desc_);
po::store(parser.run(), variables_map);
help_ = variables_map.count("help") != 0;
version_ = variables_map.count("version") != 0;
if (help_ || version_) {
return true;
}
render_axis_labels_ = variables_map.count("no-axis-labels") == 0;
const auto& end_option = variables_map["end"];
has_end_time_ = !end_option.defaulted();
const auto& samples_per_pixel_option = variables_map["zoom"];
has_samples_per_pixel_ = !samples_per_pixel_option.defaulted();
const auto& pixels_per_second_option = variables_map["pixels-per-second"];
has_pixels_per_second_ = !pixels_per_second_option.defaulted();
const auto& bits_option = variables_map["bits"];
has_bits_ = !bits_option.defaulted();
po::notify(variables_map);
has_border_color_ = hasOptionValue(variables_map, "border-color");
has_background_color_ = hasOptionValue(variables_map, "background-color");
has_waveform_color_ = hasOptionValue(variables_map, "waveform-color");
has_axis_label_color_ = hasOptionValue(variables_map, "axis-label-color");
if (bits_ != 8 && bits_ != 16) {
error_stream << "Invalid bits: must be either 8 or 16\n";
success = false;
}
}
catch (std::runtime_error& e) {
reportError(e);
success = false;
}
catch (const po::error& e) {
reportError(e);
success = false;
}
return success;
}
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::MigrateGTUtilities::execute(){
std::string gtag = getOptionValue<std::string>("globaltag");
std::string release = getOptionValue<std::string>("release");
bool debug = hasDebug();
std::string destConnect = getOptionValue<std::string>("destConnect" );
std::string sourceConnect = getOptionValue<std::string>("sourceConnect");
bool verbose = hasOptionValue("verbose");
bool dryRun = hasOptionValue("dryRun");
bool onlineMode = hasOptionValue("online");
std::vector<std::tuple<std::string,std::string,std::string,std::string,std::string> > gtlist;
if(! getGTList( gtag, gtlist ) ) throw std::runtime_error( std::string("Source GT ")+gtag+" has not been found." );
ConnectionPool connPool;
if( hasDebug() ) connPool.setMessageVerbosity( coral::Debug );
Session session = connPool.createSession( destConnect, !dryRun );
session.transaction().start( dryRun );
if( session.existsGlobalTag( gtag ) ){
std::cout <<"GT "<<gtag<<" already exists in the destination database."<<std::endl;
return 1;
}
GTEditor newGT;
if( !dryRun ){
newGT = session.createGlobalTag( gtag );
newGT.setDescription( "GT "+gtag+" migrated from account "+sourceConnect );
newGT.setRelease( release );
newGT.setSnapshotTime( boost::posix_time::time_from_string(std::string(cond::time::MAX_TIMESTAMP) ) );
}
std::cout <<"Processing "<<gtlist.size()<<" tags."<<std::endl;
size_t nerr = 0;
for(auto gtitem : gtlist ){
std::string tag = std::get<0>( gtitem );
std::string payloadTypeName = std::get<1>( gtitem );
std::string recordName = std::get<2>( gtitem );
std::string recordLabel = std::get<3>( gtitem );
std::string connectionString = std::get<4>( gtitem );
std::cout <<"--> Processing tag "<<tag<<" (objectType: "<<payloadTypeName<<") on account "<<connectionString<<std::endl;
std::string sourceConn = convert( connectionString, onlineMode ); // "oracle://cms_orcon_adg/"+account;
std::string destTag("");
cond::MigrationStatus status;
bool exists = session.checkMigrationLog( sourceConn, tag, destTag, status );
if(!exists || status==cond::ERROR){
std::cout <<" ERROR: Tag "<<tag<<" from "<<sourceConn<<" has not been migrated to the destination database."<<std::endl;
if( !dryRun ){
return 1;
} else {
nerr++;
}
} else {
std::cout <<" Inserting tag "<<destTag<<std::endl;
}
if( !dryRun ) newGT.insert( recordName, recordLabel, destTag );
}
if( !dryRun )newGT.flush();
session.transaction().commit();
std::cout << std::endl;
if( !dryRun ) {
std::cout <<"Global Tag \""<<gtag<<"\" imported."<<std::endl;
} else {
std::cout <<"Importing Global Tag \""<<gtag<<"\" will run with "<<nerr<<" error(s)"<<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;
}
int cond::TestGTPerf::execute(){
std::string gtag = getOptionValue<std::string>("globaltag");
bool debug = hasDebug();
std::string connect = getOptionValue<std::string>("connect");
bool verbose = hasOptionValue("verbose");
int nThrF = getOptionValue<int>("n_fetch");
int nThrD = getOptionValue<int>("n_deser");
std::cout << "\n++> going to use " << nThrF << " threads for loading, " << nThrD << " threads for deserialization. \n" << std::endl;
std::string serType = "unknown";
if ( connect.find("CMS_CONDITIONS") != -1 ) {
serType = "ROOT-5";
} else if (connect.find("CMS_TEST_CONDITIONS") != -1 ) {
serType = "boost";
}
Time_t startRun= 150005;
if(hasOptionValue("start_run")) startRun = getOptionValue<Time_t>("start_run");
Time_t startTs= 5800013687234232320;
if(hasOptionValue("start_ts")) startTs = getOptionValue<Time_t>("start_ts");
Time_t startLumi= 908900979179966;
if(hasOptionValue("start_lumi")) startLumi = getOptionValue<Time_t>("start_lumi");
std::string authPath("");
if( hasOptionValue("authPath")) authPath = getOptionValue<std::string>("authPath");
initializePluginManager();
Timer timex(serType);
ConnectionPoolWrapper connPool( 1, authPath, hasDebug() );
Session session = connPool.createSession( connect );
session.transaction().start();
std::cout <<"Loading Global Tag "<<gtag<<std::endl;
GTProxy gt = session.readGlobalTag( gtag );
session.transaction().commit();
std::cout <<"Loading "<<gt.size()<<" tags..."<<std::endl;
std::vector<UntypedPayloadProxy *> proxies;
std::map<std::string,size_t> requests;
size_t nt = 0;
for( auto t: gt ){
nt++;
UntypedPayloadProxy * p = new UntypedPayloadProxy;
p->init( session );
try{
p->load( t.tagName() );
if (nThrF == 1) { // detailed info only needed in single-threaded mode to get the types/names
p->setRecordInfo( t.recordName(), t.recordLabel() );
}
proxies.push_back( p );
requests.insert( std::make_pair( t.tagName(), 0 ) );
} catch ( const cond::Exception& e ){
std::cout <<"ERROR: "<<e.what()<<std::endl;
}
}
std::cout << proxies.size() << " tags successfully loaded." << std::endl;
timex.interval("loading iovs");
Time_t run = startRun;
Time_t lumi = startLumi;
Time_t ts = startTs;
if (nThrF > 1) session.transaction().commit();
tbb::task_scheduler_init init( nThrF );
std::vector<std::shared_ptr<FetchWorker> > tasks;
std::string payloadTypeName;
for( auto p: proxies ){
payloadTypeName = p->payloadType();
// ignore problematic ones for now
if ( (payloadTypeName == "SiPixelGainCalibrationOffline") // 2 * 133 MB !!!
) {
std::cout << "WARNING: Ignoring problematic payload of type " << payloadTypeName << std::endl;
continue;
}
if (nThrF > 1) {
auto fw = std::make_shared<FetchWorker>(connPool, connect, p, (std::map<std::string,size_t> *) &requests,
run, lumi, ts);
tasks.push_back(fw);
} else {
bool loaded = false;
time::TimeType ttype = p->timeType();
auto r = requests.find( p->tag() );
try{
if( ttype==runnumber ){
p->get( run, hasDebug() );
r->second++;
} else if( ttype==lumiid ){
p->get( lumi, hasDebug() );
r->second++;
} else if( ttype==timestamp){
p->get( ts, hasDebug() );
r->second++;
} else {
std::cout <<"WARNING: iov request on tag "<<p->tag()<<" (timeType="<<time::timeTypeName(p->timeType())<<") has been skipped."<<std::endl;
}
timex.fetchInt(p->getBufferSize()); // keep track of time vs. size
} catch ( const cond::Exception& e ){
std::cout <<"ERROR:"<<e.what()<<std::endl;
}
} // end else (single thread)
}
tbb::parallel_for_each(tasks.begin(),tasks.end(),invoker<std::shared_ptr<FetchWorker> >() );
std::cout << "global counter : " << fooGlobal << std::endl;
if (nThrF == 1) session.transaction().commit();
// session.transaction().commit();
timex.interval("loading payloads");
size_t totBufSize = 0;
for( auto p: proxies ){
totBufSize += p->getBufferSize();
}
std::cout << "++> total buffer size used : " << totBufSize << std::endl;
std::vector<std::shared_ptr<void> > payloads;
payloads.resize(400); //-todo: check we don't have more payloads than that !!
std::shared_ptr<void> payloadPtr;
tbb::task_scheduler_init initD( nThrD );
std::vector<std::shared_ptr<DeserialWorker> > tasksD;
timex.interval("setup deserialization");
int nEmpty = 0;
int nBig = 0;
int index = 0;
for( auto p: proxies ){
/// if ( p->getBufferSize() == 0 ) { // nothing to do for these ...
/// std::cout << "empty buffer found for " << p->payloadType() << std::endl;
/// nEmpty++;
/// continue;
/// }
payloadTypeName = p->payloadType();
// ignore problematic ones for now
if ( (payloadTypeName == "SiPixelGainCalibrationForHLT")
or (payloadTypeName == "SiPixelGainCalibrationOffline") // 2 * 133 MB !!!
or (payloadTypeName == "DTKeyedConfig")
or (payloadTypeName == "std::vector<unsigned long long>")
or (payloadTypeName == " AlignmentSurfaceDeformations")
// only in root for now:
or (payloadTypeName == "PhysicsTools::Calibration::MVAComputerContainer")
or (payloadTypeName == "PhysicsTools::Calibration::MVAComputerContainer")
or (payloadTypeName == "PhysicsTools::Calibration::MVAComputerContainer")
or (payloadTypeName == "PhysicsTools::Calibration::MVAComputerContainer")
) {
std::cout << "INFO: Ignoring payload of type " << payloadTypeName << std::endl;
continue;
}
if (nThrD > 1) {
auto dw = std::make_shared<DeserialWorker>(p, payloads[index]);
tasksD.push_back(dw);
} else { // single tread only
try {
std::pair<std::string, std::shared_ptr<void> > result = fetchOne( payloadTypeName, p->getBuffer(), p->getStreamerInfo(), payloadPtr);
payloads.push_back(result.second);
} catch ( const cond::Exception& e ){
std::cout << "\nERROR (cond): " << e.what() << std::endl;
std::cout << "for payload type name: " << payloadTypeName << std::endl;
} catch ( const std::exception& e ){
std::cout << "\nERROR (boost/std): " << e.what() << std::endl;
std::cout << "for payload type name: " << payloadTypeName << std::endl;
}
timex.deserInt(p->getBufferSize()); // keep track of time vs. size
} // single-thread
index++; // increment index into payloads
}
std::cout << std::endl;
tbb::parallel_for_each(tasksD.begin(),tasksD.end(),invoker<std::shared_ptr<DeserialWorker> >() );
timex.interval("deserializing payloads");
std::cout << "global counter : " << fooGlobal << std::endl;
std::cout << "found " << nEmpty << " empty payloads while deserialising " << std::endl;
std::cout <<std::endl;
std::cout <<"*** End of job."<<std::endl;
std::cout <<"*** GT: "<<gtag<<" Tags:"<<gt.size()<<" Loaded:"<<proxies.size()<<std::endl;
std::cout<<std::endl;
for( auto p: proxies ){
auto r = requests.find( p->tag() );
if( verbose ){
std::cout <<"*** Tag: "<<p->tag()<<" Requests processed:"<<r->second<<" Queries:"<< p->numberOfQueries() <<std::endl;
const std::vector<std::string>& hist = p->history();
for( auto e: p->history() ) std::cout <<" "<<e<<std::endl;
}
}
// only for igprof checking of live mem:
// ::exit(0);
timex.interval("postprocessing ... ");
timex.showIntervals();
if ( nThrF == 1) {
std::ofstream ofs("fetchInfo.txt");
timex.showFetchInfo(ofs);
std::ofstream ofs2("sizeInfo.txt");
for ( auto p: proxies ) {
ofs2 << p->payloadType() << "[" << p->recName() << ":" << p->recLabel() << "]" << " : " << p->getBufferSize() << std::endl;
}
}
if ( nThrD == 1) {
std::ofstream ofs1("deserializeInfo.txt");
timex.showDeserInfo(ofs1);
}
return 0;
}