Status storeMongoBridgeOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
if (!params.count("port")) {
return {ErrorCodes::BadValue, "Missing required option: --port"};
}
if (!params.count("dest")) {
return {ErrorCodes::BadValue, "Missing required option: --dest"};
}
mongoBridgeGlobalParams.port = params["port"].as<int>();
mongoBridgeGlobalParams.destUri = params["dest"].as<std::string>();
if (!params.count("seed")) {
std::unique_ptr<SecureRandom> seedSource{SecureRandom::create()};
mongoBridgeGlobalParams.seed = seedSource->nextInt64();
} else {
mongoBridgeGlobalParams.seed = static_cast<int64_t>(params["seed"].as<long>());
}
if (params.count("verbose")) {
std::string verbosity = params["verbose"].as<std::string>();
if (std::any_of(verbosity.cbegin(), verbosity.cend(), [](char ch) { return ch != 'v'; })) {
return {ErrorCodes::BadValue,
"The string for the --verbose option cannot contain characters other than 'v'"};
}
logger::globalLogDomain()->setMinimumLoggedSeverity(
logger::LogSeverity::Debug(verbosity.length()));
}
return Status::OK();
}
Status handlePreValidationMongoShellOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
if (params.count("help")) {
std::cout << getMongoShellHelp(args[0], moe::startupOptions) << std::endl;
::_exit(EXIT_CLEAN);
}
if (params.count("version")) {
cout << "MongoDB shell version: " << mongo::versionString << endl;
::_exit(EXIT_CLEAN);
}
if (params.count("quiet")) {
mongo::serverGlobalParams.quiet = true;
}
#ifdef MONGO_SSL
Status ret = storeSSLClientOptions(params);
if (!ret.isOK()) {
return ret;
}
#endif
if (params.count("ipv6")) {
mongo::enableIPv6();
}
if (params.count("verbose")) {
logger::globalLogDomain()->setMinimumLoggedSeverity(logger::LogSeverity::Debug(1));
}
return Status::OK();
}
bool handlePreValidationMongodOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
if (params.count("help") && params["help"].as<bool>() == true) {
printMongodHelp(moe::startupOptions);
return false;
}
if (params.count("version") && params["version"].as<bool>() == true) {
setPlainConsoleLogger();
auto&& vii = VersionInfoInterface::instance();
log() << mongodVersion(vii);
vii.logBuildInfo();
return false;
}
if (params.count("sysinfo") && params["sysinfo"].as<bool>() == true) {
setPlainConsoleLogger();
sysRuntimeInfo();
return false;
}
if (params.count("master") || params.count("slave")) {
severe() << "Master/slave replication is no longer supported";
return false;
}
return true;
}
Status validateSSLMongoShellOptions(const moe::Environment& params) {
// Users must specify either a CAFile or allowInvalidCertificates if ssl=true.
if (params.count("ssl") && params["ssl"].as<bool>() == true && !params.count("ssl.CAFile") &&
!params.count("ssl.allowInvalidCertificates")) {
return Status(ErrorCodes::BadValue,
"need to either provide sslCAFile or specify sslAllowInvalidCertificates");
}
return Status::OK();
}
Status storeMongoShellOptions() {
if ( params.count( "quiet" ) ) {
mongo::cmdLine.quiet = true;
}
#ifdef MONGO_SSL
if ( params.count( "ssl" ) ) {
mongo::cmdLine.sslOnNormalPorts = true;
}
if (params.count("ssl.PEMKeyFile")) {
mongo::cmdLine.sslPEMKeyFile = params["ssl.PEMKeyFile"].as<std::string>();
}
if (params.count("ssl.PEMKeyPassword")) {
mongo::cmdLine.sslPEMKeyPassword = params["ssl.PEMKeyPassword"].as<std::string>();
}
if (params.count("ssl.CAFile")) {
mongo::cmdLine.sslCAFile = params["ssl.CAFile"].as<std::string>();
}
if (params.count("ssl.CRLFile")) {
mongo::cmdLine.sslCRLFile = params["ssl.CRLFile"].as<std::string>();
}
if (params.count( "ssl.FIPSMode")) {
mongo::cmdLine.sslFIPSMode = true;
}
#endif
if ( params.count( "ipv6" ) ) {
mongo::enableIPv6();
}
if ( params.count( "verbose" ) ) {
logger::globalLogDomain()->setMinimumLoggedSeverity(logger::LogSeverity::Debug(1));
}
return Status::OK();
}
Status WiredTigerGlobalOptions::store(const moe::Environment& params,
const std::vector<std::string>& args) {
// WiredTiger storage engine options
if (params.count("storage.wiredTiger.engineConfig.cacheSizeGB")) {
wiredTigerGlobalOptions.cacheSizeGB =
params["storage.wiredTiger.engineConfig.cacheSizeGB"].as<int>();
}
if (params.count("storage.syncPeriodSecs")) {
wiredTigerGlobalOptions.checkpointDelaySecs =
static_cast<size_t>(params["storage.syncPeriodSecs"].as<double>());
}
if (params.count("storage.wiredTiger.engineConfig.statisticsLogDelaySecs")) {
wiredTigerGlobalOptions.statisticsLogDelaySecs =
params["storage.wiredTiger.engineConfig.statisticsLogDelaySecs"].as<int>();
}
if (params.count("storage.wiredTiger.engineConfig.journalCompressor")) {
wiredTigerGlobalOptions.journalCompressor =
params["storage.wiredTiger.engineConfig.journalCompressor"].as<std::string>();
}
if (params.count("storage.wiredTiger.engineConfig.directoryForIndexes")) {
wiredTigerGlobalOptions.directoryForIndexes =
params["storage.wiredTiger.engineConfig.directoryForIndexes"].as<bool>();
}
if (params.count("storage.wiredTiger.engineConfig.configString")) {
wiredTigerGlobalOptions.engineConfig =
params["storage.wiredTiger.engineConfig.configString"].as<std::string>();
log() << "Engine custom option: " << wiredTigerGlobalOptions.engineConfig;
}
// WiredTiger collection options
if (params.count("storage.wiredTiger.collectionConfig.blockCompressor")) {
wiredTigerGlobalOptions.collectionBlockCompressor =
params["storage.wiredTiger.collectionConfig.blockCompressor"].as<std::string>();
}
if (params.count("storage.wiredTiger.collectionConfig.configString")) {
wiredTigerGlobalOptions.collectionConfig =
params["storage.wiredTiger.collectionConfig.configString"].as<std::string>();
log() << "Collection custom option: " << wiredTigerGlobalOptions.collectionConfig;
}
// WiredTiger index options
if (params.count("storage.wiredTiger.indexConfig.prefixCompression")) {
wiredTigerGlobalOptions.useIndexPrefixCompression =
params["storage.wiredTiger.indexConfig.prefixCompression"].as<bool>();
}
if (params.count("storage.wiredTiger.indexConfig.configString")) {
wiredTigerGlobalOptions.indexConfig =
params["storage.wiredTiger.indexConfig.configString"].as<std::string>();
log() << "Index custom option: " << wiredTigerGlobalOptions.indexConfig;
}
return Status::OK();
}
bool handlePreValidationMongoShellOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
if (params.count("help")) {
std::cout << getMongoShellHelp(args[0], moe::startupOptions) << std::endl;
return false;
}
if (params.count("version")) {
cout << "MongoDB shell version: " << mongo::versionString << endl;
return false;
}
return true;
}
Status handlePreValidationMongosOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
if (params.count("help")) {
printMongosHelp(serverOptions);
::_exit(EXIT_SUCCESS);
}
if (params.count("version")) {
printShardingVersionInfo(true);
::_exit(EXIT_SUCCESS);
}
return Status::OK();
}
Status storeSSLClientOptions(const moe::Environment& params) {
if (params.count("ssl") && params["ssl"].as<bool>() == true) {
sslGlobalParams.sslMode.store(SSLGlobalParams::SSLMode_requireSSL);
}
if (params.count("ssl.PEMKeyFile")) {
sslGlobalParams.sslPEMKeyFile = params["ssl.PEMKeyFile"].as<std::string>();
}
if (params.count("ssl.PEMKeyPassword")) {
sslGlobalParams.sslPEMKeyPassword = params["ssl.PEMKeyPassword"].as<std::string>();
}
if (params.count("ssl.CAFile")) {
sslGlobalParams.sslCAFile = params["ssl.CAFile"].as<std::string>();
}
if (params.count("ssl.CRLFile")) {
sslGlobalParams.sslCRLFile = params["ssl.CRLFile"].as<std::string>();
}
if (params.count("net.ssl.allowInvalidHostnames")) {
sslGlobalParams.sslAllowInvalidHostnames =
params["net.ssl.allowInvalidHostnames"].as<bool>();
}
if (params.count("ssl.allowInvalidCertificates")) {
sslGlobalParams.sslAllowInvalidCertificates = true;
}
if (params.count("ssl.FIPSMode")) {
sslGlobalParams.sslFIPSMode = true;
}
return Status::OK();
}
Status storeSASLOptions(const moe::Environment& params) {
bool haveAuthenticationMechanisms = false;
bool haveHostName = false;
bool haveServiceName = false;
bool haveAuthdPath = false;
// Check our setParameter options first so that these values can be properly overridden via
// the command line even though the options have different names.
if (params.count("setParameter")) {
std::map<std::string, std::string> parameters =
params["setParameter"].as<std::map<std::string, std::string> >();
for (std::map<std::string, std::string>::iterator parametersIt = parameters.begin();
parametersIt != parameters.end(); parametersIt++) {
if (parametersIt->first == "authenticationMechanisms") {
haveAuthenticationMechanisms = true;
}
else if (parametersIt->first == "saslHostName") {
haveHostName = true;
}
else if (parametersIt->first == "saslServiceName") {
haveServiceName = true;
}
else if (parametersIt->first == "saslauthdPath") {
haveAuthdPath = true;
}
}
}
if (params.count("security.authenticationMechanisms") &&
!haveAuthenticationMechanisms) {
saslGlobalParams.authenticationMechanisms =
params["security.authenticationMechanisms"].as<std::vector<std::string> >();
}
if (params.count("security.sasl.hostName") && !haveHostName) {
saslGlobalParams.hostName =
params["security.sasl.hostName"].as<std::string>();
}
if (params.count("security.sasl.serviceName") && !haveServiceName) {
saslGlobalParams.serviceName =
params["security.sasl.serviceName"].as<std::string>();
}
if (params.count("security.sasl.saslauthdSocketPath") && !haveAuthdPath) {
saslGlobalParams.authdPath =
params["security.sasl.saslauthdSocketPath"].as<std::string>();
}
return Status::OK();
}
bool handlePreValidationMongoShellOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
auto&& vii = VersionInfoInterface::instance();
if (params.count("version") || params.count("help")) {
setPlainConsoleLogger();
log() << mongoShellVersion(vii);
if (params.count("help")) {
log() << getMongoShellHelp(args[0], moe::startupOptions);
} else {
vii.logBuildInfo();
}
return false;
}
return true;
}
bool handlePreValidationBSONDumpOptions(const moe::Environment& params) {
if (params.count("help")) {
printBSONDumpHelp(&std::cout);
return false;
}
return true;
}
Status storeMongoRestoreOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
ret = storeBSONToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
mongoRestoreGlobalParams.restoreDirectory = getParam("dir");
mongoRestoreGlobalParams.drop = hasParam("drop");
mongoRestoreGlobalParams.keepIndexVersion = hasParam("keepIndexVersion");
mongoRestoreGlobalParams.restoreOptions = !hasParam("noOptionsRestore");
mongoRestoreGlobalParams.restoreIndexes = !hasParam("noIndexRestore");
mongoRestoreGlobalParams.w = getParam( "w" , 0 );
mongoRestoreGlobalParams.oplogReplay = hasParam("oplogReplay");
mongoRestoreGlobalParams.oplogLimit = getParam("oplogLimit", "");
// Make the default db "" if it was not explicitly set
if (!params.count("db")) {
toolGlobalParams.db = "";
}
return Status::OK();
}
bool handlePreValidationMongoImportOptions(const moe::Environment& params) {
if (params.count("help")) {
printMongoImportHelp(&std::cout);
return true;
}
return false;
}
Status storeBSONDumpOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
ret = storeBSONToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
// BSONDump never has a db connection
toolGlobalParams.noconnection = true;
bsonDumpGlobalParams.type = getParam("type");
bsonDumpGlobalParams.file = getParam("file");
// Make the default db "" if it was not explicitly set
if (!params.count("db")) {
toolGlobalParams.db = "";
}
// bsondump always outputs data to stdout, so we can't send messages there
toolGlobalParams.canUseStdout = false;
return Status::OK();
}
Status handlePreValidationMongoTopOptions(const moe::Environment& params) {
if (params.count("help")) {
printMongoTopHelp(&std::cout);
::_exit(0);
}
return Status::OK();
}
bool handlePreValidationTestFrameworkOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
if (params.count("help")) {
std::cout << getTestFrameworkHelp(args[0], moe::startupOptions) << std::endl;
return false;
}
if (params.count("list")) {
std::vector<std::string> suiteNames = mongo::unittest::getAllSuiteNames();
for (std::vector<std::string>::const_iterator i = suiteNames.begin(); i != suiteNames.end();
++i) {
std::cout << *i << std::endl;
}
return false;
}
return true;
}
bool handlePreValidationMongoStatOptions(const moe::Environment& params) {
if (!handlePreValidationGeneralToolOptions(params)) {
return false;
}
if (params.count("help")) {
printMongoStatHelp(&std::cout);
return false;
}
return true;
}
bool handlePreValidationMongosOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
if (params.count("help")) {
printMongosHelp(moe::startupOptions);
return false;
}
if (params.count("version")) {
printShardingVersionInfo(true);
return false;
}
if ( params.count( "test" ) ) {
::mongo::logger::globalLogDomain()->setMinimumLoggedSeverity(
::mongo::logger::LogSeverity::Debug(5));
StartupTest::runTests();
return false;
}
return true;
}
Status handlePreValidationMongodOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
if (params.count("help")) {
printMongodHelp(serverOptions);
::_exit(EXIT_SUCCESS);
}
if (params.count("version")) {
cout << mongodVersion() << endl;
printGitVersion();
printOpenSSLVersion();
::_exit(EXIT_SUCCESS);
}
if (params.count("sysinfo")) {
sysRuntimeInfo();
::_exit(EXIT_SUCCESS);
}
return Status::OK();
}
bool handlePreValidationMongodOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
if (params.count("help")) {
printMongodHelp(moe::startupOptions);
return false;
}
if (params.count("version")) {
cout << mongodVersion() << endl;
printGitVersion();
printOpenSSLVersion();
return false;
}
if (params.count("sysinfo")) {
sysRuntimeInfo();
return false;
}
return true;
}
Status storeMongoBridgeOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
if (!params.count("port")) {
return Status(ErrorCodes::BadValue, "Missing required option: \"--port\"");
}
if (!params.count("dest")) {
return Status(ErrorCodes::BadValue, "Missing required option: \"--dest\"");
}
mongoBridgeGlobalParams.port = params["port"].as<int>();
mongoBridgeGlobalParams.destUri = params["dest"].as<std::string>();
if (params.count("delay")) {
mongoBridgeGlobalParams.delay = params["delay"].as<int>();
}
return Status::OK();
}
Status storeSASLSSPIOptions(const moe::Environment& params) {
if (params.count("security.sspiHostnameCanonicalization")) {
if (params["security.sspiHostnameCanonicalization"].as<std::string>() == "none") {
saslSSPIGlobalParams.canonicalization = HostnameCanonicalizationMode::kNone;
} else if (params["security.sspiHostnameCanonicalization"].as<std::string>() == "forward") {
saslSSPIGlobalParams.canonicalization = HostnameCanonicalizationMode::kForward;
} else if (params["security.sspiHostnameCanonicalization"].as<std::string>() ==
"forwardAndReverse") {
saslSSPIGlobalParams.canonicalization =
HostnameCanonicalizationMode::kForwardAndReverse;
} else {
return Status(ErrorCodes::InvalidOptions,
"Unrecognized sspiHostnameCanonicalization option");
}
}
if (params.count("security.sspiRealmOverride")) {
saslSSPIGlobalParams.realmOverride = params["security.sspiRealmOverride"].as<std::string>();
}
return Status::OK();
}
Status validateServerOptions(const moe::Environment& params) {
if (params.count("verbose")) {
std::string verbosity = params["verbose"].as<std::string>();
// Skip this for backwards compatibility. See SERVER-11471.
if (verbosity != "true") {
for (std::string::iterator iterator = verbosity.begin();
iterator != verbosity.end(); iterator++) {
if (*iterator != 'v') {
return Status(ErrorCodes::BadValue,
"The \"verbose\" option string cannot contain any characters "
"other than \"v\"");
}
}
}
}
#ifdef _WIN32
if (params.count("install") || params.count("reinstall")) {
if (params.count("logpath") &&
!boost::filesystem::path(params["logpath"].as<string>()).is_absolute()) {
return Status(ErrorCodes::BadValue,
"logpath requires an absolute file path with Windows services");
}
if (params.count("config") &&
!boost::filesystem::path(params["config"].as<string>()).is_absolute()) {
return Status(ErrorCodes::BadValue,
"config requires an absolute file path with Windows services");
}
if (params.count("processManagement.pidFilePath") &&
!boost::filesystem::path(
params["processManagement.pidFilePath"].as<string>()).is_absolute()) {
return Status(ErrorCodes::BadValue,
"pidFilePath requires an absolute file path with Windows services");
}
if (params.count("security.keyFile") &&
!boost::filesystem::path(params["security.keyFile"].as<string>()).is_absolute()) {
return Status(ErrorCodes::BadValue,
"keyFile requires an absolute file path with Windows services");
}
}
#endif
#ifdef MONGO_SSL
Status ret = validateSSLServerOptions(params);
if (!ret.isOK()) {
return ret;
}
#endif
return Status::OK();
}
Status validateSSLServerOptions(const moe::Environment& params) {
#ifdef _WIN32
if (params.count("install") || params.count("reinstall")) {
if (params.count("net.ssl.PEMKeyFile") &&
!boost::filesystem::path(params["net.ssl.PEMKeyFile"].as<string>()).is_absolute()) {
return Status(ErrorCodes::BadValue,
"PEMKeyFile requires an absolute file path with Windows services");
}
if (params.count("net.ssl.clusterFile") &&
!boost::filesystem::path(
params["net.ssl.clusterFile"].as<string>()).is_absolute()) {
return Status(ErrorCodes::BadValue,
"clusterFile requires an absolute file path with Windows services");
}
if (params.count("net.ssl.CAFile") &&
!boost::filesystem::path(params["net.ssl.CAFile"].as<string>()).is_absolute()) {
return Status(ErrorCodes::BadValue,
"CAFile requires an absolute file path with Windows services");
}
if (params.count("net.ssl.CRLFile") &&
!boost::filesystem::path(params["net.ssl.CRLFile"].as<string>()).is_absolute()) {
return Status(ErrorCodes::BadValue,
"CRLFile requires an absolute file path with Windows services");
}
}
#endif
return Status::OK();
}
Status storeMessageCompressionOptions(const moe::Environment& params) {
std::vector<std::string> restrict;
if (params.count("net.compression.compressors")) {
auto compressorListStr = params["net.compression.compressors"].as<std::string>();
if (compressorListStr != kDisabledConfigValue) {
boost::algorithm::split(restrict, compressorListStr, boost::is_any_of(", "));
}
}
auto& compressorFactory = MessageCompressorRegistry::get();
compressorFactory.setSupportedCompressors(std::move(restrict));
return Status::OK();
}
Status storeMongoStatOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
if (hasParam("http")) {
mongoStatGlobalParams.http = true;
toolGlobalParams.noconnection = true;
}
if (hasParam("host") && getParam("host").find(',') != string::npos) {
toolGlobalParams.noconnection = true;
mongoStatGlobalParams.many = true;
}
if (hasParam("discover")) {
mongoStatGlobalParams.discover = true;
mongoStatGlobalParams.many = true;
}
mongoStatGlobalParams.showHeaders = !hasParam("noheaders");
mongoStatGlobalParams.rowCount = getParam("rowcount", 0);
mongoStatGlobalParams.sleep = getParam("sleep", 1);
mongoStatGlobalParams.allFields = hasParam("all");
// Make the default db "admin" if it was not explicitly set
if (!params.count("db")) {
toolGlobalParams.db = "admin";
}
// end of storage / start of validation
if (mongoStatGlobalParams.sleep <= 0) {
return Status(ErrorCodes::BadValue,
"Error parsing command line: --sleep must be greater than 0");
}
if (mongoStatGlobalParams.rowCount < 0) {
return Status(ErrorCodes::BadValue,
"Error parsing command line: --rowcount (-n) can't be negative");
}
return Status::OK();
}
Status storeMongoTopOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
mongoTopGlobalParams.sleep = getParam("sleep", 1);
mongoTopGlobalParams.useLocks = hasParam("locks");
// Make the default db "admin" if it was not explicitly set
if (!params.count("db")) {
toolGlobalParams.db = "admin";
}
return Status::OK();
}
Status storeMongoDumpOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
mongoDumpGlobalParams.repair = hasParam("repair");
if (mongoDumpGlobalParams.repair){
if (!hasParam("dbpath")) {
return Status(ErrorCodes::BadValue, "repair mode only works with --dbpath");
}
if (!hasParam("db")) {
return Status(ErrorCodes::BadValue,
"repair mode only works on 1 db at a time right now");
}
}
mongoDumpGlobalParams.query = getParam("query");
mongoDumpGlobalParams.useOplog = hasParam("oplog");
if (mongoDumpGlobalParams.useOplog) {
if (hasParam("query") || hasParam("db") || hasParam("collection")) {
return Status(ErrorCodes::BadValue, "oplog mode is only supported on full dumps");
}
}
mongoDumpGlobalParams.outputDirectory = getParam("out");
mongoDumpGlobalParams.snapShotQuery = false;
if (!hasParam("query") && !hasParam("dbpath") && !hasParam("forceTableScan")) {
mongoDumpGlobalParams.snapShotQuery = true;
}
// Make the default db "" if it was not explicitly set
if (!params.count("db")) {
toolGlobalParams.db = "";
}
if (mongoDumpGlobalParams.outputDirectory == "-") {
// write output to standard error to avoid mangling output
// must happen early to avoid sending junk to stdout
toolGlobalParams.canUseStdout = false;
}
return Status::OK();
}
Status validateServerOptions(const moe::Environment& params) {
if (params.count("verbose")) {
std::string verbosity = params["verbose"].as<std::string>();
// Skip this for backwards compatibility. See SERVER-11471.
if (verbosity != "true") {
for (std::string::iterator iterator = verbosity.begin();
iterator != verbosity.end(); iterator++) {
if (*iterator != 'v') {
return Status(ErrorCodes::BadValue,
"The \"verbose\" option string cannot contain any characters "
"other than \"v\"");
}
}
}
}
return Status::OK();
}