Пример #1
0
        private object CancelTask(MapReduceOperation operation)
        {
            string taskID = (string)operation.TaskID;

            lock (_lock)
            {
                if (runningTasks.ContainsKey(taskID))
                {
                    TaskBase t = (TaskBase)runningTasks[taskID];
                    t.StopTask();
                    t.Dispose();

                    this.cancelledTask.Add(taskID);

                    if (_context.CacheImpl != null && _context.CacheInternal != null)
                    {
                        EventContext eventContext = new EventContext();
                        eventContext.TaskStatus        = TaskStatus.Cancelled;
                        eventContext.TaskFailureReason = "Task was Cancelled by user.";
                        _context.CacheInternal.NotifyTaskCallback(t.TaskId, t.CallbackListeners, false, null, eventContext);
                    }
                    runningTasks.Remove(taskID);
                    if (_context.PerfStatsColl != null)
                    {
                        _context.PerfStatsColl.DecrementRunningTasks();
                    }
                    if (_context.NCacheLog.IsInfoEnabled)
                    {
                        _context.NCacheLog.Info("TaskTracker.CancelTask", "Task with task ID '" + taskID.ToUpper() + "' has been cancelled.");
                    }
                }
                else
                {
                    _context.NCacheLog.Error("TaskTracker.CancelTask", "Task with task ID '" + taskID.ToUpper() + "' does not exist.");
                }
            }
            return(true);
        }
Пример #2
0
        private object CancelAllTasks(bool topologyChanged)
        {
            //Stop and Remove all running/waiting tasks
            lock (_lock)
            {
                foreach (object taskID in runningTasks.Keys)
                {
                    TaskBase t = (TaskBase)runningTasks[taskID];
                    if (t != null)
                    {
                        t.StopTask();
                        t.Dispose();

                        this.cancelledTask.Add(taskID.ToString());

                        if (_context.CacheImpl != null && _context.CacheInternal != null)
                        {
                            EventContext eventContext = new EventContext();
                            eventContext.TaskStatus = TaskStatus.Cancelled;
                            if (topologyChanged)
                            {
                                eventContext.TaskFailureReason = "Task was cancelled because Toplogy has been change.";
                            }
                            _context.CacheInternal.NotifyTaskCallback(t.TaskId, t.CallbackListeners, false, null, eventContext);
                        }
                    }
                }
            }

            runningTasks.Clear();
            if (_context.PerfStatsColl != null)
            {
                _context.PerfStatsColl.RunningTasksCount(0);
            }

            lock (_lock)
            {
                foreach (object taskID in waitingTasks.Keys)
                {
                    TaskBase t = (TaskBase)waitingTasks[taskID];
                    if (t != null)
                    {
                        t.StopTask();
                        t.Dispose();

                        if (_context.CacheImpl != null && _context.CacheInternal != null)
                        {
                            EventContext eventContext = new EventContext();
                            eventContext.TaskStatus = TaskStatus.Cancelled;
                            if (topologyChanged)
                            {
                                eventContext.TaskFailureReason = "Task was cancelled because of Toplogy change.";
                            }
                            _context.CacheInternal.NotifyTaskCallback(t.TaskId, t.CallbackListeners, false, null, eventContext);
                        }
                    }
                }
            }
            waitingTasks.Clear();

            if (_context.PerfStatsColl != null)
            {
                _context.PerfStatsColl.WaitingTasksCount(0);
            }
            //Reset the sequenceID and lastRunningID

            sequenceId        = 0;
            lastRunningTaskId = 0;

            if (taskOutputStore != null)
            {
                taskOutputStore.Dispose();
            }

            return(true);
        }
