Execute all queued transitions step by step.
192772
def _transition_loop(self):
        """"""
        while self._transitions:
            start = time.time()
            for transition in self._transitions:
                transition.step()
                if transition.finished:
                    self._transitions.remove(transition)

            time_delta = time.time() - start
            sleep_time = max(0, self.MIN_STEP_TIME - time_delta)
            time.sleep(sleep_time)
427500
def _run_queued_callbacks(self):
        '''  '''
        for callback in self._queued_callbacks:
            try:
                callback()
            except Exception as ex:
                logger.error("Exception: %s" % str(ex))
539483
protected function executeQueue()
    {
        foreach ($this->queueActions as $key => $action) {
            if (self::QUEUE_ACTION_PERSIST === $action) {
                $this->doPersist($this->queueManagerNames[$key], $this->queueModels[$key], $this->queueIds[$key]);
            } else {
                $this->manager->getPool()->getManager($this->queueManagerNames[$key])->remove($this->queueModels[$key]);
            }
        }

        $this->cleanQueue();
    }
1282564
def execute(self):
        
        stack = self._stack
        callbacks = self._callbacks
        self._stack = []
        self._callbacks = []

        deferred = []

        build = self._nested_future

        pipe = self._pipeline(self.connection_name)
        for item, args, kwargs, ref in stack:
            f = getattr(pipe, item)
            deferred.append(build(f(*args, **kwargs), ref))

        inject_callbacks = getattr(self.parent, '_inject_callbacks')
        inject_callbacks(deferred + callbacks)
670070
function flush() {
  if (queue.length) {
    let bench = queue[0]
    process.nextTick(() => {
      run(bench).then(() => {
        queue.shift()
        flush()
      }, console.error)
    })
  }
}
357392
def execute_all(self):
        
        for workflow_id in self.workflows:
            if self.workflows[workflow_id].online:
                for interval in self.workflows[workflow_id].requested_intervals:
                    logging.info("Executing workflow {} over interval {}".format(workflow_id, interval))
                    self.workflows[workflow_id].execute(interval)
1364832
def run_steps(node: Node, pipeline: RenderingPipeline, **args):
    """"""
    for step in pipeline.steps:
        result = step(node, pipeline=pipeline, **args)
        if isinstance(result, dict):
            args = {**args, **result}
480169
public function run()
    {
        $this->init();

        // Loop forever, except when a maximum number of requests is configured
        $requestsHandled = 0;
        while ($this->maxRequests === null || $requestsHandled < $this->maxRequests) {
            $this->doStep();
            $requestsHandled++;
        }
    }
785481
protected function executeCallQueues()
    {
        foreach ($this->inputs->getEntries() as $entry)
        {
            $this->executeCallQueueEntry($entry);
            if (!$this->executeQueues) return;
        }

        foreach ($this->operations->getEntries() as $entry)
        {
            $this->executeCallQueueEntry($entry);
            if (!$this->executeQueues) return;
        }

        foreach ($this->outputs->getEntries() as $entry)
        {
            $this->executeCallQueueEntry($entry);
            if (!$this->executeQueues) return;
        }
    }
242535
def run(self):
        
        try:
            while True:
                input_chunks = [input.get() for input in self.input_queues]
                for input in self.input_queues:
                    input.task_done()
                if any(chunk is QUEUE_ABORT for chunk in input_chunks):
                    self.abort()
                    return
                if any(chunk is QUEUE_FINISHED for chunk in input_chunks):
                    break
                self.output(self.process_chunks(input_chunks))
            # Finalise the final chunk (process_chunks does this for all
            # but the last chunk).
            self.output(self.finalise())
        except:
            self.abort()
            raise
        else:
            for queue in self.output_queues:
                queue.put(QUEUE_FINISHED)
708285
private void doRun() {
        if (migrationInfo.startProcessing()) {
            try {
                if (firstFragment) {
                    executeBeforeMigrations();
                }

                for (Operation migrationOperation : fragmentMigrationState.getMigrationOperations()) {
                    runMigrationOperation(migrationOperation);
                }

                success = true;
            } catch (Throwable e) {
                failureReason = e;
                getLogger().severe("Error while executing replication operations " + migrationInfo, e);
            } finally {
                afterMigrate();
            }
        } else {
            logMigrationCancelled();
        }
    }
1304717
def backward_step(self):
        
        logger.debug("Executing backward step ...")
        self.run_to_states = []
        self.set_execution_mode(StateMachineExecutionStatus.BACKWARD)
881576
def do_execute(self):
        
        for i in range(
                int(self.resolve_option("min")),
                int(self.resolve_option("max")) + 1,
                int(self.resolve_option("step"))):
            self._output.append(Token(i))
        return None
715544
def run(self):
        '''
        
        '''
        self.thread = Thread(target=self.__processQueue)
        self.thread.start()
392752
protected function executeNextJob(): void
    {
        while ($this->jobs) {
            $job = \array_pop($this->jobs);
            
            if ($job->state & AbstractPromise::PENDING) {
                $done = false;
                
                (new Coroutine($job->context, $job->generator))->when(function (?\Throwable $e, $v = null) use ($job, & $done) {
                    if ($e) {
                        $job->fail($e);
                    } else {
                        $job->resolve($v);
                    }
                    
                    if ($done) {
                        $this->executeNextJob();
                    } else {
                        $done = true;
                    }
                });
                
                if (!$done) {
                    $done = true;
                    
                    return;
                }
            }
        }
        
        $this->running--;
    }
102439
def step_into(self):
        
        logger.debug("Execution step into ...")
        self.run_to_states = []
        if self.finished_or_stopped():
            self.set_execution_mode(StateMachineExecutionStatus.FORWARD_INTO)
            self._run_active_state_machine()
        else:
            self.set_execution_mode(StateMachineExecutionStatus.FORWARD_INTO)
385563
def run_all(self, direction):
        
        for key in sorted(migration_registry.keys):
            self.run(key, direction)