tus-server 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f187175b5569bccd517340434f973d7e96f132ba
-  data.tar.gz: 0ff7f0123216ce0dbdb2489b6adcebf3926c5c45
+SHA256:
+  metadata.gz: 16cf0c007be7d383ca0bf2d4aefa6d6c477ac7d32b1905a8ad6c0413da233e57
+  data.tar.gz: 258d7d591fc1416468ea21ea42d29ed53f2a64eeade9e5293bdbecc3e5f6a599
 SHA512:
-  metadata.gz: 2dd9f5915eb84b1a1ac82bffa71b5d928dcba9663e2af9cc296643fd22bd378fa09d211df0e3099c339bab7e4da64503d36c3b6b4e6041bf990edd5991691591
-  data.tar.gz: f7fba129bb83e2e2ff8d526bd31581192952f7b86690809c4f1c011df7d31d20b618a088831c7d0e777e86c5c4ce031b652146c3bf54c7a13091a1524e32af20
+  metadata.gz: d642a6f120fd220af27bfc7cf8904459acafa6191934a4922913b10b296e0308cd3093223b39317ffb901318e83da2bcd3fa056cf7d2a36a2f7131ce18b8d8ca
+  data.tar.gz: c0bf56b77ee95fa1aab167f29fd38feabb1919f7e7d85b1c7705c5adbcba97f9612b5633880af9b603b433a3778518b7875bd5bfafff4f446c476d621c0b9c99

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 2.1.0 (2018-05-15)
+
+* Add `:download_url` server option for redirecting to a download URL (@janko-m)
+
+* Allow application servers to serve files stored on disk via the `Rack::Sendfile` middleware (@janko-m)
+
+* Reject `Upload-Metadata` which contains key-value pairs separated by spaces (@janko-m)
+
+* Don't overwite info file if it already exists in `Tus::Storage::FileSystem` (@janko-m)
+
 ## 2.0.2 (2017-12-24)
 
 * Handle `name` and `type` metadata for Uppy compatibility (@janko-m)

data/README.md

@@ -12,62 +12,81 @@ A Ruby server for the [tus resumable upload protocol]. It implements the core
 ## Installation
 
 ```rb
-gem "tus-server"
+# Gemfile
+gem "tus-server", "~> 2.0"
 ```
 
 ## Usage
 
-Tus-ruby-server provides a `Tus::Server` Roda app, which you can run in your
-`config.ru`. That way you can run `Tus::Server` both as a standalone app or as
-part of your main app.
+The gem provides a `Tus::Server` Rack app, which you can mount inside your
+main application. If you're using Rails, you can mount it in `config/routes.rb`:
 
 ```rb
-# config.ru
+# config/routes.rb (Rails)
+Rails.application.routes.draw do
+  # ...
+  mount Tus::Server => "/files"
+end
+```
+
+Otherwise you can run it in `config.ru`:
+
+```rb
+# config.ru (Rack)
 require "tus/server"
 
 map "/files" do
   run Tus::Server
 end
-
-run YourApp
 ```
 
