mirror of
https://github.com/XRPLF/rippled.git
synced 2025-11-21 11:35:53 +00:00
405 lines
13 KiB
C++
405 lines
13 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
Copyright (c) 2011-2013, OpenCoin, Inc.
|
|
*/
|
|
//==============================================================================
|
|
|
|
namespace po = boost::program_options;
|
|
|
|
void setupServer ()
|
|
{
|
|
getApp().setup ();
|
|
}
|
|
|
|
void startServer ()
|
|
{
|
|
//
|
|
// Execute start up rpc commands.
|
|
//
|
|
if (theConfig.RPC_STARTUP.isArray ())
|
|
{
|
|
for (int i = 0; i != theConfig.RPC_STARTUP.size (); ++i)
|
|
{
|
|
const Json::Value& jvCommand = theConfig.RPC_STARTUP[i];
|
|
|
|
if (!theConfig.QUIET)
|
|
Log::out() << "Startup RPC: " << jvCommand;
|
|
|
|
RPCHandler rhHandler (&getApp().getOPs ());
|
|
|
|
// VFALCO TODO Clean up this magic number
|
|
LoadType loadType = LT_RPCReference;
|
|
Json::Value jvResult = rhHandler.doCommand (jvCommand, RPCHandler::ADMIN, &loadType);
|
|
|
|
if (!theConfig.QUIET)
|
|
Log::out() << "Result: " << jvResult;
|
|
}
|
|
}
|
|
|
|
getApp().run (); // Blocks till we get a stop RPC.
|
|
}
|
|
|
|
bool init_unit_test ()
|
|
{
|
|
getApp ();
|
|
|
|
return true;
|
|
}
|
|
|
|
void printHelp (const po::options_description& desc)
|
|
{
|
|
using namespace std;
|
|
|
|
cerr << SYSTEM_NAME "d [options] <command> <params>" << endl;
|
|
|
|
cerr << desc << endl;
|
|
|
|
cerr << "Commands: " << endl;
|
|
cerr << " account_info <account>|<nickname>|<seed>|<pass_phrase>|<key> [<ledger>] [strict]" << endl;
|
|
cerr << " account_lines <account> <account>|\"\" [<ledger>]" << endl;
|
|
cerr << " account_offers <account>|<nickname>|<account_public_key> [<ledger>]" << endl;
|
|
cerr << " account_tx accountID [ledger_min [ledger_max [limit [offset]]]] [binary] [count] [descending]" << endl;
|
|
cerr << " book_offers <taker_pays> <taker_gets> [<taker [<ledger> [<limit> [<proof> [<marker>]]]]]" << endl;
|
|
cerr << " connect <ip> [<port>]" << endl;
|
|
cerr << " consensus_info" << endl;
|
|
#if ENABLE_INSECURE
|
|
cerr << " data_delete <key>" << endl;
|
|
cerr << " data_fetch <key>" << endl;
|
|
cerr << " data_store <key> <value>" << endl;
|
|
#endif
|
|
cerr << " get_counts" << endl;
|
|
cerr << " json <method> <json>" << endl;
|
|
cerr << " ledger [<id>|current|closed|validated] [full]" << endl;
|
|
cerr << " ledger_accept" << endl;
|
|
cerr << " ledger_closed" << endl;
|
|
cerr << " ledger_current" << endl;
|
|
cerr << " ledger_header <ledger>" << endl;
|
|
cerr << " logrotate " << endl;
|
|
cerr << " peers" << endl;
|
|
cerr << " proof_create [<difficulty>] [<secret>]" << endl;
|
|
cerr << " proof_solve <token>" << endl;
|
|
cerr << " proof_verify <token> <solution> [<difficulty>] [<secret>]" << endl;
|
|
cerr << " random" << endl;
|
|
cerr << " ripple ..." << endl;
|
|
cerr << " ripple_path_find <json> [<ledger>]" << endl;
|
|
// cerr << " send <seed> <paying_account> <account_id> <amount> [<currency>] [<send_max>] [<send_currency>]" << endl;
|
|
cerr << " stop" << endl;
|
|
cerr << " tx <id>" << endl;
|
|
cerr << " unl_add <domain>|<public> [<comment>]" << endl;
|
|
cerr << " unl_delete <domain>|<public_key>" << endl;
|
|
cerr << " unl_list" << endl;
|
|
cerr << " unl_load" << endl;
|
|
cerr << " unl_network" << endl;
|
|
cerr << " unl_reset" << endl;
|
|
cerr << " validation_create [<seed>|<pass_phrase>|<key>]" << endl;
|
|
cerr << " validation_seed [<seed>|<pass_phrase>|<key>]" << endl;
|
|
cerr << " wallet_add <regular_seed> <paying_account> <master_seed> [<initial_funds>] [<account_annotation>]" << endl;
|
|
cerr << " wallet_accounts <seed>" << endl;
|
|
cerr << " wallet_claim <master_seed> <regular_seed> [<source_tag>] [<account_annotation>]" << endl;
|
|
cerr << " wallet_seed [<seed>|<passphrase>|<passkey>]" << endl;
|
|
cerr << " wallet_propose [<passphrase>]" << endl;
|
|
|
|
// Transaction helpers (that were removed):
|
|
// cerr << " account_domain_set <seed> <paying_account> [<domain>]" << endl;
|
|
// cerr << " account_email_set <seed> <paying_account> [<email_address>]" << endl;
|
|
// cerr << " account_rate_set <seed> <paying_account> <rate>" << endl;
|
|
// cerr << " account_wallet_set <seed> <paying_account> [<wallet_hash>]" << endl;
|
|
// cerr << " nickname_info <nickname>" << endl;
|
|
// cerr << " nickname_set <seed> <paying_account> <nickname> [<offer_minimum>] [<authorization>]" << endl;
|
|
// cerr << " offer_create <seed> <paying_account> <taker_pays_amount> <taker_pays_currency> <taker_pays_issuer> <takers_gets_amount> <takers_gets_currency> <takers_gets_issuer> <expires> [passive]" << endl;
|
|
// cerr << " offer_cancel <seed> <paying_account> <sequence>" << endl;
|
|
// cerr << " password_fund <seed> <paying_account> [<account>]" << endl;
|
|
// cerr << " password_set <master_seed> <regular_seed> [<account>]" << endl;
|
|
// cerr << " trust_set <seed> <paying_account> <destination_account> <limit_amount> <currency> [<quality_in>] [<quality_out>]" << endl;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// OUr custom unit test runner
|
|
class RippleUnitTests : public UnitTests
|
|
{
|
|
public:
|
|
void logMessage (String const& message)
|
|
{
|
|
Log::out () << message.toStdString ();
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
/** Run the Beast unit tests.
|
|
*/
|
|
static void runBeastUnitTests ()
|
|
{
|
|
RippleUnitTests tr;
|
|
|
|
tr.setAssertOnFailure (false);
|
|
tr.setPassesAreLogged (false);
|
|
|
|
tr.runAllTests ();
|
|
|
|
// Report
|
|
for (int i = 0; i < tr.getNumResults (); ++i)
|
|
{
|
|
UnitTests::TestResult const& r (*tr.getResult (i));
|
|
|
|
for (int j = 0; j < r.messages.size (); ++i)
|
|
Log::out () << r.messages [j].toStdString ();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
/** Run the Boost unit tests.
|
|
|
|
@note These are deprecated. We want to migrate to using only
|
|
the Beast unit testing framework. Please do not add more
|
|
Boost based unit tests.
|
|
*/
|
|
// VFALCO NOTE What are argc and argv for?
|
|
// Where does the boost unit test framework write its output?
|
|
//
|
|
static void runBoostUnitTests (int argc, char* argv [])
|
|
{
|
|
// DEPRECATED
|
|
boost::unit_test::unit_test_main (init_unit_test, argc, argv);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
int rippleMain (int argc, char** argv)
|
|
{
|
|
//
|
|
// These debug heap calls do nothing in release or non Visual Studio builds.
|
|
//
|
|
|
|
// Checks the heap at every allocation and deallocation (slow).
|
|
//
|
|
//Debug::setAlwaysCheckHeap (false);
|
|
|
|
// Keeps freed memory blocks and fills them with a guard value.
|
|
//
|
|
//Debug::setHeapDelayedFree (false);
|
|
|
|
// At exit, reports all memory blocks which have not been freed.
|
|
//
|
|
#if 1
|
|
Debug::setHeapReportLeaks (false);
|
|
|
|
#else
|
|
// This is some temporary leak checking test code
|
|
//
|
|
Debug::setHeapReportLeaks (false);
|
|
|
|
//malloc (512); // Any leaks before this line in the output are from static initializations.
|
|
|
|
ThreadWithCallQueue t ("test");
|
|
GlobalPagedFreeStore::getInstance ();
|
|
t.start ();
|
|
|
|
return 0;
|
|
#endif
|
|
|
|
using namespace std;
|
|
|
|
setCallingThreadName ("main");
|
|
int iResult = 0;
|
|
po::variables_map vm; // Map of options.
|
|
|
|
// VFALCO TODO Replace boost program options with something from Beast.
|
|
//
|
|
// Set up option parsing.
|
|
//
|
|
po::options_description desc ("General Options");
|
|
desc.add_options ()
|
|
("help,h", "Display this message.")
|
|
("conf", po::value<std::string> (), "Specify the configuration file.")
|
|
("rpc", "Perform rpc command (default).")
|
|
("rpc_ip", po::value <std::string> (), "Specify the IP address for RPC command. Format: <ip-address>[':'<port-number>]")
|
|
("rpc_port", po::value <int> (), "Specify the port number for RPC command.")
|
|
("standalone,a", "Run with no peers.")
|
|
("testnet,t", "Run in test net mode.")
|
|
("unittest,u", "Perform unit tests.")
|
|
("unittest2", "Perform new unit tests.")
|
|
("parameters", po::value< vector<string> > (), "Specify comma separated parameters.")
|
|
("quiet,q", "Reduce diagnotics.")
|
|
("verbose,v", "Verbose logging.")
|
|
("load", "Load the current ledger from the local DB.")
|
|
("ledger", po::value<std::string> (), "Load the specified ledger and start from .")
|
|
("start", "Start from a fresh Ledger.")
|
|
("net", "Get the initial ledger from the network.")
|
|
("fg", "Run in the foreground.")
|
|
("import", po::value<std::string> (), "Import old DB into new DB.")
|
|
;
|
|
|
|
// Interpret positional arguments as --parameters.
|
|
po::positional_options_description p;
|
|
p.add ("parameters", -1);
|
|
|
|
// These must be added before the Application object is created
|
|
NodeStore::addBackendFactory (SqliteBackendFactory::getInstance ());
|
|
NodeStore::addBackendFactory (LevelDBBackendFactory::getInstance ());
|
|
#if RIPPLE_HYPERLEVELDB_AVAILABLE
|
|
NodeStore::addBackendFactory (HyperLevelDBBackendFactory::getInstance ());
|
|
#endif
|
|
#if RIPPLE_MDB_AVAILABLE
|
|
NodeStore::addBackendFactory (MdbBackendFactory::getInstance ());
|
|
#endif
|
|
|
|
if (! RandomNumbers::getInstance ().initialize ())
|
|
{
|
|
Log::out() << "Unable to add system entropy";
|
|
iResult = 2;
|
|
}
|
|
|
|
if (iResult)
|
|
{
|
|
nothing ();
|
|
}
|
|
else
|
|
{
|
|
// Parse options, if no error.
|
|
try
|
|
{
|
|
po::store (po::command_line_parser (argc, argv)
|
|
.options (desc) // Parse options.
|
|
.positional (p) // Remainder as --parameters.
|
|
.run (),
|
|
vm);
|
|
po::notify (vm); // Invoke option notify functions.
|
|
}
|
|
catch (...)
|
|
{
|
|
iResult = 1;
|
|
}
|
|
}
|
|
|
|
if (iResult)
|
|
{
|
|
nothing ();
|
|
}
|
|
else if (vm.count ("help"))
|
|
{
|
|
iResult = 1;
|
|
}
|
|
|
|
if (HaveSustain () &&
|
|
!iResult && !vm.count ("parameters") && !vm.count ("fg") && !vm.count ("standalone") && !vm.count ("unittest"))
|
|
{
|
|
std::string logMe = DoSustain ();
|
|
|
|
if (!logMe.empty ())
|
|
Log (lsWARNING) << logMe;
|
|
}
|
|
|
|
if (vm.count ("quiet"))
|
|
{
|
|
Log::setMinSeverity (lsFATAL, true);
|
|
}
|
|
else if (vm.count ("verbose"))
|
|
{
|
|
Log::setMinSeverity (lsTRACE, true);
|
|
}
|
|
else
|
|
{
|
|
Log::setMinSeverity (lsINFO, true);
|
|
}
|
|
|
|
// Run the unit tests if requested.
|
|
//
|
|
if (vm.count ("unittest"))
|
|
{
|
|
// DEPRECATED
|
|
runBoostUnitTests (argc, argv);
|
|
return 0;
|
|
}
|
|
|
|
if (vm.count ("unittest2"))
|
|
{
|
|
runBeastUnitTests ();
|
|
return 0;
|
|
}
|
|
|
|
if (!iResult)
|
|
{
|
|
theConfig.setup (
|
|
vm.count ("conf") ? vm["conf"].as<std::string> () : "", // Config file.
|
|
!!vm.count ("testnet"), // Testnet flag.
|
|
!!vm.count ("quiet")); // Quiet flag.
|
|
|
|
if (vm.count ("standalone"))
|
|
{
|
|
theConfig.RUN_STANDALONE = true;
|
|
theConfig.LEDGER_HISTORY = 0;
|
|
}
|
|
}
|
|
|
|
if (vm.count ("start")) theConfig.START_UP = Config::FRESH;
|
|
|
|
if (vm.count ("import"))
|
|
theConfig.DB_IMPORT = vm["import"].as<std::string> ();
|
|
|
|
if (vm.count ("ledger"))
|
|
{
|
|
theConfig.START_LEDGER = vm["ledger"].as<std::string> ();
|
|
theConfig.START_UP = Config::LOAD;
|
|
}
|
|
else if (vm.count ("load"))
|
|
{
|
|
theConfig.START_UP = Config::LOAD;
|
|
}
|
|
else if (vm.count ("net"))
|
|
{
|
|
theConfig.START_UP = Config::NETWORK;
|
|
|
|
if (theConfig.VALIDATION_QUORUM < 2)
|
|
theConfig.VALIDATION_QUORUM = 2;
|
|
}
|
|
|
|
if (iResult == 0)
|
|
{
|
|
// These overrides must happen after the config file is loaded.
|
|
|
|
// Override the RPC destination IP address
|
|
//
|
|
if (vm.count ("rpc_ip"))
|
|
{
|
|
theConfig.setRpcIpAndOptionalPort (vm ["rpc_ip"].as <std::string> ());
|
|
}
|
|
|
|
// Override the RPC destination port number
|
|
//
|
|
if (vm.count ("rpc_port"))
|
|
{
|
|
// VFALCO TODO This should be a short.
|
|
theConfig.setRpcPort (vm ["rpc_port"].as <int> ());
|
|
}
|
|
}
|
|
|
|
if (iResult)
|
|
{
|
|
nothing ();
|
|
}
|
|
else if (!vm.count ("parameters"))
|
|
{
|
|
// No arguments. Run server.
|
|
setupServer ();
|
|
setCallingThreadName ("io");
|
|
startServer ();
|
|
}
|
|
else
|
|
{
|
|
// Have a RPC command.
|
|
setCallingThreadName ("rpc");
|
|
std::vector<std::string> vCmd = vm["parameters"].as<std::vector<std::string> > ();
|
|
|
|
iResult = commandLineRPC (vCmd);
|
|
}
|
|
|
|
if (1 == iResult && !vm.count ("quiet"))
|
|
printHelp (desc);
|
|
|
|
return iResult;
|
|
}
|
|
// vim:ts=4
|