first commit

apps/frontend/lib/google/service/Google_MediaFileUpload.php

@@ -0,0 +1,262 @@
+<?php
+/**
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Chirag Shah <chirags@google.com>
+ *
+ */
+class Google_MediaFileUpload {
+  const UPLOAD_MEDIA_TYPE = 'media';
+  const UPLOAD_MULTIPART_TYPE = 'multipart';
+  const UPLOAD_RESUMABLE_TYPE = 'resumable';
+
+  /** @var string $mimeType */
+  public $mimeType;
+
+  /** @var string $data */
+  public $data;
+
+  /** @var bool $resumable */
+  public $resumable;
+
+  /** @var int $chunkSize */
+  public $chunkSize;
+
+  /** @var int $size */
+  public $size;
+
+  /** @var string $resumeUri */
+  public $resumeUri;
+
+  /** @var int $progress */
+  public $progress;
+
+  /**
+   * @param $mimeType string
+   * @param $data string The bytes you want to upload.
+   * @param $resumable bool
+   * @param bool $chunkSize File will be uploaded in chunks of this many bytes.
+   * only used if resumable=True
+   */
+  public function __construct($mimeType, $data, $resumable=false, $chunkSize=false) {
+    $this->mimeType = $mimeType;
+    $this->data = $data;
+    $this->size = strlen($this->data);
+    $this->resumable = $resumable;
+    if(!$chunkSize) {
+      $chunkSize = 256 * 1024;
+    }
+    $this->chunkSize = $chunkSize;
+    $this->progress = 0;
+  }
+
+  public function setFileSize($size) {
+    $this->size = $size;
+  }
+
+  /**
+   * @static
+   * @param $meta
+   * @param $params
+   * @return array|bool
+   */
+  public static function process($meta, &$params) {
+    $payload = array();
+    $meta = is_string($meta) ? json_decode($meta, true) : $meta;
+    $uploadType = self::getUploadType($meta, $payload, $params);
+    if (!$uploadType) {
+      // Process as a normal API request.
+      return false;
+    }
+
+    // Process as a media upload request.
+    $params['uploadType'] = array(
+        'type' => 'string',
+        'location' => 'query',
+        'value' => $uploadType,
+    );
+
+    $mimeType = isset($params['mimeType'])
+        ? $params['mimeType']['value']
+        : false;
+    unset($params['mimeType']);
+
+    if (!$mimeType) {
+      $mimeType = $payload['content-type'];
+    }
+
+    if (isset($params['file'])) {
+      // This is a standard file upload with curl.
+      $file = $params['file']['value'];
+      unset($params['file']);
+      return self::processFileUpload($file, $mimeType);
+    }
+
+    $data = isset($params['data'])
+        ? $params['data']['value']
+        : false;
+    unset($params['data']);
+
+    if (self::UPLOAD_RESUMABLE_TYPE == $uploadType) {
+      $payload['content-type'] = $mimeType;
+      $payload['postBody'] = is_string($meta) ? $meta : json_encode($meta);
+
+    } elseif (self::UPLOAD_MEDIA_TYPE == $uploadType) {
+      // This is a simple media upload.
+      $payload['content-type'] = $mimeType;
+      $payload['postBody'] = $data;
+    }
+
+    elseif (self::UPLOAD_MULTIPART_TYPE == $uploadType) {
+      // This is a multipart/related upload.
+      $boundary = isset($params['boundary']['value']) ? $params['boundary']['value'] : mt_rand();
+      $boundary = str_replace('"', '', $boundary);
+      $payload['content-type'] = 'multipart/related; boundary=' . $boundary;
+      $related = "--$boundary\r\n";
+      $related .= "Content-Type: application/json; charset=UTF-8\r\n";
+      $related .= "\r\n" . json_encode($meta) . "\r\n";
+      $related .= "--$boundary\r\n";
+      $related .= "Content-Type: $mimeType\r\n";
+      $related .= "Content-Transfer-Encoding: base64\r\n";
+      $related .= "\r\n" . base64_encode($data) . "\r\n";
+      $related .= "--$boundary--";
+      $payload['postBody'] = $related;
+    }
+
+    return $payload;
+  }
+
+  /**
+   * Prepares a standard file upload via cURL.
+   * @param $file
+   * @param $mime
+   * @return array Includes the processed file name.
+   * @visible For testing.
+   */
+  public static function processFileUpload($file, $mime) {
+    if (!$file) return array();
+    if (substr($file, 0, 1) != '@') {
+      $file = '@' . $file;
+    }
+
+    // This is a standard file upload with curl.
+    $params = array('postBody' => array('file' => $file));
+    if ($mime) {
+      $params['content-type'] = $mime;
+    }
+
+    return $params;
+  }
+
+  /**
+   * Valid upload types:
+   * - resumable (UPLOAD_RESUMABLE_TYPE)
+   * - media (UPLOAD_MEDIA_TYPE)
+   * - multipart (UPLOAD_MULTIPART_TYPE)
+   * - none (false)
+   * @param $meta
+   * @param $payload
+   * @param $params
+   * @return bool|string
+   */
+  public static function getUploadType($meta, &$payload, &$params) {
+    if (isset($params['mediaUpload'])
+        && get_class($params['mediaUpload']['value']) == 'Google_MediaFileUpload') {
+      $upload = $params['mediaUpload']['value'];
+      unset($params['mediaUpload']);
+      $payload['content-type'] = $upload->mimeType;
+      if (isset($upload->resumable) && $upload->resumable) {
+        return self::UPLOAD_RESUMABLE_TYPE;
+      }
+    }
+
+    // Allow the developer to override the upload type.
+    if (isset($params['uploadType'])) {
+      return $params['uploadType']['value'];
+    }
+
+    $data = isset($params['data']['value'])
+        ? $params['data']['value'] : false;
+
+    if (false == $data && false == isset($params['file'])) {
+      // No upload data available.
+      return false;
+    }
+
+    if (isset($params['file'])) {
+      return self::UPLOAD_MEDIA_TYPE;
+    }
+
+    if (false == $meta) {
+      return self::UPLOAD_MEDIA_TYPE;
+    }
+
+    return self::UPLOAD_MULTIPART_TYPE;
+  }
+
+
+  public function nextChunk(Google_HttpRequest $req, $chunk=false) {
+    if (false == $this->resumeUri) {
+      $this->resumeUri = $this->getResumeUri($req);
+    }
+
+    if (false == $chunk) {
+      $chunk = substr($this->data, $this->progress, $this->chunkSize);
+    }
+
+    $lastBytePos = $this->progress + strlen($chunk) - 1;
+    $headers = array(
+      'content-range' => "bytes $this->progress-$lastBytePos/$this->size",
+      'content-type' => $req->getRequestHeader('content-type'),
+      'content-length' => $this->chunkSize,
+      'expect' => '',
+    );
+
+    $httpRequest = new Google_HttpRequest($this->resumeUri, 'PUT', $headers, $chunk);
+    $response = Google_Client::$io->authenticatedRequest($httpRequest);
+    $code = $response->getResponseHttpCode();
+    if (308 == $code) {
+      $range = explode('-', $response->getResponseHeader('range'));
+      $this->progress = $range[1] + 1;
+      return false;
+    } else {
+      return Google_REST::decodeHttpResponse($response);
+    }
+  }
+
+  private function getResumeUri(Google_HttpRequest $httpRequest) {
+    $result = null;
+    $body = $httpRequest->getPostBody();
+    if ($body) {
+      $httpRequest->setRequestHeaders(array(
+        'content-type' => 'application/json; charset=UTF-8',
+        'content-length' => Google_Utils::getStrLen($body),
+        'x-upload-content-type' => $this->mimeType,
+        'x-upload-content-length' => $this->size,
+        'expect' => '',
+      ));
+    }
+
+    $response = Google_Client::$io->makeRequest($httpRequest);
+    $location = $response->getResponseHeader('location');
+    $code = $response->getResponseHttpCode();
+    if (200 == $code && true == $location) {
+      return $location;
+    }
+    throw new Google_Exception("Failed to start the resumable upload");
+  }
+}