tus-server 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 37df5f3056cadbbdf3b73e78a24894232584f184
-  data.tar.gz: 6b04e64b37d3f95e4e8f458866313338a97ce060
+  metadata.gz: f18da15eb73c98ae5dba91a27fcd0bb139281be0
+  data.tar.gz: 534ba0c6d6886e65f35c13e108ae40fb36a3a8de
 SHA512:
-  metadata.gz: ac910fc9997db3a4f99b5d56529e16c60cd596e0a29ec7b18bd3c60936c9d31a3662988183382c0ffef5664766eb439de73fad2d02fdd499953580855b9b4b1d
-  data.tar.gz: 20ae1bbce665211819fc2921a247bb89990f89bf985d25c245cfa7b26970a90eef2cc0ce1631c5567357252e91b45b5f3a2bf19f45f25f51b352c4c85fc1064f
+  metadata.gz: fce19c8935054e91852ff8b41449b6de7ddda6c780b9b7c4700311e62dcbc416032ad584c6de814d5cd80a2c726438a562d2d3417e5d586246c3ee55158fa50f
+  data.tar.gz: 1d7abdbaa7d83bdbed79bb4073491ba5e2f0ac4c0bf472b9a9022840474eb398bbf9ac9414f541861bd51c9d2fb2eb0e828a541f1ce792cb2497a7c8ba8b3a71

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 2.0.0 (2017-11-13)
+
+* Upgrade to Roda 3 (@janko-m)
+
+* Remove deprecated support for aws-sdk 2.x in `Tus::Storage::S3` (@janko-m)
+
+* Drop official support for MRI 2.1 (@janko-m)
+
+* Add generic `Tus::Response` class that storages can use (@janko-m)
+
+* Remove `Tus::Response#length` (@janko-m)
+
+* Remove deprecated Goliath integration (@janko-m)
+
+* Return `400 Bad Request` instead of `404 Not Found` when some partial uploads are missing in a concatenation request (@janko-m)
+
+* Use Rack directly instead of Roda's `streaming` plugin for downloding (@janko-m)
+
 ## 1.2.1 (2017-11-05)
 
 * Improve communication when handling `aws-sdk 2.x` fallback in `Tus::Storage::S3` (@janko-m)

data/lib/tus/checksum.rb

@@ -1,6 +1,15 @@
 # frozen-string-literal: true
 
 module Tus
+  # Generates various checksums for given IO objects. The following algorithms
+  # are supported:
+  #
+  # * SHA1
+  # * SHA256
+  # * SHA384
+  # * SHA512
+  # * MD5
+  # * CRC32
   class Checksum
     CHUNK_SIZE = 16*1024
 

data/lib/tus/info.rb

@@ -1,8 +1,10 @@
 # frozen-string-literal: true
+
 require "base64"
 require "time"
 
 module Tus
