static int main(int argc, char** argv) { Options options; bool isDaemon = false; std::string configFile; po::options_description optionsDescription("Options"); optionsDescription.add_options() ("help,h", "print this message and exit") ("version,V", "show version information and exit") ("daemon,d", po::bool_switch(&isDaemon)->default_value(isDaemon), "Run in daemon mode, detecting network change events and re-running the auto-discovery procedure. " "In addition, the auto-discovery procedure is unconditionally re-run every hour.\n" "NOTE: if the connection to NFD fails, the daemon will exit.") ("ndn-fch-url", po::value<std::string>(&options.ndnFchUrl)->default_value(options.ndnFchUrl), "URL for NDN-FCH (Find Closest Hub) service") ("config,c", po::value<std::string>(&configFile), "Configuration file. Exit immediately unless 'enabled = true' is specified in the config file.") ; po::variables_map vm; try { po::store(po::parse_command_line(argc, argv, optionsDescription), vm); po::notify(vm); } catch (const std::exception& e) { std::cerr << "ERROR: " << e.what() << "\n\n"; usage(std::cerr, optionsDescription, argv[0]); return 2; } if (vm.count("help")) { usage(std::cout, optionsDescription, argv[0]); return 0; } if (vm.count("version")) { std::cout << NFD_VERSION_BUILD_STRING << std::endl; return 0; } if (vm.count("config")) { po::options_description configFileOptions; configFileOptions.add_options() ("enabled", po::value<bool>()->default_value(false)) ; try { po::store(po::parse_config_file<char>(configFile.data(), configFileOptions), vm); po::notify(vm); } catch (const std::exception& e) { std::cerr << "ERROR in config: " << e.what() << "\n\n"; return 2; } if (!vm["enabled"].as<bool>()) { // not enabled in config return 0; } } int exitCode = 0; try { Face face; KeyChain keyChain; Procedure proc(face, keyChain); proc.initialize(options); if (isDaemon) { runDaemon(proc); } else { proc.onComplete.connect([&exitCode] (bool isSuccess) { exitCode = isSuccess ? 0 : 1; }); proc.runOnce(); face.processEvents(); } } catch (const std::exception& e) { std::cerr << ::nfd::getExtendedErrorMessage(e) << std::endl; return 1; } return exitCode; }
int main(int argc, char* argv[]) { bool verbose = false; opt::options_description desc = optionsDescription(); opt::variables_map vmap; opt::store(opt::parse_command_line(argc,argv,desc),vmap); opt::notify(vmap); if (vmap.count("help")) { std::cout << desc << "\n"; return 1; } if(vmap.count("distribution")) { isingEnergyDistribution(vmap["dimension"].as<int>(), vmap["clusters"].as<int>()); exit(0); } verbose = vmap.count("verbose"); size_t iterations = vmap["iterations"].as<size_t>(); DemonBase::ReservoirFactory *rFactory = NULL; if ( vmap.count("ising") ) { if (!vmap.count("dimension")) { std::clog << "Option --ising requires -d\n"; exit(1); } int dim = vmap["dimension"].as<int>(); int clst = vmap["clusters"].as<int>(); rFactory = new Ising::Reservoir::Factory(dim,clst); } else if ( vmap.count("tmgas") ){ if (!vmap.count("dimension")) { std::clog << "Option --tmgas requires -d\n"; exit(1); } int dim = vmap["dimension"].as<int>(); rFactory = new TMGas::Reservoir::Factory(dim); } else { //Assume stochastic rFactory = new DemonBase::DefaultArgsReservoirFactory<Stochastic::Reservoir>; } DemonBase::SystemFactory *sFactory = new DemonBase::BinomialSystemFactory; assert(rFactory); assert(sFactory); int dimension = 50; const double tau = vmap["tau"].as<double>(); mpi::environment env(argc, argv); mpi::communicator world; char hostname[256]; int requester; if (world.rank()==0) { std::string args; for (int k=1; k!=argc; ++k) { args += " "; args += argv[k]; } printf("%s%s\n",PACKAGE_STRING,args.c_str()); std::clog << "Running v" << PACKAGE_VERSION << " on " << world.size() << " nodes." << std::endl; std::clog << (double)(dimension*dimension*iterations)/world.size() << " simulations per node." << std::endl; printf("%s\n",DemonBase::outputHeader().c_str()); } world.barrier(); gethostname(hostname,255); fprintf(stderr, "Hello world from host %s (rank %d)\n",hostname,world.rank()); DemonBase::Experiment::range work; DemonBase::Experiment experiment; experiment.iterations = iterations; experiment.dimension = dimension; experiment.sfactory = sFactory; experiment.rfactory = rFactory; for (int k=world.rank(); k<dimension*dimension; k+=world.size()) { DemonBase::MeasurementResult result = experiment.performIteration(k); printf("%s\n",outputString(result).c_str()); } std::clog<<"Rank "<< world.rank()<<" finished.\n"; return 0; }
int main( int argc, char * argv [] ) { boost::program_options::options_description optionsDescription( "options" ); optionsDescription.add_options() ("help", "produce help message") ("objectStoreRootPath", boost::program_options::value< std::string >()->default_value( "/var/lib/osmosis/objectstore" ), "Path where osmosis will store objects. relevant for 'server', 'purge', 'labellog' and 'leastrecentlyused' commands" ) ("serverTCPPort", boost::program_options::value< unsigned short >()->default_value( 1010 ), "the TCP port to bind to, if command is 'server'") ( "objectStores", boost::program_options::value< std::string >()->default_value( "127.0.0.1:1010" ), "the object store to act againt. May be a '+' seperated list for 'checkout' command" ) ( "MD5", "use MD5, not SHA1 for hash in 'checkin' operation" ) ( "putIfMissing", "when command is 'checkout' or 'transfer', this flag will cause any objects received not from the " "nearest object store to be put into all objects stores up to the one it was fetched from" ) ( "removeUnknownFiles", "for checkout: remove files from disk that are not in the dirlist being checked out" ) ( "myUIDandGIDcheckout", "for checkout: use my uid and gid" ) ( "ignore", boost::program_options::value< std::string >(), "for checkout: ignore the existance of all files in this ':' seperated list. " "if a directory was specified, ignored everything under it as well. specified paths " "must reside inside the checkout path" ) ( "transferDestination", boost::program_options::value< std::string >(), "destination object store to transfer the label into" ) ( "reportFile", boost::program_options::value< std::string >()->default_value( "" ), "periodically write report in JSON format into this file" ) ( "reportIntervalSeconds", boost::program_options::value< unsigned >()->default_value( 15 ), "period to report progress" ) ( "noChainTouch", "avoid touching fetched label in all object stores in chain (used for label bookeeping)" ) ( "keep", boost::program_options::value< std::string >()->default_value( "keepforever|bootstrap" ), "regular expression for labels to never erase. Only relevant under 'leastrecentlyused' command" ) ( "maximumDiskUsage", boost::program_options::value< std::string >(), "<number>M or <number>G for the amount of storage used for label objects before 'leastrecentlyused' starts erasing labels"); boost::program_options::options_description positionalDescription( "positionals" ); positionalDescription.add_options() ( "command", boost::program_options::value< std::string >() ) ( "arg1", boost::program_options::value< std::string >() ) ( "arg2", boost::program_options::value< std::string >() ); boost::program_options::positional_options_description positionalMapping; positionalMapping.add( "command", 1 ).add( "arg1", 1 ).add( "arg2", 1 ); boost::program_options::options_description allOptions; allOptions.add( optionsDescription ).add( positionalDescription ); boost::program_options::variables_map options; try { boost::program_options::store( boost::program_options::command_line_parser( argc, argv ). positional( positionalMapping ).options( allOptions ). run(), options ); boost::program_options::notify( options ); } catch ( boost::exception & e ) { TRACE_BOOST_EXCEPTION( e, "Unable to parse command line" ); usage( optionsDescription ); return 1; } if ( options.count( "help" ) ) { usage( optionsDescription ); return 1; } try { std::string command = options[ "command" ].as< std::string >(); if ( command == "server" ) { if ( options.count( "arg1" ) > 0 or options.count( "arg2" ) > 0 ) { TRACE_ERROR( "'workDir' or 'label' must not be present in command line" "if 'server' is specified as the command" ); usage( optionsDescription ); return 1; } server( options ); } else if ( command == "checkin" ) checkIn( options ); else if ( command == "checkout" ) checkOut( options ); else if ( command == "transfer" ) transfer( options ); else if ( command == "listlabels" ) listLabels( options ); else if ( command == "eraselabel" ) eraseLabel( options ); else if ( command == "purge" ) purge( options ); else if ( command == "renamelabel" ) renameLabel( options ); else if ( command == "labellog" ) dumpLabelLog( options ); else if ( command == "leastrecentlyused" ) leastRecentlyUsed( options ); else if ( command == "testhash" ) testHash( options ); else { TRACE_ERROR( "Unknown command '" << command << "'" ); usage( optionsDescription ); return 1; } } catch ( boost::exception & e ) { TRACE_BOOST_EXCEPTION( e, "Terminated on a boost exception" ); return 1; } catch ( Error & e ) { TRACE_ERROR( "Terminated on 'Error' exception: '" << e.what() << "' from " << e.backtrace() ); return 1; } catch ( std::exception & e ) { TRACE_ERROR( "Terminated on std::exception: '" << e.what() ); return 1; } catch ( ... ) { TRACE_ERROR( "Terminated on unknown exception" ); return 1; } return 0; }