void run() {
OpTime o;
{
mongo::mutex::scoped_lock lk2(OpTime::m);
o = OpTime::now(lk2);
}
BSONObjBuilder b;
b.append("ns","dummy");
b.appendTimestamp("ts", o.asLL());
BSONObj obj = b.obj();
MockInitialSync mock;
// all three should succeed
std::vector<BSONObj> ops;
ops.push_back(obj);
replset::multiInitialSyncApply(ops, &mock);
mock.failOnStep = MockInitialSync::FAIL_FIRST_APPLY;
replset::multiInitialSyncApply(ops, &mock);
mock.retry = false;
replset::multiInitialSyncApply(ops, &mock);
drop();
}
int main() {
boost::shared_mutex mtx; boost::upgrade_lock<boost::shared_mutex> lk(mtx);
boost::upgrade_to_unique_lock<boost::shared_mutex> lk2(lk);
return 0;
}
CoreBoundQueuesScheduler::~CoreBoundQueuesScheduler() {
std::lock_guard<lock_t> lk2(this->_queuesMutex);
task_queue_t *queue;
for (unsigned i = 0; i < this->_taskQueues.size(); ++i) {
queue = this->_taskQueues[i];
queue->stopQueue();
delete queue;
}
}
void insertSucceed() {
BSONObjBuilder b;
{
mongo::mutex::scoped_lock lk2(OpTime::m);
b.appendTimestamp("ts", OpTime::now(lk2).asLL());
}
b.append("op", "i");
b.append("o", BSON("_id" << 123 << "x" << 456));
b.append("ns", cappedNs());
verify(apply(b.obj()));
}
int main()
{
{
boost::thread t0( (G()));
BOOST_TEST(t0.joinable());
t0.join();
BOOST_TEST(!t0.joinable());
}
{
boost::unique_lock<boost::mutex> lk(resource_deadlock_would_occur_mtx);
boost::thread t0( resource_deadlock_would_occur_tester );
resource_deadlock_would_occur_th = &t0;
BOOST_TEST(t0.joinable());
lk.unlock();
boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
boost::unique_lock<boost::mutex> lk2(resource_deadlock_would_occur_mtx);
t0.join();
BOOST_TEST(!t0.joinable());
}
{
boost::thread t0( (G()));
t0.detach();
try
{
t0.join();
BOOST_TEST(false);
}
catch (boost::system::system_error& e)
{
BOOST_TEST(e.code().value() == boost::system::errc::invalid_argument);
}
}
{
boost::thread t0( (G()));
BOOST_TEST(t0.joinable());
t0.join();
try
{
t0.join();
BOOST_TEST(false);
}
catch (boost::system::system_error& e)
{
BOOST_TEST(e.code().value() == boost::system::errc::invalid_argument);
}
}
return boost::report_errors();
}
void updateSucceed() {
BSONObjBuilder b;
{
mongo::mutex::scoped_lock lk2(OpTime::m);
b.appendTimestamp("ts", OpTime::now(lk2).asLL());
}
b.append("op", "u");
b.append("o", BSON("$set" << BSON("x" << 789)));
b.append("o2", BSON("x" << 456));
b.append("ns", cappedNs());
verify(apply(b.obj()));
}
void swap()
{
boost::fibers::mutex mtx1, mtx2;
boost::unique_lock< boost::fibers::mutex > lk1( mtx1), lk2( mtx2);
BOOST_CHECK_EQUAL( lk1.mutex(), & mtx1);
BOOST_CHECK_EQUAL( lk2.mutex(), & mtx2);
lk1.swap( lk2);
BOOST_CHECK_EQUAL( lk1.mutex(), & mtx2);
BOOST_CHECK_EQUAL( lk2.mutex(), & mtx1);
}
__declspec(noinline) void makeChunkWritable(size_t chunkno) {
scoped_lock lk(mapViewMutex);
if( writable.get(chunkno) ) // double check lock
return;
// remap all maps in this chunk. common case is a single map, but could have more than one with smallfiles or .ns files
size_t chunkStart = chunkno * MemoryMappedFile::ChunkSize;
size_t chunkNext = chunkStart + MemoryMappedFile::ChunkSize;
scoped_lock lk2(privateViews._mutex());
map<void*,DurableMappedFile*>::iterator i = privateViews.finditer_inlock((void*) (chunkNext-1));
while( 1 ) {
const pair<void*,DurableMappedFile*> x = *(--i);
DurableMappedFile *mmf = x.second;
if( mmf == 0 )
break;
size_t viewStart = (size_t) x.first;
size_t viewEnd = (size_t) (viewStart + mmf->length());
if( viewEnd <= chunkStart )
break;
size_t protectStart = max(viewStart, chunkStart);
dassert(protectStart<chunkNext);
size_t protectEnd = min(viewEnd, chunkNext);
size_t protectSize = protectEnd - protectStart;
dassert(protectSize>0&&protectSize<=MemoryMappedFile::ChunkSize);
DWORD oldProtection;
bool ok = VirtualProtect( reinterpret_cast<void*>( protectStart ),
protectSize,
PAGE_WRITECOPY,
&oldProtection );
if ( !ok ) {
DWORD dosError = GetLastError();
log() << "VirtualProtect for " << mmf->filename()
<< " chunk " << chunkno
<< " failed with " << errnoWithDescription( dosError )
<< " (chunk size is " << protectSize
<< ", address is " << hex << protectStart << dec << ")"
<< " in mongo::makeChunkWritable, terminating"
<< endl;
fassertFailed( 16362 );
}
}
writable.set(chunkno);
}
BSONObj updateFail() {
BSONObjBuilder b;
{
mongo::mutex::scoped_lock lk2(OpTime::m);
b.appendTimestamp("ts", OpTime::now(lk2).asLL());
}
b.append("op", "u");
b.append("o", BSON("$set" << BSON("x" << 456)));
b.append("o2", BSON("_id" << 123 << "x" << 123));
b.append("ns", _ns);
BSONObj o = b.obj();
verify(!apply(o));
return o;
}
void try_lock_concept()
{
dummy_mutex mtx1, mtx2;
mtx2.lock();
boost::unique_lock< dummy_mutex > lk1( mtx1, boost::defer_lock),
lk2( mtx2, boost::defer_lock);
int res = boost::try_lock( lk1, lk2);
BOOST_CHECK( res == 1);
BOOST_CHECK( ! mtx1.is_locked);
BOOST_CHECK( mtx2.is_locked);
BOOST_CHECK( ! lk1.owns_lock() );
BOOST_CHECK( ! lk2.owns_lock() );
}
std::shared_ptr<Task> WSCoreBoundTaskQueue::stealTask() {
std::shared_ptr<Task> task = NULL;
// first check if status of thread is still ok; hold queueMutex, to avoid race conditions
std::lock_guard<std::mutex> lk1(_queueMutex);
// gather _threadStatusMutex, so thread cannot go to sleep
std::lock_guard<std::mutex> lk2(_threadStatusMutex);
// dont steal tasks if thread is about to stop
if (_status == RUN) {
// acquire queue mutex to check size and pop task
if (_runQueue.size() >= 1) {
task = _runQueue.back();
_runQueue.pop_back();
}
}
return task;
}
void transfer(int from, int to, int sum)
{
auto& acc1 = _accounts[from];
auto& acc2 = _accounts[to];
std::lock(acc1.get_mutex(), acc2.get_mutex());
lock_guard lk1(acc1.get_mutex(), std::adopt_lock);
lock_guard lk2(acc2.get_mutex(), std::adopt_lock);
std::cout << "Moving money from = " << from << " to = " << to << " sum = " << sum << "\n";
if (acc1.balance() >= sum)
{
acc1.deposit(-sum);
acc2.deposit(sum);
}
}
void lock_concept()
{
boost::fibers::mutex mtx1, mtx2, mtx3;
boost::fibers::mutex::scoped_lock lk1( mtx1, boost::defer_lock),
lk2( mtx2, boost::defer_lock),
lk3( mtx3, boost::defer_lock);
BOOST_CHECK( ! lk1.owns_lock() );
BOOST_CHECK( ! lk2.owns_lock() );
BOOST_CHECK( ! lk3.owns_lock() );
boost::lock( lk1, lk2, lk3);
BOOST_CHECK( lk1.owns_lock() );
BOOST_CHECK( lk2.owns_lock() );
BOOST_CHECK( lk3.owns_lock() );
}
TEST(unique_lock, swap) {
lockable_mock m1, m2;
ASSERT_FALSE(m1.locked());
ASSERT_FALSE(m2.locked());
{
unique_lock lk1(m1);
ASSERT_TRUE(lk1.locked());
ASSERT_TRUE(m1.locked());
{
unique_lock lk2;
ASSERT_FALSE(lk2.locked());
swap(lk1, lk2); // NOLINT
EXPECT_FALSE(lk1.locked());
EXPECT_TRUE(lk2.locked());
EXPECT_TRUE(m1.locked());
}
EXPECT_FALSE(lk1.locked());
EXPECT_FALSE(m1.locked());
}
{
unique_lock lk1(m1);
ASSERT_TRUE(lk1.locked());
ASSERT_TRUE(m1.locked());
{
unique_lock lk2(m2);
ASSERT_TRUE(lk2.locked());
swap(lk1, lk2); // NOLINT
EXPECT_TRUE(lk1.locked());
EXPECT_TRUE(lk2.locked());
EXPECT_TRUE(m1.locked());
EXPECT_TRUE(m2.locked());
}
EXPECT_TRUE(lk1.locked());
EXPECT_FALSE(m1.locked());
EXPECT_TRUE(m2.locked());
}
}
void WSCoreBoundQueuesScheduler::pushToQueue(std::shared_ptr<Task> task) {
int core = task->getPreferredCore();
if (core >= 0 && core < static_cast<int>(this->_queues)) {
// push task to queue that runs on given core
this->_taskQueues[core]->push(task);
LOG4CXX_DEBUG(this->_logger, "Task " << std::hex << (void *)task.get() << std::dec << " pushed to queue " << core);
} else if (core == Task::NO_PREFERRED_CORE || core >= static_cast<int>(this->_queues)) {
if (core < Task::NO_PREFERRED_CORE || core >= static_cast<int>(this->_queues))
// Tried to assign task to core which is not assigned to scheduler; assigned to other core, log warning
LOG4CXX_WARN(this->_logger, "Tried to assign task " << std::hex << (void *)task.get() << std::dec << " to core " << std::to_string(core) << " which is not assigned to scheduler; assigned it to next available core");
// push task to next queue
{
std::lock_guard<lock_t> lk2(this->_queuesMutex);
this->_taskQueues[this->_nextQueue]->push(task);
//std::cout << "Task " << task->vname() << "; hex " << std::hex << &task << std::dec << " pushed to queue " << this->_nextQueue << std::endl;
//round robin on cores
this->_nextQueue = (this->_nextQueue + 1) % this->_queues;
}
}
}
__declspec(noinline) void makeChunkWritable(size_t chunkno) {
scoped_lock lk(mapViewMutex);
if( writable.get(chunkno) ) // double check lock
return;
// remap all maps in this chunk. common case is a single map, but could have more than one with smallfiles or .ns files
size_t chunkStart = chunkno * MemoryMappedFile::ChunkSize;
size_t chunkNext = chunkStart + MemoryMappedFile::ChunkSize;
scoped_lock lk2(privateViews._mutex());
map<void*,MongoMMF*>::iterator i = privateViews.finditer_inlock((void*) (chunkNext-1));
while( 1 ) {
const pair<void*,MongoMMF*> x = *(--i);
MongoMMF *mmf = x.second;
if( mmf == 0 )
break;
size_t viewStart = (size_t) x.first;
size_t viewEnd = (size_t) (viewStart + mmf->length());
if( viewEnd <= chunkStart )
break;
size_t protectStart = max(viewStart, chunkStart);
dassert(protectStart<chunkNext);
size_t protectEnd = min(viewEnd, chunkNext);
size_t protectSize = protectEnd - protectStart;
dassert(protectSize>0&&protectSize<=MemoryMappedFile::ChunkSize);
DWORD old;
bool ok = VirtualProtect((void*)protectStart, protectSize, PAGE_WRITECOPY, &old);
if( !ok ) {
DWORD e = GetLastError();
log() << "VirtualProtect failed (mcw) " << mmf->filename() << ' ' << chunkno << hex << protectStart << ' ' << protectSize << ' ' << errnoWithDescription(e) << endl;
verify(false);
}
}
writable.set(chunkno);
}
// ##############################################################################################################
void jevois::Camera::streamOff()
{
JEVOIS_TRACE(2);
// Note: we allow for several streamOff() without complaining, this happens, e.g., when destroying a Camera that is
// not currently streaming.
LDEBUG("Turning off camera stream");
// Abort stream in case it was not already done, which will introduce some sleeping in our run() thread, thereby
// helping us acquire our needed double lock:
abortStream();
// We need a double lock here so that we can both turn off the stream and nuke our output image and done idx:
std::unique_lock<std::timed_mutex> lk1(itsMtx, std::defer_lock);
std::unique_lock<std::mutex> lk2(itsOutputMtx, std::defer_lock);
std::lock(lk1, lk2);
// Invalidate our output image:
itsOutputImage.invalidate();
// User may have called done() but our run() thread has not yet gotten to requeueing this image, if so requeue it here
// as it seems to keep the driver happier:
if (itsBuffers)
for (size_t idx : itsDoneIdx) try { itsBuffers->qbuf(idx); } catch (...) { jevois::warnAndIgnoreException(); }
itsDoneIdx.clear();
// Stop streaming at the device level:
int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
try { XIOCTL_QUIET(itsFd, VIDIOC_STREAMOFF, &type); } catch (...) { }
// Nuke all the buffers:
if (itsBuffers) { delete itsBuffers; itsBuffers = nullptr; }
// Unblock any get() that is waiting on itsOutputCondVar, it will then throw now that streaming is off:
lk2.unlock();
itsOutputCondVar.notify_all();
LDEBUG("Camera stream is off");
}
__FORCE_ALIGN_STACK__
static void WorkerLoop(int id)
{
SetThreadNum(id);
Threading::SetThreadName(IntToString(id, "worker%i"));
boost::shared_lock<boost::shared_mutex> lk(taskMutex, boost::defer_lock);
boost::mutex m;
boost::unique_lock<boost::mutex> lk2(m);
while (!exitThread) {
const auto spinlockStart = boost::chrono::high_resolution_clock::now() + boost::chrono::milliseconds(spinlockMs);
while (!DoTask(lk) && !exitThread) {
if (spinlockStart < boost::chrono::high_resolution_clock::now()) {
#ifndef BOOST_THREAD_USES_CHRONO
const boost::system_time timeout = boost::get_system_time() + boost::posix_time::microseconds(1);
newTasks.timed_wait(lk2, timeout);
#else
newTasks.wait_for(lk2, boost::chrono::nanoseconds(100));
#endif
}
}
}
}
__declspec(noinline) void makeChunkWritable(size_t chunkno) {
scoped_lock lk(mapViewMutex);
if( writable.get(chunkno) ) // double check lock
return;
// remap all maps in this chunk. common case is a single map, but could have more than one with smallfiles or .ns files
size_t chunkStart = chunkno * MemoryMappedFile::ChunkSize;
size_t chunkNext = chunkStart + MemoryMappedFile::ChunkSize;
scoped_lock lk2(privateViews._mutex());
map<void*,DurableMappedFile*>::iterator i = privateViews.finditer_inlock((void*) (chunkNext-1));
while( 1 ) {
const pair<void*,DurableMappedFile*> x = *(--i);
DurableMappedFile *mmf = x.second;
if( mmf == 0 )
break;
size_t viewStart = (size_t) x.first;
size_t viewEnd = (size_t) (viewStart + mmf->length());
if( viewEnd <= chunkStart )
break;
size_t protectStart = max(viewStart, chunkStart);
dassert(protectStart<chunkNext);
size_t protectEnd = min(viewEnd, chunkNext);
size_t protectSize = protectEnd - protectStart;
dassert(protectSize>0&&protectSize<=MemoryMappedFile::ChunkSize);
DWORD oldProtection;
bool ok = VirtualProtect( reinterpret_cast<void*>( protectStart ),
protectSize,
PAGE_WRITECOPY,
&oldProtection );
if ( !ok ) {
DWORD dosError = GetLastError();
if (dosError == ERROR_COMMITMENT_LIMIT) {
// System has run out of memory between physical RAM & page file, tell the user
BSONObjBuilder bb;
ProcessInfo p;
p.getExtraInfo(bb);
log() << "MongoDB has exhausted the system memory capacity.";
log() << "Current Memory Status: " << bb.obj().toString();
}
log() << "VirtualProtect for " << mmf->filename()
<< " chunk " << chunkno
<< " failed with " << errnoWithDescription( dosError )
<< " (chunk size is " << protectSize
<< ", address is " << hex << protectStart << dec << ")"
<< " in mongo::makeChunkWritable, terminating"
<< endl;
fassertFailed( 16362 );
}
}
writable.set(chunkno);
}
/* we write to local.oplog.$main:
{ ts : ..., op: ..., ns: ..., o: ... }
ts: an OpTime timestamp
op:
"i" insert
"u" update
"d" delete
"c" db cmd
"db" declares presence of a database (ns is set to the db name + '.')
"n" no op
logNS: where to log it. 0/null means "local.oplog.$main".
bb:
if not null, specifies a boolean to pass along to the other side as b: param.
used for "justOne" or "upsert" flags on 'd', 'u'
first: true
when set, indicates this is the first thing we have logged for this database.
thus, the slave does not need to copy down all the data when it sees this.
note this is used for single collection logging even when --replSet is enabled.
*/
static void _logOpOld(const char *opstr, const char *ns, const char *logNS, const BSONObj& obj, BSONObj *o2, bool *bb, bool fromMigrate ) {
Lock::DBWrite lk("local");
static BufBuilder bufbuilder(8*1024); // todo there is likely a mutex on this constructor
if ( strncmp(ns, "local.", 6) == 0 ) {
if ( strncmp(ns, "local.slaves", 12) == 0 ) {
resetSlaveCache();
}
return;
}
mutex::scoped_lock lk2(OpTime::m);
const OpTime ts = OpTime::now(lk2);
Client::Context context("",0,false);
/* we jump through a bunch of hoops here to avoid copying the obj buffer twice --
instead we do a single copy to the destination position in the memory mapped file.
*/
bufbuilder.reset();
BSONObjBuilder b(bufbuilder);
b.appendTimestamp("ts", ts.asDate());
b.append("op", opstr);
b.append("ns", ns);
if (fromMigrate)
b.appendBool("fromMigrate", true);
if ( bb )
b.appendBool("b", *bb);
if ( o2 )
b.append("o2", *o2);
BSONObj partial = b.done(); // partial is everything except the o:... part.
int po_sz = partial.objsize();
int len = po_sz + obj.objsize() + 1 + 2 /*o:*/;
Record *r;
if( logNS == 0 ) {
logNS = "local.oplog.$main";
if ( localOplogMainDetails == 0 ) {
Client::Context ctx( logNS , dbpath, false);
localDB = ctx.db();
verify( localDB );
localOplogMainDetails = nsdetails(logNS);
verify( localOplogMainDetails );
}
Client::Context ctx( logNS , localDB, false );
r = theDataFileMgr.fast_oplog_insert(localOplogMainDetails, logNS, len);
}
else {
Client::Context ctx( logNS, dbpath, false );
verify( nsdetails( logNS ) );
// first we allocate the space, then we fill it below.
r = theDataFileMgr.fast_oplog_insert( nsdetails( logNS ), logNS, len);
}
append_O_Obj(r->data(), partial, obj);
context.getClient()->setLastOp( ts );
if ( logLevel >= 6 ) {
BSONObj temp(r);
log( 6 ) << "logging op:" << temp << endl;
}
}
static void _logOpRS(const char *opstr, const char *ns, const char *logNS, const BSONObj& obj, BSONObj *o2, bool *bb, bool fromMigrate ) {
Lock::DBWrite lk1("local");
if ( strncmp(ns, "local.", 6) == 0 ) {
if ( strncmp(ns, "local.slaves", 12) == 0 )
resetSlaveCache();
return;
}
mutex::scoped_lock lk2(OpTime::m);
const OpTime ts = OpTime::now(lk2);
long long hashNew;
if( theReplSet ) {
massert(13312, "replSet error : logOp() but not primary?", theReplSet->box.getState().primary());
hashNew = (theReplSet->lastH * 131 + ts.asLL()) * 17 + theReplSet->selfId();
}
else {
// must be initiation
verify( *ns == 0 );
hashNew = 0;
}
/* we jump through a bunch of hoops here to avoid copying the obj buffer twice --
instead we do a single copy to the destination position in the memory mapped file.
*/
logopbufbuilder.reset();
BSONObjBuilder b(logopbufbuilder);
b.appendTimestamp("ts", ts.asDate());
b.append("h", hashNew);
b.append("op", opstr);
b.append("ns", ns);
if (fromMigrate)
b.appendBool("fromMigrate", true);
if ( bb )
b.appendBool("b", *bb);
if ( o2 )
b.append("o2", *o2);
BSONObj partial = b.done();
int posz = partial.objsize();
int len = posz + obj.objsize() + 1 + 2 /*o:*/;
Record *r;
DEV verify( logNS == 0 );
{
const char *logns = rsoplog;
if ( rsOplogDetails == 0 ) {
Client::Context ctx( logns , dbpath, false);
localDB = ctx.db();
verify( localDB );
rsOplogDetails = nsdetails(logns);
massert(13347, "local.oplog.rs missing. did you drop it? if so restart server", rsOplogDetails);
}
Client::Context ctx( logns , localDB, false );
r = theDataFileMgr.fast_oplog_insert(rsOplogDetails, logns, len);
/* todo: now() has code to handle clock skew. but if the skew server to server is large it will get unhappy.
this code (or code in now() maybe) should be improved.
*/
if( theReplSet ) {
if( !(theReplSet->lastOpTimeWritten<ts) ) {
log() << "replSet ERROR possible failover clock skew issue? " << theReplSet->lastOpTimeWritten << ' ' << ts << rsLog;
log() << "replSet " << theReplSet->isPrimary() << rsLog;
}
theReplSet->lastOpTimeWritten = ts;
theReplSet->lastH = hashNew;
ctx.getClient()->setLastOp( ts );
}
}
append_O_Obj(r->data(), partial, obj);
if ( logLevel >= 6 ) {
BSONObj temp(r);
log( 6 ) << "logOp:" << temp << endl;
}
}
static void _logOpRS(OperationContext* txn,
const char *opstr,
const char *ns,
const char *logNS,
const BSONObj& obj,
BSONObj *o2,
bool *bb,
bool fromMigrate ) {
Lock::DBLock lk1(txn->lockState(), "local", newlm::MODE_X);
WriteUnitOfWork wunit(txn);
if ( strncmp(ns, "local.", 6) == 0 ) {
if ( strncmp(ns, "local.slaves", 12) == 0 )
resetSlaveCache();
return;
}
ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator();
mutex::scoped_lock lk2(newOpMutex);
OpTime ts(getNextGlobalOptime());
newOptimeNotifier.notify_all();
long long hashNew = BackgroundSync::get()->getLastAppliedHash();
// Check to make sure logOp() is legal at this point.
if (*opstr == 'n') {
// 'n' operations are always logged
invariant(*ns == '\0');
// 'n' operations do not advance the hash, since they are not rolled back
}
else {
if (!replCoord->canAcceptWritesForDatabase(nsToDatabaseSubstring(ns))) {
severe() << "replSet error : logOp() but can't accept write to collection " << ns;
fassertFailed(17405);
}
// Advance the hash
hashNew = (hashNew * 131 + ts.asLL()) * 17 + replCoord->getMyId();
}
/* we jump through a bunch of hoops here to avoid copying the obj buffer twice --
instead we do a single copy to the destination position in the memory mapped file.
*/
logopbufbuilder.reset();
BSONObjBuilder b(logopbufbuilder);
b.appendTimestamp("ts", ts.asDate());
b.append("h", hashNew);
b.append("v", OPLOG_VERSION);
b.append("op", opstr);
b.append("ns", ns);
if (fromMigrate)
b.appendBool("fromMigrate", true);
if ( bb )
b.appendBool("b", *bb);
if ( o2 )
b.append("o2", *o2);
BSONObj partial = b.done();
DEV verify( logNS == 0 ); // check this was never a master/slave master
if ( localOplogRSCollection == 0 ) {
Client::Context ctx(txn, rsoplog);
localDB = ctx.db();
verify( localDB );
localOplogRSCollection = localDB->getCollection( txn, rsoplog );
massert(13347, "local.oplog.rs missing. did you drop it? if so restart server", localOplogRSCollection);
}
Client::Context ctx(txn, rsoplog, localDB);
OplogDocWriter writer( partial, obj );
checkOplogInsert( localOplogRSCollection->insertDocument( txn, &writer, false ) );
BackgroundSync::get()->setLastAppliedHash(hashNew);
ctx.getClient()->setLastOp( ts );
replCoord->setMyLastOptime(txn, ts);
wunit.commit();
}
static void _logOpOld(OperationContext* txn,
const char *opstr,
const char *ns,
const char *logNS,
const BSONObj& obj,
BSONObj *o2,
bool *bb,
bool fromMigrate ) {
Lock::DBLock lk(txn->lockState(), "local", newlm::MODE_X);
WriteUnitOfWork wunit(txn);
static BufBuilder bufbuilder(8*1024); // todo there is likely a mutex on this constructor
if ( strncmp(ns, "local.", 6) == 0 ) {
if ( strncmp(ns, "local.slaves", 12) == 0 ) {
resetSlaveCache();
}
return;
}
mutex::scoped_lock lk2(newOpMutex);
OpTime ts(getNextGlobalOptime());
newOptimeNotifier.notify_all();
/* we jump through a bunch of hoops here to avoid copying the obj buffer twice --
instead we do a single copy to the destination position in the memory mapped file.
*/
bufbuilder.reset();
BSONObjBuilder b(bufbuilder);
b.appendTimestamp("ts", ts.asDate());
b.append("op", opstr);
b.append("ns", ns);
if (fromMigrate)
b.appendBool("fromMigrate", true);
if ( bb )
b.appendBool("b", *bb);
if ( o2 )
b.append("o2", *o2);
BSONObj partial = b.done(); // partial is everything except the o:... part.
if( logNS == 0 ) {
logNS = "local.oplog.$main";
}
if ( localOplogMainCollection == 0 ) {
Client::Context ctx(txn, logNS);
localDB = ctx.db();
verify( localDB );
localOplogMainCollection = localDB->getCollection(txn, logNS);
verify( localOplogMainCollection );
}
Client::Context ctx(txn, logNS , localDB);
OplogDocWriter writer( partial, obj );
checkOplogInsert( localOplogMainCollection->insertDocument( txn, &writer, false ) );
ctx.getClient()->setLastOp( ts );
ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator();
replCoord->setMyLastOptime(txn, ts);
wunit.commit();
}
static void _logOpRS(OperationContext* txn,
const char *opstr,
const char *ns,
const char *logNS,
const BSONObj& obj,
BSONObj *o2,
bool *bb,
bool fromMigrate ) {
Lock::DBWrite lk1(txn->lockState(), "local");
WriteUnitOfWork wunit(txn);
if ( strncmp(ns, "local.", 6) == 0 ) {
if ( strncmp(ns, "local.slaves", 12) == 0 )
resetSlaveCache();
return;
}
mutex::scoped_lock lk2(newOpMutex);
OpTime ts(getNextGlobalOptime());
newOptimeNotifier.notify_all();
long long hashNew;
if( theReplSet ) {
if (!theReplSet->box.getState().primary()) {
log() << "replSet error : logOp() but not primary";
fassertFailed(17405);
}
hashNew = (theReplSet->lastH * 131 + ts.asLL()) * 17 + theReplSet->selfId();
}
else {
// must be initiation
verify( *ns == 0 );
hashNew = 0;
}
/* we jump through a bunch of hoops here to avoid copying the obj buffer twice --
instead we do a single copy to the destination position in the memory mapped file.
*/
logopbufbuilder.reset();
BSONObjBuilder b(logopbufbuilder);
b.appendTimestamp("ts", ts.asDate());
b.append("h", hashNew);
b.append("v", OPLOG_VERSION);
b.append("op", opstr);
b.append("ns", ns);
if (fromMigrate)
b.appendBool("fromMigrate", true);
if ( bb )
b.appendBool("b", *bb);
if ( o2 )
b.append("o2", *o2);
BSONObj partial = b.done();
DEV verify( logNS == 0 ); // check this was never a master/slave master
if ( localOplogRSCollection == 0 ) {
Client::Context ctx(txn, rsoplog);
localDB = ctx.db();
verify( localDB );
localOplogRSCollection = localDB->getCollection( txn, rsoplog );
massert(13347, "local.oplog.rs missing. did you drop it? if so restart server", localOplogRSCollection);
}
Client::Context ctx(txn, rsoplog, localDB);
OplogDocWriter writer( partial, obj );
checkOplogInsert( localOplogRSCollection->insertDocument( txn, &writer, false ) );
/* todo: now() has code to handle clock skew. but if the skew server to server is large it will get unhappy.
this code (or code in now() maybe) should be improved.
*/
if( theReplSet ) {
if( !(theReplSet->lastOpTimeWritten<ts) ) {
log() << "replication oplog stream went back in time. previous timestamp: "
<< theReplSet->lastOpTimeWritten << " newest timestamp: " << ts
<< ". attempting to sync directly from primary." << endl;
BSONObjBuilder result;
Status status = theReplSet->forceSyncFrom(theReplSet->box.getPrimary()->fullName(),
&result);
if (!status.isOK()) {
log() << "Can't sync from primary: " << status;
}
}
theReplSet->lastOpTimeWritten = ts;
theReplSet->lastH = hashNew;
ctx.getClient()->setLastOp( ts );
}
wunit.commit();
}