Resume a paused scan.

        Normally it will return in Running state. If something goes wrong it
        will return in Fault state.
358736
def resume(self):
        # type: () -> None
        
        self.transition(ss.RUNNING)
        self.resume_queue.put(True)
334767
@Override
    public void resume() throws PauseableComponentException {
        try {
            shouldActivate = true;
            if (ivState == INACTIVE_STATE) {
                activateEndpoint();
            } else if (ivState == ACTIVE_STATE) {
                Tr.info(tc, "MDB_ENDPOINT_ALREADY_ACTIVE_CNTR4118I", beanMetaData.enterpriseBeanName, beanMetaData.getModuleMetaData().getName(),
                        beanMetaData.getModuleMetaData().getApplicationMetaData().getName());
            } else {
                throw new PauseableComponentException(Tr.formatMessage(tc, "MDB_ENDPOINT_DID_NOT_RESUME_CNTR4120W", beanMetaData.enterpriseBeanName,
                                                                       beanMetaData.getModuleMetaData().getName(),
                                                                       beanMetaData.getModuleMetaData().getApplicationMetaData().getName()));
            }
        } catch (ResourceException re) {
            throw new PauseableComponentException(re);
        }

    }
1051240
def pause(self) -> None:
        """"""
        with self.__state_lock:
            if self.__state == DataChannelBuffer.State.started:
                self.__state = DataChannelBuffer.State.paused
604043
def resume_reading(self):
        

        # Clear the read pause status
        self._recv_paused = False

        # Call resume_reading() on the transport
        self._transport.resume_reading()

        # If there's data in the receive buffer, pass it on to the
        # client protocol
        if self._recv_buf:
            self.data_received(b'')
731268
def resume(localfile, jottafile, JFS):
    """"""
    with open(localfile) as lf:
        _complete = jottafile.resume(lf)
    return _complete
827866
public void resumed(CmmnActivityExecution execution) {
    if (execution.isAvailable()) {
      // trigger created() to check whether an exit- or
      // entryCriteria has been satisfied in the meantime.
      created(execution);

    } else if (execution.isActive()) {
      // if the given case execution is active after resuming,
      // then propagate it to the children.
      resumeChildren(execution);
    }
  }
1058482
@Override
	public void pauseScan() {
		lock.lock();
		try {
			if (State.RUNNING.equals(state)) {
				spiderThread.pauseScan();
				state = State.PAUSED;
				SpiderEventPublisher.publishScanEvent(
						ScanEventPublisher.SCAN_PAUSED_EVENT, this.scanId);
			}
		} finally {
			lock.unlock();
		}
	}
1078973
public final void resumeState(final WebDriver webDriver) {
        Validate.validState(crawlFrontier != null, "Cannot resume state at this point.");

        start(webDriver, true);
    }
1098015
public void pause() {
        checkState();
        if (mState == STATE_PLAYING) {
            PlaybackService.pause(getContext(), mClientKey);
            mState = STATE_PAUSED;
        }
    }
910693
def periodic_callback(self):
        

        if self.stopped:
            return

        # Check if we should start scanning again
        if not self.scanning and len(self._connections) == 0 and self.connecting_count == 0:
            self._logger.info("Restarting scan for devices")
            self.start_scan(self._active_scan)
            self._logger.info("Finished restarting scan for devices")
6659
public void pause() {
        if (hasState(TICKING) && !hasState(PAUSED)) {
            if (DBG) Log.v(TAG, "pause. " + mEntries.size());
            mContentView.animate().cancel();
            addState(PAUSED);
            cancel(-1);
        }
    }
1097965
def start_scan(self, scan_id, targets, parallel=1):
        

        os.setsid()
        multiscan_proc = []
        logger.info("%s: Scan started.", scan_id)
        target_list = targets
        if target_list is None or not target_list:
            raise OSPDError('Erroneous targets list', 'start_scan')

        for index, target in enumerate(target_list):
            while len(multiscan_proc) >= parallel:
                progress = self.calculate_progress(scan_id)
                self.set_scan_progress(scan_id, progress)
                multiscan_proc = self.check_pending_target(scan_id,
                                                           multiscan_proc)
                time.sleep(1)

            #If the scan status is stopped, does not launch anymore target scans
            if self.get_scan_status(scan_id) == ScanStatus.STOPPED:
                return

            logger.info("%s: Host scan started on ports %s.", target[0], target[1])
            scan_process = multiprocessing.Process(target=self.parallel_scan,
                                                   args=(scan_id, target[0]))
            multiscan_proc.append((scan_process, target[0]))
            scan_process.start()
            self.set_scan_status(scan_id, ScanStatus.RUNNING)

        # Wait until all single target were scanned
        while multiscan_proc:
            multiscan_proc = self.check_pending_target(scan_id, multiscan_proc)
            if multiscan_proc:
                progress = self.calculate_progress(scan_id)
                self.set_scan_progress(scan_id, progress)
            time.sleep(1)

        # Only set the scan as finished if the scan was not stopped.
        if self.get_scan_status(scan_id) != ScanStatus.STOPPED:
            self.finish_scan(scan_id)
830434
def resume(self):
        
        if self.get_state() != Target.TARGET_HALTED:
            logging.debug('cannot resume: target not halted')
            return
        self.notify(Notification(event=Target.EVENT_PRE_RUN, source=self, data=Target.RUN_TYPE_RESUME))
        self._run_token += 1
        self.clear_debug_cause_bits()
        self.write_memory(CortexM.DHCSR, CortexM.DBGKEY | CortexM.C_DEBUGEN)
        self.flush()
        self.notify(Notification(event=Target.EVENT_POST_RUN, source=self, data=Target.RUN_TYPE_RESUME))
142147
def pause(self):
        
        if self._status == TransferState.RUNNING:
            self._running.clear()
            self._status = TransferState.PAUSED
        else:
            raise SbgError('Can not pause. Download not in RUNNING state.')
611031
def resume_trial(self, trial):
        """"""

        assert trial.status == Trial.PAUSED, trial.status
        self.start_trial(trial)
194401
def restart(self, offset: int):
        '''
        '''
        yield from self._control_stream.write_command(Command('REST', str(offset)))

        reply = yield from self._control_stream.read_reply()

        self.raise_if_not_match('Restart', ReplyCodes.requested_file_action_pending_further_information, reply)
907288
async def resume(self):
        """"""

        self.logger.debug("resume command")

        if not self.state == 'ready':
            return

        if self.streamer is None:
            return

        try:
            if not self.streamer.is_playing():
                play_state = "Streaming" if self.is_live else "Playing"
                self.statuslog.info(play_state)
                self.streamer.resume()

                if self.pause_time is not None:
                    self.vclient_starttime += (self.vclient.loop.time() - self.pause_time)
                self.pause_time = None
        except Exception as e:
            logger.error(e)
            pass