TEST(Deadlock, Simple) {
const ResourceId resIdA(RESOURCE_DATABASE, std::string("A"));
const ResourceId resIdB(RESOURCE_DATABASE, std::string("B"));
LockerForTests locker1(MODE_IX);
LockerForTests locker2(MODE_IX);
ASSERT_EQUALS(LOCK_OK, locker1.lockBegin(nullptr, resIdA, MODE_X));
ASSERT_EQUALS(LOCK_OK, locker2.lockBegin(nullptr, resIdB, MODE_X));
// 1 -> 2
ASSERT_EQUALS(LOCK_WAITING, locker1.lockBegin(nullptr, resIdB, MODE_X));
// 2 -> 1
ASSERT_EQUALS(LOCK_WAITING, locker2.lockBegin(nullptr, resIdA, MODE_X));
DeadlockDetector wfg1(*getGlobalLockManager(), &locker1);
ASSERT(wfg1.check().hasCycle());
DeadlockDetector wfg2(*getGlobalLockManager(), &locker2);
ASSERT(wfg2.check().hasCycle());
// Cleanup, so that LockerImpl doesn't complain about leaked locks
locker1.unlock(resIdB);
locker2.unlock(resIdA);
}
Structure* ExampleSearch::replaceWithRandom(Structure *s,
const QString & reason)
{
QWriteLocker locker1 (s->lock());
// Generate/Check new structure
Structure *structure = generateRandomStructure();
// Copy info over
QWriteLocker locker2 (structure->lock());
s->copyStructure(*structure);
s->resetEnergy();
s->resetEnthalpy();
s->setPV(0);
s->setCurrentOptStep(1);
QString parents = "Randomly generated";
if (!reason.isEmpty())
parents += " (" + reason + ")";
s->setParents(parents);
s->resetFailCount();
// Delete random structure
structure->deleteLater();
return s;
}
void PrerenderThread::run()
{
setPriority(QThread::IdlePriority);
bool restart = true;
while(restart)
{
restart = false;
for(int i = std::max(0, m_currentPage - 2); i < std::min(m_pagecount, m_currentPage + 10); ++i)
{
{
QMutexLocker locker(&m_stopmutex);
if(m_bStop)
return;
if(m_bViewingPage)
{
m_bViewingPage = false;
restart = true;
break;
}
}
while(m_bPause)
sleep(1);
m_sdoc->page(i)->render_page(m_settings->resolution(), 1.0);
}
QMutexLocker locker2(&m_stopmutex);
m_bSelfStop = true;
}
}
TEST(Deadlock, Indirect) {
const ResourceId resIdA(RESOURCE_DATABASE, std::string("A"));
const ResourceId resIdB(RESOURCE_DATABASE, std::string("B"));
LockerForTests locker1(MODE_IX);
LockerForTests locker2(MODE_IX);
LockerForTests lockerIndirect(MODE_IX);
ASSERT_EQUALS(LOCK_OK, locker1.lockBegin(nullptr, resIdA, MODE_X));
ASSERT_EQUALS(LOCK_OK, locker2.lockBegin(nullptr, resIdB, MODE_X));
// 1 -> 2
ASSERT_EQUALS(LOCK_WAITING, locker1.lockBegin(nullptr, resIdB, MODE_X));
// 2 -> 1
ASSERT_EQUALS(LOCK_WAITING, locker2.lockBegin(nullptr, resIdA, MODE_X));
// 3 -> 2
ASSERT_EQUALS(LOCK_WAITING, lockerIndirect.lockBegin(nullptr, resIdA, MODE_X));
DeadlockDetector wfg1(*getGlobalLockManager(), &locker1);
ASSERT(wfg1.check().hasCycle());
DeadlockDetector wfg2(*getGlobalLockManager(), &locker2);
ASSERT(wfg2.check().hasCycle());
// Indirect locker should not report the cycle since it does not participate in it
DeadlockDetector wfgIndirect(*getGlobalLockManager(), &lockerIndirect);
ASSERT(!wfgIndirect.check().hasCycle());
// Cleanup, so that LockerImpl doesn't complain about leaked locks
locker1.unlock(resIdB);
locker2.unlock(resIdA);
}
void DanmakusManager::FetchNewDanmakus(Displayer* displayer) {
std::lock_guard<Win32Mutex> locker1(mAllDanmakusMutex);
std::lock_guard<Win32Mutex> locker2(mActiveDanmakusMutex);
time_t current = mTimer->GetMilliseconds();
for (auto iter = mNextFetchIter; iter != mAllDanmakus.end(); /* ignore */) {
if ((*iter)->GetStartTime() < current) {
if (!(*iter)->HasMeasured(&mConfig)) {
(*iter)->Measure(displayer, &mConfig);
}
if ((*iter)->IsAlive(current)) {
mActiveDanmakus.insert(*iter);
}
} else {
mNextFetchIter = iter;
break;
}
if (++iter == mAllDanmakus.end()) {
mNextFetchIter = mAllDanmakus.end();
break;
}
}
mLastFetchTime = current;
}
void SavingThread::stop()
{
QMutexLocker locker1(&doStopMutex);
QMutexLocker locker2(&processingMutex);
doStop = true;
releaseFile();
}
void StreamHandler::AddListener(MPEGStreamData *data,
bool allow_section_reader,
bool needs_buffering,
QString output_file)
{
QMutexLocker locker(&m_add_rm_lock);
LOG(VB_RECORD, LOG_INFO, LOC + QString("AddListener(0x%1) -- begin")
.arg((uint64_t)data,0,16));
if (!data)
{
LOG(VB_GENERAL, LOG_ERR, LOC +
QString("AddListener(0x%1) -- null data")
.arg((uint64_t)data,0,16));
return;
}
m_listener_lock.lock();
LOG(VB_RECORD, LOG_INFO, LOC + QString("AddListener(0x%1) -- locked")
.arg((uint64_t)data,0,16));
if (m_stream_data_list.empty())
{
QMutexLocker locker2(&m_start_stop_lock);
m_allow_section_reader = allow_section_reader;
m_needs_buffering = needs_buffering;
}
else
{
QMutexLocker locker2(&m_start_stop_lock);
m_allow_section_reader &= allow_section_reader;
m_needs_buffering |= needs_buffering;
}
m_stream_data_list[data] = output_file;
m_listener_lock.unlock();
Start();
LOG(VB_RECORD, LOG_INFO, LOC + QString("AddListener(0x%1) -- end")
.arg((uint64_t)data,0,16));
}
void CraftingSessionImplementation::removeIngredient(TangibleObject* tano, int slotUpdated, int clientCounter) {
ManagedReference<CraftingTool*> craftingTool = this->craftingTool.get();
ManagedReference<CreatureObject*> crafter = this->crafter.get();
ManagedReference<PlayerObject*> crafterGhost = this->crafterGhost.get();
ManagedReference<CraftingStation*> craftingStation = this->craftingStation.get();
ManagedReference<ManufactureSchematic*> manufactureSchematic = this->manufactureSchematic.get();
ManagedReference<TangibleObject*> prototype = this->prototype.get();
if (crafter == NULL) {
sendSlotMessage(clientCounter, IngredientSlot::INVALID);
return;
}
if (manufactureSchematic == NULL) {
sendSlotMessage(clientCounter, IngredientSlot::NOSCHEMATIC);
return;
}
if (prototype == NULL) {
sendSlotMessage(clientCounter, IngredientSlot::PROTOTYPENOTFOUND);
return;
}
if (tano == NULL) {
sendSlotMessage(clientCounter, IngredientSlot::INVALIDINGREDIENT);
return;
}
SceneObject* inventory = crafter->getSlottedObject("inventory");
if (inventory == NULL) {
sendSlotMessage(clientCounter, IngredientSlot::NOINVENTORY);
return;
}
Locker locker(_this.get());
Locker locker2(tano);
int result = manufactureSchematic->removeIngredientFromSlot(crafter, tano, slotUpdated);
if(result == IngredientSlot::OK) {
// Object Controller ********************************************
// Updates the screen with the resource removal
ObjectControllerMessage* objMsg = new ObjectControllerMessage(
crafter->getObjectID(), 0x1B, 0x010C);
objMsg->insertInt(0x108);
objMsg->insertInt(0);
objMsg->insertByte(clientCounter);
crafter->sendMessage(objMsg);
// End Object Controller *****************************************
}
if(crafterGhost != NULL && crafterGhost->getDebug()) {
crafter->sendSystemMessage("Removing ingredient: " + tano->getDisplayedName());
}
}
// Destructor
SavingThread::~SavingThread()
{
QMutexLocker locker1(&doStopMutex);
QMutexLocker locker2(&processingMutex);
doStop = true;
releaseFile();
doStopMutex.unlock();
wait();
}
int CraftingSessionImplementation::clearSession() {
Locker slocker(_this.get());
ManagedReference<CraftingTool*> craftingTool = this->craftingTool.get();
ManagedReference<CreatureObject*> crafter = this->crafter.get();
ManagedReference<PlayerObject*> crafterGhost = this->crafterGhost.get();
ManagedReference<CraftingStation*> craftingStation = this->craftingStation.get();
ManagedReference<ManufactureSchematic*> manufactureSchematic = this->manufactureSchematic.get();
ManagedReference<TangibleObject*> prototype = this->prototype.get();
if (manufactureSchematic != NULL) {
Locker locker(manufactureSchematic);
if (manufactureSchematic->getParent() == craftingTool) {
manufactureSchematic->setDraftSchematic(NULL);
manufactureSchematic->cleanupIngredientSlots(crafter);
manufactureSchematic->destroyObjectFromWorld(true);
}
this->manufactureSchematic = NULL;
}
if (craftingTool != NULL) {
Locker locker2(craftingTool);
// Remove all items that aren't the prototype
while (craftingTool->getContainerObjectsSize() > 1) {
craftingTool->getContainerObject(1)->destroyObjectFromWorld(true);
}
craftingTool->dropSlottedObject("crafted_components");
if (prototype != NULL) {
Locker locker3(prototype);
if (craftingTool->isReady()) {
if (prototype->getParent() == craftingTool) {
prototype->destroyObjectFromWorld(true);
}
this->prototype = NULL;
}
}
}
if(crafterGhost != NULL && crafterGhost->getDebug()) {
crafter->sendSystemMessage("*** Clearing crafting session ***");
}
return 0;
}
TEST(LockerImpl, ConflictWithTimeout) {
const ResourceId resId(RESOURCE_COLLECTION, std::string("TestDB.collection"));
LockerImpl locker1(1);
ASSERT(LOCK_OK == locker1.lock(resId, MODE_X));
LockerImpl locker2(2);
ASSERT(LOCK_TIMEOUT == locker2.lock(resId, MODE_S, 0));
ASSERT(locker2.isLockHeldForMode(resId, MODE_NONE));
ASSERT(locker1.unlock(resId));
}
void SavingThread::resetSaver()
{
QMutexLocker locker1(&doStopMutex);
QMutexLocker locker2(&processingMutex);
processingBuffer.clear();
magnificator.clearBuffer();
currentWriteIndex = 0;
releaseFile();
cap.set(CV_CAP_PROP_POS_FRAMES,0);
doStop = true;
}
void CraftingSessionImplementation::createPrototype(int clientCounter, bool createItem) {
ManagedReference<CraftingTool*> craftingTool = this->craftingTool.get();
ManagedReference<CreatureObject*> crafter = this->crafter.get();
ManagedReference<ManufactureSchematic*> manufactureSchematic = this->manufactureSchematic.get();
if (manufactureSchematic == NULL) {
sendSlotMessage(clientCounter, IngredientSlot::NOSCHEMATIC);
return;
}
if (prototype == NULL) {
sendSlotMessage(clientCounter, IngredientSlot::PROTOTYPENOTFOUND);
return;
}
Locker locker(_this.get());
Locker locker2(manufactureSchematic);
if (manufactureSchematic->isAssembled()
&& !manufactureSchematic->isCompleted()) {
closeCraftingWindow(clientCounter);
String xpType = manufactureSchematic->getDraftSchematic()->getXpType();
int xp = manufactureSchematic->getDraftSchematic()->getXpAmount();
if (createItem) {
startCreationTasks(manufactureSchematic->getComplexity() * 2, false);
} else {
// This is for practicing
startCreationTasks(manufactureSchematic->getComplexity() * 2, true);
xp *= 1.05f;
}
Reference<PlayerManager*> playerManager = crafter->getZoneServer()->getPlayerManager();
playerManager->awardExperience(crafter, xpType, xp, true);
manufactureSchematic->setCompleted();
} else {
closeCraftingWindow(clientCounter);
sendSlotMessage(clientCounter, IngredientSlot::WEIRDFAILEDMESSAGE);
}
cancelSession();
}
void ReactionTimeTracker::updateFollowingVehicleAcceleration( float acceleration ) {
QMutexLocker locker1( &leadVehicleIsStoppingMutex );
QMutexLocker locker2( &timeSinceBrakingEventMutex );
/* We wait at least thirty seconds between events to make sure every event is unique */
if ( leadVehicleIsStopping && (timeSinceBrakingEvent->elapsed() > 30000) ) {
if ( acceleration < ACCELERATION_THRESHOLD ) {
/* Okay, the following vehicle is braking in response to the lead vehicle */
QMutexLocker locker1( &timerMutex );
QMutexLocker locker2( &reactionTimeAccumulatorMutex );
reactionTimeAccumulator = 0.5 * reactionTimeAccumulator + 0.5 * (timer->elapsed() / 1000 );
emit gotReactionTime( reactionTimeAccumulator );
timer = new QTime();
timeSinceBrakingEvent = new QTime();
timeSinceBrakingEvent->start();
} else {
/* The following vehicle hasn't stopped braking yet */
}
}
}
/**
* This function is used internally for incoming connections. This function should never be called directly.
* @param desc Socket Descriptor of the incoming connection.
*/
void ServerProtocolListenerTcp::incomingConnection(qintptr desc)
{
QReadLocker locker(&qxt_d().modemutex);
QReadLocker locker2(&qxt_d().certmutex);
ServerProtocolInstanceTcp* instance = new ServerProtocolInstanceTcp(server());
instance->setProperty("descriptor", desc);
qxt_d().modemutex.lockForRead();
instance->setProperty("sslmode", qxt_d().sslmode);
qxt_d().modemutex.unlock();
qxt_d().certmutex.lockForRead();
instance->setProperty("certificate", qxt_d().cert);
qxt_d().certmutex.unlock();
prepareInstance(instance);
}
void ServiceDataBufferTest::test_retiredData()
{
{
// Use Case:
// dataRetired called on current
// Expect the data to remain current and not be retired
AbstractLockableData* d1 = 0;
ServiceDataBuffer buffer("test");
{
WritableData data1 = buffer.getWritable(1);
CPPUNIT_ASSERT(data1.isValid());
d1 = data1.data();
// becomes active when it goes out of scope here
}
LockedData locker("test",0);
buffer.getCurrent(locker);
CPPUNIT_ASSERT( d1 == locker.object() );
buffer.deactivateData(static_cast<LockableServiceData*>(d1) );
LockedData locker2("test",0);
buffer.getCurrent(locker2);
CPPUNIT_ASSERT( d1 == locker2.object() );
CPPUNIT_ASSERT( ! buffer._expiredData.contains(static_cast<LockableServiceData*>(d1) ) );
}
{
// Use Case:
// dataRetired called on non-current
// Expect the data to remain available, yet also become available for reuse
AbstractLockableData* d1 = 0;
AbstractLockableData* d2 = 0;
ServiceDataBuffer buffer("test");
{
WritableData data1 = buffer.getWritable(1);
CPPUNIT_ASSERT(data1.isValid());
d1 = data1.data();
// becomes active when it goes out of scope here
}
{
WritableData data2 = buffer.getWritable(1);
CPPUNIT_ASSERT(data2.isValid());
d2 = data2.data();
// becomes active current when it goes out of scope here
}
LockedData locker("test",0);
buffer.getCurrent(locker);
CPPUNIT_ASSERT( d2 == locker.object() );
buffer.deactivateData(static_cast<LockableServiceData*>(d1) );
CPPUNIT_ASSERT( buffer._expiredData.contains( static_cast<LockableServiceData*>(d1) ) );
}
}
TEST(Deadlock, NoDeadlock) {
const ResourceId resId(RESOURCE_DATABASE, std::string("A"));
LockerForTests locker1(MODE_IS);
LockerForTests locker2(MODE_IS);
ASSERT_EQUALS(LOCK_OK, locker1.lockBegin(nullptr, resId, MODE_S));
ASSERT_EQUALS(LOCK_OK, locker2.lockBegin(nullptr, resId, MODE_S));
DeadlockDetector wfg1(*getGlobalLockManager(), &locker1);
ASSERT(!wfg1.check().hasCycle());
DeadlockDetector wfg2(*getGlobalLockManager(), &locker2);
ASSERT(!wfg2.check().hasCycle());
}
void FrontEnd::removeControlPoint(ControlPoint *controlPoint)
{
ReadLocker locker1(m_stateLock);
WriteLocker locker2(m_cpLock);
if (controlPoint) {
NPT_List<ControlPointInfo*>::Iterator it = m_controlPointList.Find(ControlPointInfoFinder(controlPoint));
if (it) {
ControlPointInfo *controlPointInfo = *it;
if (m_state == State_Running) {
controlPoint->implDetach();
}
m_controlPointList.Erase(it);
delete controlPointInfo;
}
}
}
void ChatRoomImplementation::removePlayer(CreatureObject* player, bool doLock) {
Locker locker(player);
PlayerObject* ghost = player->getPlayerObject();
ghost->removeChatRoom(_this.get());
locker.release();
Locker locker2(_this.get());
playerList.drop(player->getFirstName());
ChatOnLeaveRoom* msg = new ChatOnLeaveRoom(_this.get(), player);
player->sendMessage(msg);
}
StreamHandler::~StreamHandler()
{
QMutexLocker locker(&_add_rm_lock);
{
QMutexLocker locker2(&_listener_lock);
if (!_stream_data_list.empty())
{
LOG(VB_GENERAL, LOG_ERR, LOC +
"dtor & _stream_data_list not empty");
}
}
// This should never be triggered.. just to be safe..
if (_running)
Stop();
}
TEST(LockerImpl, ConflictUpgradeWithTimeout) {
const ResourceId resId(RESOURCE_COLLECTION, std::string("TestDB.collection"));
MMAPV1LockerImpl locker1(1);
ASSERT(LOCK_OK == locker1.lockGlobal(MODE_IS));
ASSERT(LOCK_OK == locker1.lock(resId, MODE_S));
MMAPV1LockerImpl locker2(2);
ASSERT(LOCK_OK == locker2.lockGlobal(MODE_IS));
ASSERT(LOCK_OK == locker2.lock(resId, MODE_S));
// Try upgrading locker 1, which should block and timeout
ASSERT(LOCK_TIMEOUT == locker1.lock(resId, MODE_X, 1));
locker1.unlockAll();
locker2.unlockAll();
}
void FrontEnd::removeDeviceImpl(DeviceImpl *deviceImpl)
{
ReadLocker locker1(m_stateLock);
WriteLocker locker2(m_dsLock);
if (deviceImpl) {
NPT_List<DeviceImplInfo*>::Iterator it = m_deviceImplList.Find(DeviceImplInfoFinder(deviceImpl));
if (it) {
DeviceImplInfo *deviceImplInfo = *it;
if (m_state == State_Running) {
broadcastLocked(deviceImplInfo, false);
deviceImpl->implDetach();
}
m_deviceImplIndex.Erase(deviceImpl->uuid());
m_deviceImplList.Erase(it);
delete deviceImplInfo;
}
}
}
void DroidStimpackModuleDataComponent::initialize(CreatureObject* droid) {
// grab the crafted components in this module and remove then
// then change capacity to the new capacity so we store the stims directly in the component.
DroidComponent* droidComponent = cast<DroidComponent*>(getParent());
if (droidComponent == NULL) {
info("droidComponent was null");
return;
}
droidComponent->dropSlottedObject("crafted_components");
ManagedReference<SceneObject*> craftingComponents = droidComponent->getSlottedObject("crafted_components");
if(craftingComponents == NULL) {
// create the satchel and container as it would not be present as this object doesnt use components.
ManagedReference<SceneObject*> craftingComponentsSatchel = NULL;
String craftingComponentsPath = "object/tangible/crafting/crafting_components_container.iff";
craftingComponents = droidComponent->getZoneServer()->createObject(craftingComponentsPath.hashCode(), 1);
craftingComponents->removeAllContainerObjects();
craftingComponents->setSendToClient(false);
droidComponent->transferObject(craftingComponents, 4, false);
Locker locker(craftingComponents);
craftingComponents->setContainerDefaultDenyPermission(ContainerPermissions::OPEN + ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponents->setContainerDefaultAllowPermission(0);
craftingComponents->setContainerDenyPermission("owner", ContainerPermissions::OPEN + ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponents->setContainerDenyPermission("admin", ContainerPermissions::OPEN + ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponents->setContainerAllowPermission("owner", 0);
craftingComponents->setContainerAllowPermission("admin", 0);
craftingComponents->setContainerInheritPermissionsFromParent(false);
locker.release();
String craftingComponentsSatchelPath = "object/tangible/hopper/crafting_station_hopper/crafting_station_ingredient_hopper_large.iff";
craftingComponentsSatchel = droidComponent->getZoneServer()->createObject(craftingComponentsSatchelPath.hashCode(), 1);
Locker locker2(craftingComponentsSatchel);
craftingComponentsSatchel->setContainerVolumeLimit(capacity);
craftingComponentsSatchel->setContainerInheritPermissionsFromParent(false);
craftingComponentsSatchel->setContainerDefaultDenyPermission(ContainerPermissions::OPEN + ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponentsSatchel->setContainerDefaultAllowPermission(0);
craftingComponentsSatchel->setContainerAllowPermission("admin", ContainerPermissions::OPEN);
craftingComponentsSatchel->setContainerDenyPermission("admin", ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponentsSatchel->setContainerAllowPermission("owner", 0);
craftingComponentsSatchel->setContainerDenyPermission("owner", ContainerPermissions::OPEN + ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponentsSatchel->sendTo(droid, true);
craftingComponents->transferObject(craftingComponentsSatchel, -1, false);
}
}
void MTPSessionData::clear() {
RPCCallbackClears clearCallbacks;
{
QReadLocker locker1(haveSentMutex()), locker2(toResendMutex()), locker3(haveReceivedMutex()), locker4(wereAckedMutex());
mtpResponseMap::const_iterator end = haveReceived.cend();
clearCallbacks.reserve(haveSent.size() + wereAcked.size());
for (mtpRequestMap::const_iterator i = haveSent.cbegin(), e = haveSent.cend(); i != e; ++i) {
mtpRequestId requestId = i.value()->requestId;
if (haveReceived.find(requestId) == end) {
clearCallbacks.push_back(requestId);
}
}
for (mtpRequestIdsMap::const_iterator i = toResend.cbegin(), e = toResend.cend(); i != e; ++i) {
mtpRequestId requestId = i.value();
if (haveReceived.find(requestId) == end) {
clearCallbacks.push_back(requestId);
}
}
for (mtpRequestIdsMap::const_iterator i = wereAcked.cbegin(), e = wereAcked.cend(); i != e; ++i) {
mtpRequestId requestId = i.value();
if (haveReceived.find(requestId) == end) {
clearCallbacks.push_back(requestId);
}
}
}
{
QWriteLocker locker(haveSentMutex());
haveSent.clear();
}
{
QWriteLocker locker(toResendMutex());
toResend.clear();
}
{
QWriteLocker locker(wereAckedMutex());
wereAcked.clear();
}
{
QWriteLocker locker(receivedIdsMutex());
receivedIds.clear();
}
_mtp_internal::clearCallbacksDelayed(clearCallbacks);
}
void FrontEnd::addControlPoint(ControlPoint *controlPoint)
{
ReadLocker locker1(m_stateLock);
WriteLocker locker2(m_cpLock);
if (controlPoint) {
NPT_List<ControlPointInfo*>::Iterator it = m_controlPointList.Find(ControlPointInfoFinder(controlPoint));
if (!it) {
ControlPointInfo *controlPointInfo = new ControlPointInfo();
controlPointInfo->m_controlPoint = controlPoint;
controlPointInfo->m_context.m_httpRoot = NPT_String::Format("/cp%p/", controlPoint);
controlPointInfo->m_context.m_userAgentHeader = m_userAgentHeader;
controlPointInfo->m_context.m_serverHeader = m_serverHeader;
m_controlPointList.Add(controlPointInfo);
if (m_state == State_Running) {
controlPoint->implAttach(this, controlPointInfo->m_context);
}
}
}
}
void ReactionTimeTracker::updateTimeHeadway( float time ) {
QMutexLocker locker( &smallTimeHeadwayMutex );
/* TODO: What constitutes a "small" time headway */
if ( time < 3.5 ) {
smallTimeHeadway = true;
} else {
/* Vehicle is out of range; reset everything */
QMutexLocker locker1( &timerMutex );
QMutexLocker locker2( &leadVehicleIsStoppingMutex );
smallTimeHeadway = false;
leadVehicleIsStopping = false;
if ( timer->elapsed() > 0 ) {
timer = new QTime();
}
}
}
void ChatRoomImplementation::removePlayer(const String& player) {
// Pre: player unlocked
Locker locker(_this.get());
ManagedReference<CreatureObject*> play = playerList.get(player);
playerList.drop(player);
locker.release();
if (play == NULL)
return;
Locker locker2(play);
PlayerObject* ghost = play->getPlayerObject();
ghost->removeChatRoom(_this.get());
ChatOnLeaveRoom* msg = new ChatOnLeaveRoom(_this.get(), play);
play->sendMessage(msg);
}
void FrontEnd::addDeviceImpl(DeviceImpl *deviceImpl)
{
ReadLocker locker1(m_stateLock);
WriteLocker locker2(m_dsLock);
if (deviceImpl) {
NPT_List<DeviceImplInfo*>::Iterator it = m_deviceImplList.Find(DeviceImplInfoFinder(deviceImpl));
if (!it) {
DeviceImplInfo *deviceImplInfo = new DeviceImplInfo;
deviceImplInfo->m_deviceImpl = deviceImpl;
deviceImplInfo->m_context.m_httpRoot = NPT_String::Format("/devices/%s/", deviceImpl->uuid().toString().GetChars());
deviceImplInfo->m_context.m_userAgentHeader = m_userAgentHeader;
deviceImplInfo->m_context.m_serverHeader = m_serverHeader;
m_deviceImplList.Add(deviceImplInfo);
m_deviceImplIndex.Put(deviceImpl->uuid(), deviceImplInfo);
if (m_state == State_Running) {
deviceImpl->implAttach(this, deviceImplInfo->m_context);
//broadcastLocked(deviceImplInfo, false);
broadcastLocked(deviceImplInfo, true);
}
}
}
}
void FrontEnd::broadcastIfNecessary()
{
ReadLocker locker1(m_stateLock);
if (m_state != State_Running) {
return;
}
NPT_TimeStamp ts;
NPT_System::GetCurrentTimeStamp(ts);
NPT_Int64 tsMillis = ts.ToMillis();
WriteLocker locker2(m_dsLock);
for (NPT_Ordinal i = 0; i < m_deviceImplList.GetItemCount(); i++)
{
NPT_List<DeviceImplInfo*>::Iterator it = m_deviceImplList.GetItem(i);
DeviceImplInfo *info = *it;
//if (info->m_updateTS.ToMillis() + info->m_deviceImpl->m_expireSeconds * 1000 - 11000 < tsMillis)
if (tsMillis - info->m_updateTS.ToMillis() > 30000)
{
broadcastLocked(info, true);
}
}
}
// A NetworkBootInfo sub-descriptor is present in the PMT.
void MHIContext::SetNetBootInfo(const unsigned char *data, uint length)
{
if (length < 2) // A valid descriptor should always have at least 2 bytes.
return;
LOG(VB_MHEG, LOG_INFO, QString("[mhi] SetNetBootInfo version %1 mode %2 len %3")
.arg(data[0]).arg(data[1]).arg(length));
QMutexLocker locker(&m_dsmccLock);
// Save the data from the descriptor.
m_nbiData.resize(0);
m_nbiData.reserve(length);
m_nbiData.insert(m_nbiData.begin(), data, data+length);
// If there is no Network Boot Info or we're setting it
// for the first time just update the "last version".
if (m_lastNbiVersion == NBI_VERSION_UNSET)
m_lastNbiVersion = data[0];
else
{
locker.unlock();
QMutexLocker locker2(&m_runLock);
m_engine_wait.wakeAll();
}
}