-While this is the most flexible option, it's not optimal in terms of
-performance; see the [Goliath](#goliath) section for an alternative approach.
-
 Now you can tell your tus client library (e.g. [tus-js-client]) to use this
 endpoint:
 
 ```js
 // using tus-js-client
 new tus.Upload(file, {
-  endpoint: "http://localhost:9292/files",
-  chunkSize: 5*1024*1024, // required unless using Goliath or Unicorn
+  endpoint: "/files",
+  chunkSize: 5*1024*1024, // required unless using Goliath
   // ...
 })
 ```
 
-After the upload is complete, you'll probably want to attach the uploaded file
-to a database record. [Shrine] is one file attachment library that integrates
-nicely with tus-ruby-server, see [shrine-tus-demo] for an example integration.
+By default uploaded files will be stored in the `data/` directory. After the
+upload is complete, you'll probably want to attach the uploaded file to a
+database record. [Shrine] is one file attachment library that integrates nicely
+with tus-ruby-server, see [shrine-tus-demo] for an example integration.
 
 ### Goliath
 
-Among all the existing Ruby web servers, [Goliath] is probably the ideal one to
-run tus-ruby-server on. It's built on top of [EventMachine], making it
-asynchronous both in reading the request body and writing to the response body.
-Goliath also allows tus-ruby-server to handle interrupted requests, by saving
-data that has been uploaded until the interruption. This means that with
-Goliath it's **not** mandatory for client to chunk the upload into multiple
-requests in order to achieve resumable upload (which would be the case for most
-other web servers).
+Running the tus server alongside your main app using classic web servers like
+Puma or Unicorn is probably fine for most cases, however, it does come with a
+few gotchas. First, since these web servers don't accept partial requests
+(request where the request body hasn't been fully received), the tus client
+must be configured to split the upload into multiple requests. Second, since
+web workers are tied for the duration of the request, serving uploaded files
+through the tus server app could significantly impact request throughput, so
+you need to be careful to avoid that.
+
+There is an alternative. [Goliath] is an asychronous web server built on top of
+[EventMachine], which supports streaming requests and streaming responses.
+
+* Asynchronous streaming requests allows the tus server to begin saving
+  uploaded data while it's still being received. If the request is interrupted,
+  the tus server will attempt to save as much of the data that was received so
+  far. This means it's not necessary for the tus client to split the upload
+  into multiple smaller requests.
 
-It's recommended that you use [goliath-rack_proxy] for running your tus server
-app:
+* Asynchronous streaming responses allows the tus server to stream large files
+  with very small impact to the request throughput.
+
+Since Goliath is web server, to run tus server on it we'll have to run it as a
+standalone web app. It's recommended that you use [goliath-rack_proxy] for
+running your tus server app:
 
 ```rb
 # Gemfile
-gem "tus-server", "~> 1.0"
+gem "tus-server", "~> 2.0"
 gem "goliath-rack_proxy", "~> 1.0"
 ```
 ```rb
@@ -92,66 +111,34 @@ path you can use `Rack::Builder`:
 ```rb
 class GoliathTusServer < Goliath::RackProxy
   rack_app Rack::Builder.new {
-    map "/files" do
-      run Tus::Server
-    end
+    map("/files") { run Tus::Server }
   }
   rewindable_input false # set to true if you're using checksums
 end
 ```
 
-### Unicorn
-
-Like Goliath, Unicorn also support streaming uploads, and tus-ruby-server knows
-how to automatically recover from `Unicorn::ClientShutdown` exceptions during
-upload, storing data that it has received up until that point. Just note that
-in order to achieve streaming uploads, Nginx should be configured **not** to
-buffer incoming requests, and to disable worker timeout to enable long running
-upload requests:
+In this case you'll have to configure the tus client to point to the standalone
+Goliath app:
 
-```rb
-timeout 60*60*24*30 # set worker timeout to 30 days
-```
-
-But it's also fine to have Nginx buffer requests, just note that in this case
-Nginx won't forward incomplete upload requests to tus-ruby-server, so in order
-for resumable upload to be possible the client needs to send data in multiple
-upload requests (which can then be retried individually).
-
-Unless you're using the "checksum" tus feature, you might want to consider
-disabling rewindability of request body, to prevent Unicorn from additionally
-caching received data onto the disk (since that's not necessary unless request
-body needs to be rewinded).
-
-```rb
-# config/unicorn.rb
-# ...
-
-rewindable_input false
+```js
+// using tus-js-client
+new tus.Upload(file, {
+  endpoint: "http://localhost:9000/files",
+  // ...
+})
 ```
 
-### Other web servers
-
-It's perfectly feasible to run tus-ruby-server on web servers other than
-Goliath or Unicorn (even necessary if you want to run it inside another app).
-Just keep in mind that most other web servers don't support request streaming,
-which means that tus-ruby-server will be able to start processing upload
-requess only once the whole request body has been received. Additionally,
-incomplete upload requests won't be forwarded to tus-ruby-server, so in order
-for resumable upload to be possible the client needs to send data in multiple
-upload requests (which can then be retried individually).
-
 ## Storage
 
 ### Filesystem
 
-By default `Tus::Server` stores uploaded files to disk, in the `data/`
-directory. You can configure a different directory:
+By default `Tus::Server` stores uploaded files in the `data/` directory. You
+can configure a different directory:
 
 ```rb
 require "tus/storage/filesystem"
 
-Tus::Server.opts[:storage] = Tus::Storage::Filesystem.new("public/cache")
+Tus::Server.opts[:storage] = Tus::Storage::Filesystem.new("public/tus")
 ```
 
 If the configured directory doesn't exist, it will automatically be created.
@@ -171,59 +158,56 @@ store files on the filesystem as they won't persist.
 All these are reasons why you might store uploaded data on a different storage,
 and luckily tus-ruby-server ships with two more storages.
 
-### MongoDB GridFS
-
-MongoDB has a specification for storing and retrieving large files, called
-"[GridFS]". Tus-ruby-server ships with `Tus::Storage::Gridfs` that you can
-use, which uses the [Mongo] gem.
-
-```rb
-gem "mongo", ">= 2.2.2", "< 3"
-```
+#### Serving files
 
-```rb
-require "tus/storage/gridfs"
+If your retrieving uploaded files through the download endpoint, by default the
+files will be served through the Ruby application. However, that's very
+inefficient, as web workers are tied when serving download requests and cannot
+serve additional requests for that duration.
 
-client = Mongo::Client.new("mongodb://127.0.0.1:27017/mydb")
-Tus::Server.opts[:storage] = Tus::Storage::Gridfs.new(client: client)
-```
+Therefore, it's highly recommended to delegate serving uploaded files to your
+frontend server (Nginx, Apache). This can be achieved with the
+`Rack::Sendfile` middleware, see its [documentation][Rack::Sendfile] to learn
+more about how to use it with popular frontend servers.
 
-You can change the database prefix (defaults to `fs`):
+If you're using Rails, you can enable the `Rack::Sendfile` middleware by
+setting the `config.action_dispatch.x_sendfile_header` value accordingly:
 
 ```rb
-Tus::Storage::Gridfs.new(client: client, prefix: "fs_temp")
+config.action_dispatch.x_sendfile_header = "X-Sendfile" # Apache and lighttpd
+# or
+config.action_dispatch.x_sendfile_header = "X-Accel-Redirect" # Nginx
 ```
 
-By default MongoDB Gridfs stores files in chunks of 256KB, but you can change
-that with the `:chunk_size` option:
+Otherwise you can add the `Rack::Sendfile` middleware to the stack in
+`config.ru`:
 
 ```rb
-Tus::Storage::Gridfs.new(client: client, chunk_size: 1*1024*1024) # 1 MB
+use Rack::Sendfile, "X-Sendfile" # Apache and lighttpd
+# or
+use Rack::Sendfile, "X-Accel-Redirect" # Nginx
 ```
 
-Note that if you're using the [concatenation] tus feature with Gridfs, all
-partial uploads except the last one are required to fill in their Gridfs
-chunks, meaning the length of each partial upload needs to be a multiple of the
-`:chunk_size` number.
-
 ### Amazon S3
 
-Amazon S3 is probably one of the most popular services for storing files, and
-tus-ruby-server ships with `Tus::Storage::S3` which utilizes S3's multipart API
-to upload files, and depends on the [aws-sdk-s3] gem.
+You can switch to `Tus::Storage::S3` to uploads files to AWS S3 using the
+multipart API. For this you'll also need to add the [aws-sdk-s3] gem to your
+Gemfile.
 
 ```rb
+# Gemfile
 gem "aws-sdk-s3", "~> 1.2"
 ```
 
 ```rb
 require "tus/storage/s3"
 
+# You can omit AWS credentials if you're authenticating in other ways
 Tus::Server.opts[:storage] = Tus::Storage::S3.new(
+  bucket:            "my-app", # required
   access_key_id:     "abc",
   secret_access_key: "xyz",
   region:            "eu-west-1",
-  bucket:            "my-app",
 )
 ```
 
@@ -231,6 +215,27 @@ One thing to note is that S3's multipart API requires each chunk except the
 last to be **5MB or larger**, so that is the minimum chunk size that you can
 specify on your tus client if you want to use the S3 storage.
 
+If you'll be retrieving uploaded files through the tus server app, it's
+recommended to set `Tus::Server.opts[:download_url]` to `true`. This will avoid
+tus server downloading and serving the file from S3, and instead have the
+download endpoint redirect to the direct S3 object URL.
+
+```rb
+Tus::Server.opts[:download_url] = true
+```
+
+You can customize how the S3 object URL is being generated by passing a block
+to `:download_url`, which will then be evaluated in the context of the
+`Tus::Server` instance (which allows accessing the `request` object). See
+[`Aws::S3::Object#get`] for the list of options that
+`Tus::Storage::S3#file_url` accepts.
+
+```rb
+Tus::Server.opts[:download_url] = -> (uid, info, **options) do
+  storage.file_url(uid, info, response_expires: 10, **options) # link expires after 10 seconds
+end
+```
+
 If you want to files to be stored in a certain subdirectory, you can specify
 a `:prefix` in the storage configuration.
 
@@ -252,6 +257,42 @@ can for example change the `:endpoint` to use S3's accelerate host:
 Tus::Storage::S3.new(endpoint: "https://s3-accelerate.amazonaws.com", **options)
 ```
 
+### MongoDB GridFS
+
+MongoDB has a specification for storing and retrieving large files, called
+"[GridFS]". Tus-ruby-server ships with `Tus::Storage::Gridfs` that you can
+use, which uses the [Mongo] gem.
+
+```rb
+# Gemfile
+gem "mongo", "~> 2.3"
+```
+
+```rb
+require "tus/storage/gridfs"
+
+client = Mongo::Client.new("mongodb://127.0.0.1:27017/mydb")
+Tus::Server.opts[:storage] = Tus::Storage::Gridfs.new(client: client)
+```
+
+You can change the database prefix (defaults to `fs`):
+
+```rb
+Tus::Storage::Gridfs.new(client: client, prefix: "fs_temp")
+```
+
+By default MongoDB Gridfs stores files in chunks of 256KB, but you can change
+that with the `:chunk_size` option:
+
+```rb
+Tus::Storage::Gridfs.new(client: client, chunk_size: 1*1024*1024) # 1 MB
+```
+
+Note that if you're using the [concatenation] tus feature with Gridfs, all
+partial uploads except the last one are required to fill in their Gridfs
+chunks, meaning the length of each partial upload needs to be a multiple of the
+`:chunk_size` number.
+
 ### Other storages
 
 If none of these storages suit you, you can write your own, you just need to
@@ -264,6 +305,7 @@ def patch_file(uid, io, info = {})         ... end
 def update_info(uid, info)                 ... end
 def read_info(uid)                         ... end
 def get_file(uid, info = {}, range: nil)   ... end
+def file_url(uid, info = {}, **options)    ... end # optional
 def delete_file(uid, info = {})            ... end
 def expire_files(expiration_date)          ... end
 ```
@@ -302,14 +344,20 @@ tus_storage.expire_files(expiration_time)
 ## Download
 
 In addition to implementing the tus protocol, tus-ruby-server also comes with a
-GET endpoint for downloading the uploaded file, which streams the file from the
-storage into the response body.
+GET endpoint for downloading the uploaded file, which by default streams the
+file from the storage. It supports [Range requests], so you can use the tus
+file URL as `src` in `<video>` and `<audio>` HTML tags.
+
+It's highly recommended not to serve files through the app, but offload it to
+your frontend server if using disk storage, or if using S3 storage have the
+download endpoint redirect to the S3 object URL. See the documentation for the
+individual storage for instructions how to set this up.
 
 The endpoint will automatically use the following `Upload-Metadata` values if
 they're available:
 
-* `type` -- used in the `Content-Type` response header
-* `name` -- used in the `Content-Disposition` response header
+* `type` -- used to set `Content-Type` response header
+* `name` -- used to set `Content-Disposition` response header
 
 The `Content-Disposition` header will be set to "inline" by default, but you
 can change it to "attachment" if you want the browser to always force download:
@@ -318,9 +366,6 @@ can change it to "attachment" if you want the browser to always force download:
 Tus::Server.opts[:disposition] = "attachment"
 ```
 
-The download endpoint supports [Range requests], so you can use the tus
-file URL as `src` in `<video>` and `<audio>` HTML tags.
-
 ## Checksum
 
 The following checksum algorithms are supported for the `checksum` extension:
@@ -358,8 +403,8 @@ The tus-ruby-server was inspired by [rubytus].
 [termination]: http://tus.io/protocols/resumable-upload.html#termination
 [GridFS]: https://docs.mongodb.org/v3.0/core/gridfs/
 [Mongo]: https://github.com/mongodb/mongo-ruby-driver
-[shrine-tus-demo]: https://github.com/janko-m/shrine-tus-demo
-[Shrine]: https://github.com/janko-m/shrine
+[shrine-tus-demo]: https://github.com/shrinerb/shrine-tus-demo
+[Shrine]: https://github.com/shrinerb/shrine
 [trailing headers]: https://tools.ietf.org/html/rfc7230#section-4.1.2
 [rubytus]: https://github.com/picocandy/rubytus
 [aws-sdk-s3]: https://github.com/aws/aws-sdk-ruby/tree/master/gems/aws-sdk-s3
@@ -369,3 +414,5 @@ The tus-ruby-server was inspired by [rubytus].
 [Goliath]: https://github.com/postrank-labs/goliath
 [EventMachine]: https://github.com/eventmachine/eventmachine
 [goliath-rack_proxy]: https://github.com/janko-m/goliath-rack_proxy
+[Rack::Sendfile]: https://www.rubydoc.info/github/rack/rack/master/Rack/Sendfile
+[`Aws::S3::Object#get`]: https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#get-instance_method

data/lib/tus/server.rb

@@ -26,6 +26,7 @@ module Tus
     opts[:max_size]        = nil
     opts[:expiration_time] = 7*24*60*60
     opts[:disposition]     = "inline"
+    opts[:download_url]    = nil
 
     plugin :all_verbs
     plugin :default_headers, {"Content-Type" => ""}
@@ -112,6 +113,7 @@ module Tus
           error!(404, "Upload Not Found")
         end
 
+        # HEAD /{uid}
         r.head do
           response.headers.update(info.headers)
           response.headers["Cache-Control"] = "no-store"
@@ -157,22 +159,33 @@ module Tus
         # GET /{uid}
         r.get do
           validate_upload_finished!(info)
-          range = handle_range_request!(info.length)
-
-          response.headers["Content-Length"] = (range.end - range.begin + 1).to_s
 
           metadata = info.metadata
           name     = metadata["name"] || metadata["filename"]
           type     = metadata["type"] || metadata["content_type"]
 
-          response.headers["Content-Disposition"]  = opts[:disposition]
-          response.headers["Content-Disposition"] += "; filename=\"#{name}\"" if name
-          response.headers["Content-Type"] = type || "application/octet-stream"
-          response.headers
+          content_disposition  = opts[:disposition]
+          content_disposition += "; filename=\"#{name}\"" if name
+          content_type = type || "application/octet-stream"
+
+          if download_url
+            redirect_url = instance_exec(uid, info.to_h,
+              content_type:        content_type,
+              content_disposition: content_disposition,
+              &download_url)
+
+            r.redirect redirect_url
+          else
+            range = handle_range_request!(info.length)
+
+            response.headers["Content-Length"]      = range.size.to_s
+            response.headers["Content-Disposition"] = content_disposition
+            response.headers["Content-Type"]        = content_type
 
-          body = storage.get_file(uid, info.to_h, range: range)
+            body = storage.get_file(uid, info.to_h, range: range)
 
-          request.halt response.finish_with_body(body)
+            r.halt response.finish_with_body(body)
+          end
         end
 
         # DELETE /{uid}
@@ -248,7 +261,7 @@ module Tus
       upload_metadata = request.headers["Upload-Metadata"]
 
       upload_metadata.split(",").each do |string|
-        key, value = string.split(" ")
+        key, value = string.split(" ", 2)
 
         error!(400, "Invalid Upload-Metadata header") if key.nil?
         error!(400, "Invalid Upload-Metadata header") if key.ord > 127
@@ -309,15 +322,15 @@ module Tus
     # Handles partial responses requested in the "Range" header. Implementation
     # is mostly copied from Rack::File.
     def handle_range_request!(length)
-      # we support ranged requests
-      response.headers["Accept-Ranges"] = "bytes"
-
       if Rack.release >= "2.0"
         ranges = Rack::Utils.get_byte_ranges(request.headers["Range"], length)
       else
         ranges = Rack::Utils.byte_ranges(request.env, length)
       end
 
+      # we support ranged requests
+      response.headers["Accept-Ranges"] = "bytes"
+
       if ranges.nil? || ranges.length > 1
         # no ranges, or multiple ranges (which we don't support)
         response.status = 200
@@ -369,6 +382,14 @@ module Tus
       request.halt
     end
 
+    def download_url
+      if opts[:download_url] == true
+        storage.method(:file_url)
+      else
+        opts[:download_url]
+      end
+    end
+
     def storage
       opts[:storage] || Tus::Storage::Filesystem.new("data")
     end

data/lib/tus/storage/filesystem.rb

@@ -27,7 +27,7 @@ module Tus
         file_path(uid).binwrite("")
         file_path(uid).chmod(@permissions)
 
-        info_path(uid).binwrite("{}")
+        info_path(uid).binwrite("{}") unless info_path(uid).exist?
         info_path(uid).chmod(@permissions)
       end
 
@@ -99,7 +99,7 @@ module Tus
           end
         end
 
-        Tus::Response.new(chunks: chunks, close: file.method(:close))
+        Response.new(chunks: chunks, close: file.method(:close), path: file_path(uid).to_s)
       end
 
       # Deletes data and info files for the specified upload.
@@ -136,6 +136,18 @@ module Tus
         directory.mkpath
         directory.chmod(@directory_permissions)
       end
+
+      class Response < Tus::Response
+        def initialize(path:, **options)
+          super(**options)
+          @path = path
+        end
+
+        # Rack::Sendfile middleware needs response body to respond to #to_path
+        def to_path
+          @path
+        end
+      end
     end
   end
 end

data/lib/tus/storage/gridfs.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+gem "mongo", "~> 2.3"
+
 require "mongo"
 
 require "tus/info"

data/lib/tus/storage/s3.rb

@@ -1,9 +1,8 @@
 # frozen-string-literal: true
 
+gem "aws-sdk-s3", "~> 1.2"
+
 require "aws-sdk-s3"
-if Gem::Version.new(Aws::S3::GEM_VERSION) < Gem::Version.new("1.2.0")
-  raise "Tus::Storage::S3 requires aws-sdk-s3 version 1.2.0 or above"
-end
 
 require "tus/info"
 require "tus/response"
@@ -11,8 +10,6 @@ require "tus/errors"
 
 require "json"
 require "cgi"
-require "fiber"
-require "stringio"
 
 module Tus
   module Storage
@@ -106,39 +103,34 @@ module Tus
         bytes_uploaded = 0
 
         jobs = []
-        chunk = StringIO.new(input.read(MIN_PART_SIZE).to_s)
+        chunk = input.read(MIN_PART_SIZE)
 
-        loop do
-          next_chunk = StringIO.new(input.read(MIN_PART_SIZE).to_s)
+        while chunk
+          next_chunk = input.read(MIN_PART_SIZE)
 
           # merge next chunk into previous if it's smaller than minimum chunk size
-          if next_chunk.size < MIN_PART_SIZE
-            chunk = StringIO.new(chunk.string + next_chunk.string)
-            next_chunk.close
+          if next_chunk && next_chunk.bytesize < MIN_PART_SIZE
+            chunk << next_chunk
+            next_chunk.clear
             next_chunk = nil
           end
 
           # abort if chunk is smaller than 5MB and is not the last chunk
-          if chunk.size < MIN_PART_SIZE
+          if chunk.bytesize < MIN_PART_SIZE
             break if (tus_info.length && tus_info.offset) &&
-                     chunk.size + tus_info.offset < tus_info.length
+                     chunk.bytesize + tus_info.offset < tus_info.length
           end
 
-          thread = upload_part_thread(chunk, uid, upload_id, part_offset += 1)
-          jobs << [thread, chunk]
-
-          chunk = next_chunk or break
-        end
-
-        begin
-          jobs.each do |thread, body|
-            info["multipart_parts"] << thread.value
-            bytes_uploaded += body.size
-            body.close
+          begin
+            info["multipart_parts"] << upload_part(chunk, uid, upload_id, part_offset += 1)
+            bytes_uploaded += chunk.bytesize
+          rescue Seahorse::Client::NetworkingError => exception
+            warn "ERROR: #{exception.inspect} occurred during upload"
+            break # ignore networking errors and return what client has uploaded so far
           end
-        rescue Seahorse::Client::NetworkingError => exception
-          warn "ERROR: #{exception.inspect} occurred during upload"
-          # ignore networking errors and return what client has uploaded so far
+
+          chunk.clear
+          chunk = next_chunk
         end
 
         bytes_uploaded
@@ -177,14 +169,20 @@ module Tus
       # upload can be retrieved in a streaming fashion. Accepts an optional
       # range parameter for selecting a subset of bytes to retrieve.
       def get_file(uid, info = {}, range: nil)
-        tus_info = Tus::Info.new(info)
-
         range  = "bytes=#{range.begin}-#{range.end}" if range
         chunks = object(uid).enum_for(:get, range: range)
 
         Tus::Response.new(chunks: chunks)
       end
 
+      # Returns a signed expiring URL to the S3 object.
+      def file_url(uid, info = {}, content_type: nil, content_disposition: nil, **options)
+        options[:response_content_type]        ||= content_type
+        options[:response_content_disposition] ||= content_disposition
+
+        object(uid).presigned_url(:get, **options)
+      end
+
       # Deletes resources for the specified upload. If multipart upload is
       # still in progress, aborts the multipart upload, otherwise deletes the
       # object.
@@ -222,12 +220,6 @@ module Tus
 
       private
 
-      # Spawns a thread which uploads given body as a new multipart part with
-      # the specified part number to the specified multipart upload.
-      def upload_part_thread(body, key, upload_id, part_number)
-        Thread.new { upload_part(body, key, upload_id, part_number) }
-      end
-
       # Uploads given body as a new multipart part with the specified part
       # number to the specified multipart upload. Returns part number and ETag
       # that will be required later for completing the multipart upload.

data/tus-server.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name         = "tus-server"
-  gem.version      = "2.0.2"
+  gem.version      = "2.1.0"
 
   gem.required_ruby_version = ">= 2.2"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tus-server
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-24 00:00:00.000000000 Z
+date: 2018-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: roda
@@ -156,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Ruby server implementation of tus.io, the open protocol for resumable file