//Called to update the display.
//You should call glutSwapBuffers after all of your rendering to display what you rendered.
//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
void display()
{
if (cullFlag)
{
glEnable(GL_CULL_FACE);
}
else
{
glDisable(GL_CULL_FACE);
}
if (lineModeFlag)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
else
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
ITask* currentTask = tasks[currentTaskNumber];
if (currentTask != NULL)
{
currentTask->Draw();
}
// bind 1-3
glutSwapBuffers();
}
//Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
void init()
{
tasks.push_back(new TaskOne());
tasks.push_back(new TaskTwo());
tasks.push_back(new TaskThree());
tasks.push_back(new TaskFour());
tasks.push_back(new BonusTask());
// initialize all our new tasks
for (TaskVector::iterator it = tasks.begin(); it != tasks.end(); it++)
{
ITask* task = (*it);
task->InitializeProgram();
task->Initialize();
}
currentTaskNumber = 0;
ITask* currentTask = tasks[currentTaskNumber];
if (currentTask != NULL)
{
currentTask->InitializeProgram();
}
glCullFace(GL_BACK); // only back faces will be culled, if enabled
glClearColor(0.3f, 0.3f, 0.3f, 1.0f); // color for cleaning the screen
}
//---------------------------------------------------------------------------
int TTaskScheduler::AddNewScheduledTask(wstring taskName){
/////////////////////////////////////////////////////////////////
// Call ITaskScheduler::NewWorkItem to create new task.
/////////////////////////////////////////////////////////////////
ITask *pITask;
HRESULT hr = pITS->NewWorkItem(taskName.data(), // Name of task
CLSID_CTask, // Class identifier
IID_ITask, // Interface identifier
(IUnknown**)&pITask); // Address of task interface
if (FAILED(hr)){
sprintf(lastError, "Failed calling NewWorkItem, error = 0x%x\n",hr);
return 0;
}
Save(pITask);
pITask->Release();
return 1;
}
bool LocalXmlBackend::start()
{
qsrand( QDateTime::currentDateTime().toMSecsSinceEpoch() );
QList<OpenTodoList::IAccount*> accounts = m_database->getAccounts(
OpenTodoList::IDatabase::QueryAny, 1 );
if ( accounts.isEmpty() ) {
m_account = m_database->createAccount();
m_account->setUuid( QUuid::createUuid() );
} else {
m_account = accounts.first();
}
m_account->setName( tr( "Local Todo Lists" ) );
m_database->insertAccount( m_account );
QStringList todoLists = locateTodoLists();
for ( const QString &todoListFile : todoLists ) {
fixTodoList( todoListFile );
ITodoList *todoList = m_database->createTodoList();
QDomDocument doc = documentForFile( todoListFile );
QByteArray todoListHash;
if ( domToTodoList( doc, todoList ) && todoListNeedsUpdate( todoList, todoListFile, todoListHash ) ) {
todoList->insertMetaAttribute( TodoListMetaFileName, todoListFile );
todoList->insertMetaAttribute( TodoListMetaHash, todoListHash );
todoList->setAccount( m_account->uuid() );
m_database->insertTodoList( todoList );
}
QStringList todos = locateTodos( todoListFile );
for ( const QString &todoFile : todos ) {
fixTodo( todoFile );
ITodo *todo = m_database->createTodo();
doc = documentForFile( todoFile );
QByteArray todoHash;
if ( domToTodo( doc, todo ) && todoNeedsUpdate( todo, todoFile, todoHash )) {
todo->insertMetaAttribute( TodoMetaFileName, todoFile );
todo->insertMetaAttribute( TodoMetaHash, todoHash );
todo->setTodoList( todoList->uuid() );
m_database->insertTodo( todo );
}
QStringList tasks = locateTasks( todoFile );
for ( const QString &taskFile : tasks ) {
ITask *task = m_database->createTask();
doc = documentForFile( taskFile );
QByteArray taskHash;
if ( domToTask( doc, task ) && taskNeedsUpdate( task, taskFile, taskHash ) ) {
task->insertMetaAttribute( TaskMetaFileName, taskFile );
task->insertMetaAttribute( TaskMetaHash, taskHash );
task->setTodo( todo->uuid() );
m_database->insertTask( task );
}
delete task;
}
delete todo;
}
delete todoList;
}
return true;
}
void TaskQueue::onTick()
{
ITask* task = removeResult();
if (task != nullptr)
{
task->exeResult();
SAFE_DELETE(task);
}
}
void Worker::Run() {
while (!_Shutdown) {
ITask* currentJob = _Q->FetchTask();
if (currentJob != NULL) {
currentJob->Run();
if (currentJob->ToBeDisposedByWorker()) {
delete currentJob;
}
}
}
}
bool LocalXmlBackend::taskNeedsUpdate(ITask *task, const QString &fileName, QByteArray &hash) const
{
bool result = true;
hash = hashForFile( fileName );
ITask *existingTask = m_database->getTask( task->uuid() );
if ( existingTask ) {
result = existingTask->metaAttributes().value( TaskMetaHash ).toByteArray() != hash;
delete existingTask;
}
return result;
}
//---------------------------------------------------------------------------
// @function:
// IMemoryPool::FSimulateAllocFailure
//
// @doc:
// Check whether to simulate an OOM
//
//---------------------------------------------------------------------------
BOOL
CMemoryPoolInjectFault::SimulateAllocFailure()
{
ITask *task = ITask::Self();
if (NULL != task)
{
return
task->IsTraceSet(EtraceSimulateOOM) &&
CFSimulator::FSim()->NewStack(CException::ExmaSystem, CException::ExmiOOM);
}
return false;
}
virtual void run()
{
while(true)
{
ITask * task = ptThreadPool_->queue_.pop();
if(task == NULL)
{
break;
}
task->run();
delete task;
}
}
void GetTaskDetails2(wchar_t* buf, int bufSize, ITaskScheduler *pITS, LPCWSTR lpcwszTaskName)
{
HRESULT hr = S_OK;
ITask *pITask = 0;
wchar_t tmp[500];
hr = pITS->Activate(lpcwszTaskName, IID_ITask, (IUnknown**) &pITask);
if (FAILED(hr))
{
_snwprintf(tmp, sizeof(tmp), L"Failed calling ITaskScheduler::Activate; error = 0x%x\n",hr);
wcsncat(buf, tmp, bufSize);
return;
}
LPWSTR lpwszApplicationName;
hr = pITask->GetApplicationName(&lpwszApplicationName);
if (FAILED(hr))
{
_snwprintf(tmp, sizeof(tmp), L"Failed calling ITask::GetApplicationName error = 0x%x\n", hr);
wcsncat(buf, tmp, bufSize);
lpwszApplicationName = 0;
}
LPWSTR lpwszParameters;
hr = pITask->GetParameters(&lpwszParameters);
if (FAILED(hr))
{
_snwprintf(tmp, sizeof(tmp), L"Failed calling ITask::GetApplicationName error = 0x%x\n", hr);
wcsncat(buf, tmp, bufSize);
lpwszParameters = 0;
}
pITask->Release();
if(lpwszApplicationName){
_snwprintf(tmp, sizeof(tmp), L"\t-Exe: %s\n", lpwszApplicationName);
wcsncat(buf, tmp, bufSize);
CoTaskMemFree(lpwszApplicationName);
}
if(lpwszParameters){
_snwprintf(tmp, sizeof(tmp), L"\t-Params: %s\n", lpwszParameters);
wcsncat(buf, tmp, bufSize);
CoTaskMemFree(lpwszParameters);
}
}
void DoTasks()
{
ITask* task ;
do
{
{
CriticalSectionHelper c;
task = Tasks.Dequeue();
}
if(task!=NULL)
task->DoTask();
}
while(task!=NULL);
}
void FuncTimerCallback(int value)
{
if (spinFlag)
{
glutTimerFunc(TIMER_STEP, FuncTimerCallback, 0); //333 (1%) -> 3 -> (14%)
ITask* currentTask = tasks[currentTaskNumber];
if (currentTask != NULL)
{
currentTask->Update();
}
}
glutPostRedisplay();
}
//---------------------------------------------------------------------------
// @function:
// CAutoMemoryPool::~CAutoMemoryPool
//
// @doc:
// Release the pool back to the manager and perform leak checks if
// (1) strict leak checking indicated, or
// (2) no checking while pending exception indicated and no pending exception
//
//---------------------------------------------------------------------------
CAutoMemoryPool::~CAutoMemoryPool()
{
if (NULL == m_mp)
{
return;
}
// suspend cancellation
CAutoSuspendAbort asa;
#ifdef GPOS_DEBUG
ITask *task = ITask::Self();
// ElcExc must be used inside tasks only
GPOS_ASSERT_IMP(ElcExc == m_leak_check_type, NULL != task);
GPOS_TRY
{
if (ElcStrict == m_leak_check_type || (ElcExc == m_leak_check_type && !task->GetErrCtxt()->IsPending()))
{
gpos::IOstream &os = gpos::oswcerr;
// check for leaks, use this to trigger standard Assert handling
m_mp->AssertEmpty(os);
}
// release pool
CMemoryPoolManager::GetMemoryPoolMgr()->Destroy(m_mp);
}
GPOS_CATCH_EX(ex)
{
GPOS_ASSERT(GPOS_MATCH_EX(ex, CException::ExmaSystem, CException::ExmiAssert));
// release pool
CMemoryPoolManager::GetMemoryPoolMgr()->Destroy(m_mp);
GPOS_RETHROW(ex);
}
GPOS_CATCH_END;
#else // GPOS_DEBUG
// hand in pool and return
CMemoryPoolManager::GetMemoryPoolMgr()->Destroy(m_mp);
#endif // GPOS_DEBUG
}
gep::Result gep::TaskWorker::runSingleTask()
{
ITask* pTaskToExecute = nullptr;
{
// try to get a task from our internal task list
ScopedLock<Mutex> lock(m_tasksMutex);
if(m_tasks.length() == 0)
return FAILURE;
pTaskToExecute = m_tasks.lastElement();
m_tasks.resize(m_tasks.length() - 1);
}
pTaskToExecute->execute();
m_pActiveGroup->taskFinished();
return SUCCESS;
}
void CTaskManager::remove(ITask &task)
{
//nlinfo("Removing task %s", task.name().c_str());
// release and remove task from Task
for(std::list<ITask*>::iterator it = Tasks.begin(); it != Tasks.end();)
{
if(&task == (*it))
{
Tasks.erase(it);
break;
}
else
{
it++;
}
}
// remove task from OrderSortedTasks
for(std::list<ITask*>::iterator it = OrderSortedTasks.begin(); it != OrderSortedTasks.end();)
{
if(&task == (*it))
{
OrderSortedTasks.erase(it);
break;
}
else
{
it++;
}
}
//nlinfo("Removed task %s from list", task.name().c_str());
task.release();
//nlinfo("Removed task %s and release called", task.name().c_str());
}
void GetTaskDetails(FILE* f, ITaskScheduler *pITS, LPCWSTR lpcwszTaskName)
{
HRESULT hr = S_OK;
ITask *pITask = 0;
hr = pITS->Activate(lpcwszTaskName, IID_ITask, (IUnknown**) &pITask);
if (FAILED(hr))
{
fwprintf(f, L"Failed calling ITaskScheduler::Activate; error = 0x%x\n",hr);
return;
}
LPWSTR lpwszApplicationName;
hr = pITask->GetApplicationName(&lpwszApplicationName);
if (FAILED(hr))
{
fwprintf(f, L"Failed calling ITask::GetApplicationName error = 0x%x\n", hr);
lpwszApplicationName = 0;
}
LPWSTR lpwszParameters;
hr = pITask->GetParameters(&lpwszParameters);
if (FAILED(hr))
{
fwprintf(f, L"Failed calling ITask::GetApplicationName error = 0x%x\n", hr);
lpwszParameters = 0;
}
pITask->Release();
if(lpwszApplicationName){
fwprintf(f, L"\t-Exe: %s\n", lpwszApplicationName);
CoTaskMemFree(lpwszApplicationName);
}
if(lpwszParameters){
fwprintf(f, L"\t-Params: %s\n", lpwszParameters);
CoTaskMemFree(lpwszParameters);
}
}
//---------------------------------------------------------------------------
void TTaskScheduler::SetTaskProperties(wstring taskName, TTaskParams taskParams){
ITask *pITask = Activate(taskName);
if(pITask == NULL){
return;
}
if(taskParams.accountName.length() > 0 && taskParams.accountPwd.length() > 0){
pITask->SetAccountInformation(taskParams.accountName.data(),
taskParams.accountPwd.data());
}
if(taskParams.appName.length() > 0){
pITask->SetApplicationName(taskParams.appName.data());
}
if(taskParams.appParameters.length() > 0){
pITask->SetParameters(taskParams.accountName.data());
}
if(taskParams.comments.length() > 0){
pITask->SetComment(taskParams.comments.data());
}
if(taskParams.workingDirectory.length() > 0){
pITask->SetWorkingDirectory(taskParams.workingDirectory.data());
}
Save(pITask);
pITask->Release();
}
void QueueRunnable::CancelCurrentTask()
{
queue->LockQueue();
if(currentTask)
{
currentTask->Cancel();
}
queue->UnlockQueue();
}
//Called whenever a key on the keyboard was pressed.
//The key is given by the ''key'' parameter, which is in ASCII.
//It's often a good idea to have the escape key (ASCII value 27) call glutLeaveMainLoop() to
//exit the program.
void myKeyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 27:
exit(0);
break;
case ' ':
currentTaskNumber = (currentTaskNumber + 1) % tasks.size();
ITask* currentTask = tasks[currentTaskNumber];
if (currentTask != NULL)
{
currentTask->InitializeProgram();
printf("Current Task = %s\n", currentTask->ToString());
}
break;
}
glutPostRedisplay(); // Nutno, kdybychom nevolali prekresleni casovacem ci Idle
}
void QueueRunnable::run()
{
while (queue->IsStarted()) {
queue->LockQueue();
ITask* task = queue->NextTask();
if (task == NULL) {
queue->UnlockQueue();
continue;
}
currentTask = task;
queue->UnlockQueue();
task->Run();
queue->LockQueue();
currentTask = NULL;
queue->FinishTask(task);
queue->NotifyQueue();
queue->UnlockQueue();
}
}
void CTaskManager::add(ITask &task, sint32 order, bool startNow)
{
// Check that the task is not already in the array
list<ITask*>::iterator result = find(Tasks.begin(), Tasks.end(), &task);
nlassert(result == Tasks.end());
result = find(OrderSortedTasks.begin(), OrderSortedTasks.end(), &task);
nlassert(result == OrderSortedTasks.end());
task.Order = order;
std::string n = task.name() + "Update";
strcpy(task.NameUpdate, n.c_str());
n = task.name() + "Render";
strcpy(task.NameRender, n.c_str());
task.HTimerUpdate.setName(task.NameUpdate);
task.HTimerRender.setName(task.NameRender);
task.NeedRemove = false;
task.Execute = startNow;
Tasks.push_back(&task);
if(order == -1)
{
OrderSortedTasks.push_back(&task);
}
else
{
list<ITask*>::iterator it;
for(it = OrderSortedTasks.begin(); it != OrderSortedTasks.end(); it++)
{
if((*it)->Order > order)
{
break;
}
}
OrderSortedTasks.insert(it, &task);
}
// nlinfo("Init during exec %s", task.name().c_str());
task.init();
}
void TaskThread::run()
{
ITask* task;
while (!m_exitFlag)
{
if (m_pTaskQueue)
{
task = m_pTaskQueue->removeTask();
if (task)
{
task->exeTask();
m_pTaskQueue->addResult(task);
}
else
{
m_pMCondition->wait();
}
}
}
}
void ThreadPoolImpl::PopAndExecuteTask()
{
ITask* currentTask = nullptr;
mutex_.Lock();
if(!tasks_.empty())
{
currentTask = tasks_.front();
tasks_.pop();
}
mutex_.UnLock();
if (currentTask)
{
currentTask->Run();
delete currentTask;
}
}
unsigned Thread::Run()
{
DebugLog << "Thread::Run" << std::endl;
while (true)
{
if (mpThreadPool == NULL)
{
DebugLog << "mpThreadPool == NULL" << std::endl;
}
ITask* pTask = mpThreadPool->GetTask();
if (pTask != NULL)
{
DebugLog << "Get a valid task" << std::endl;
if (pTask->GetType() == TP_Exit)
{
pTask->OnComplete();
mpThreadPool->FinishATask();
break;
}
else if (pTask->GetType() == TP_Normal)
{
pTask->Run();
pTask->OnComplete();
mpThreadPool->FinishATask();
}
}
else
{
DebugLog << "Get an invalid task" << std::endl;
}
}
return 0;
}
void myMenu(int item)
{
switch (item) {
case 1:
case 2:
case 3:
case 4:
case 5:
{
currentTaskNumber = item - 1;
ITask* currentTask = tasks[currentTaskNumber];
if (currentTask != NULL)
{
currentTask->InitializeProgram();
printf("Current Task = %s\n", currentTask->ToString());
}
}
break;
case 10:
spinFlag = !spinFlag;
if (spinFlag)
{
glutTimerFunc(TIMER_STEP, FuncTimerCallback, 0);
}
break;
case 11:
cullFlag = !cullFlag;
glutPostRedisplay();
break;
case 12:
lineModeFlag = !lineModeFlag;
glutPostRedisplay();
break;
case 99:
exit(0);
break; // never reached
}
glutPostRedisplay(); // Nutno, kdybychom nevolali prekresleni casovacem ci Idle
}
//---------------------------------------------------------------------------
// @function:
// CUnittest::FSimulated
//
// @doc:
// Check if exception was injected by simulation
//
//---------------------------------------------------------------------------
BOOL
CUnittest::FSimulated
(
CException ex
)
{
ITask *ptsk = ITask::PtskSelf();
GPOS_ASSERT(NULL != ptsk);
return
(ptsk->FTrace(EtraceSimulateOOM) &&
GPOS_MATCH_EX(ex, CException::ExmaSystem, CException::ExmiOOM)) ||
(ptsk->FTrace(EtraceSimulateAbort) &&
GPOS_MATCH_EX(ex, CException::ExmaSystem, CException::ExmiAbort)) ||
(ptsk->FTrace(EtraceSimulateIOError) &&
GPOS_MATCH_EX(ex, CException::ExmaSystem, CException::ExmiIOError)) ||
(ptsk->FTrace(EtraceSimulateNetError) &&
GPOS_MATCH_EX(ex, CException::ExmaSystem, CException::ExmiNetError));
}
//---------------------------------------------------------------------------
// @function:
// FSimulateIOErrorInternal
//
// @doc:
// Inject I/O exception
//
//---------------------------------------------------------------------------
static BOOL
FSimulateIOErrorInternal
(
INT iErrno,
const CHAR *szFile,
ULONG ulLine
)
{
BOOL fRes = false;
ITask *ptsk = ITask::PtskSelf();
if (NULL != ptsk &&
ptsk->FTrace(EtraceSimulateIOError) &&
CFSimulator::Pfsim()->FNewStack(CException::ExmaSystem, CException::ExmiIOError) &&
!GPOS_MATCH_EX(ptsk->Perrctxt()->Exc(), CException::ExmaSystem, CException::ExmiIOError))
{
// disable simulation temporarily to log injection
CAutoTraceFlag(EtraceSimulateIOError, false);
CLogger *plogger = dynamic_cast<CLogger*>(ITask::PtskSelf()->Ptskctxt()->PlogErr());
if (!plogger->FLogging())
{
GPOS_TRACE_FORMAT_ERR("Simulating I/O error at %s:%d", szFile, ulLine);
}
errno = iErrno;
if (ptsk->Perrctxt()->FPending())
{
ptsk->Perrctxt()->Reset();
}
// inject I/O error
fRes = true;
}
return fRes;
}
//---------------------------------------------------------------------------
void TTaskScheduler::Execute(wstring taskName){
ITask *pITask = Activate(taskName);
if(pITask == NULL){
return;
}
///////////////////////////////////////////////////////////////////
// Call ITask::Run to start execution of "Test Task".
///////////////////////////////////////////////////////////////////
HRESULT hr = pITask->Run();
if (FAILED(hr)){
sprintf(lastError, "Failed calling ITask::Run, error = 0x%x\n", hr);
return;
}
pITask->Release();
}
//---------------------------------------------------------------------------
void TTaskScheduler::EditExistingTask(wstring taskName){
ITask *pITask = Activate(taskName);
if(pITask == NULL){
return;
}
///////////////////////////////////////////////////////////////////
// Call ITask::EditWorkItem. Note that this method is
// inherited from IScheduledWorkItem.
///////////////////////////////////////////////////////////////////
HWND hParent = NULL;
DWORD dwReserved = 0;
HRESULT hr = pITask->EditWorkItem(hParent, dwReserved);
// Release ITask interface
pITask->Release();
if (FAILED(hr)){
sprintf(lastError, "Failed calling ITask::EditWorkItem, error = 0x%x\n", hr);
return;
}
}
//---------------------------------------------------------------------------
// @function:
// netutils::FSimulateNetError
//
// @doc:
// Inject networking exception
//
//---------------------------------------------------------------------------
BOOL
gpos::netutils::FSimulateNetError
(
INT iErrno,
const CHAR *szFile,
ULONG ulLine
)
{
GPOS_ASSERT(0 < iErrno);
ITask *ptsk = ITask::PtskSelf();
if (NULL != ptsk &&
ptsk->FTrace(EtraceSimulateNetError) &&
CFSimulator::Pfsim()->FNewStack(CException::ExmaSystem, CException::ExmiNetError) &&
!GPOS_MATCH_EX(ptsk->Perrctxt()->Exc(), CException::ExmaSystem, CException::ExmiNetError))
{
// disable simulation temporarily to log injection
CAutoTraceFlag(EtraceSimulateNetError, false);
CLogger *plogger = dynamic_cast<CLogger*>(ITask::PtskSelf()->Ptskctxt()->PlogErr());
if (!plogger->FLogging())
{
GPOS_TRACE_FORMAT_ERR("Simulating networking error at %s:%d", szFile, ulLine);
}
errno = iErrno;
if (ptsk->Perrctxt()->FPending())
{
ptsk->Perrctxt()->Reset();
}
return true;
}
return false;
}