support resumableThreshold & using simple vs resumable

lib/storage/bucket.js

@@ -228,13 +228,16 @@ Bucket.prototype.setMetadata = function(metadata, callback) {
  *
  * @param {string} localPath - The fully qualified path to the file you wish to
  *     upload to your bucket.
- * @param {string=|module:storage/file=} destination - The place to save your
- *     file. If given a string, the file will be uploaded to the bucket using
- *     the string as a filename. When given a File object, your local file will
- *     be uploaded to the File object's bucket and under the File object's name.
- *     Lastly, when this argument is omitted, the file is uploaded to your
+ * @param {object=} options - Configuration options.
+ * @param {string=|module:storage/file=} options.destination - The place to save
+ *     your file. If given a string, the file will be uploaded to the bucket
+ *     using the string as a filename. When given a File object, your local file
+ *     will be uploaded to the File object's bucket and under the File object's
+ *     name. Lastly, when this argument is omitted, the file is uploaded to your
  *     bucket using the name of the local file.
- * @param {object=} metadata - Metadata to set for your file.
+ * @param {object=} options.metadata - Metadata to set for your file.
+ * @param {boolean=} options.resumable - Whether to use a resumable upload or
+ *     simple upload.
  * @param {function} callback - The callback function.
  *
  * @example
@@ -251,8 +254,19 @@ Bucket.prototype.setMetadata = function(metadata, callback) {
  * //-
  * // It's not always that easy. You will likely want to specify the filename
  * // used when your new file lands in your bucket.
+ * //
+ * // You may also need to set metadata, or customize other options, like if you
+ * // want the security of a resumable upload.
  * //-
- * bucket.upload('/local/path/image.png', 'new-image.png', function(err, file) {
+ * var options = {
+ *   destination: 'new-image.png',
+ *   resumable: true,
+ *   metadata: {
+ *     event: 'Fall trip to the zoo'
+ *   }
+ * };
+ *
+ * bucket.upload('/local/path/image.png', options, function(err, file) {
  *   // Your bucket now contains:
  *   // - "new-image.png" (with the contents of `/local/path/image.png')
  *
@@ -263,45 +277,37 @@ Bucket.prototype.setMetadata = function(metadata, callback) {
  * // You may also re-use a File object, {module:storage/file}, that references
  * // the file you wish to create or overwrite.
  * //-
- * var file = bucket.file('existing-file.png');
- * bucket.upload('/local/path/image.png', file, function(err, newFile) {
+ * var options = {
+ *   destination: bucket.file('existing-file.png'),
+ *   resumable: false
+ * };
+ *
+ * bucket.upload('/local/path/image.png', options, function(err, newFile) {
  *   // Your bucket now contains:
  *   // - "existing-file.png" (with the contents of `/local/path/image.png')
  *
  *   // Note:
  *   // The `newFile` parameter is equal to `file`.
  * });
  */
-Bucket.prototype.upload = function(localPath, destination, metadata, callback) {
-  var name;
-  var newFile;
-  switch (arguments.length) {
-    case 4:
-      break;
-    case 3:
-      callback = metadata;
-      if (util.is(destination, 'object')) {
-        metadata = destination;
-      } else {
-        metadata = {};
-      }
-      /* falls through */
-    default:
-      callback = callback || destination;
-      name = path.basename(localPath);
-      break;
-  }
-  metadata = metadata || {};
-  callback = callback || util.noop;
-  if (util.is(destination, 'string')) {
-    name = destination;
+Bucket.prototype.upload = function(localPath, options, callback) {
+  if (util.is(options, 'function')) {
+    callback = options;
+    options = {};
   }
-  if (destination instanceof File) {
-    name = destination.name;
-    newFile = destination;
+
+  var newFile;
+  if (options.destination instanceof File) {
+    newFile = options.destination;
+  } else if (util.is(options.destination, 'string')) {
+    // Use the string as the name of the file.
+    newFile = this.file(options.destination);
+  } else {
+    // Resort to using the name of the incoming file.
+    newFile = this.file(path.basename(localPath));
   }
-  newFile = newFile || this.file(name);
 
+  var metadata = options.metadata || {};
   var contentType = mime.lookup(localPath);
   if (contentType && !metadata.contentType) {
     metadata.contentType = contentType;
@@ -312,12 +318,38 @@ Bucket.prototype.upload = function(localPath, destination, metadata, callback) {
     metadata.contentType += '; charset=' + charset;
   }
 
-  fs.createReadStream(localPath)
-    .pipe(newFile.createWriteStream(metadata))
-    .on('error', callback)
-    .on('complete', function() {
-      callback(null, newFile);
+  var resumable;
+  if (util.is(options.resumable, 'boolean')) {
+    resumable = options.resumable;
+    upload();
+  } else {
+    // Determine if the upload should be resumable based on if it meets the
+    // resumableThreshold.
+    var resumableThreshold = this.storage.resumableThreshold;
+
+    fs.stat(localPath, function(err, fd) {
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      resumable = fd.size > resumableThreshold;
+
+      upload();
     });
+  }
+
+  function upload() {
+    fs.createReadStream(localPath)
+      .pipe(newFile.createWriteStream({
+        resumable: resumable,
+        metadata: metadata
+      }))
+      .on('error', callback)
+      .on('complete', function() {
+        callback(null, newFile);
+      });
+  }
 };
 
 /**