can be removed when a proper task manager admin interface implemented
512317
def post_save(self):
        """"""
        if self.run:
            self.run = False
            self.create_tasks()
            self.save()
1270619
function removeThis()
    {
        $workflowParameters = $this->attribute( 'parameter_list' );
        $cleanupList = array();

        $db = eZDB::instance();
        $db->begin();
        if ( isset( $workflowParameters['cleanup_list'] ) && is_array( $workflowParameters['cleanup_list'] ) )
        {
            $cleanupList = $workflowParameters['cleanup_list'];
            foreach ( $cleanupList as $workflowEventID )
            {
                $workflowEvent = eZWorkflowEvent::fetch( $workflowEventID );
                $workflowType = $workflowEvent->eventType();
                $workflowType->cleanup( $this, eZWorkflowEvent::fetch( $workflowEventID ) );
            }
        }
        eZPersistentObject::removeObject( eZWorkflowProcess::definition(), array( 'id' => $this->attribute( 'id' ) ) );
        $db->commit();
    }
146176
def RemoveTask(self, task):
    
    with self._lock:
      if task.identifier not in self._tasks_abandoned:
        raise KeyError('Task {0:s} was not abandoned.'.format(task.identifier))

      if not task.has_retry:
        raise KeyError(
            'Will not remove a task {0:s} without retry task.'.format(
                task.identifier))

      del self._tasks_abandoned[task.identifier]

      logger.debug('Removed task {0:s}.'.format(task.identifier))
1362403
public void unregisterTaskDef(String taskType) {
        Preconditions.checkArgument(StringUtils.isNotBlank(taskType), "Task type cannot be blank");
        stub.deleteTask(MetadataServicePb.DeleteTaskRequest.newBuilder()
                .setTaskType(taskType)
                .build()
        );
    }
402662
def RemoveProcessedTaskStorage(self, task):
    
    if task.identifier not in self._task_storage_writers:
      raise IOError('Storage writer for task: {0:s} does not exist.'.format(
          task.identifier))

    del self._task_storage_writers[task.identifier]
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()
1172693
def remove_system(self, system):
        '''
        
        '''
        if system in self._systems:
            self._systems.remove(system)
        else:
            raise UnmanagedSystemError(system)
185641
public synchronized void submitCancelTaskCommand(long jobId, int taskId, long workerId) {
    CancelTaskCommand.Builder cancelTaskCommand = CancelTaskCommand.newBuilder();
    cancelTaskCommand.setJobId(jobId);
    cancelTaskCommand.setTaskId(taskId);
    JobCommand.Builder command = JobCommand.newBuilder();
    command.setCancelTaskCommand(cancelTaskCommand);
    if (!mWorkerIdToPendingCommands.containsKey(workerId)) {
      mWorkerIdToPendingCommands.put(workerId, Lists.<JobCommand>newArrayList());
    }
    mWorkerIdToPendingCommands.get(workerId).add(command.build());
  }
902394
protected synchronized void removeAdminObjectService(ServiceReference<AdminObjectService> reference) {
        String id = (String) reference.getProperty(ADMIN_OBJECT_CFG_ID);
        if (id != null) {
            removeAdminObjectService(reference, id, false);

            String jndiName = (String) reference.getProperty(ADMIN_OBJECT_CFG_JNDI_NAME);
            if (jndiName != null && !jndiName.equals(id)) {
                removeAdminObjectService(reference, jndiName, true);
            }
        }
    }
1131138
public function cancelTask($task_id) {
        $redis = Cache::redis();
        $timer_id = $redis->hGet(self::TIMER_TIME_QUEUE, $task_id);
        $redis->hDel(self::TIMER_QUEUE, $task_id);
        $redis->hDel(self::TIMER_TIME_QUEUE, $task_id);
        $redis->hDel(self::SWOOLE_TASK_WAIT, $task_id);
        if ($timer_id) {
            swoole_timer_clear($timer_id);
        }
    }
663323
public boolean removeTaskByTaskId(String taskId, boolean isInterrupt) {
        ScheduledFuture<?> future = runningTask.get(taskId);
        boolean flag = future.cancel(isInterrupt);
        if (flag) {
            runningTask.remove(taskId);
        }
        return flag;
    }
1149649
public void removeFromApplication(boolean bFreeIfDone)
    {
        if (m_application == null)
            return; // In free.
        Application app = m_application;
        m_application = null;
        boolean bEmptyTaskList = app.removeTask(this);    // Remove this session from the list
        if (bFreeIfDone)
            if (bEmptyTaskList)
                app.free();     // No more tasks -> Quit app!
    }
289353
public static TaskManager unregisterResource(Object resource) {
		if (resource == null) return null;
		synchronized (resources) {
			return resources.remove(resource);
		}
	}
137883
public synchronized void cleanWaitTaskQueue() {

        for (ParallelTask task : waitQ) {
            task.setState(ParallelTaskState.COMPLETED_WITH_ERROR);
            task.getTaskErrorMetas().add(
                    new TaskErrorMeta(TaskErrorType.USER_CANCELED, "NA"));
            logger.info(
                    "task {} removed from wait q. This task has been marked as USER CANCELED.",
                    task.getTaskId());

        }

        waitQ.clear();
    }
744465
def DisableInterfaces(interface):
  
  set_tested_versions = ['vista', '2008']
  set_args = ['/c', 'netsh', 'set', 'interface', interface, 'DISABLED']
  host_version = platform.platform().lower()
  for version in set_tested_versions:
    if host_version.find(version) != -1:
      # pylint: disable=undefined-variable
      res = client_utils_common.Execute(
          'cmd', set_args, time_limit=-1, bypass_whitelist=True)
      return res
  return ('', 'Command not available for this version.', 99, '')
515242
def process_remove_action(processors, action, argument):
    """"""
    for processor in processors:
        processor(action, argument)
    db.session.commit()
588577
private void remove_poll_object(final DeviceProxy deviceProxy, final String objname,
            final String objtype) throws DevFailed {
        // Send command on administration device.
        if (deviceProxy.getAdm_dev() == null) {
            import_admin_device(deviceProxy, "remove_poll_object");
        }
        if (DeviceProxy.isCheck_idl() && deviceProxy.getAdm_dev().get_idl_version() < 2) {
            Except.throw_non_supported_exception("TangoApi_IDL_NOT_SUPPORTED",
                "Not supported by the IDL version used by device", deviceProxy
                    .getFull_class_name()
                    + ".remove_poll_object()");
        }

        final DeviceData argin = new DeviceData();
        final String[] params = new String[3];
        params[0] = deviceProxy.devname;
        params[1] = objtype;
        params[2] = objname.toLowerCase();
        argin.insert(params);
        deviceProxy.getAdm_dev().command_inout("RemObjPolling", argin);
    }