void _initAndListen(int listenPort, const char *appserverLoc = null) {
#if !defined(_WIN32)
pid_t pid = 0;
pid = getpid();
#else
int pid=0;
#endif
bool is32bit = sizeof(int*) == 4;
log() << "Mongo DB : starting : pid = " << pid << " port = " << cmdLine.port << " dbpath = " << dbpath
<< " master = " << master << " slave = " << (int) slave << " " << ( is32bit ? "32" : "64" ) << "-bit " << endl;
show_32_warning();
stringstream ss;
ss << "dbpath (" << dbpath << ") does not exist";
massert( ss.str().c_str(), boost::filesystem::exists( dbpath ) );
acquirePathLock();
theFileAllocator().start();
BOOST_CHECK_EXCEPTION( clearTmpFiles() );
clearTmpCollections();
if ( opLogging )
log() << "opLogging = " << opLogging << endl;
_oplog.init();
mms.go();
#if 0
{
stringstream indexpath;
indexpath << dbpath << "/indexes.dat";
RecCache::tempStore.init(indexpath.str().c_str(), BucketSize);
}
#endif
if ( useJNI ) {
ScriptEngine::setup();
}
repairDatabases();
if ( shouldRepairDatabases )
return;
/* this is for security on certain platforms */
srand(curTimeMicros() ^ startupSrandTimer.micros());
listen(listenPort);
// listen() will return when exit code closes its socket.
while( 1 )
sleepsecs( 100 );
}
void _initAndListen(int listenPort ) {
Client::initThread("initandlisten");
Database::_openAllFiles = false;
Logstream::get().addGlobalTee( new RamLog("global") );
bool is32bit = sizeof(int*) == 4;
{
#if !defined(_WIN32)
pid_t pid = getpid();
#else
DWORD pid=GetCurrentProcessId();
#endif
Nullstream& l = log();
l << "MongoDB starting : pid=" << pid << " port=" << cmdLine.port << " dbpath=" << dbpath;
if( replSettings.master ) l << " master=" << replSettings.master;
if( replSettings.slave ) l << " slave=" << (int) replSettings.slave;
l << ( is32bit ? " 32" : " 64" ) << "-bit host=" << getHostNameCached() << endl;
}
DEV log() << "_DEBUG build (which is slower)" << endl;
show_warnings();
log() << mongodVersion() << endl;
printGitVersion();
printSysInfo();
printCommandLineOpts();
{
stringstream ss;
ss << endl;
ss << "*********************************************************************" << endl;
ss << " ERROR: dbpath (" << dbpath << ") does not exist." << endl;
ss << " Create this directory or give existing directory in --dbpath." << endl;
ss << " See http://www.mongodb.org/display/DOCS/Starting+and+Stopping+Mongo" << endl;
ss << "*********************************************************************" << endl;
uassert( 10296 , ss.str().c_str(), boost::filesystem::exists( dbpath ) );
}
{
stringstream ss;
ss << "repairpath (" << repairpath << ") does not exist";
uassert( 12590 , ss.str().c_str(), boost::filesystem::exists( repairpath ) );
}
acquirePathLock(forceRepair);
boost::filesystem::remove_all( dbpath + "/_tmp/" );
FileAllocator::get()->start();
MONGO_ASSERT_ON_EXCEPTION_WITH_MSG( clearTmpFiles(), "clear tmp files" );
dur::startup();
if( cmdLine.durOptions & CmdLine::DurRecoverOnly )
return;
// comes after getDur().startup() because this reads from the database
clearTmpCollections();
checkIfReplMissingFromCommandLine();
Module::initAll();
if ( scriptingEnabled ) {
ScriptEngine::setup();
globalScriptEngine->setCheckInterruptCallback( jsInterruptCallback );
globalScriptEngine->setGetInterruptSpecCallback( jsGetInterruptSpecCallback );
}
repairDatabasesAndCheckVersion();
/* we didn't want to pre-open all files for the repair check above. for regular
operation we do for read/write lock concurrency reasons.
*/
Database::_openAllFiles = true;
if ( shouldRepairDatabases )
return;
/* this is for security on certain platforms (nonce generation) */
srand((unsigned) (curTimeMicros() ^ startupSrandTimer.micros()));
snapshotThread.go();
d.clientCursorMonitor.go();
PeriodicTask::theRunner->go();
startTTLBackgroundJob();
#ifndef _WIN32
CmdLine::launchOk();
#endif
if( !noauth ) {
// open admin db in case we need to use it later. TODO this is not the right way to
// resolve this.
Client::WriteContext c("admin",dbpath,false);
}
listen(listenPort);
// listen() will return when exit code closes its socket.
exitCleanly(EXIT_NET_ERROR);
}
void _initAndListen(int listenPort, const char *appserverLoc = NULL) {
bool is32bit = sizeof(int*) == 4;
{
#if !defined(_WIN32)
pid_t pid = getpid();
#else
DWORD pid=GetCurrentProcessId();
#endif
Nullstream& l = log();
l << "MongoDB starting : pid=" << pid << " port=" << cmdLine.port << " dbpath=" << dbpath;
if( replSettings.master ) l << " master=" << replSettings.master;
if( replSettings.slave ) l << " slave=" << (int) replSettings.slave;
l << ( is32bit ? " 32" : " 64" ) << "-bit " << endl;
}
DEV log() << "_DEBUG build (which is slower)" << endl;
show_warnings();
log() << mongodVersion() << endl;
printGitVersion();
printSysInfo();
{
stringstream ss;
ss << "dbpath (" << dbpath << ") does not exist";
uassert( 10296 , ss.str().c_str(), boost::filesystem::exists( dbpath ) );
}
{
stringstream ss;
ss << "repairpath (" << repairpath << ") does not exist";
uassert( 12590 , ss.str().c_str(), boost::filesystem::exists( repairpath ) );
}
acquirePathLock();
remove_all( dbpath + "/_tmp/" );
theFileAllocator().start();
BOOST_CHECK_EXCEPTION( clearTmpFiles() );
Client::initThread("initandlisten");
_diaglog.init();
clearTmpCollections();
Module::initAll();
#if 0
{
stringstream indexpath;
indexpath << dbpath << "/indexes.dat";
RecCache::tempStore.init(indexpath.str().c_str(), BucketSize);
}
#endif
if ( useJNI ) {
ScriptEngine::setup();
globalScriptEngine->setCheckInterruptCallback( jsInterruptCallback );
}
repairDatabases();
/* we didn't want to pre-open all fiels for the repair check above. for regular
operation we do for read/write lock concurrency reasons.
*/
Database::_openAllFiles = true;
if ( shouldRepairDatabases )
return;
/* this is for security on certain platforms (nonce generation) */
srand((unsigned) (curTimeMicros() ^ startupSrandTimer.micros()));
snapshotThread.go();
clientCursorMonitor.go();
if( !cmdLine._replSet.empty() ) {
replSet = true;
ReplSetCmdline *replSetCmdline = new ReplSetCmdline(cmdLine._replSet);
boost::thread t( boost::bind( &startReplSets, replSetCmdline) );
}
listen(listenPort);
// listen() will return when exit code closes its socket.
exitCleanly(EXIT_NET_ERROR);
}
/**
* Return whether there are non-local databases. If there was an error becauses the wrong mongod
* version was used for these datafiles, a DBException with status ErrorCodes::MustDowngrade is
* thrown.
*/
bool repairDatabasesAndCheckVersion(OperationContext* opCtx) {
auto const storageEngine = opCtx->getServiceContext()->getStorageEngine();
Lock::GlobalWrite lk(opCtx);
std::vector<std::string> dbNames = storageEngine->listDatabases();
// Rebuilding indexes must be done before a database can be opened, except when using repair,
// which rebuilds all indexes when it is done.
if (!storageGlobalParams.readOnly && !storageGlobalParams.repair) {
// Determine whether this is a replica set node running in standalone mode. If we're in
// repair mode, we cannot set the flag yet as it needs to open a database and look through a
// collection. Rebuild the necessary indexes after setting the flag.
setReplSetMemberInStandaloneMode(opCtx);
rebuildIndexes(opCtx, storageEngine);
}
bool ensuredCollectionProperties = false;
// Repair all databases first, so that we do not try to open them if they are in bad shape
auto databaseHolder = DatabaseHolder::get(opCtx);
if (storageGlobalParams.repair) {
invariant(!storageGlobalParams.readOnly);
if (MONGO_FAIL_POINT(exitBeforeDataRepair)) {
log() << "Exiting because 'exitBeforeDataRepair' fail point was set.";
quickExit(EXIT_ABRUPT);
}
// Ensure that the local database is repaired first, if it exists, so that we can open it
// before any other database to be able to determine if this is a replica set node running
// in standalone mode before rebuilding any indexes.
auto dbNamesIt = std::find(dbNames.begin(), dbNames.end(), NamespaceString::kLocalDb);
if (dbNamesIt != dbNames.end()) {
std::swap(dbNames.front(), *dbNamesIt);
invariant(dbNames.front() == NamespaceString::kLocalDb);
}
stdx::function<void(const std::string& dbName)> onRecordStoreRepair =
[opCtx](const std::string& dbName) {
if (dbName == NamespaceString::kLocalDb) {
setReplSetMemberInStandaloneMode(opCtx);
}
};
for (const auto& dbName : dbNames) {
LOG(1) << " Repairing database: " << dbName;
fassertNoTrace(18506,
repairDatabase(opCtx, storageEngine, dbName, onRecordStoreRepair));
}
// All collections must have UUIDs before restoring the FCV document to a version that
// requires UUIDs.
uassertStatusOK(ensureCollectionProperties(opCtx, dbNames));
ensuredCollectionProperties = true;
// Attempt to restore the featureCompatibilityVersion document if it is missing.
NamespaceString fcvNSS(NamespaceString::kServerConfigurationNamespace);
auto db = databaseHolder->getDb(opCtx, fcvNSS.db());
Collection* versionColl;
BSONObj featureCompatibilityVersion;
if (!db || !(versionColl = db->getCollection(opCtx, fcvNSS)) ||
!Helpers::findOne(opCtx,
versionColl,
BSON("_id" << FeatureCompatibilityVersionParser::kParameterName),
featureCompatibilityVersion)) {
uassertStatusOK(restoreMissingFeatureCompatibilityVersionDocument(opCtx, dbNames));
}
}
if (!ensuredCollectionProperties) {
uassertStatusOK(ensureCollectionProperties(opCtx, dbNames));
}
if (!storageGlobalParams.readOnly) {
// We open the "local" database before calling hasReplSetConfigDoc() to ensure the in-memory
// catalog entries for the 'kSystemReplSetNamespace' collection have been populated if the
// collection exists. If the "local" database didn't exist at this point yet, then it will
// be created. If the mongod is running in a read-only mode, then it is fine to not open the
// "local" database and populate the catalog entries because we won't attempt to drop the
// temporary collections anyway.
Lock::DBLock dbLock(opCtx, NamespaceString::kSystemReplSetNamespace.db(), MODE_X);
databaseHolder->openDb(opCtx, NamespaceString::kSystemReplSetNamespace.db());
}
if (storageGlobalParams.repair) {
if (MONGO_FAIL_POINT(exitBeforeRepairInvalidatesConfig)) {
log() << "Exiting because 'exitBeforeRepairInvalidatesConfig' fail point was set.";
quickExit(EXIT_ABRUPT);
}
// This must be done after opening the "local" database as it modifies the replica set
// config.
auto repairObserver = StorageRepairObserver::get(opCtx->getServiceContext());
repairObserver->onRepairDone(opCtx);
if (repairObserver->isDataModified()) {
warning() << "Modifications made by repair:";
const auto& mods = repairObserver->getModifications();
for (const auto& mod : mods) {
warning() << " " << mod;
}
if (hasReplSetConfigDoc(opCtx)) {
warning() << "WARNING: Repair may have modified replicated data. This node will no "
"longer be able to join a replica set without a full re-sync";
}
}
}
const repl::ReplSettings& replSettings =
repl::ReplicationCoordinator::get(opCtx)->getSettings();
// On replica set members we only clear temp collections on DBs other than "local" during
// promotion to primary. On pure slaves, they are only cleared when the oplog tells them
// to. The local DB is special because it is not replicated. See SERVER-10927 for more
// details.
const bool shouldClearNonLocalTmpCollections =
!(hasReplSetConfigDoc(opCtx) || replSettings.usingReplSets());
// To check whether a featureCompatibilityVersion document exists.
bool fcvDocumentExists = false;
// To check whether we have databases other than local.
bool nonLocalDatabases = false;
// Refresh list of database names to include newly-created admin, if it exists.
dbNames = storageEngine->listDatabases();
for (const auto& dbName : dbNames) {
if (dbName != "local") {
nonLocalDatabases = true;
}
LOG(1) << " Recovering database: " << dbName;
auto db = databaseHolder->openDb(opCtx, dbName);
invariant(db);
// First thing after opening the database is to check for file compatibility,
// otherwise we might crash if this is a deprecated format.
auto status = storageEngine->currentFilesCompatible(opCtx);
if (!status.isOK()) {
if (status.code() == ErrorCodes::CanRepairToDowngrade) {
// Convert CanRepairToDowngrade statuses to MustUpgrade statuses to avoid logging a
// potentially confusing and inaccurate message.
//
// TODO SERVER-24097: Log a message informing the user that they can start the
// current version of mongod with --repair and then proceed with normal startup.
status = {ErrorCodes::MustUpgrade, status.reason()};
}
severe() << "Unable to start mongod due to an incompatibility with the data files and"
" this version of mongod: "
<< redact(status);
severe() << "Please consult our documentation when trying to downgrade to a previous"
" major release";
quickExit(EXIT_NEED_UPGRADE);
MONGO_UNREACHABLE;
}
// If the server configuration collection already contains a valid
// featureCompatibilityVersion document, cache it in-memory as a server parameter.
if (dbName == "admin") {
if (Collection* versionColl =
db->getCollection(opCtx, NamespaceString::kServerConfigurationNamespace)) {
BSONObj featureCompatibilityVersion;
if (Helpers::findOne(
opCtx,
versionColl,
BSON("_id" << FeatureCompatibilityVersionParser::kParameterName),
featureCompatibilityVersion)) {
auto swVersion =
FeatureCompatibilityVersionParser::parse(featureCompatibilityVersion);
// Note this error path captures all cases of an FCV document existing,
// but with any value other than "4.0" or "4.2". This includes unexpected
// cases with no path forward such as the FCV value not being a string.
uassert(ErrorCodes::MustDowngrade,
str::stream()
<< "UPGRADE PROBLEM: Found an invalid "
"featureCompatibilityVersion document (ERROR: "
<< swVersion.getStatus()
<< "). If the current featureCompatibilityVersion is below "
"4.0, see the documentation on upgrading at "
<< feature_compatibility_version_documentation::kUpgradeLink
<< ".",
swVersion.isOK());
fcvDocumentExists = true;
auto version = swVersion.getValue();
serverGlobalParams.featureCompatibility.setVersion(version);
FeatureCompatibilityVersion::updateMinWireVersion();
// On startup, if the version is in an upgrading or downrading state, print a
// warning.
if (version ==
ServerGlobalParams::FeatureCompatibility::Version::kUpgradingTo42) {
log() << "** WARNING: A featureCompatibilityVersion upgrade did not "
<< "complete. " << startupWarningsLog;
log() << "** The current featureCompatibilityVersion is "
<< FeatureCompatibilityVersionParser::toString(version) << "."
<< startupWarningsLog;
log() << "** To fix this, use the setFeatureCompatibilityVersion "
<< "command to resume upgrade to 4.2." << startupWarningsLog;
} else if (version == ServerGlobalParams::FeatureCompatibility::Version::
kDowngradingTo40) {
log() << "** WARNING: A featureCompatibilityVersion downgrade did not "
<< "complete. " << startupWarningsLog;
log() << "** The current featureCompatibilityVersion is "
<< FeatureCompatibilityVersionParser::toString(version) << "."
<< startupWarningsLog;
log() << "** To fix this, use the setFeatureCompatibilityVersion "
<< "command to resume downgrade to 4.0." << startupWarningsLog;
}
}
}
}
if (replSettings.usingReplSets()) {
// We only care about _id indexes and drop-pending collections if we are in a replset.
db->checkForIdIndexesAndDropPendingCollections(opCtx);
// Ensure oplog is capped (mongodb does not guarantee order of inserts on noncapped
// collections)
if (db->name() == "local") {
checkForCappedOplog(opCtx, db);
}
}
if (!storageGlobalParams.readOnly &&
(shouldClearNonLocalTmpCollections || dbName == "local")) {
db->clearTmpCollections(opCtx);
}
}
// Fail to start up if there is no featureCompatibilityVersion document and there are non-local
// databases present.
if (!fcvDocumentExists && nonLocalDatabases) {
severe()
<< "Unable to start up mongod due to missing featureCompatibilityVersion document.";
severe() << "Please run with --repair to restore the document.";
fassertFailedNoTrace(40652);
}
LOG(1) << "done repairDatabases";
return nonLocalDatabases;
}
