Status storeServerOptions(const moe::Environment& params) {
Status ret = storeBaseOptions(params);
if (!ret.isOK()) {
return ret;
}
if (params.count("net.port")) {
serverGlobalParams.port = params["net.port"].as<int>();
}
if (params.count("net.ipv6") && params["net.ipv6"].as<bool>() == true) {
serverGlobalParams.enableIPv6 = true;
enableIPv6();
}
if (params.count("net.listenBacklog")) {
serverGlobalParams.listenBacklog = params["net.listenBacklog"].as<int>();
}
if (params.count("net.transportLayer")) {
serverGlobalParams.transportLayer = params["net.transportLayer"].as<std::string>();
if (serverGlobalParams.transportLayer != "asio") {
return {ErrorCodes::BadValue, "Unsupported value for transportLayer. Must be \"asio\""};
}
}
if (params.count("net.serviceExecutor")) {
auto value = params["net.serviceExecutor"].as<std::string>();
const auto valid = {"synchronous"_sd, "adaptive"_sd};
if (std::find(valid.begin(), valid.end(), value) == valid.end()) {
return {ErrorCodes::BadValue, "Unsupported value for serviceExecutor"};
}
serverGlobalParams.serviceExecutor = value;
} else {
serverGlobalParams.serviceExecutor = "synchronous";
}
if (params.count("security.transitionToAuth")) {
serverGlobalParams.transitionToAuth = params["security.transitionToAuth"].as<bool>();
}
if (params.count("security.clusterAuthMode")) {
std::string clusterAuthMode = params["security.clusterAuthMode"].as<std::string>();
if (clusterAuthMode == "keyFile") {
serverGlobalParams.clusterAuthMode.store(ServerGlobalParams::ClusterAuthMode_keyFile);
} else if (clusterAuthMode == "sendKeyFile") {
serverGlobalParams.clusterAuthMode.store(
ServerGlobalParams::ClusterAuthMode_sendKeyFile);
} else if (clusterAuthMode == "sendX509") {
serverGlobalParams.clusterAuthMode.store(ServerGlobalParams::ClusterAuthMode_sendX509);
} else if (clusterAuthMode == "x509") {
serverGlobalParams.clusterAuthMode.store(ServerGlobalParams::ClusterAuthMode_x509);
} else {
return Status(ErrorCodes::BadValue,
"unsupported value for clusterAuthMode " + clusterAuthMode);
}
serverGlobalParams.authState = ServerGlobalParams::AuthState::kEnabled;
} else {
serverGlobalParams.clusterAuthMode.store(ServerGlobalParams::ClusterAuthMode_undefined);
}
if (params.count("net.maxIncomingConnections")) {
serverGlobalParams.maxConns = params["net.maxIncomingConnections"].as<int>();
if (serverGlobalParams.maxConns < 5) {
return Status(ErrorCodes::BadValue, "maxConns has to be at least 5");
}
}
if (params.count("net.maxIncomingConnectionsOverride")) {
auto ranges = params["net.maxIncomingConnectionsOverride"].as<std::vector<std::string>>();
for (const auto& range : ranges) {
auto swr = CIDR::parse(range);
if (!swr.isOK()) {
serverGlobalParams.maxConnsOverride.push_back(range);
} else {
serverGlobalParams.maxConnsOverride.push_back(std::move(swr.getValue()));
}
}
}
if (params.count("net.reservedAdminThreads")) {
serverGlobalParams.reservedAdminThreads = params["net.reservedAdminThreads"].as<int>();
}
if (params.count("net.wireObjectCheck")) {
serverGlobalParams.objcheck = params["net.wireObjectCheck"].as<bool>();
}
if (params.count("net.bindIp")) {
std::string bind_ip = params["net.bindIp"].as<std::string>();
if (bind_ip == "*") {
serverGlobalParams.bind_ips.emplace_back("0.0.0.0");
if (params.count("net.ipv6") && params["net.ipv6"].as<bool>()) {
serverGlobalParams.bind_ips.emplace_back("::");
}
} else {
boost::split(serverGlobalParams.bind_ips,
bind_ip,
[](char c) { return c == ','; },
boost::token_compress_on);
}
}
for (auto& ip : serverGlobalParams.bind_ips) {
boost::algorithm::trim(ip);
}
#ifndef _WIN32
if (params.count("net.unixDomainSocket.pathPrefix")) {
serverGlobalParams.socket = params["net.unixDomainSocket.pathPrefix"].as<string>();
}
if (params.count("net.unixDomainSocket.enabled")) {
serverGlobalParams.noUnixSocket = !params["net.unixDomainSocket.enabled"].as<bool>();
}
if (params.count("net.unixDomainSocket.filePermissions")) {
serverGlobalParams.unixSocketPermissions =
params["net.unixDomainSocket.filePermissions"].as<int>();
}
if (params.count("security.relaxPermChecks") &&
params["security.relaxPermChecks"].as<bool>() == true) {
serverGlobalParams.relaxPermChecks = true;
}
if ((params.count("processManagement.fork") &&
params["processManagement.fork"].as<bool>() == true) &&
(!params.count("shutdown") || params["shutdown"].as<bool>() == false)) {
serverGlobalParams.doFork = true;
}
#endif // _WIN32
if (params.count("security.redactClientLogData")) {
logger::globalLogDomain()->setShouldRedactLogs(params["security.redactClientLogData"].as<bool>());
}
if (serverGlobalParams.doFork && serverGlobalParams.logpath.empty() &&
!serverGlobalParams.logWithSyslog) {
return Status(ErrorCodes::BadValue, "--fork has to be used with --logpath or --syslog");
}
if (params.count("security.keyFile")) {
serverGlobalParams.keyFile =
boost::filesystem::absolute(params["security.keyFile"].as<string>()).generic_string();
serverGlobalParams.authState = ServerGlobalParams::AuthState::kEnabled;
}
if (serverGlobalParams.transitionToAuth ||
(params.count("security.authorization") &&
params["security.authorization"].as<std::string>() == "disabled")) {
serverGlobalParams.authState = ServerGlobalParams::AuthState::kDisabled;
} else if (params.count("security.authorization") &&
params["security.authorization"].as<std::string>() == "enabled") {
serverGlobalParams.authState = ServerGlobalParams::AuthState::kEnabled;
}
if (params.count("processManagement.pidFilePath")) {
serverGlobalParams.pidFile = params["processManagement.pidFilePath"].as<string>();
}
if (params.count("processManagement.timeZoneInfo")) {
serverGlobalParams.timeZoneInfoPath = params["processManagement.timeZoneInfo"].as<string>();
}
if (!params.count("security.clusterAuthMode") && params.count("security.keyFile")) {
serverGlobalParams.clusterAuthMode.store(ServerGlobalParams::ClusterAuthMode_keyFile);
}
int clusterAuthMode = serverGlobalParams.clusterAuthMode.load();
if (serverGlobalParams.transitionToAuth &&
(clusterAuthMode != ServerGlobalParams::ClusterAuthMode_keyFile &&
clusterAuthMode != ServerGlobalParams::ClusterAuthMode_x509)) {
return Status(ErrorCodes::BadValue,
"--transitionToAuth must be used with keyFile or x509 authentication");
}
if (params.count("net.compression.compressors")) {
const auto ret =
storeMessageCompressionOptions(params["net.compression.compressors"].as<string>());
if (!ret.isOK()) {
return ret;
}
}
return Status::OK();
}
Status storeMongosOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeServerOptions(params, args);
if (!ret.isOK()) {
return ret;
}
if ( params.count( "chunkSize" ) ) {
int csize = params["chunkSize"].as<int>();
// validate chunksize before proceeding
if ( csize == 0 ) {
return Status(ErrorCodes::BadValue, "error: need a non-zero chunksize");
}
if ( !Chunk::setMaxChunkSizeSizeMB( csize ) ) {
return Status(ErrorCodes::BadValue, "MaxChunkSize invalid");
}
}
if (params.count( "port" ) ) {
int port = params["port"].as<int>();
if ( port <= 0 || port > 65535 ) {
return Status(ErrorCodes::BadValue,
"error: port number must be between 1 and 65535");
}
}
if ( params.count( "localThreshold" ) ) {
serverGlobalParams.defaultLocalThresholdMillis = params["localThreshold"].as<int>();
}
if ( params.count( "ipv6" ) ) {
enableIPv6();
}
if ( params.count( "jsonp" ) ) {
serverGlobalParams.jsonp = true;
}
if (params.count("noscripting")) {
// This option currently has no effect for mongos
}
if (params.count("httpinterface")) {
if (params.count("nohttpinterface")) {
return Status(ErrorCodes::BadValue,
"can't have both --httpinterface and --nohttpinterface");
}
serverGlobalParams.isHttpInterfaceEnabled = true;
}
if (params.count("noAutoSplit")) {
warning() << "running with auto-splitting disabled" << endl;
Chunk::ShouldAutoSplit = false;
}
if ( ! params.count( "configdb" ) ) {
return Status(ErrorCodes::BadValue, "error: no args for --configdb");
}
splitStringDelim(params["configdb"].as<std::string>(), &mongosGlobalParams.configdbs, ',');
if (mongosGlobalParams.configdbs.size() != 1 && mongosGlobalParams.configdbs.size() != 3) {
return Status(ErrorCodes::BadValue, "need either 1 or 3 configdbs");
}
if (mongosGlobalParams.configdbs.size() == 1) {
warning() << "running with 1 config server should be done only for testing purposes "
<< "and is not recommended for production" << endl;
}
mongosGlobalParams.upgrade = params.count("upgrade");
return Status::OK();
}
int Tool::main( int argc , char ** argv ){
static StaticObserver staticObserver;
cmdLine.prealloc = false;
boost::filesystem::path::default_name_check( boost::filesystem::no_check );
_name = argv[0];
/* using the same style as db.cpp */
int command_line_style = (((po::command_line_style::unix_style ^
po::command_line_style::allow_guessing) |
po::command_line_style::allow_long_disguise) ^
po::command_line_style::allow_sticky);
try {
po::options_description all_options("all options");
all_options.add(*_options).add(*_hidden_options);
po::store( po::command_line_parser( argc , argv ).
options(all_options).
positional( _positonalOptions ).
style(command_line_style).run() , _params );
po::notify( _params );
} catch (po::error &e) {
cerr << "ERROR: " << e.what() << endl << endl;
printHelp(cerr);
return EXIT_BADOPTIONS;
}
// hide password from ps output
for (int i=0; i < (argc-1); ++i){
if (!strcmp(argv[i], "-p") || !strcmp(argv[i], "--password")){
char* arg = argv[i+1];
while (*arg){
*arg++ = 'x';
}
}
}
if ( _params.count( "help" ) ){
printHelp(cout);
return 0;
}
if ( _params.count( "verbose" ) ) {
logLevel = 1;
}
for (string s = "vv"; s.length() <= 10; s.append("v")) {
if (_params.count(s)) {
logLevel = s.length();
}
}
preSetup();
bool useDirectClient = hasParam( "dbpath" );
if ( ! useDirectClient ) {
_host = "127.0.0.1";
if ( _params.count( "host" ) )
_host = _params["host"].as<string>();
if ( _params.count( "port" ) )
_host += ':' + _params["port"].as<string>();
if ( _noconnection ){
// do nothing
}
else if ( _host.find( "," ) == string::npos ){
DBClientConnection * c = new DBClientConnection( _autoreconnect );
_conn = c;
string errmsg;
if ( ! c->connect( _host , errmsg ) ){
cerr << "couldn't connect to [" << _host << "] " << errmsg << endl;
return -1;
}
}
else {
log(1) << "using pairing" << endl;
DBClientPaired * c = new DBClientPaired();
_paired = true;
_conn = c;
if ( ! c->connect( _host ) ){
cerr << "couldn't connect to paired server: " << _host << endl;
return -1;
}
}
(_usesstdout ? cout : cerr ) << "connected to: " << _host << endl;
}
else {
if ( _params.count( "directoryperdb" ) ) {
directoryperdb = true;
}
assert( lastError.get( true ) );
Client::initThread("tools");
_conn = new DBDirectClient();
_host = "DIRECT";
static string myDbpath = getParam( "dbpath" );
dbpath = myDbpath.c_str();
try {
acquirePathLock();
}
catch ( DBException& e ){
cerr << endl << "If you are running a mongod on the same "
"path you should connect to that instead of direct data "
"file access" << endl << endl;
dbexit( EXIT_CLEAN );
return -1;
}
theFileAllocator().start();
}
if ( _params.count( "db" ) )
_db = _params["db"].as<string>();
if ( _params.count( "collection" ) )
_coll = _params["collection"].as<string>();
if ( _params.count( "username" ) )
_username = _params["username"].as<string>();
if ( _params.count( "password" )
&& ( _password.empty() ) ) {
_password = askPassword();
}
if (_params.count("ipv6"))
enableIPv6();
int ret = -1;
try {
ret = run();
}
catch ( DBException& e ){
cerr << "assertion: " << e.toString() << endl;
ret = -1;
}
if ( currentClient.get() )
currentClient->shutdown();
if ( useDirectClient )
dbexit( EXIT_CLEAN );
return ret;
}
Status storeGeneralToolOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
toolGlobalParams.name = args[0];
storageGlobalParams.prealloc = false;
// The default value may vary depending on compile options, but for tools
// we want durability to be disabled.
storageGlobalParams.dur = false;
// Set authentication parameters
if (params.count("authenticationDatabase")) {
toolGlobalParams.authenticationDatabase =
params["authenticationDatabase"].as<string>();
}
if (params.count("authenticationMechanism")) {
toolGlobalParams.authenticationMechanism =
params["authenticationMechanism"].as<string>();
}
if (params.count("verbose")) {
logger::globalLogDomain()->setMinimumLoggedSeverity(logger::LogSeverity::Debug(1));
}
for (string s = "vv"; s.length() <= 12; s.append("v")) {
if (params.count(s)) {
logger::globalLogDomain()->setMinimumLoggedSeverity(
logger::LogSeverity::Debug(s.length()));
}
}
toolGlobalParams.quiet = params.count("quiet");
#ifdef MONGO_SSL
Status ret = storeSSLClientOptions(params);
if (!ret.isOK()) {
return ret;
}
#endif
if (args.empty()) {
return Status(ErrorCodes::InternalError, "Cannot get binary name: argv array is empty");
}
// setup binary name
toolGlobalParams.name = args[0];
size_t i = toolGlobalParams.name.rfind('/');
if (i != string::npos) {
toolGlobalParams.name = toolGlobalParams.name.substr(i + 1);
}
toolGlobalParams.db = "test";
toolGlobalParams.coll = "";
toolGlobalParams.noconnection = false;
if (params.count("db"))
toolGlobalParams.db = params["db"].as<string>();
if (params.count("collection"))
toolGlobalParams.coll = params["collection"].as<string>();
if (params.count("username"))
toolGlobalParams.username = params["username"].as<string>();
if (params.count("password")) {
toolGlobalParams.password = params["password"].as<string>();
if (toolGlobalParams.password.empty()) {
toolGlobalParams.password = askPassword();
}
}
if (params.count("ipv6")) {
enableIPv6();
}
toolGlobalParams.dbpath = getParam("dbpath");
toolGlobalParams.useDirectClient = hasParam("dbpath");
if (toolGlobalParams.useDirectClient && params.count("journal")) {
storageGlobalParams.dur = true;
}
if (!toolGlobalParams.useDirectClient) {
toolGlobalParams.connectionString = "127.0.0.1";
if (params.count("host")) {
toolGlobalParams.hostSet = true;
toolGlobalParams.host = params["host"].as<string>();
toolGlobalParams.connectionString = params["host"].as<string>();
}
if (params.count("port")) {
toolGlobalParams.portSet = true;
toolGlobalParams.port = params["port"].as<string>();
toolGlobalParams.connectionString += ':' + params["port"].as<string>();
}
}
else {
if (params.count("directoryperdb")) {
storageGlobalParams.directoryperdb = true;
}
toolGlobalParams.connectionString = "DIRECT";
}
return Status::OK();
}
Status storeMongodOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeServerOptions(params, args);
if (!ret.isOK()) {
std::cerr << "Error storing command line: " << ret.toString() << std::endl;
::_exit(EXIT_BADOPTIONS);
}
if (params.count("dbpath")) {
storageGlobalParams.dbpath = params["dbpath"].as<string>();
if (params.count("fork") && storageGlobalParams.dbpath[0] != '/') {
// we need to change dbpath if we fork since we change
// cwd to "/"
// fork only exists on *nix
// so '/' is safe
storageGlobalParams.dbpath = serverGlobalParams.cwd + "/" +
storageGlobalParams.dbpath;
}
}
#ifdef _WIN32
if (storageGlobalParams.dbpath.size() > 1 &&
storageGlobalParams.dbpath[storageGlobalParams.dbpath.size()-1] == '/') {
// size() check is for the unlikely possibility of --dbpath "/"
storageGlobalParams.dbpath =
storageGlobalParams.dbpath.erase(storageGlobalParams.dbpath.size()-1);
}
#endif
if ( params.count("slowms")) {
serverGlobalParams.slowMS = params["slowms"].as<int>();
}
if ( params.count("syncdelay")) {
storageGlobalParams.syncdelay = params["syncdelay"].as<double>();
}
if (params.count("directoryperdb")) {
storageGlobalParams.directoryperdb = true;
}
if (params.count("cpu")) {
serverGlobalParams.cpu = true;
}
if (params.count("noauth")) {
getGlobalAuthorizationManager()->setAuthEnabled(false);
}
if (params.count("auth")) {
getGlobalAuthorizationManager()->setAuthEnabled(true);
}
if (params.count("quota")) {
storageGlobalParams.quota = true;
}
if (params.count("quotaFiles")) {
storageGlobalParams.quota = true;
storageGlobalParams.quotaFiles = params["quotaFiles"].as<int>() - 1;
}
if ((params.count("nodur") || params.count("nojournal")) &&
(params.count("dur") || params.count("journal"))) {
std::cerr << "Can't specify both --journal and --nojournal options." << std::endl;
::_exit(EXIT_BADOPTIONS);
}
if (params.count("nodur") || params.count("nojournal")) {
storageGlobalParams.dur = false;
}
if (params.count("dur") || params.count("journal")) {
storageGlobalParams.dur = true;
}
if (params.count("durOptions")) {
storageGlobalParams.durOptions = params["durOptions"].as<int>();
}
if( params.count("journalCommitInterval") ) {
// don't check if dur is false here as many will just use the default, and will default
// to off on win32. ie no point making life a little more complex by giving an error on
// a dev environment.
storageGlobalParams.journalCommitInterval =
params["journalCommitInterval"].as<unsigned>();
if (storageGlobalParams.journalCommitInterval <= 1 ||
storageGlobalParams.journalCommitInterval > 300) {
std::cerr << "--journalCommitInterval out of allowed range (0-300ms)" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
}
if (params.count("journalOptions")) {
storageGlobalParams.durOptions = params["journalOptions"].as<int>();
}
if (params.count("nohints")) {
storageGlobalParams.useHints = false;
}
if (params.count("nopreallocj")) {
storageGlobalParams.preallocj = false;
}
if (params.count("httpinterface")) {
if (params.count("nohttpinterface")) {
std::cerr << "can't have both --httpinterface and --nohttpinterface" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
serverGlobalParams.isHttpInterfaceEnabled = true;
}
// SERVER-10019 Enabling rest/jsonp without --httpinterface should break in the future
if (params.count("rest")) {
if (params.count("nohttpinterface")) {
log() << "** WARNING: Should not specify both --rest and --nohttpinterface" <<
startupWarningsLog;
}
else if (!params.count("httpinterface")) {
log() << "** WARNING: --rest is specified without --httpinterface," <<
startupWarningsLog;
log() << "** enabling http interface" << startupWarningsLog;
serverGlobalParams.isHttpInterfaceEnabled = true;
}
serverGlobalParams.rest = true;
}
if (params.count("jsonp")) {
if (params.count("nohttpinterface")) {
log() << "** WARNING: Should not specify both --jsonp and --nohttpinterface" <<
startupWarningsLog;
}
else if (!params.count("httpinterface")) {
log() << "** WARNING --jsonp is specified without --httpinterface," <<
startupWarningsLog;
log() << "** enabling http interface" << startupWarningsLog;
serverGlobalParams.isHttpInterfaceEnabled = true;
}
serverGlobalParams.jsonp = true;
}
if (params.count("noscripting")) {
mongodGlobalParams.scriptingEnabled = false;
}
if (params.count("noprealloc")) {
storageGlobalParams.prealloc = false;
cout << "note: noprealloc may hurt performance in many applications" << endl;
}
if (params.count("smallfiles")) {
storageGlobalParams.smallfiles = true;
}
if (params.count("diaglog")) {
int x = params["diaglog"].as<int>();
if ( x < 0 || x > 7 ) {
std::cerr << "can't interpret --diaglog setting" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
_diaglog.setLevel(x);
}
if ((params.count("dur") || params.count("journal")) && params.count("repair")) {
std::cerr << "Can't specify both --journal and --repair options." << std::endl;
::_exit(EXIT_BADOPTIONS);
}
if (params.count("repair")) {
Record::MemoryTrackingEnabled = false;
mongodGlobalParams.upgrade = 1; // --repair implies --upgrade
mongodGlobalParams.repair = 1;
storageGlobalParams.dur = false;
}
if (params.count("upgrade")) {
Record::MemoryTrackingEnabled = false;
mongodGlobalParams.upgrade = 1;
}
if (params.count("notablescan")) {
storageGlobalParams.noTableScan = true;
}
if (params.count("master")) {
replSettings.master = true;
}
if (params.count("slave")) {
replSettings.slave = SimpleSlave;
}
if (params.count("slavedelay")) {
replSettings.slavedelay = params["slavedelay"].as<int>();
}
if (params.count("fastsync")) {
replSettings.fastsync = true;
}
if (params.count("autoresync")) {
replSettings.autoresync = true;
if( params.count("replSet") ) {
std::cerr << "--autoresync is not used with --replSet\nsee "
<< "http://dochub.mongodb.org/core/resyncingaverystalereplicasetmember"
<< std::endl;
::_exit(EXIT_BADOPTIONS);
}
}
if (params.count("source")) {
/* specifies what the source in local.sources should be */
replSettings.source = params["source"].as<string>().c_str();
}
if( params.count("pretouch") ) {
replSettings.pretouch = params["pretouch"].as<int>();
}
if (params.count("replSet")) {
if (params.count("slavedelay")) {
std::cerr << "--slavedelay cannot be used with --replSet" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
else if (params.count("only")) {
std::cerr << "--only cannot be used with --replSet" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
/* seed list of hosts for the repl set */
replSettings.replSet = params["replSet"].as<string>().c_str();
}
if (params.count("replIndexPrefetch")) {
replSettings.rsIndexPrefetch = params["replIndexPrefetch"].as<std::string>();
}
if (params.count("noIndexBuildRetry")) {
serverGlobalParams.indexBuildRetry = false;
}
if (params.count("only")) {
replSettings.only = params["only"].as<string>().c_str();
}
if( params.count("nssize") ) {
int x = params["nssize"].as<int>();
if (x <= 0 || x > (0x7fffffff/1024/1024)) {
std::cerr << "bad --nssize arg" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
storageGlobalParams.lenForNewNsFiles = x * 1024 * 1024;
verify(storageGlobalParams.lenForNewNsFiles > 0);
}
if (params.count("oplogSize")) {
long long x = params["oplogSize"].as<int>();
if (x <= 0) {
std::cerr << "bad --oplogSize arg" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
// note a small size such as x==1 is ok for an arbiter.
if( x > 1000 && sizeof(void*) == 4 ) {
StringBuilder sb;
std::cerr << "--oplogSize of " << x
<< "MB is too big for 32 bit version. Use 64 bit build instead."
<< std::endl;
::_exit(EXIT_BADOPTIONS);
}
replSettings.oplogSize = x * 1024 * 1024;
verify(replSettings.oplogSize > 0);
}
if (params.count("cacheSize")) {
long x = params["cacheSize"].as<long>();
if (x <= 0) {
std::cerr << "bad --cacheSize arg" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
std::cerr << "--cacheSize option not currently supported" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
if (!params.count("port")) {
if( params.count("configsvr") ) {
serverGlobalParams.port = ServerGlobalParams::ConfigServerPort;
}
if( params.count("shardsvr") ) {
if( params.count("configsvr") ) {
std::cerr << "can't do --shardsvr and --configsvr at the same time"
<< std::endl;
::_exit(EXIT_BADOPTIONS);
}
serverGlobalParams.port = ServerGlobalParams::ShardServerPort;
}
}
else {
if (serverGlobalParams.port <= 0 || serverGlobalParams.port > 65535) {
std::cerr << "bad --port number" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
}
if ( params.count("configsvr" ) ) {
serverGlobalParams.configsvr = true;
storageGlobalParams.smallfiles = true; // config server implies small files
if (replSettings.usingReplSets() || replSettings.master || replSettings.slave) {
std::cerr << "replication should not be enabled on a config server" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
if (!params.count("nodur") && !params.count("nojournal"))
storageGlobalParams.dur = true;
if (!params.count("dbpath"))
storageGlobalParams.dbpath = "/data/configdb";
replSettings.master = true;
if (!params.count("oplogSize"))
replSettings.oplogSize = 5 * 1024 * 1024;
}
if ( params.count( "profile" ) ) {
serverGlobalParams.defaultProfile = params["profile"].as<int>();
}
if (params.count("ipv6")) {
enableIPv6();
}
if (params.count("noMoveParanoia") && params.count("moveParanoia")) {
std::cerr << "The moveParanoia and noMoveParanoia flags cannot both be set; "
<< "please use only one of them." << std::endl;
::_exit(EXIT_BADOPTIONS);
}
if (params.count("noMoveParanoia"))
serverGlobalParams.moveParanoia = false;
if (params.count("moveParanoia"))
serverGlobalParams.moveParanoia = true;
if (params.count("pairwith") || params.count("arbiter") || params.count("opIdMem")) {
std::cerr << "****\n"
<< "Replica Pairs have been deprecated. Invalid options: --pairwith, "
<< "--arbiter, and/or --opIdMem\n"
<< "<http://dochub.mongodb.org/core/replicapairs>\n"
<< "****" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
// needs to be after things like --configsvr parsing, thus here.
if (params.count("repairpath")) {
storageGlobalParams.repairpath = params["repairpath"].as<string>();
if (!storageGlobalParams.repairpath.size()) {
std::cerr << "repairpath is empty" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
if (storageGlobalParams.dur &&
!str::startsWith(storageGlobalParams.repairpath,
storageGlobalParams.dbpath)) {
std::cerr << "You must use a --repairpath that is a subdirectory of "
<< "--dbpath when using journaling" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
}
else {
storageGlobalParams.repairpath = storageGlobalParams.dbpath;
}
if (replSettings.pretouch)
log() << "--pretouch " << replSettings.pretouch << endl;
if (sizeof(void*) == 4 && !(params.count("nodur") || params.count("nojournal") ||
params.count("dur") || params.count("journal"))) {
// trying to make this stand out more like startup warnings
log() << endl;
warning() << "32-bit servers don't have journaling enabled by default. "
<< "Please use --journal if you want durability." << endl;
log() << endl;
}
return Status::OK();
}
int Tool::main( int argc , char ** argv ) {
static StaticObserver staticObserver;
cmdLine.prealloc = false;
// The default value may vary depending on compile options, but for tools
// we want durability to be disabled.
cmdLine.dur = false;
#if( BOOST_VERSION >= 104500 )
boost::filesystem::path::default_name_check( boost::filesystem2::no_check );
#else
boost::filesystem::path::default_name_check( boost::filesystem::no_check );
#endif
_name = argv[0];
/* using the same style as db.cpp */
int command_line_style = (((po::command_line_style::unix_style ^
po::command_line_style::allow_guessing) |
po::command_line_style::allow_long_disguise) ^
po::command_line_style::allow_sticky);
try {
po::options_description all_options("all options");
all_options.add(*_options).add(*_hidden_options);
po::store( po::command_line_parser( argc , argv ).
options(all_options).
positional( _positonalOptions ).
style(command_line_style).run() , _params );
po::notify( _params );
}
catch (po::error &e) {
cerr << "ERROR: " << e.what() << endl << endl;
printHelp(cerr);
::_exit(EXIT_BADOPTIONS);
}
// hide password from ps output
for (int i=0; i < (argc-1); ++i) {
if (!strcmp(argv[i], "-p") || !strcmp(argv[i], "--password")) {
char* arg = argv[i+1];
while (*arg) {
*arg++ = 'x';
}
}
}
if ( _params.count( "help" ) ) {
printHelp(cout);
::_exit(0);
}
if ( _params.count( "version" ) ) {
printVersion(cout);
::_exit(0);
}
if ( _params.count( "verbose" ) ) {
logLevel = 1;
}
for (string s = "vv"; s.length() <= 10; s.append("v")) {
if (_params.count(s)) {
logLevel = s.length();
}
}
#ifdef MONGO_SSL
if (_params.count("ssl")) {
mongo::cmdLine.sslOnNormalPorts = true;
}
#endif
preSetup();
bool useDirectClient = hasParam( "dbpath" );
if ( ! useDirectClient ) {
_host = "127.0.0.1";
if ( _params.count( "host" ) )
_host = _params["host"].as<string>();
if ( _params.count( "port" ) )
_host += ':' + _params["port"].as<string>();
if ( _noconnection ) {
// do nothing
}
else {
string errmsg;
ConnectionString cs = ConnectionString::parse( _host , errmsg );
if ( ! cs.isValid() ) {
cerr << "invalid hostname [" << _host << "] " << errmsg << endl;
::_exit(-1);
}
_conn = cs.connect( errmsg );
if ( ! _conn ) {
cerr << "couldn't connect to [" << _host << "] " << errmsg << endl;
::_exit(-1);
}
(_usesstdout ? cout : cerr ) << "connected to: " << _host << endl;
}
}
else {
if ( _params.count( "directoryperdb" ) ) {
directoryperdb = true;
}
verify( lastError.get( true ) );
if (_params.count("journal")){
cmdLine.dur = true;
}
Client::initThread("tools");
_conn = new DBDirectClient();
_host = "DIRECT";
static string myDbpath = getParam( "dbpath" );
dbpath = myDbpath.c_str();
try {
acquirePathLock();
}
catch ( DBException& ) {
cerr << endl << "If you are running a mongod on the same "
"path you should connect to that instead of direct data "
"file access" << endl << endl;
dbexit( EXIT_CLEAN );
::_exit(-1);
}
FileAllocator::get()->start();
dur::startup();
}
if ( _params.count( "db" ) )
_db = _params["db"].as<string>();
if ( _params.count( "collection" ) )
_coll = _params["collection"].as<string>();
if ( _params.count( "username" ) )
_username = _params["username"].as<string>();
if ( _params.count( "password" )
&& ( _password.empty() ) ) {
_password = askPassword();
}
if (_params.count("ipv6"))
enableIPv6();
int ret = -1;
try {
ret = run();
}
catch ( DBException& e ) {
cerr << "assertion: " << e.toString() << endl;
ret = -1;
}
catch(const boost::filesystem::filesystem_error &fse) {
/*
https://jira.mongodb.org/browse/SERVER-2904
Simple tools that don't access the database, such as
bsondump, aren't throwing DBExceptions, but are throwing
boost exceptions.
The currently available set of error codes don't seem to match
boost documentation. boost::filesystem::not_found_error
(from http://www.boost.org/doc/libs/1_31_0/libs/filesystem/doc/exception.htm)
doesn't seem to exist in our headers. Also, fse.code() isn't
boost::system::errc::no_such_file_or_directory when this
happens, as you would expect. And, determined from
experimentation that the command-line argument gets turned into
"\\?" instead of "/?" !!!
*/
#if defined(_WIN32)
if (/*(fse.code() == boost::system::errc::no_such_file_or_directory) &&*/
(fse.path1() == "\\?"))
printHelp(cerr);
else
#endif // _WIN32
cerr << "error: " << fse.what() << endl;
ret = -1;
}
if ( currentClient.get() )
currentClient.get()->shutdown();
if ( useDirectClient )
dbexit( EXIT_CLEAN );
::_exit(ret);
}
Status storeMongosOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeServerOptions(params, args);
if (!ret.isOK()) {
std::cerr << "Error storing command line: " << ret.toString() << std::endl;
::_exit(EXIT_BADOPTIONS);
}
if ( params.count( "chunkSize" ) ) {
int csize = params["chunkSize"].as<int>();
// validate chunksize before proceeding
if ( csize == 0 ) {
std::cerr << "error: need a non-zero chunksize" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
if ( !Chunk::setMaxChunkSizeSizeMB( csize ) ) {
std::cerr << "MaxChunkSize invalid" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
}
if (params.count( "port" ) ) {
int port = params["port"].as<int>();
if ( port <= 0 || port > 65535 ) {
out() << "error: port number must be between 1 and 65535" << endl;
::_exit(EXIT_FAILURE);
}
}
if ( params.count( "localThreshold" ) ) {
serverGlobalParams.defaultLocalThresholdMillis = params["localThreshold"].as<int>();
}
if ( params.count( "ipv6" ) ) {
enableIPv6();
}
if ( params.count( "jsonp" ) ) {
serverGlobalParams.jsonp = true;
}
if ( params.count( "test" ) ) {
::mongo::logger::globalLogDomain()->setMinimumLoggedSeverity(
::mongo::logger::LogSeverity::Debug(5));
StartupTest::runTests();
::_exit(EXIT_SUCCESS);
}
if (params.count("noscripting")) {
// This option currently has no effect for mongos
}
if (params.count("httpinterface")) {
if (params.count("nohttpinterface")) {
std::cerr << "can't have both --httpinterface and --nohttpinterface" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
serverGlobalParams.isHttpInterfaceEnabled = true;
}
if (params.count("noAutoSplit")) {
warning() << "running with auto-splitting disabled" << endl;
Chunk::ShouldAutoSplit = false;
}
if ( ! params.count( "configdb" ) ) {
std::cerr << "error: no args for --configdb" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
splitStringDelim(params["configdb"].as<std::string>(), &mongosGlobalParams.configdbs, ',');
if (mongosGlobalParams.configdbs.size() != 1 && mongosGlobalParams.configdbs.size() != 3) {
std::cerr << "need either 1 or 3 configdbs" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
if (mongosGlobalParams.configdbs.size() == 1) {
warning() << "running with 1 config server should be done only for testing purposes "
<< "and is not recommended for production" << endl;
}
mongosGlobalParams.upgrade = params.count("upgrade");
return Status::OK();
}
