graphtool.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS dbe source for the DUNE DAQ project.
// Fork baseline commit: dbe-02-12-17 (2022-05-12).
// Renamed since fork: yes (from src/graphtool.cpp to apps/graphtool.cpp).
 
/************************************************************
 * graphtool.cpp
 *
 * Main file of graphtool ( aka gtool ) used to generate dot
 * files of the ATLAS configuration database. The latter can
 * be used to generate graphs that visualize the database
 * patterns
 *
 *  Created on: Jun 10, 2016
 *      Author: Leonidas Georgopoulos
 ************************************************************/
#include "dbe/graphtool.hpp"
#include "dbe/messenger.hpp"
#include "dbe/confaccessor.hpp"
#include "dbe/gtool.hpp"
#include "dbe/segregate.hpp"
 
#include <boost/program_options.hpp>
 
#include <numeric>
 
namespace bop = boost::program_options;
 
int main ( int argc, char * argv[] )
{

  setenv ( "LC_ALL", "C", 1 );
 
  std::string oksfn, rdbrl, roksrl, outfn, sepfnbase, stats, logfile, msglevel ( "ERROR" );
 
  size_t min_component_size = 0;
  size_t max_component_size = std::numeric_limits<size_t>::max();
 
  bop::options_description options_description (
    "Allowed options ( warning : almost no sanity checks performed )", 128 );
 
  options_description.add_options()
 
  ( "help,h", "Provide help message" )
 
  ( "file,f", bop::value<std::string> ( &oksfn ), "OKS database file name" )
 
  ( "rdb,r", bop::value<std::string> ( &rdbrl ),
    "RDB String (e.g. partition::rdbServerName)" )
 
  ( "roks,o", bop::value<std::string> ( &roksrl ),
    "ROKS String (e.g. oracle://atlas_oksprod/r:atlas_oks_tdaq:24:77)" )
 
  ( "result,u", bop::value<std::string> ( &outfn ),
    "Output file which can be used as input to graphviz" )
 
  ( "separate,s", bop::value<std::string> ( &sepfnbase ),
    "Output pathnames to prepend to subgraph files" )
 
  ( "stats,S",
    bop::value<std::string> ( &stats )->default_value ( stats ),
    "The statistic to compute can be a comma sperated list \" e.g. min_dist,num_of_component \"..." )
 
  ( "minc,m", bop::value<size_t> ( &min_component_size )->default_value (
      min_component_size ),
    "The minimum component size to output" )
 
  ( "maxc,M", bop::value<size_t> ( &max_component_size )->default_value (
      max_component_size ),
    "The maximum component size to output" )
 
  ( "msglevel,L", bop::value<std::string> ( &msglevel )->default_value ( msglevel ),
    "The minimum level of error messages to report (INFO,WARN,ERROR,FAIL)" )
 
  ( "log,l", bop::value<std::string> ( &logfile ),
    "Redirect error messages to logfile instead of cerr" );
 
  bop::variables_map args;
 
  std::unique_ptr<dbe::tool::graph::gtool> proc;
 
  auto display_help_message = [&options_description]()
  {
    std::cout
        << "DBE gtool : Generate dot graphs from database files"
        << std::endl
        << std::endl
        << "Usage: dbe_gtool [options] , only the first option is taken into account "
        << "and the output file. If no output file is specified the result is sent to stdout"
        << std::endl
        << std::endl
        << options_description
        << std::endl;
  };
 
  try
  {
    bop::store ( bop::command_line_parser ( argc, argv ).options ( options_description ).run(),
                 args );
    bop::notify ( args );
 
    // Set the message level to output
    t_msghandler::ref().setlevel ( msglevel, t_messenger::all_levels );
 
    // Send output to the specified file
    if ( args.count ( "log" ) )
    {
      t_msghandler::ref().set ( logfile );
    }
 
    // Initialize access to configuration backend
    dbe::confaccessor::init();
 
    // Select input source
    if ( args.count ( "help" ) or argc == 1 )
    {
      display_help_message();
      return EXIT_FAILURE;
    }
    else if ( args.count ( "file" ) )
    {
      proc = std::unique_ptr<dbe::tool::graph::gtool> (
               new dbe::tool::graph::gtool ( oksfn, dbe::dbinfo::oks ) );
    }
    else if ( args.count ( "rdb" ) )
    {
      proc = std::unique_ptr<dbe::tool::graph::gtool> (
               new dbe::tool::graph::gtool ( rdbrl, dbe::dbinfo::rdb ) );
    }
    else if ( args.count ( "roks" ) )
    {
      proc = std::unique_ptr<dbe::tool::graph::gtool> (
               new dbe::tool::graph::gtool ( roksrl, dbe::dbinfo::roks ) );
    }
    else
    {
      display_help_message();
      return EXIT_FAILURE;
    }
 
    // If neither separate or result have been provided , output the help message and a warning
    if ( not args.count ( "result" ) and not args.count ( "separate" ) )
    {
      WARN ( "Output file not specified ", "User input warning",
             "Output will be sent to standard output" );
      display_help_message();
    }
 
  }
  catch ( std::string const & e )
  {
    ERROR ( "Program execution failure", e );
    return EXIT_FAILURE;
  }
  catch ( std::exception const & e )
  {
    ERROR ( "Incorrect command line argument", e.what() );
    display_help_message();
    return EXIT_FAILURE;
  }
 
  try
  {
    if ( args.count ( "separate" ) )
    {
      INFO ( "Graph will be separated to its components", "Program execution control" );
      dbe::tool::graph::segregated_graph_write sgw ( sepfnbase, min_component_size,
                                                     max_component_size );
      return proc->load_and_run ( sgw );
    }
    else
    {
      INFO ( "One large output file to be created", "Program execution control" );
      dbe::tool::graph::writegraph w ( outfn );
      return proc->load_and_run ( w );
    }
  }
  catch ( std::exception const & e )
  {
    std::cerr << "Exception: " << e.what() << std::endl;
  }
  catch ( ... )
  {
    std::cerr << "Unknown Exception" << std::endl;
  }
 
  return EXIT_FAILURE;
 
}