PHP RequestUtil::runWithRetry方法代码示例

 /**
  * @param string $path
  *
  * @param WriteMode $writeMode
  *    What to do if there's already a file at the given path (UTF-8).
  *
  * @param resource $inStream
  *    The source of data to upload.
  *
  * @param int|null $numBytes
  *    You can pass in <code>null</code>.  But if you know how many bytes you expect, pass in
  *    that value and this function will do a sanity check at the end to make sure the number of
  *    bytes read from $inStream matches up.
  *
  * @param int $chunkSize
  *
  * @return array
  *    The <a href="https://www.dropbox.com/developers/core/docs#metadata-details>metadata
  *    object</a> for the newly-added file.
  */
 private function _uploadFileChunked($path, $writeMode, $inStream, $numBytes, $chunkSize)
 {
     Path::checkArg("path", $path);
     WriteMode::checkArg("writeMode", $writeMode);
     Checker::argResource("inStream", $inStream);
     Checker::argNatOrNull("numBytes", $numBytes);
     Checker::argNat("chunkSize", $chunkSize);
     // NOTE: This function performs 3 retries on every call.  This is maybe not the right
     // layer to make retry decisions.  It's also awkward because none of the other calls
     // perform retries.
     assert($chunkSize > 0);
     $data = self::readFully($inStream, $chunkSize);
     $len = strlen($data);
     $client = $this;
     $uploadId = RequestUtil::runWithRetry(3, function () use($data, $client) {
         return $client->chunkedUploadStart($data);
     });
     $byteOffset = $len;
     while (!feof($inStream)) {
         $data = self::readFully($inStream, $chunkSize);
         $len = strlen($data);
         while (true) {
             $r = RequestUtil::runWithRetry(3, function () use($client, $uploadId, $byteOffset, $data) {
                 return $client->chunkedUploadContinue($uploadId, $byteOffset, $data);
             });
             if ($r === true) {
                 // Chunk got uploaded!
                 $byteOffset += $len;
                 break;
             }
             if ($r === false) {
                 // Server didn't recognize our upload ID
                 // This is very unlikely since we're uploading all the chunks in sequence.
                 throw new Exception_BadResponse("Server forgot our uploadId");
             }
             // Otherwise, the server is at a different byte offset from us.
             $serverByteOffset = $r;
             assert($serverByteOffset !== $byteOffset);
             // chunkedUploadContinue ensures this.
             // An earlier byte offset means the server has lost data we sent earlier.
             if ($serverByteOffset < $byteOffset) {
                 throw new Exception_BadResponse("Server is at an ealier byte offset: us={$byteOffset}, server={$serverByteOffset}");
             }
             $diff = $serverByteOffset - $byteOffset;
             // If the server is past where we think it could possibly be, something went wrong.
             if ($diff > $len) {
                 throw new Exception_BadResponse("Server is more than a chunk ahead: us={$byteOffset}, server={$serverByteOffset}");
             }
             // The normal case is that the server is a bit further along than us because of a
             // partially-uploaded chunk.  Finish it off.
             $byteOffset += $diff;
             if ($diff === $len) {
                 break;
             }
             // If the server is at the end, we're done.
             $data = substr($data, $diff);
         }
     }
     if ($numBytes !== null && $byteOffset !== $numBytes) {
         throw new \InvalidArgumentException("You passed numBytes={$numBytes} but the stream had {$byteOffset} bytes.");
     }
     $metadata = RequestUtil::runWithRetry(3, function () use($client, $uploadId, $path, $writeMode) {
         return $client->chunkedUploadFinish($uploadId, $path, $writeMode);
     });
     return $metadata;
 }