std::vector<std::string> process()
{
std::srand(std::time(0));
std::vector<CallbackData> dbs;
std::vector<std::string> tortured_databases;
dbs.emplace_back(CallbackData(tortured_databases, open_database("test1.db")));
dbs.emplace_back(CallbackData(tortured_databases, open_database("test2.db")));
dbs.emplace_back(CallbackData(tortured_databases, open_database("test3.db")));
dbs.emplace_back(CallbackData(tortured_databases, open_database("test4.db")));
dbs.emplace_back(CallbackData(tortured_databases, open_database("test5.db")));
for (size_t i = 0; i<dbs.size(); ++i) {
sqlite3_trace(dbs[i].db_, trace_callback, &dbs[i]);
}
for (size_t i = 0; i<dbs.size(); ++i) {
torture_database(dbs[std::rand() % dbs.size()].db_);
}
for (size_t i = 0; i<dbs.size(); ++i) {
sqlite3_close(dbs[i].db_);
}
return tortured_databases;
}
void ReplicationExecutor::doOperationWithGlobalExclusiveLock(
OperationContext* txn,
const CallbackHandle& cbHandle) {
boost::unique_lock<boost::mutex> lk(_mutex);
if (_inShutdown)
return;
const WorkQueue::iterator iter = cbHandle._iter;
const uint64_t generation = iter->generation;
invariant(generation == cbHandle._generation);
WorkItem work = *iter;
iter->callback = CallbackFn();
_freeQueue.splice(_freeQueue.begin(), _exclusiveLockInProgressQueue, iter);
lk.unlock();
{
boost::lock_guard<boost::mutex> terribleLock(_terribleExLockSyncMutex);
work.callback(CallbackData(this,
cbHandle,
(work.isCanceled ?
Status(ErrorCodes::CallbackCanceled, "Callback canceled") :
Status::OK()),
txn));
}
lk.lock();
signalEvent_inlock(work.finishedEvent);
}
nsresult
WindowHook::RemoveHook(UINT nMsg, Callback callback, void *context) {
CallbackData cbdata(callback, context);
MessageData *data = Lookup(nMsg);
if (!data)
return NS_ERROR_UNEXPECTED;
if (data->hook != cbdata)
return NS_ERROR_UNEXPECTED;
data->hook = CallbackData();
DeleteIfEmpty(data);
return NS_OK;
}
nsresult
WindowHook::AddHook(UINT nMsg, Callback callback, void *context) {
MessageData *data = LookupOrCreate(nMsg);
if (!data)
return NS_ERROR_OUT_OF_MEMORY;
// Ensure we don't overwrite another hook
NS_ENSURE_TRUE(nullptr == data->hook.cb, NS_ERROR_UNEXPECTED);
data->hook = CallbackData(callback, context);
return NS_OK;
}
void ReplicationExecutor::run() {
_networkInterface->startup();
_dblockWorkers.startThreads();
std::pair<WorkItem, CallbackHandle> work;
while ((work = getWork()).first.callback) {
{
boost::lock_guard<boost::mutex> lk(_terribleExLockSyncMutex);
const Status inStatus = work.first.isCanceled ?
Status(ErrorCodes::CallbackCanceled, "Callback canceled") :
Status::OK();
makeNoExcept(stdx::bind(work.first.callback,
CallbackData(this, work.second, inStatus)))();
}
signalEvent(work.first.finishedEvent);
}
finishShutdown();
_networkInterface->shutdown();
}
//////////////////////////////////////////////////////////////////////////
// processCallbacks
void CsCore::processCallbacks()
{
TPackageReadyCallbackListIterator It = PackageReadyCallbackList_.begin();
while( It != PackageReadyCallbackList_.end() )
{
TPackageReadyCallback& CallbackData( *It );
CsPackage* pPackage = findPackage( CallbackData.Package_ );
if( pPackage != NULL &&
pPackage->isReady() )
{
CallbackData.Callback_( pPackage, CallbackData.ID_ );
It = PackageReadyCallbackList_.erase( It );
}
else
{
++It;
}
}
}
SSMRESULT CSensingEngine::registerContext(TypeofEvent callType, ISSMResource *pSSMResource,
IEvent *pEvent)
{
m_mtxRequestedContextData.lock();
// if already exists
if (m_requestedCallbackData.find(pSSMResource->type) != m_requestedCallbackData.end())
{
//m_requestedCallbackData.erase(m_requestedCallbackData.find(nameString));
unregisterContext(callType, pSSMResource, pEvent);
}
else
{
m_requestedCallbackData[pSSMResource->type] = CallbackData(callType, pSSMResource->type, pEvent);
}
m_pContextExecutor->registerContext(callType, pSSMResource, this);
m_mtxRequestedContextData.unlock();
return SSM_S_OK;
}
nsresult
WindowHook::AddMonitor(UINT nMsg, Callback callback, void *context) {
MessageData *data = LookupOrCreate(nMsg);
return (data && data->monitors.AppendElement(CallbackData(callback, context)))
? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
