void MainWin::Play() { printf("Playing.\n"); if (sp && sp->HasData()) { sp->Start(); return; } printf("Starting at position %d.\n", (int) position); status_t err; LibraryItem *item = dynamic_cast<LibraryItem *>(be_app->library->list->ItemAt(position)); printf("Playing track %s.\n", item->entry.name); mediaFile = new BMediaFile(&item->entry); if ((err = mediaFile->InitCheck()) != B_OK) { printf("Play: Initiating media file failed: %s; skipping.\n", strerror(err)); delete mediaFile; Next(); return; } playTrack = 0; for (int i = 0; i < mediaFile->CountTracks(); i++) { playTrack = mediaFile->TrackAt(i); playFormat.type = B_MEDIA_RAW_AUDIO; if (playTrack->DecodedFormat(&playFormat) == B_OK) break; if (playTrack) mediaFile->ReleaseTrack(playTrack); } if (playTrack) { sp = new BSoundPlayer(&playFormat.u.raw_audio, "playfile", PlayBuffer, Notifier); sp->SetCookie(this); sp->SetVolume(1.0f); sp->SetHasData(true); sp->Start(); char timestamp[100]; Timestamp(timestamp, playTrack->Duration()); progress->Reset(NULL, timestamp); progress->SetMaxValue(playTrack->Duration()); BMessage *select = new BMessage(MSG_LIBRARY_HIGHLIGHT); select->AddUInt32("position", position); be_app->library->PostMessage(select); printf("Playback started.\n"); } else { printf("ERROR: No valid track found. Skipping.\n"); Next(); } }
bool Condition::safeWait(const Mutex& mutex, double seconds) const { bool result = true; Thread* self = 0; try { self = &Threads::getInstance().getSelf(); } catch (...) { self = 0; } Thread::State threadState; if (self) { if (&mutex == &self->mMutex) threadState = self->safeSetState(Thread::waiting); else threadState = self->setState(Thread::waiting); } if (seconds == Timer::eternal()) result = safeEternalWait(mutex); else if (seconds > 0.0) result = safeWaitUntil(mutex, Timestamp(Timestamp::now() + seconds)); if (self) { if (&mutex == &self->mMutex) self->safeSetState(threadState); else self->setState(threadState); } return result; }
bool _testOplogEntryIsForCappedCollection(OperationContext* txn, const NamespaceString& nss, const CollectionOptions& options) { auto writerPool = SyncTail::makeWriterPool(); MultiApplier::Operations operationsApplied; auto applyOperationFn = [&operationsApplied](MultiApplier::OperationPtrs* operationsToApply) { for (auto&& opPtr : *operationsToApply) { operationsApplied.push_back(*opPtr); } }; createCollection(txn, nss, options); auto op = makeInsertDocumentOplogEntry({Timestamp(Seconds(1), 0), 1LL}, nss, BSON("a" << 1)); ASSERT_FALSE(op.isForCappedCollection); auto lastOpTime = unittest::assertGet(multiApply(txn, writerPool.get(), {op}, applyOperationFn)); ASSERT_EQUALS(op.getOpTime(), lastOpTime); ASSERT_EQUALS(1U, operationsApplied.size()); const auto& opApplied = operationsApplied.front(); ASSERT_EQUALS(op, opApplied); // "isForCappedCollection" is not parsed from raw oplog entry document. return opApplied.isForCappedCollection; }
TEST_F(SyncTailTest, MultiApplyReturnsBadValueOnNullOperationContext) { auto writerPool = SyncTail::makeWriterPool(); auto op = makeCreateCollectionOplogEntry({Timestamp(Seconds(1), 0), 1LL}); auto status = multiApply(nullptr, writerPool.get(), {op}, noopApplyOperationFn).getStatus(); ASSERT_EQUALS(ErrorCodes::BadValue, status); ASSERT_STRING_CONTAINS(status.reason(), "invalid operation context"); }
Mp3PspStream::Mp3PspStream(Common::SeekableReadStream *inStream, DisposeAfterUse::Flag dispose) : _inStream(inStream), _disposeAfterUse(dispose), _pcmLength(0), _posInFrame(0), _state(MP3_STATE_INIT), _length(0, 1000), _sampleRate(0), _totalTime(mad_timer_zero) { DEBUG_ENTER_FUNC(); assert(_decoderInit); // must be initialized by now // let's leave the buffer guard -- who knows, it may be good? memset(_buf, 0, sizeof(_buf)); memset(_codecInBuffer, 0, sizeof(_codecInBuffer)); initStream(); // init needed stuff for the stream findValidHeader(); // get a first header so we can read basic stuff _sampleRate = _header.samplerate; // copy it before it gets destroyed _stereo = (MAD_NCHANNELS(&_header) == 2); while (_state != MP3_STATE_EOS) findValidHeader(); // get a first header so we can read basic stuff _length = Timestamp(mad_timer_count(_totalTime, MAD_UNITS_MILLISECONDS), getRate()); deinitStream(); _state = MP3_STATE_INIT; }
TEST_F(KeysManagerShardedTest, GetKeyForValidationErrorsIfKeyDoesntExist) { keyManager()->startMonitoring(getServiceContext()); auto keyStatus = keyManager()->getKeyForValidation(operationContext(), 1, LogicalTime(Timestamp(100, 0))); ASSERT_EQ(ErrorCodes::KeyNotFound, keyStatus.getStatus()); }
void testObj::test<6>(void) { Persistency::MetaAlertPtrNN maPtr( new Persistency::MetaAlert( Persistency::MetaAlert::Name(name_), 0.1, 0.2, makeNewReferenceURL().shared_ptr(), Timestamp(), 42u ) ); Persistency::IO::Postgres::MetaAlert malert(maPtr, t_, dbh_); malert.save(); const DataBaseID malertID = dbh_->getIDCache()->get( maPtr ); double delta = 0.1; stringstream ss; ss << "SELECT * FROM meta_alerts WHERE id = " << malertID << ";"; { const result r = t_.getAPI<TransactionAPI>().exec(ss); ensure_equals("invalid size",r.size(), 1u); ensure_equals("invalid certainty delta", ReaderHelper<double>::readAsNotNull(r[0]["certainty_delta"]), 0.2); } malert.updateCertaintyDelta(delta); { const result r = t_.getAPI<TransactionAPI>().exec(ss); ensure_equals("invalid size",r.size(), 1u); ensure("invalid certainty delta", ( ReaderHelper<double>::readAsNotNull(r[0]["certainty_delta"]) - (0.2+delta) ) < 0.01 ); } t_.commit(); }
Status ModifierCurrentDate::apply() const { const bool destExists = (_preparedState->elemFound.ok() && _preparedState->idxFound == (_updatePath.numParts() - 1)); mutablebson::Document& doc = _preparedState->doc; StringData lastPart = _updatePath.getPart(_updatePath.numParts() - 1); // If the element exists and is the same type, then that is what we want to work with mutablebson::Element elemToSet = destExists ? _preparedState->elemFound : doc.end(); if (!destExists) { // Creates the final element that's going to be $set in 'doc'. // fills in the value with place-holder/empty elemToSet = _typeIsDate ? doc.makeElementDate(lastPart, Date_t()) : doc.makeElementTimestamp(lastPart, Timestamp()); if (!elemToSet.ok()) { return Status(ErrorCodes::InternalError, "can't create new element"); } // Now, we can be in two cases here, as far as attaching the element being set goes: // (a) none of the parts in the element's path exist, or (b) some parts of the path // exist but not all. if (!_preparedState->elemFound.ok()) { _preparedState->elemFound = doc.root(); _preparedState->idxFound = 0; } else { _preparedState->idxFound++; } // createPathAt() will complete the path and attach 'elemToSet' at the end of it. Status s = pathsupport::createPathAt( _updatePath, _preparedState->idxFound, _preparedState->elemFound, elemToSet) .getStatus(); if (!s.isOK()) return s; } dassert(elemToSet.ok()); // By the time we are here the element is in place and we just need to update the value if (_typeIsDate) { const mongo::Date_t now = mongo::jsTime(); Status s = elemToSet.setValueDate(now); if (!s.isOK()) return s; } else { ServiceContext* service = getGlobalServiceContext(); auto ts = LogicalClock::get(service)->reserveTicks(1).asTimestamp(); Status s = elemToSet.setValueTimestamp(ts); if (!s.isOK()) return s; } // Set the elemFound, idxFound to the changed element for oplog logging. _preparedState->elemFound = elemToSet; _preparedState->idxFound = (_updatePath.numParts() - 1); return Status::OK(); }
void PeersManager::dumpConnectionMap() { // 这里上锁仅仅是为了锁住对ApplicationData的访问 cacti::RecursiveMutex::ScopedLock sclock(m_applock); m_connMap.info("\n%s:\n", Timestamp::getNowTime().getFormattedTime("%m%d %H:%M:%S").c_str()); std::map<u32, ApplicationData>::iterator it = m_applications.begin(); while(it != m_applications.end()) { ApplicationData& ad = it->second; m_connMap.info("[%d, %s] \n", ad.m_appid, ad.m_appName.c_str()); m_connMap.info("\t addr=%s|%s:%d\n", ad.m_primAddress.c_str(), ad.m_backAddress.c_str(), ad.m_connectPort); m_connMap.info("\t pasv=%08X\n", ad.m_passiveConnection); m_connMap.info("\t svrs="); u32 starttime = 0; for(size_t i=0; i<ad.m_activeServices.size(); ++i) { m_connMap.info("%d ", ad.m_activeServices[i]); starttime = ad.m_starttimes[ad.m_activeServices[i]]; } m_connMap.info("\n\t boot timestamp:%s\n", Timestamp((time_t)starttime).getFormattedTime("%Y%m%d %H:%M:%S").c_str()); ++it; } // check anonymous for(size_t i=0; i<m_anonymousApps.size(); ++i) { ApplicationData& ad = m_anonymousApps[i]; m_connMap.info("[%d, %s] \n", ad.m_appid, ad.m_appName.c_str()); m_connMap.info("\t addr=%s|%s:%d\n", ad.m_primAddress.c_str(), ad.m_backAddress.c_str(), ad.m_connectPort); m_connMap.info("\t pasv=%08X\n", ad.m_passiveConnection); m_connMap.info("\t svrs="); u32 starttime = 0; for(size_t i=0; i<ad.m_activeServices.size(); ++i) { m_connMap.info("%d ", ad.m_activeServices[i]); starttime = ad.m_starttimes[ad.m_activeServices[i]]; } m_connMap.info("\n\t boot timestamp:%s\n", Timestamp((time_t)starttime).getFormattedTime("%Y%m%d %H:%M:%S").c_str()); } }
TEST_F(OplogBufferCollectionTest, extractEmbeddedOplogDocumentChangesIdToTimestamp) { auto nss = makeNamespace(_agent); OplogBufferCollection oplogBuffer(_storageInterface, nss); const BSONObj expectedOp = makeOplogEntry(1); BSONObj originalOp = BSON("_id" << Timestamp(1, 1) << "entry" << expectedOp); ASSERT_BSONOBJ_EQ(expectedOp, OplogBufferCollection::extractEmbeddedOplogDocument(originalOp)); }
TEST_F(KeyGeneratorUpdateTest, ShouldCreateAnotherKeyIfOnlyOneKeyExists) { KeyGenerator generator("dummy", catalogClient(), Seconds(5)); LogicalClock::get(operationContext()) ->setClusterTimeFromTrustedSource(LogicalTime(Timestamp(100, 2))); KeysCollectionDocument origKey1( 1, "dummy", TimeProofService::generateRandomKey(), LogicalTime(Timestamp(105, 0))); ASSERT_OK(insertToConfigCollection( operationContext(), KeysCollectionDocument::ConfigNS, origKey1.toBSON())); { auto allKeys = getKeys(operationContext()); ASSERT_EQ(1u, allKeys.size()); const auto& key1 = allKeys.front(); ASSERT_EQ(1, key1.getKeyId()); ASSERT_EQ("dummy", key1.getPurpose()); ASSERT_EQ(Timestamp(105, 0), key1.getExpiresAt().asTimestamp()); } auto currentTime = LogicalClock::get(operationContext())->getClusterTime(); auto generateStatus = generator.generateNewKeysIfNeeded(operationContext()); ASSERT_OK(generateStatus); { auto allKeys = getKeys(operationContext()); ASSERT_EQ(2u, allKeys.size()); const auto& key1 = allKeys.front(); ASSERT_EQ(1, key1.getKeyId()); ASSERT_EQ("dummy", key1.getPurpose()); ASSERT_EQ(origKey1.getKey(), key1.getKey()); ASSERT_EQ(Timestamp(105, 0), key1.getExpiresAt().asTimestamp()); const auto& key2 = allKeys.back(); ASSERT_EQ(currentTime.asTimestamp().asLL(), key2.getKeyId()); ASSERT_EQ("dummy", key2.getPurpose()); ASSERT_EQ(Timestamp(110, 0), key2.getExpiresAt().asTimestamp()); ASSERT_NE(key1.getKey(), key2.getKey()); } }
MetaAlertPtrNN makeNewMetaAlert(const char *name, const unsigned int id) { return MetaAlertPtrNN( new MetaAlert( MetaAlert::Name(name), 0.1, 0.2, makeNewReferenceURL().shared_ptr(), Timestamp(), id ) ); }
TEST_F(SyncTailTest, MultiSyncApplyGroupsInsertOperationByNamespaceBeforeApplying) { int seconds = 0; auto makeOp = [&seconds](const NamespaceString& nss) { return makeInsertDocumentOplogEntry( {Timestamp(Seconds(seconds), 0), 1LL}, nss, BSON("_id" << seconds++)); }; NamespaceString nss1("test." + _agent.getSuiteName() + "_" + _agent.getTestName() + "_1"); NamespaceString nss2("test." + _agent.getSuiteName() + "_" + _agent.getTestName() + "_2"); auto createOp1 = makeCreateCollectionOplogEntry({Timestamp(Seconds(seconds++), 0), 1LL}, nss1); auto createOp2 = makeCreateCollectionOplogEntry({Timestamp(Seconds(seconds++), 0), 1LL}, nss2); auto insertOp1a = makeOp(nss1); auto insertOp1b = makeOp(nss1); auto insertOp2a = makeOp(nss2); auto insertOp2b = makeOp(nss2); MultiApplier::Operations operationsApplied; auto syncApply = [&operationsApplied](OperationContext*, const BSONObj& op, bool) { operationsApplied.push_back(OplogEntry(op)); return Status::OK(); }; MultiApplier::OperationPtrs ops = { &createOp1, &createOp2, &insertOp1a, &insertOp2a, &insertOp1b, &insertOp2b}; ASSERT_OK(multiSyncApply_noAbort(_txn.get(), &ops, syncApply)); ASSERT_EQUALS(4U, operationsApplied.size()); ASSERT_EQUALS(createOp1, operationsApplied[0]); ASSERT_EQUALS(createOp2, operationsApplied[1]); // Check grouped insert operations in namespace "nss1". ASSERT_EQUALS(insertOp1a.getOpTime(), operationsApplied[2].getOpTime()); ASSERT_EQUALS(insertOp1a.ns, operationsApplied[2].ns); ASSERT_EQUALS(BSONType::Array, operationsApplied[2].o.type()); auto group1 = operationsApplied[2].o.Array(); ASSERT_EQUALS(2U, group1.size()); ASSERT_EQUALS(insertOp1a.o.Obj(), group1[0].Obj()); ASSERT_EQUALS(insertOp1b.o.Obj(), group1[1].Obj()); // Check grouped insert operations in namespace "nss2". ASSERT_EQUALS(insertOp2a.getOpTime(), operationsApplied[3].getOpTime()); ASSERT_EQUALS(insertOp2a.ns, operationsApplied[3].ns); ASSERT_EQUALS(BSONType::Array, operationsApplied[3].o.type()); auto group2 = operationsApplied[3].o.Array(); ASSERT_EQUALS(2U, group2.size()); ASSERT_EQUALS(insertOp2a.o.Obj(), group2[0].Obj()); ASSERT_EQUALS(insertOp2b.o.Obj(), group2[1].Obj()); }
TEST_F(SyncTailTest, MultiApplyReturnsBadValueOnNullApplyOperation) { auto writerPool = SyncTail::makeWriterPool(); MultiApplier::ApplyOperationFn nullApplyOperationFn; auto op = makeCreateCollectionOplogEntry({Timestamp(Seconds(1), 0), 1LL}); auto status = multiApply(_txn.get(), writerPool.get(), {op}, nullApplyOperationFn).getStatus(); ASSERT_EQUALS(ErrorCodes::BadValue, status); ASSERT_STRING_CONTAINS(status.reason(), "invalid apply operation function"); }
Timestamp getNextGlobalTimestamp() { stdx::lock_guard<stdx::mutex> lk(globalTimestampMutex); const unsigned now = (unsigned)time(0); const unsigned globalSecs = globalTimestamp.getSecs(); if (globalSecs == now) { globalTimestamp = Timestamp(globalSecs, globalTimestamp.getInc() + 1); } else if (now < globalSecs) { globalTimestamp = Timestamp(globalSecs, globalTimestamp.getInc() + 1); // separate function to keep out of the hot code path fassert(17449, !skewed(globalTimestamp)); } else { globalTimestamp = Timestamp(now, 1); } return globalTimestamp; }
void WiredTigerSnapshotManager::beginTransactionOnOplog(WiredTigerOplogManager* oplogManager, WT_SESSION* session) const { invariantWTOK(session->begin_transaction(session, nullptr)); auto rollbacker = MakeGuard([&] { invariant(session->rollback_transaction(session, nullptr) == 0); }); auto allCommittedTimestamp = oplogManager->getOplogReadTimestamp(); invariant(Timestamp(static_cast<unsigned long long>(allCommittedTimestamp)).asULL() == allCommittedTimestamp); auto status = setTransactionReadTimestamp( Timestamp(static_cast<unsigned long long>(allCommittedTimestamp)), session, true /* roundToOldest */); fassert(50771, status); rollbacker.Dismiss(); }
Timestamp Timestamp::now() { struct timeval tv; gettimeofday(&tv, NULL); time_t seconds = tv.tv_sec; return Timestamp(seconds * kAccuracyPerSecond + tv.tv_usec); }
TEST_F(KeysManagerShardedTest, GetKeyForValidationTimesOutIfRefresherIsNotRunning) { operationContext()->setDeadlineAfterNowBy(Microseconds(250 * 1000), ErrorCodes::ExceededTimeLimit); ASSERT_THROWS( keyManager()->getKeyForValidation(operationContext(), 1, LogicalTime(Timestamp(100, 0))), DBException); }
// Test timestamp TEST(FTDCCompressor, TestTimeStamp) { TestTie c; BSONObjBuilder builder1; BSONObj o = builder1.append("ts", Timestamp(0x55667788LL, 0x11223344LL)).obj(); auto st = c.addSample(o); ASSERT_HAS_SPACE(st); }
TEST_F(KeysManagerShardedTest, GetKeyWithSingleKey) { keyManager()->startMonitoring(getServiceContext()); KeysCollectionDocument origKey1( 1, "dummy", TimeProofService::generateRandomKey(), LogicalTime(Timestamp(105, 0))); ASSERT_OK(insertToConfigCollection( operationContext(), KeysCollectionDocument::ConfigNS, origKey1.toBSON())); auto keyStatus = keyManager()->getKeyForValidation(operationContext(), 1, LogicalTime(Timestamp(100, 0))); ASSERT_OK(keyStatus.getStatus()); auto key = keyStatus.getValue(); ASSERT_EQ(1, key.getKeyId()); ASSERT_EQ(origKey1.getKey(), key.getKey()); ASSERT_EQ(Timestamp(105, 0), key.getExpiresAt().asTimestamp()); }
void CMakeGifDoc::saveGif(const String &fileName) { if(m_gif == NULL) { return; } ::saveGif(ByteOutputFile(fileName), m_gif); setDocName(fileName); setSaveTime(Timestamp()); }
TEST_F(KeysManagerShardedTest, GetKeyForValidationTimesOutIfRefresherIsNotRunning) { operationContext()->setDeadlineAfterNowBy(Microseconds(250 * 1000)); ASSERT_THROWS(keyManager() ->getKeyForValidation(operationContext(), 1, LogicalTime(Timestamp(100, 0))) .status_with_transitional_ignore(), DBException); }
TEST_F(CacheReaderTest, RefreshCanIncrementallyGetNewKeys) { auto catalogClient = Grid::get(operationContext())->catalogClient(operationContext()); KeysCollectionCacheReader reader("test", catalogClient); KeysCollectionDocument origKey0( 0, "test", TimeProofService::generateRandomKey(), LogicalTime(Timestamp(100, 0))); ASSERT_OK(insertToConfigCollection( operationContext(), NamespaceString(KeysCollectionDocument::ConfigNS), origKey0.toBSON())); { auto refreshStatus = reader.refresh(operationContext()); ASSERT_OK(refreshStatus.getStatus()); auto key = refreshStatus.getValue(); ASSERT_EQ(0, key.getKeyId()); ASSERT_EQ(origKey0.getKey(), key.getKey()); ASSERT_EQ("test", key.getPurpose()); ASSERT_EQ(Timestamp(100, 0), key.getExpiresAt().asTimestamp()); auto keyStatus = reader.getKey(LogicalTime(Timestamp(112, 1))); ASSERT_EQ(ErrorCodes::KeyNotFound, keyStatus.getStatus()); } KeysCollectionDocument origKey1( 1, "test", TimeProofService::generateRandomKey(), LogicalTime(Timestamp(105, 0))); ASSERT_OK(insertToConfigCollection( operationContext(), NamespaceString(KeysCollectionDocument::ConfigNS), origKey1.toBSON())); KeysCollectionDocument origKey2( 2, "test", TimeProofService::generateRandomKey(), LogicalTime(Timestamp(110, 0))); ASSERT_OK(insertToConfigCollection( operationContext(), NamespaceString(KeysCollectionDocument::ConfigNS), origKey2.toBSON())); { auto refreshStatus = reader.refresh(operationContext()); ASSERT_OK(refreshStatus.getStatus()); auto key = refreshStatus.getValue(); ASSERT_EQ(2, key.getKeyId()); ASSERT_EQ(origKey2.getKey(), key.getKey()); ASSERT_EQ("test", key.getPurpose()); ASSERT_EQ(Timestamp(110, 0), key.getExpiresAt().asTimestamp()); } { auto keyStatus = reader.getKey(LogicalTime(Timestamp(108, 1))); auto key = keyStatus.getValue(); ASSERT_EQ(2, key.getKeyId()); ASSERT_EQ(origKey2.getKey(), key.getKey()); ASSERT_EQ("test", key.getPurpose()); ASSERT_EQ(Timestamp(110, 0), key.getExpiresAt().asTimestamp()); } }
Timestamp MixerImpl::getElapsedTime(SoundHandle handle) { Common::StackLock lock(_mutex); const int index = handle._val % NUM_CHANNELS; if (!_channels[index] || _channels[index]->getHandle()._val != handle._val) return Timestamp(0, _sampleRate); return _channels[index]->getElapsedTime(); }
Timestamp WiredTigerRecoveryUnit::_beginTransactionAtAllCommittedTimestamp(WT_SESSION* session) { WiredTigerBeginTxnBlock txnOpen(session, _ignorePrepared); Timestamp txnTimestamp = Timestamp(_oplogManager->fetchAllCommittedValue(session->connection)); auto status = txnOpen.setTimestamp(txnTimestamp, WiredTigerBeginTxnBlock::RoundToOldest::kRound); fassert(50948, status); // Since this is not in a critical section, we might have rounded to oldest between // calling getAllCommitted and setTimestamp. We need to get the actual read timestamp we // used. char buf[(2 * 8 /*bytes in hex*/) + 1 /*nul terminator*/]; auto wtstatus = session->query_timestamp(session, buf, "get=read"); invariantWTOK(wtstatus); uint64_t read_timestamp; fassert(50949, parseNumberFromStringWithBase(buf, 16, &read_timestamp)); txnOpen.done(); return Timestamp(read_timestamp); }
void WiredTigerRecoveryUnit::_txnClose(bool commit) { invariant(_isActive(), toString(_state)); WT_SESSION* s = _session->getSession(); if (_timer) { const int transactionTime = _timer->millis(); // `serverGlobalParams.slowMs` can be set to values <= 0. In those cases, give logging a // break. if (transactionTime >= std::max(1, serverGlobalParams.slowMS)) { LOG(kSlowTransactionSeverity) << "Slow WT transaction. Lifetime of SnapshotId " << _mySnapshotId << " was " << transactionTime << "ms"; } } int wtRet; if (commit) { if (!_commitTimestamp.isNull()) { const std::string conf = "commit_timestamp=" + integerToHex(_commitTimestamp.asULL()); invariantWTOK(s->timestamp_transaction(s, conf.c_str())); _isTimestamped = true; } wtRet = s->commit_transaction(s, nullptr); LOG(3) << "WT commit_transaction for snapshot id " << _mySnapshotId; } else { wtRet = s->rollback_transaction(s, nullptr); invariant(!wtRet); LOG(3) << "WT rollback_transaction for snapshot id " << _mySnapshotId; } if (_isTimestamped) { if (!_orderedCommit) { // We only need to update oplog visibility where commits can be out-of-order with // respect to their assigned optime and such commits might otherwise be visible. // This should happen only on primary nodes. _oplogManager->triggerJournalFlush(); } _isTimestamped = false; } invariantWTOK(wtRet); invariant(!_lastTimestampSet || _commitTimestamp.isNull(), str::stream() << "Cannot have both a _lastTimestampSet and a " "_commitTimestamp. _lastTimestampSet: " << _lastTimestampSet->toString() << ". _commitTimestamp: " << _commitTimestamp.toString()); // We reset the _lastTimestampSet between transactions. Since it is legal for one // transaction on a RecoveryUnit to call setTimestamp() and another to call // setCommitTimestamp(). _lastTimestampSet = boost::none; _prepareTimestamp = Timestamp(); _mySnapshotId = nextSnapshotId.fetchAndAdd(1); _isOplogReader = false; _orderedCommit = true; // Default value is true; we assume all writes are ordered. }
RawStream(int rate, bool stereo, DisposeAfterUse::Flag disposeStream, Common::SeekableReadStream *stream) : _rate(rate), _isStereo(stereo), _playtime(0, rate), _stream(stream, disposeStream), _endOfData(false), _buffer(0) { // Setup our buffer for readBuffer _buffer = new byte[kSampleBufferLength * (is16Bit ? 2 : 1)]; assert(_buffer); // Calculate the total playtime of the stream _playtime = Timestamp(0, _stream->size() / (_isStereo ? 2 : 1) / (is16Bit ? 2 : 1), rate); }
TEST_F(KeysManagerShardedTest, GetKeyForSigningShouldReturnRightKey) { keyManager()->startMonitoring(getServiceContext()); KeysCollectionDocument origKey1( 1, "dummy", TimeProofService::generateRandomKey(), LogicalTime(Timestamp(105, 0))); ASSERT_OK(insertToConfigCollection( operationContext(), NamespaceString(KeysCollectionDocument::ConfigNS), origKey1.toBSON())); keyManager()->refreshNow(operationContext()); auto keyStatus = keyManager()->getKeyForSigning(nullptr, LogicalTime(Timestamp(100, 0))); ASSERT_OK(keyStatus.getStatus()); auto key = keyStatus.getValue(); ASSERT_EQ(1, key.getKeyId()); ASSERT_EQ(origKey1.getKey(), key.getKey()); ASSERT_EQ(Timestamp(105, 0), key.getExpiresAt().asTimestamp()); }
FvUInt64 MySqlThreadResPool::StopThreadTaskTiming( MySqlThreadData& threadData ) { FvUInt64 opDuration = Timestamp() - threadData.m_uiStartTimestamp; m_uiOPDurationTotal += opDuration; ++m_uiOPCount; threadData.m_uiStartTimestamp = 0; return opDuration; }
TEST_F(KeysManagerShardedTest, ShouldNotReturnKeysInFeatureCompatibilityVersion34) { serverGlobalParams.featureCompatibility.version.store( ServerGlobalParams::FeatureCompatibility::Version::k34); keyManager()->startMonitoring(getServiceContext()); keyManager()->enableKeyGenerator(operationContext(), true); KeysCollectionDocument origKey( 1, "dummy", TimeProofService::generateRandomKey(), LogicalTime(Timestamp(105, 0))); ASSERT_OK(insertToConfigCollection( operationContext(), NamespaceString(KeysCollectionDocument::ConfigNS), origKey.toBSON())); keyManager()->refreshNow(operationContext()); auto keyStatus = keyManager()->getKeyForValidation(operationContext(), 1, LogicalTime(Timestamp(100, 0))); ASSERT_EQ(ErrorCodes::KeyNotFound, keyStatus.getStatus()); }