Stop one or more running workflows.

    \b
    NAMES: The names, ids or job ids of the workflows that should be stopped.
           Leave empty to stop all running workflows.
543282
def workflow_stop(obj, names):
    
    if len(names) == 0:
        msg = 'Would you like to stop all workflows?'
    else:
        msg = '\n{}\n\n{}'.format('\n'.join(names),
                                  'Would you like to stop these jobs?')

    if click.confirm(msg, default=True, abort=True):
        stop_workflow(obj['config'], names=names if len(names) > 0 else None)
755728
@Invalidate
    public void stop(){
        for(ServiceRegistration registration: registrations){
            registration.unregister();
        }
        registrations.clear();
        names.clear();
    }
187379
def _stop_actions(self):
        
        Global.LOGGER.info("stopping actions")

        list(map(lambda x: x.stop(), self.actions))

        Global.LOGGER.info("actions stopped")
955060
def kill_all_process(self):
    
    if (runtime.get_active_config("cleanup_pending_process",False)):
      for process in self.get_processes():
        self.terminate(process.unique_id)
580385
def stop(self):
        
        super(AggregateDependency, self).stop()

        if self.services:
            return [
                (service, reference)
                for reference, service in self.services.items()
            ]

        return None
1083150
public List<String> getRunningWorkflow(String workflowName, Integer version) {
        Preconditions.checkArgument(StringUtils.isNotBlank(workflowName), "Workflow name cannot be blank");
        return getForEntity("workflow/running/{name}", new Object[]{"version", version}, new GenericType<List<String>>() {
        }, workflowName);
    }
758177
def stop(self):
        
        for subscript in list(self.scripts.values()):
            subscript.stop()
        print(('--- stopping: ', self.name))
        self._abort = True
882187
def kill_workflow(self):
        '''
        '''
        logger.info('kill workflow of experiment "%s"', self.experiment_name)
        content = dict()
        url = self._build_api_url(
            '/experiments/{experiment_id}/workflow/kill'.format(
                experiment_id=self._experiment_id
            )
        )
        res = self._session.post(url)
        res.raise_for_status()
824872
def destroy
      @workflow.destroy

      respond_to do |format|
        format.html { redirect_to workflows_url }
        format.json { head :no_content }
      end
    end
203288
function cleanupWorkFlowProcess()
    {
        $db = eZDB::instance();
        $workflowID = $this->attribute( 'id' );
        $event_list = $this->fetchEvents();
        if ( $event_list != null )
        {
            $existEventIDArray = array();
            foreach ( $event_list as $event )
            {
                $eventID = $event->attribute( 'id' );
                $existEventIDArray[] = $eventID;
            }
            $existEventIDString = implode( ',', $existEventIDArray );
            $db->query( "DELETE FROM ezworkflow_process
                               WHERE workflow_id=$workflowID
                                 AND event_id not in ( $existEventIDString )" );
        }
        else
        {
            $db->query( "DELETE FROM ezworkflow_process WHERE workflow_id=$workflowID" );
        }
    }
177117
def terminate_instances(self, instance_ids=None):
        
        params = {}
        if instance_ids:
            self.build_list_params(params, instance_ids, 'InstanceId')
        return self.get_list('TerminateInstances', params,
                             [('item', Instance)], verb='POST')
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();
    }
168612
def terminate_all(wait=False):
        
        for instance in Process.instances:
            if instance.is_running():
                instance.terminate(wait)
826483
def delete(self, *names: str, pipeline=False):
        
        if pipeline:
            self._pipeline.delete(*names)
        else:
            self._db.delete(*names)
419374
def stop_all(wait=true)
      if @scripts_to_run['terminate']
        options = { "DB_TERMINATE_SAFETY" => "text:off" }
        @servers.each { |s| s.run_executable(@scripts_to_run['terminate'], options) unless s.state == 'stopped' }
      else
        @servers.each { |s| s.stop }
      end

      wait_for_all("stopped") if wait
      # unset dns in our local cached copy..
      @servers.each { |s| s.params['dns-name'] = nil } 
    end
1309573
def stop(name, force=False, call=None):
    '''
    
    '''
    if call != 'action':
        raise SaltCloudSystemExit(
            'The stop action must be called with -a or --action.'
        )

    log.info('Stopping node %s', name)

    instanceId = _get_node(name)['InstanceId']

    params = {
        'Action': 'StopInstance',
        'InstanceId': instanceId,
        'ForceStop': six.text_type(force).lower()
    }
    result = query(params)

    return result
16502
@Service
    public void terminateWorkflow(String workflowId, String reason) {
        workflowExecutor.terminateWorkflow(workflowId, reason);
    }