Deletes a given task by name.
12724
def delete_task(self, task=None):
        
        # Iterate over the list of tasks
        for t in self.grindstone['tasks']:
            # If they key of the task matches the task given
            if key_of(t) == task:
                # Remove that task
                self.grindstone['tasks'].remove(t)
                # Return True because something did happen
                return True
        # Return false because nothing happened
        return False
642719
function(name)
{
  //Check if the queue exists
  if(typeof tasks[name] !== 'object'){ return; }

  //Check if queue is paused
  if(tasks[name].paused === true)
  {
    //Set task queue running false
    tasks[name].running = false;
  }
  else
  {
    //Set queue running
    tasks[name].running = true;

    //Check the number of tasks on this tag
    if(tasks[name].handlers.length === 0)
    {
      //Delete this path object
      delete tasks[name];
    }
    else
    {
      //Get the function to run
      var handler = tasks[name].handlers.shift();

      //Run this task
      return handler.call(null, function()
      {
        //Continue with the next task
        return process.nextTick(function()
        {
          //Continue with the next task in the queue
          return task_run(name);
        });
      });
    }
  }
}
1242739
def do_delete(self, args):
        ''''''
        namespace = self.config['namespace']
        if not args.assume_yes:
            response = raw_input('Delete everything in {0!r}?  Enter namespace: '
                                 .format(namespace))
            if response != namespace:
                self.stdout.write('not deleting anything\n')
                return
        self.stdout.write('deleting namespace {0!r}\n'.format(namespace))
        self.task_master.clear()
1183249
def filter_tasks(self, task_names, keep_dependencies=False):
        """"""
        new_tasks = {}
        for task_name in task_names:
            task = self.get_task(task_name)
            if task not in new_tasks:
                new_tasks[task.name] = task
            if keep_dependencies:
                for dependency in task.ordered_dependencies():
                    if dependency not in new_tasks:
                        new_tasks[dependency.name] = dependency
            else:
                #strip dependencies
                task.dependencies = set()

        self.tasks = new_tasks
178322
def remove(self, name):
        """"""
        self.gui.removeAction(self._actions_dict[name].qaction)
        del self._actions_dict[name]
        delattr(self, name)
826483
def delete(self, *names: str, pipeline=False):
        
        if pipeline:
            self._pipeline.delete(*names)
        else:
            self._db.delete(*names)
925303
def pop(self, queue_name):
        
        task_id = self.conn.lpop(queue_name)
        data = self.conn.get(task_id)
        self.conn.delete(task_id)
        return data
688556
function destroy() {
        foreach ($this->_task_list as $task)
            $task->destroy();
        Cron::destroy($this->_name);
    }
1236819
def get_task(self, name):
        """"""
        if name in self.tasks.keys():
            task = self.tasks[name]
        else:
            task = Task(name)
            self.tasks[name] = task
        return task
848620
public static void removeSyncCache(String name) {
		if (StrKit.isBlank(name)) {
			return;
		}
		if (GlobalSyncRedis.caches.containsKey(name)) {
			GlobalSyncRedis.caches.remove(name);
		}
	}
958758
public void deleteTmpFile(String name, JobID jobID) {
		DeleteProcess dp = new DeleteProcess(name, jobID, count.get(new ImmutablePair(jobID,name)));
		executorService.schedule(dp, 5000L, TimeUnit.MILLISECONDS);
	}
1043019
def delete(self, name):
        
        try:
            super(StaticCompilerFileStorage, self).delete(name)
        except OSError, e:
            if e.errno != errno.ENOENT:
                raise
163086
def delete(self):
        
        if not self._deleted:
            if self.api._req_lixian_task_del(self):
                self._deleted = True
                return True
        raise TaskError('This task is already deleted.')
178649
def task_del(self, t):
        
        name = t._name
        if name in self._tasknames:
            del self._tasknames[name]
        self._tasks.discard(t)
        self._tasks_scoped.discard(t)
        try:
            t.stop()
        except:
            log = self._params.get('log', self._discard)
            log.error("Failed to stop processes for task %r -- %s", name, e, exc_info=log.isEnabledFor(logging.DEBUG))
        for pid in t.get_pids():
            self.proc_del(pid)
319777
def remove_task(cls, task):
        
        with cls._lock:
            if not isinstance(task, Task):
                task = cls.resolved_task(task)

            if task:
                cls.tasks.remove(task)

            cls.tasks.sort()
402542
def delete(self, service_name, *ids, **kwargs):
        """"""
        return self._send(requests.delete, service_name, id=ids, **kwargs)
82528
def drop_all(self, queue_name):
        
        task_ids = self.conn.lrange(queue_name, 0, -1)

        for task_id in task_ids:
            self.conn.delete(task_id)

        self.conn.delete(queue_name)