Resume a previously unfinished upload
@param $resumeUri the resume-URI of the unfinished, resumable upload.
501572
public function resume($resumeUri)
  {
     $this->resumeUri = $resumeUri;
     $headers = array(
       'content-range' => "bytes */$this->size",
       'content-length' => 0,
     );
     $httpRequest = new Google_Http_Request(
         $this->resumeUri,
         'PUT',
         $headers
     );
     return $this->makePutRequest($httpRequest);
  }
378056
def resume_pass(deferred)
      deferred.exit_pass
      @delayer.new do
        next if deferred.spoiled?
        fiber.resume(nil).accept_request(worker: self,
                                         deferred: deferred)
      end
    end
1028683
public void restoreState() {
        if (artifactUploadState.areAllUploadsFinished()) {
            artifactUploadState.clearUploadTempData();
            hideUploadProgressButton();
            upload.setEnabled(true);
        } else if (artifactUploadState.isAtLeastOneUploadInProgress()) {
            showUploadProgressButton();
        }
    }
1313360
function waitforNewUpload() {
        var periodTotal = total;
        setTimeout(function () {
            if (periodTotal === total) {
                debuglog('detect upload end');
                end();
            }
            else {
                debuglog('restart upload detect', periodTotal, total);
                checkUplodingStatus(cb);
            }
        }, 50);
    }
1125699
public function resume($resumeUri)
    {
        if (!$this->data->isSeekable()) {
            throw new GoogleException('Cannot resume upload on a stream which cannot be seeked.');
        }

        $this->resumeUri = $resumeUri;
        $response = $this->getStatusResponse();

        if ($response->getBody()->getSize() > 0) {
            return $this->decodeResponse($response);
        }

        $this->rangeStart = $this->getRangeStart($response->getHeaderLine('Range'));

        return $this->upload();
    }
156224
protected function get_resume_data() {
        $resumedata = $this->behaviour->get_resume_data();
        foreach ($resumedata as $name => $value) {
            if ($value instanceof question_file_loader) {
                $resumedata[$name] = $value->get_question_file_saver();
            }
        }
        return $resumedata;
    }
723524
public function callbackAction($callbackUri) {
		try {
			$this->authenticationManager->authenticate();
		} catch (\TYPO3\Flow\Security\Exception\AuthenticationRequiredException $exception) {
			$authenticationException = $exception;
		}

		if ($this->authenticationManager->isAuthenticated()) {
			$storedRequest = $this->securityContext->getInterceptedRequest();
			if ($storedRequest !== NULL) {
				$this->securityContext->setInterceptedRequest(NULL);
				$this->redirectToRequest($storedRequest);
			} else {
				// TODO Do we have to check the URI?
				$this->redirectToUri($callbackUri);
			}
		} else {
			throw new \Flowpack\SingleSignOn\Client\Exception('Could not authenticate in callbackAction triggered by the SSO server.', 1366613161, (isset($authenticationException) ? $authenticationException : NULL));
		}
	}
1364658
public function show(ResumeRequest $request, Resume $resume)
    {

        if ($resume->exists) {
            $view = 'career::resume.show';
        } else {
            $view = 'career::resume.new';
        }

        return $this->response->title(trans('app.view') . ' ' . trans('career::resume.name'))
            ->data(compact('resume'))
            ->view($view, true)
            ->output();
    }
203259
public function resume(string $id, array $data = [], array $headers = [])
    {
        $url = $this->url('subscriptions/%s/resume', $id);

        return $this->post($url, $data, $headers);
    }
875201
@Override
    public PersistableUpload pause() throws PauseException {
        PauseResult<PersistableUpload> pauseResult = pause(true);
        if (pauseResult.getPauseStatus() != PauseStatus.SUCCESS) {
            throw new PauseException(pauseResult.getPauseStatus());
        }
        return pauseResult.getInfoToResume();
    }
25305
public function resume()
    {
        $this->paused = false;

        if($this->getProcess()->getPid() == getmypid()) {
            $this->getLogger()->notice('SIGCONT received; resuming job processing');
        }else{
            $this->getProcess()->kill(SIGCONT);
        }
    }
523513
def RefreshResumableUploadState(self):
        
        if self.strategy != RESUMABLE_UPLOAD:
            return
        self.EnsureInitialized()
        refresh_request = http_wrapper.Request(
            url=self.url, http_method='PUT',
            headers={'Content-Range': 'bytes */*'})
        refresh_response = http_wrapper.MakeRequest(
            self.http, refresh_request, redirections=0,
            retries=self.num_retries)
        range_header = self._GetRangeHeaderFromResponse(refresh_response)
        if refresh_response.status_code in (http_client.OK,
                                            http_client.CREATED):
            self.__complete = True
            self.__progress = self.total_size
            self.stream.seek(self.progress)
            # If we're finished, the refresh response will contain the metadata
            # originally requested. Cache it so it can be returned in
            # StreamInChunks.
            self.__final_response = refresh_response
        elif refresh_response.status_code == http_wrapper.RESUME_INCOMPLETE:
            if range_header is None:
                self.__progress = 0
            else:
                self.__progress = self.__GetLastByte(range_header) + 1
            self.stream.seek(self.progress)
        else:
            raise exceptions.HttpError.FromResponse(refresh_response)
1013016
def do_resume(msg)

      return unless h.state == 'paused' || h.state == 'awaiting'

      h.state = nil

      m = h.delete('paused_apply')
      return do_apply(m) if m
        # if it's a paused apply, pipe it directly to #do_apply

      replies = h.delete('paused_replies') || []

      do_persist || return

      h.children.each { |i| @context.storage.put_msg('resume', 'fei' => i) }
        # resume children

      replies.each { |m| @context.storage.put_msg(m.delete('action'), m) }
        # trigger replies
    end
792797
public void resume() {
        switch (status) {
            case PLAYING:
                return;

            case STOPPED:
                play();
                return;

            default:
                status = Status.PLAYING;

                PlayList pl = getPlaylist();
                if (pl.isAutoAdvanceEnabled()) {
                    slideHandler.removeCallbacks(moveToNextSlide);
                    slideHandler.postDelayed(moveToNextSlide, pl.getSlideDuration(pl.getCurrentSlide()));
                }
        }
    }
290465
private static function fixRequestUri(string $requestUri): string
    {
        return preg_replace_callback('|[^a-zA-Z0-9-._~:/?[\\]@!$&\'()*+,;=%]|', function (array $matches) {
            return '%' . sprintf('%02X', ord($matches[0]));
        }, $requestUri);
    }
70270
public void resumeRecording(){
        if (currentAudioState.get()==PAUSED_STATE){
            recordingStartTimeMillis=System.currentTimeMillis();
            currentAudioState.getAndSet(RECORDING_STATE);
            onTimeCompletedTimer=new Timer(true);
            onTimeCompletionTimerTask=new MaxTimeTimerTask();
            onTimeCompletedTimer.schedule(onTimeCompletionTimerTask,remainingMaxTimeInMillis);
        }
        else {
            Log.w(TAG,"Audio recording is not paused");
        }
    }
1223036
public function update(UserPolicy $user, Resume $resume)
    {
        if ($user->canDo('career.resume.edit') && $user->isAdmin()) {
            return true;
        }

        return $resume->user_id == user_id() && $resume->user_type == user_type();
    }