Resumes the response stream.
169856
def resume(self):
        """"""
        with self._wake:
            self._paused = False
            self._wake.notifyAll()
952717
def pause(self):
        """"""
        self._mq.send("p", True, type=1)
        self._paused = True
1081266
@Override
    public AsyncInputStream resume() {
        switch (state) {
            case STATUS_CLOSED:
                throw new IllegalStateException("Cannot resume, already closed");
            case STATUS_PAUSED:
                state = STATUS_ACTIVE;
                doRead();
        }
        return this;
    }
499187
public synchronized final void pause() {
        if (isStop) return ;

        isPause = true;
        mPauseTimeInFuture = mStopTimeInFuture - SystemClock.elapsedRealtime();
        mHandler.removeMessages(MSG);
    }
94196
function (done) {
      if (called) return;

      called = true;

      // wait for req events to fire
      process.nextTick(function() {
        if (waitend && req.readable) {
          // dump rest of request
          req.resume();
          req.once('end', done);
          return;
        }

        done();
      });
    }
1165097
def resume_writing(self, exc=None):
        '''
        '''
        assert self._paused
        self._paused = False
        waiter = self._waiter
        if waiter is not None:
            self._waiter = None
            if not waiter.done():
                if exc is None:
                    waiter.set_result(None)
                else:
                    waiter.set_exception(exc)
            self.transport.resume_reading()
        self._write_from_buffer()
583466
async def pause(self):
        """"""

        self.logger.debug("pause command")

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

        if self.streamer is None:
            return

        try:
            if self.streamer.is_playing():
                self.streamer.pause()
                self.pause_time = self.vclient.loop.time()
                self.statuslog.info("Paused")
        except Exception as e:
            logger.error(e)
            pass
467
def resume(self):
        
        for child in chain(self.consumers.values(), self.workers):
            child.resume()
497534
def respond(response, headers_or_body = {}, body = nil)
      raise StateError, "not in header state" if @response_state != :headers

      if headers_or_body.is_a? Hash
        headers = headers_or_body
      else
        headers = {}
        body = headers_or_body
      end

      if @keepalive
        headers[CONNECTION] = KEEP_ALIVE
      else
        headers[CONNECTION] = CLOSE
      end

      case response
      when Symbol, Fixnum, Integer
        response = Response.new(response, headers, body)
      when Response
      else raise TypeError, "invalid response: #{response.inspect}"
      end

      if current_request
        current_request.handle_response(response)
      else
        raise RequestError
      end

      # Enable streaming mode
      if response.chunked? and response.body.nil?
        @response_state = :chunked_body
      elsif @keepalive
        reset_request
      else
        @current_request = nil
        @parser.reset
        @request_fsm.transition :closed
      end
    rescue IOError, SystemCallError, RequestError
      # The client disconnected early, or there is no request
      @keepalive = false
      @request_fsm.transition :closed
      @parser.reset
      @current_request = nil
    end
596628
def resume():
	""""""

	if not settings.platformCompatible():
		return False

	(output, error) = subprocess.Popen(["osascript", "-e", RESUME], stdout=subprocess.PIPE).communicate()
1015235
public void resume(int position) throws IllegalStateException {
        // allow resume from pause
        switch (subscriberStream.getState()) {
            case PAUSED:
                subscriberStream.setState(StreamState.PLAYING);
                sendReset();
                sendResumeStatus(currentItem.get());
                if (pullMode) {
                    sendVODSeekCM(position);
                    subscriberStream.onChange(StreamState.RESUMED, currentItem.get(), position);
                    playbackStart = System.currentTimeMillis() - position;
                    long length = currentItem.get().getLength();
                    if (length >= 0 && (position - streamOffset) >= length) {
                        // Resume after end of stream
                        stop();
                    } else {
                        ensurePullAndPushRunning();
                    }
                } else {
                    subscriberStream.onChange(StreamState.RESUMED, currentItem.get(), position);
                    videoFrameDropper.reset(VideoFrameDropper.SEND_KEYFRAMES_CHECK);
                }
                break;
            default:
                throw new IllegalStateException("Cannot resume from non-paused state");
        }
    }
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)
1051240
def pause(self) -> None:
        """"""
        with self.__state_lock:
            if self.__state == DataChannelBuffer.State.started:
                self.__state = DataChannelBuffer.State.paused
979833
private void closeThreads() throws IOException {
    try {
      if (streamer != null) {
        streamer.close();
        streamer.join();
      }

      // shutdown response after streamer has exited.
      if (response != null) {
        response.close();
        response.join();
        response = null;
      }
    } catch (InterruptedException e) {
      throw new InterruptedIOException("Failed to shutdown response thread");
    }
  }
329027
public function resumeRecv()
    {
        if ($this->_isPaused === true) {
            Worker::$globalEvent->add($this->_socket, EventInterface::EV_READ, array($this, 'baseRead'));
            $this->_isPaused = false;
            $this->baseRead($this->_socket, false);
        }
    }
186164
final void continuouslyRestart(long interval) throws IOException, InterruptedException {
        LOGGER.entering(interval);

        while (true) {
            if (!isInitialized()) {
                FileDownloader.checkForDownloads(getType(), getLauncherOptions()
                        .isFileDownloadCheckTimeStampOnInvocation(), getLauncherOptions()
                        .isFileDownloadCleanupOnInvocation());
            }

            startProcess(false);

            while (!handler.hasResult()) {
                LOGGER.fine("Child process still running. Going back to sleep.");
                Thread.sleep(interval);
            }

            if (handler.hasResult()) {
                ExecuteException e = handler.getException();
                if (e != null) {
                    LOGGER.log(Level.SEVERE, handler.getException().getMessage(), handler.getException());
                }
            }
            LOGGER.info("Child process quit. Restarting it.");
            setInitialized(false);
        }
    }
1098015
public void pause() {
        checkState();
        if (mState == STATE_PLAYING) {
            PlaybackService.pause(getContext(), mClientKey);
            mState = STATE_PAUSED;
        }
    }