+  # Holds request headers and other information about tus uploads.
   class Info
     HEADERS = %w[
       Upload-Length

data/lib/tus/input.rb

@@ -1,8 +1,16 @@
 # frozen-string-literal: true
+
+require "tus/input/unicorn"
 require "tus/errors"
 
 module Tus
+  # Wrapper around the Rack input, which adds the ability to limit the amount of
+  # bytes that will be read from the Rack input. If there are more bytes in the
+  # Rack input than the specified limit, a Tus::MaxSizeExceeded exception is
+  # raised.
   class Input
+    prepend Tus::Input::Unicorn
+
     def initialize(input, limit: nil)
       @input = input
       @limit = limit
@@ -10,16 +18,12 @@ module Tus
     end
 
     def read(length = nil, outbuf = nil)
-      data = @input.read(length, outbuf)
+      data = @input.read(*length, *outbuf)
 
       @pos += data.bytesize if data
       raise MaxSizeExceeded if @limit && @pos > @limit
 
       data
-    rescue => exception
-      raise unless exception.class.name == "Unicorn::ClientShutdown"
-      outbuf = outbuf.to_s.clear
-      outbuf unless length
     end
 
     def pos

data/lib/tus/input/unicorn.rb

@@ -0,0 +1,16 @@
+module Tus
+  class Input
+    # Extension for Unicorn to gracefully handle interrupted uploads.
+    module Unicorn
+      # Rescues Unicorn::ClientShutdown exception when reading, and instead of
+      # failing just returns blank data to signal end of input.
+      def read(length = nil, outbuf = nil)
+        super
+      rescue => exception
+        raise unless exception.class.name == "Unicorn::ClientShutdown"
+        outbuf = outbuf.to_s.clear
+        outbuf unless length
+      end
+    end
+  end
+end

data/lib/tus/response.rb

@@ -0,0 +1,18 @@
+module Tus
+  # Object that responds to #each, #length, and #close, suitable for returning
+  # as a Rack response body.
+  class Response
+    def initialize(chunks:, close: ->{})
+      @chunks = chunks
+      @close  = close
+    end
+
+    def each(&block)
+      @chunks.each(&block)
+    end
+
+    def close
+      @close.call
+    end
+  end
+end

data/lib/tus/server.rb

@@ -32,7 +32,6 @@ module Tus
     plugin :delete_empty_headers
     plugin :request_headers
     plugin :not_allowed
-    plugin :streaming
 
     route do |r|
       if request.headers["X-HTTP-Method-Override"]
@@ -47,6 +46,7 @@ module Tus
       validate_tus_resumable! unless request.options? || request.get?
 
       r.is ['', true] do
+        # OPTIONS /
         r.options do
           response.headers.update(
             "Tus-Version"            => SUPPORTED_VERSIONS.join(","),
@@ -58,6 +58,7 @@ module Tus
           no_content!
         end
 
+        # POST /
         r.post do
           validate_upload_length! unless request.headers["Upload-Concat"].to_s.start_with?("final") || request.headers["Upload-Defer-Length"] == "1"
           validate_upload_metadata! if request.headers["Upload-Metadata"]
@@ -92,7 +93,8 @@ module Tus
         end
       end
 
-      r.is ":uid" do |uid|
+      r.is String do |uid|
+        # OPTIONS /{uid}
         r.options do
           response.headers.update(
             "Tus-Version"            => SUPPORTED_VERSIONS.join(","),
@@ -117,6 +119,7 @@ module Tus
           no_content!
         end
 
+        # PATCH /{uid}
         r.patch do
           if info.defer_length? && request.headers["Upload-Length"]
             validate_upload_length!
@@ -151,6 +154,7 @@ module Tus
           no_content!
         end
 
+        # GET /{uid}
         r.get do
           validate_upload_finished!(info)
           range = handle_range_request!(info.length)
@@ -163,13 +167,12 @@ module Tus
           response.headers["Content-Type"] = metadata["content_type"] || "application/octet-stream"
           response.headers
 
-          response = storage.get_file(uid, info.to_h, range: range)
+          body = storage.get_file(uid, info.to_h, range: range)
 
-          stream(callback: ->{response.close}) do |out|
-            response.each { |chunk| out << chunk }
-          end
+          request.halt response.finish_with_body(body)
         end
 
+        # DELETE /{uid}
         r.delete do
           storage.delete_file(uid, info.to_h)
 
@@ -178,6 +181,8 @@ module Tus
       end
     end
 
+    # Wraps the Rack input (request body) into a Tus::Input object, applying a
+    # size limit if one exists.
     def get_input(info)
       offset = info.offset
       total  = info.length || max_size
@@ -263,6 +268,7 @@ module Tus
       end
     end
 
+    # Validates that each partial upload exists and is marked as one.
     def validate_partial_uploads!(part_uids)
       queue = Queue.new
       part_uids.each { |part_uid| queue << part_uid }
@@ -284,7 +290,7 @@ module Tus
         error!(400, "One or more uploads were not partial")
       end
     rescue Tus::NotFound
-      error!(404, "One or more partial uploads were not found")
+      error!(400, "One or more partial uploads were not found")
     end
 
     def validate_upload_checksum!(input)
@@ -297,7 +303,8 @@ module Tus
       error!(460, "Upload-Checksum value doesn't match generated checksum") if generated_checksum != checksum
     end
 
-    # "Range" header handling logic copied from Rack::File
+    # 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"

data/lib/tus/storage/filesystem.rb

@@ -1,4 +1,6 @@
 # frozen-string-literal: true
+
+require "tus/response"
 require "tus/errors"
 
 require "pathname"
@@ -10,6 +12,8 @@ module Tus
     class Filesystem
       attr_reader :directory
 
+      # Initializes the storage with a directory, in which it will save all
+      # files. Creates the directory if it doesn't exist.
       def initialize(directory, permissions: 0644, directory_permissions: 0755)
         @directory             = Pathname(directory)
         @permissions           = permissions
@@ -18,6 +22,7 @@ module Tus
         create_directory! unless @directory.exist?
       end
 
+      # Creates a file for storing uploaded data and a file for storing info.
       def create_file(uid, info = {})
         file_path(uid).binwrite("")
         file_path(uid).chmod(@permissions)
@@ -26,6 +31,11 @@ module Tus
         info_path(uid).chmod(@permissions)
       end
 
+      # Concatenates multiple partial uploads into a single upload, and returns
+      # the size of the resulting upload. The partial uploads are deleted after
+      # concatenation.
+      #
+      # Raises Tus::Error if any partial upload is missing.
       def concatenate(uid, part_uids, info = {})
         create_file(uid, info)
 
@@ -49,20 +59,28 @@ module Tus
         file_path(uid).size
       end
 
+      # Appends data to the specified upload in a streaming fashion, and
+      # returns the number of bytes it managed to save.
       def patch_file(uid, input, info = {})
         file_path(uid).open("ab") { |file| IO.copy_stream(input, file) }
       end
 
+      # Returns info of the specified upload. Raises Tus::NotFound if the upload
+      # wasn't found.
       def read_info(uid)
         raise Tus::NotFound if !file_path(uid).exist?
 
         JSON.parse(info_path(uid).binread)
       end
 
+      # Updates info of the specified upload.
       def update_info(uid, info)
         info_path(uid).binwrite(JSON.generate(info))
       end
 
+      # Returns a Tus::Response object through which data of the specified
+      # 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)
         file = file_path(uid).open("rb")
         length = range ? range.size : file.size
@@ -81,15 +99,15 @@ module Tus
           end
         end
 
-        # We return a response object that responds to #each, #length and #close,
-        # which the tus server can return directly as the Rack response.
-        Response.new(chunks: chunks, length: length, close: -> { file.close })
+        Tus::Response.new(chunks: chunks, close: file.method(:close))
       end
 
+      # Deletes data and info files for the specified upload.
       def delete_file(uid, info = {})
         delete([uid])
       end
 
+      # Deletes data and info files of uploads older than the specified date.
       def expire_files(expiration_date)
         uids = directory.children
           .select { |pathname| pathname.mtime <= expiration_date }
@@ -118,26 +136,6 @@ module Tus
         directory.mkpath
         directory.chmod(@directory_permissions)
       end
-
-      class Response
-        def initialize(chunks:, close:, length:)
-          @chunks = chunks
-          @close  = close
-          @length = length
-        end
-
-        def length
-          @length
-        end
-
-        def each(&block)
-          @chunks.each(&block)
-        end
-
-        def close
-          @close.call
-        end
-      end
     end
   end
 end

data/lib/tus/storage/gridfs.rb

@@ -1,7 +1,9 @@
 # frozen-string-literal: true
+
 require "mongo"
 
 require "tus/info"
+require "tus/response"
 require "tus/errors"
 
 require "digest"
@@ -13,6 +15,7 @@ module Tus
 
       attr_reader :client, :prefix, :bucket, :chunk_size
 
+      # Initializes the GridFS storage and creates necessary indexes.
       def initialize(client:, prefix: "fs", chunk_size: 256*1024)
         @client     = client
         @prefix     = prefix
@@ -22,6 +25,7 @@ module Tus
         @bucket.send(:ensure_indexes!)
       end
 
+      # Creates a file for the specified upload.
       def create_file(uid, info = {})
         content_type = Tus::Info.new(info).metadata["content_type"]
 
@@ -31,6 +35,15 @@ module Tus
         )
       end
 
+      # Concatenates multiple partial uploads into a single upload, and returns
+      # the size of the resulting upload. The partial uploads are deleted after
+      # concatenation.
+      #
+      # It concatenates by updating partial upload's GridFS chunks to point to
+      # the new upload.
+      #
+      # Raises Tus::Error if GridFS chunks of partial uploads don't exist or
+      # aren't completely filled.
       def concatenate(uid, part_uids, info = {})
         grid_infos = files_collection.find(filename: {"$in" => part_uids}).to_a
         grid_infos.sort_by! { |grid_info| part_uids.index(grid_info[:filename]) }
@@ -65,14 +78,25 @@ module Tus
         length
       end
 
+      # Appends data to the specified upload in a streaming fashion, and
+      # returns the number of bytes it managed to save.
+      #
+      # It does so by reading the input data in batches of chunks, creating a
+      # new GridFS chunk for each chunk of data and appending it to the
+      # existing list.
       def patch_file(uid, input, info = {})
         grid_info      = files_collection.find(filename: uid).first
         current_length = grid_info[:length]
         chunk_size     = grid_info[:chunkSize]
         bytes_saved    = 0
 
+        # It's possible that the previous data append didn't fill in the last
+        # GridFS chunk completely, so we fill in that gap now before creating
+        # new GridFS chunks.
         bytes_saved += patch_last_chunk(input, grid_info) if current_length % chunk_size != 0
 
+        # Create an Enumerator which yields chunks of input data which have the
+        # size of the configured :chunkSize of the GridFS file.
         chunks_enumerator = Enumerator.new do |yielder|
           while (data = input.read(chunk_size))
             yielder << data
@@ -82,6 +106,9 @@ module Tus
         chunks_in_batch = (BATCH_SIZE.to_f / chunk_size).ceil
         chunks_offset   = chunks_collection.count(files_id: grid_info[:_id]) - 1
 
+        # Iterate in batches of data chunks and bulk-insert new GridFS chunks.
+        # This way we try to have a balance between bulking inserts and keeping
+        # memory usage low.
         chunks_enumerator.each_slice(chunks_in_batch) do |chunks|
           grid_chunks = chunks.map do |data|
             Mongo::Grid::File::Chunk.new(
@@ -107,23 +134,24 @@ module Tus
         bytes_saved
       end
 
+      # Returns info of the specified upload. Raises Tus::NotFound if the upload
+      # wasn't found.
       def read_info(uid)
         grid_info = files_collection.find(filename: uid).first or raise Tus::NotFound
-
         grid_info[:metadata]
       end
 
+      # Updates info of the specified upload.
       def update_info(uid, info)
-        grid_info = files_collection.find(filename: uid).first
-
         files_collection.update_one({filename: uid}, {"$set" => {metadata: info}})
       end
 
+      # Returns a Tus::Response object through which data of the specified
+      # upload can be retrieved in a streaming fashion. Accepts an optional
+      # range parameter for selecting a subset of bytes we want to retrieve.
       def get_file(uid, info = {}, range: nil)
         grid_info = files_collection.find(filename: uid).first
 
-        length = range ? range.size : grid_info[:length]
-
         filter = { files_id: grid_info[:_id] }
 
         if range
@@ -166,16 +194,16 @@ module Tus
           end
         end
 
-        # We return a response object that responds to #each, #length and #close,
-        # which the tus server can return directly as the Rack response.
-        Response.new(chunks: chunks, length: length, close: ->{chunks_view.close_query})
+        Tus::Response.new(chunks: chunks, close: chunks_view.method(:close_query))
       end
 
+      # Deletes the GridFS file and chunks for the specified upload.
       def delete_file(uid, info = {})
         grid_info = files_collection.find(filename: uid).first
         bucket.delete(grid_info[:_id]) if grid_info
       end
 
+      # Deletes GridFS file and chunks of uploads older than the specified date.
       def expire_files(expiration_date)
         grid_infos = files_collection.find(uploadDate: {"$lte" => expiration_date}).to_a
         grid_info_ids = grid_infos.map { |info| info[:_id] }
@@ -186,15 +214,18 @@ module Tus
 
       private
 
+      # Creates a GridFS file.
       def create_grid_file(**options)
-        file_options = {metadata: {}, chunk_size: chunk_size}.merge(options)
-        grid_file = Mongo::Grid::File.new("", file_options)
+        grid_file = Mongo::Grid::File.new("", metadata: {}, chunk_size: chunk_size, **options)
 
         bucket.insert_one(grid_file)
 
         grid_file
       end
 
+      # If the last GridFS chunk of the file is incomplete (meaning it's smaller
+      # than the configured :chunkSize of the GridFS file), fills the missing
+      # data by reading a chunk of the input data.
       def patch_last_chunk(input, grid_info)
         last_chunk = chunks_collection.find(files_id: grid_info[:_id]).sort(n: -1).limit(1).first
         data = last_chunk[:data].data
@@ -210,17 +241,21 @@ module Tus
         patch.bytesize
       end
 
+      # Validates that GridFS files of partial uploads are suitable for
+      # concatentation.
       def validate_parts!(grid_infos, part_uids)
         validate_parts_presence!(grid_infos, part_uids)
         validate_parts_full_chunks!(grid_infos)
       end
 
+      # Validates that each partial upload has a corresponding GridFS file.
       def validate_parts_presence!(grid_infos, part_uids)
         if grid_infos.count != part_uids.count
           raise Tus::Error, "some parts for concatenation are missing"
         end
       end
 
+      # Validates that GridFS chunks of each file are filled completely.
       def validate_parts_full_chunks!(grid_infos)
         grid_infos.each do |grid_info|
           if grid_info[:length] % grid_info[:chunkSize] != 0 && grid_info != grid_infos.last
@@ -236,26 +271,6 @@ module Tus
       def chunks_collection
         bucket.chunks_collection
       end
-
-      class Response
-        def initialize(chunks:, close:, length:)
-          @chunks = chunks
-          @close  = close
-          @length = length
-        end
-
-        def length
-          @length
-        end
-
-        def each(&block)
-          @chunks.each(&block)
-        end
-
-        def close
-          @close.call
-        end
-      end
     end
   end
 end

data/lib/tus/storage/s3.rb

@@ -1,21 +1,12 @@
 # frozen-string-literal: true
 
-begin
-  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
-rescue LoadError => exception
-  begin
-    require "aws-sdk"
-    warn "Using aws-sdk 2.x is deprecated and support for it will be removed in tus-server 2.0, use the new aws-sdk-s3 gem instead."
-    Aws.eager_autoload!(services: ["S3"])
-  rescue LoadError
-    raise exception
-  end
+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"
 require "tus/errors"
 
 require "json"
@@ -30,6 +21,7 @@ module Tus
 
       attr_reader :client, :bucket, :prefix, :upload_options
 
+      # Initializes an aws-sdk-s3 client with the given credentials.
       def initialize(bucket:, prefix: nil, upload_options: {}, thread_count: 10, **client_options)
         resource = Aws::S3::Resource.new(**client_options)
 
@@ -40,6 +32,8 @@ module Tus
         @thread_count   = thread_count
       end
 
+      # Initiates multipart upload for the given upload, and stores its
+      # information inside the info hash.
       def create_file(uid, info = {})
         tus_info = Tus::Info.new(info)
 
@@ -63,6 +57,15 @@ module Tus
         multipart_upload
       end
 
+      # Concatenates multiple partial uploads into a single upload, and returns
+      # the size of the resulting upload. The partial uploads are deleted after
+      # concatenation.
+      #
+      # Internally it creates a new multipart upload, copies objects of the
+      # given partial uploads into multipart parts, and finalizes the multipart
+      # upload.
+      #
+      # The multipart upload is automatically aborted in case of an exception.
       def concatenate(uid, part_uids, info = {})
         multipart_upload = create_file(uid, info)
 
@@ -83,6 +86,18 @@ module Tus
         raise error
       end
 
+      # Appends data to the specified upload in a streaming fashion, and returns
+      # the number of bytes it managed to save.
+      #
+      # The data read from the input is first buffered in memory, and once 5MB
+      # (AWS S3's mininum allowed size for a multipart part) or more data has
+      # been retrieved, it starts being uploaded in a background thread as the
+      # next multipart part. This allows us to start reading the next chunk of
+      # input data and soon as possible, achieving streaming.
+      #
+      # If any network error is raised during the upload to S3, the upload of
+      # further input data stops and the number of bytes that manged to get
+      # uploaded is returned.
       def patch_file(uid, input, info = {})
         tus_info = Tus::Info.new(info)
 
@@ -129,6 +144,8 @@ module Tus
         bytes_uploaded
       end
 
+      # Completes the multipart upload using the part information saved in the
+      # info hash.
       def finalize_file(uid, info = {})
         upload_id = info["multipart_id"]
         parts = info["multipart_parts"].map do |part|
@@ -142,6 +159,8 @@ module Tus
         info.delete("multipart_parts")
       end
 
+      # Returns info of the specified upload. Raises Tus::NotFound if the upload
+      # wasn't found.
       def read_info(uid)
         response = object("#{uid}.info").get
         JSON.parse(response.body.string)
@@ -149,22 +168,26 @@ module Tus
         raise Tus::NotFound
       end
 
+      # Updates info of the specified upload.
       def update_info(uid, info)
         object("#{uid}.info").put(body: info.to_json)
       end
 
+      # Returns a Tus::Response object through which data of the specified
+      # 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)
 
-        length = range ? range.size : tus_info.length
         range  = "bytes=#{range.begin}-#{range.end}" if range
         chunks = object(uid).enum_for(:get, range: range)
 
-        # We return a response object that responds to #each, #length and #close,
-        # which the tus server can return directly as the Rack response.
-        Response.new(chunks: chunks, length: length)
+        Tus::Response.new(chunks: chunks)
       end
 
+      # Deletes resources for the specified upload. If multipart upload is
+      # still in progress, aborts the multipart upload, otherwise deletes the
+      # object.
       def delete_file(uid, info = {})
         if info["multipart_id"]
           multipart_upload = object(uid).multipart_upload(info["multipart_id"])
@@ -176,6 +199,9 @@ module Tus
         end
       end
 
+      # Deletes resources of uploads older than the specified date. For
+      # multipart uploads still in progress, it checks the upload date of the
+      # last multipart part.
       def expire_files(expiration_date)
         old_objects = bucket.objects.select do |object|
           object.last_modified <= expiration_date
@@ -196,10 +222,15 @@ 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.
       def upload_part(body, key, upload_id, part_number)
         multipart_upload = object(key).multipart_upload(upload_id)
         multipart_part   = multipart_upload.part(part_number)
@@ -229,6 +260,9 @@ module Tus
         # multipart upload was successfully aborted or doesn't exist
       end
 
+      # Creates multipart parts for the specified multipart upload by copying
+      # given objects into them. It uses a queue and a fixed-size thread pool
+      # which consumes that queue.
       def copy_parts(objects, multipart_upload)
         parts = compute_parts(objects, multipart_upload)
         queue = parts.inject(Queue.new) { |queue, part| queue << part }
@@ -238,6 +272,7 @@ module Tus
         threads.flat_map(&:value).sort_by { |part| part["part_number"] }
       end
 
+      # Computes data required for copying objects into new multipart parts.
       def compute_parts(objects, multipart_upload)
         objects.map.with_index do |object, idx|
           {
@@ -250,6 +285,8 @@ module Tus
         end
       end
 
+      # Consumes the queue for new multipart part information and issues the
+      # copy requests.
       def copy_part_thread(queue)
         Thread.new do
           begin
@@ -266,50 +303,19 @@ module Tus
         end
       end
 
+      # Creates a new multipart part by copying the object specified in the
+      # given data. Returns part number and ETag that will be required later
+      # for completing the multipart upload.
       def copy_part(part)
         response = client.upload_part_copy(part)
 
         { "part_number" => part[:part_number], "etag" => response.copy_part_result.etag }
       end
 
+      # Retuns an Aws::S3::Object with the prefix applied.
       def object(key)
         bucket.object([*prefix, key].join("/"))
       end
-
-      class Response
-        def initialize(chunks:, length:)
-          @chunks = chunks
-          @length = length
-        end
-
-        def length
-          @length
-        end
-
-        def each
-          return enum_for(__method__) unless block_given?
-
-          while (chunk = chunks_fiber.resume)
-            yield chunk
-          end
-        end
-
-        def close
-          chunks_fiber.resume(:close) if chunks_fiber.alive?
-        end
-
-        private
-
-        def chunks_fiber
-          @chunks_fiber ||= Fiber.new do
-            @chunks.each do |chunk|
-              action = Fiber.yield chunk
-              break if action == :close
-            end
-            nil
-          end
-        end
-      end
     end
   end
 end

data/tus-server.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |gem|
   gem.name         = "tus-server"
-  gem.version      = "1.2.1"
+  gem.version      = "2.0.0"
 
-  gem.required_ruby_version = ">= 2.1"
+  gem.required_ruby_version = ">= 2.2"
 
   gem.summary      = "Ruby server implementation of tus.io, the open protocol for resumable file uploads."
 
@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
   gem.files        = Dir["README.md", "LICENSE.txt", "CHANGELOG.md", "lib/**/*.rb", "*.gemspec"]
   gem.require_path = "lib"
 
-  gem.add_dependency "roda", "~> 2.19"
+  gem.add_dependency "roda", "~> 3.0"
 
   gem.add_development_dependency "rake", "~> 11.1"
   gem.add_development_dependency "minitest", "~> 5.8"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tus-server
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-05 00:00:00.000000000 Z
+date: 2017-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: roda
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.19'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.19'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -123,8 +123,9 @@ files:
 - lib/tus/errors.rb
 - lib/tus/info.rb
 - lib/tus/input.rb
+- lib/tus/input/unicorn.rb
+- lib/tus/response.rb
 - lib/tus/server.rb
-- lib/tus/server/goliath.rb
 - lib/tus/storage/filesystem.rb
 - lib/tus/storage/gridfs.rb
 - lib/tus/storage/s3.rb
@@ -141,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '2.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/tus/server/goliath.rb

@@ -1,71 +0,0 @@
-# frozen-string-literal: true
-require "tus/server"
-require "goliath"
-
-warn "Tus::Server::Goliath has been deprecated in favor of goliath-rack_proxy -- https://github.com/janko-m/goliath-rack_proxy"
-
-class Tus::Server::Goliath < Goliath::API
-  # Called as soon as request headers are parsed.
-  def on_headers(env, headers)
-    # the write end of the pipe is written in #on_body, and the read end is read by Tus::Server
-    env["tus.input-reader"], env["tus.input-writer"] = IO.pipe
-    # use a thread so that request is being processed in parallel
-    env["tus.request-thread"] = Thread.new do
-      call_tus_server env.merge("rack.input" => env["tus.input-reader"])
-    end
-  end
-
-  # Called on each request body chunk received from the client.
-  def on_body(env, data)
-    # append data to the write end of the pipe if open, otherwise do nothing
-    env["tus.input-writer"].write(data) unless env["tus.input-writer"].closed?
-  rescue Errno::EPIPE
-    # read end of the pipe has been closed, so we close the write end as well
-    env["tus.input-writer"].close
-  end
-
-  # Called at the end of the request (after #response is called), but also on
-  # client disconnect (in which case #response isn't called), so we want to do
-  # the same finalization in both methods.
-  def on_close(env)
-    finalize(env)
-  end
-
-  # Called after all the data has been received from the client.
-  def response(env)
-    status, headers, body = finalize(env)
-
-    env[STREAM_START].call(status, headers)
-
-    operation = proc { body.each { |chunk| env.stream_send(chunk) } }
-    callback  = proc { env.stream_close }
-
-    EM.defer(operation, callback) # use an outside thread pool for streaming
-
-    nil
-  end
-
-  private
-
-  # Calls the actual Roda application with the slightly modified env hash.
-  def call_tus_server(env)
-    Tus::Server.call env.merge(
-      "rack.url_scheme" => (env["options"][:ssl] ? "https" : "http"), # https://github.com/postrank-labs/goliath/issues/210
-      "async.callback"  => nil, # prevent Roda from calling EventMachine when streaming
-    )
-  end
-
-  # This method needs to be idempotent, because it can be called twice (on
-  # normal requests both #response and #on_close will be called, and on client
-  # disconnect only #on_close will be called).
-  def finalize(env)
-    # closing the write end of the pipe will mark EOF on the read end
-    env["tus.input-writer"].close unless env["tus.input-writer"].closed?
-    # wait for the request to finish
-    result = env["tus.request-thread"].value
-    # close read end of the pipe, since nothing is going to read from it anymore
-    env["tus.input-reader"].close unless env["tus.input-reader"].closed?
-    # return rack response
-    result
-  end
-end