Пример #3
0
        private TaskExecutionStatus StartTask(string taskId, long sequenceId)
        {
            lock (_lock)
            {
                TaskBase task = (TaskBase)submittedTasks[taskId];
                if (task != null)
                {
                    submittedTasks.Remove(taskId);
                    if (SlotAvailable)
                    {
                        if (sequenceId == lastRunningTaskId + 1)
                        {
                            try
                            {
                                if (!runningTasks.ContainsKey(task.TaskId))
                                {
                                    runningTasks.Add(task.TaskId, task);
                                }
                                if (_context.PerfStatsColl != null)
                                {
                                    _context.PerfStatsColl.IncrementRunningTasks();
                                }
                                lastRunningTaskId++;
                                task.StartTask();
                            }
                            catch (Exception exx)
                            {
                                task.StopTask();
                                task.Dispose();
                                if (runningTasks.ContainsKey(task.TaskId))
                                {
                                    runningTasks.Remove(task.TaskId);
                                    if (_context.PerfStatsColl != null)
                                    {
                                        _context.PerfStatsColl.DecrementRunningTasks();
                                    }
                                }
                                throw new OperationFailedException(exx.Message);
                            }

                            while (taskSequenceList.Count != 0 && SlotAvailable)
                            {
                                long seqID = 0;
                                foreach (long key in taskSequenceList.Keys)
                                {
                                    seqID = key;
                                    break;
                                }

                                if (seqID == lastRunningTaskId + 1)
                                {
                                    if (waitingTasks.Count > 0)
                                    {
                                        TaskBase t = (TaskBase)waitingTasks[taskSequenceList[seqID]];
                                        try
                                        {
                                            if (!runningTasks.ContainsKey(t.TaskId))
                                            {
                                                runningTasks.Add(t.TaskId, t);
                                            }
                                            if (_context.PerfStatsColl != null)
                                            {
                                                _context.PerfStatsColl.IncrementRunningTasks();
                                            }
                                            lastRunningTaskId++;
                                            taskSequenceList.Remove(seqID);
                                            waitingTasks.Remove(t.TaskId);
                                            if (_context.PerfStatsColl != null)
                                            {
                                                _context.PerfStatsColl.DecrementWaitingTasks();
                                            }

                                            t.StartTask();
                                        }
                                        catch (Exception exx)
                                        {
                                            t.StopTask();
                                            if (runningTasks.ContainsKey(t.TaskId))
                                            {
                                                runningTasks.Remove(t.TaskId);
                                                if (_context.PerfStatsColl != null)
                                                {
                                                    _context.PerfStatsColl.DecrementRunningTasks();
                                                }
                                            }
                                            throw new OperationFailedException(exx.Message);
                                        }
                                    }
                                }
                                else
                                {
                                    break;
                                }
                            }
                            return(TaskExecutionStatus.Running);
                        }
                        else
                        {
                            taskSequenceList.Add(sequenceId, task.TaskId);
                            if (!waitingTasks.ContainsKey(task.TaskId))
                            {
                                waitingTasks.Add(task.TaskId, task);
                            }
                            if (_context.PerfStatsColl != null)
                            {
                                _context.PerfStatsColl.IncrementWaitingTasks();
                            }
                            if (_context.NCacheLog.IsInfoEnabled)
                            {
                                _context.NCacheLog.Info("TaskTracker.StartTask", "MapReduce task with task ID '" + task.TaskId.ToUpper() + "' is in the waiting queue.");
                            }
                            return(TaskExecutionStatus.Waiting);
                        }
                    }
                    else if (taskSequenceList.Count < _queueSize)
                    {
                        taskSequenceList.Add(sequenceId, task.TaskId);
                        if (!waitingTasks.ContainsKey(task.TaskId))
                        {
                            waitingTasks.Add(task.TaskId, task);
                        }
                        if (_context.PerfStatsColl != null)
                        {
                            _context.PerfStatsColl.IncrementWaitingTasks();
                        }
                        if (_context.NCacheLog.IsInfoEnabled)
                        {
                            _context.NCacheLog.Info("TaskTracker.StartTask", "MapReduce task with task ID '" + task.TaskId.ToUpper() + "' is in the waiting queue.");
                        }
                        return(TaskExecutionStatus.Waiting);
                    }
                    else
                    {
                        throw new Exception("No more task can be submitted");
                    }
                }
            }
            return(TaskExecutionStatus.Failure);
        }