dis 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b78f0ff03e09c43d839c8ba8e119c6548ae518469d17d6646767c987f36f6a15
-  data.tar.gz: 3c9d88b627d1eadb871f926a2552e9761eb007442543db0aa65f88623e00f168
+  metadata.gz: d4c3624aed32276988e39638489e694b4755991ec156d6e334013ff3e9f6dcae
+  data.tar.gz: 381f0c8bad7c0895f556d08040b2e83f514a8b52deca71db27740802048b5029
 SHA512:
-  metadata.gz: 7987a1138a986daa040447ff607a07b6bf077a0ea0450274dafbff3b977cca1fee9bdf2121847c9492ffe75fe12b7bb11fc8a056240d473a69129e205ca821af
-  data.tar.gz: 888c70668ce77b47451359d5cfe953793488eb1238749eaa0f7151e6779ed105ff6a1941cd9b8e3d69419c24a349c022fc857cea443bb48b48f102f4711507bf
+  metadata.gz: 911c9655763e26056cd0a93e32b37a546983798d24271be047d4c720a8a8fcbc5db0152dafabf147cf3cc788e60e6cf7e53222afc414345b0ac483a470967af0
+  data.tar.gz: efe469600850c64269abfbd2fecdf221cb70d8a1de9200022891440cc432d37bde55b0535f88fed462e8fa51c8b90fdd492f0079f7333d28be9b55599487f19a

data/lib/dis/controller.rb

@@ -29,6 +29,10 @@ module Dis
     # +filename+ and +content_type+ default to the record's own
     # metadata.
     #
+    # Responds with +206 Partial Content+ to a range request, or +416
+    # Range Not Satisfiable+ if the range lies beyond the data. Several
+    # ranges are sent as +multipart/byteranges+.
+    #
     # @param record [Dis::Model] the record to send data from
     # @param filename [String, nil] suggested filename
     # @param content_type [String, nil] the content type
@@ -42,14 +46,62 @@ module Dis
     def send_dis_data(record, filename: nil, content_type: nil,
                       disposition: "attachment", status: 200)
       file = record.open_data
+      ranges = dis_byte_ranges(file.size, status)
+      response.headers["Accept-Ranges"] = "bytes"
+      return dis_unsatisfiable_range(file) if ranges && ranges.empty?
+
+      type = content_type || dis_metadata(record, :content_type)
+      dis_send_file_headers(record, filename, type, disposition)
+      dis_send_body(
+        Dis::ResponseBody.new(file, ranges:, content_type: type), file.size,
+        status
+      )
+    end
+
+    def dis_byte_ranges(size, status)
+      return unless status == 200
+      return unless dis_if_range_matches?
+
+      Rack::Utils.get_byte_ranges(request.get_header("HTTP_RANGE"), size)
+    end
+
+    def dis_if_range_matches?
+      if_range = request.get_header("HTTP_IF_RANGE")
+      return true if if_range.blank?
+
+      [response.etag, response.headers["Last-Modified"]].any? do |validator|
+        validator.present? && if_range == validator
+      end
+    end
+
+    def dis_unsatisfiable_range(file)
+      response.headers["Content-Range"] = "bytes */#{file.size}"
+      file.close
+      head :range_not_satisfiable
+    end
+
+    def dis_send_file_headers(record, filename, type, disposition)
       send_file_headers!(
         { filename: filename || dis_metadata(record, :filename),
-          type: content_type || dis_metadata(record, :content_type),
-          disposition: }.compact
+          type:, disposition: }.compact
       )
-      self.status = status
-      response.headers["Content-Length"] = file.size.to_s
-      self.response_body = Dis::ResponseBody.new(file)
+    end
+
+    def dis_send_body(body, size, status)
+      self.status = body.ranges.any? ? :partial_content : status
+      dis_partial_headers(body, size)
+      response.headers["Content-Length"] = body.length.to_s
+      self.response_body = body
+    end
+
+    def dis_partial_headers(body, size)
+      if body.multipart?
+        self.content_type =
+          "multipart/byteranges; boundary=#{body.boundary}"
+      elsif body.range
+        response.headers["Content-Range"] =
+          "bytes #{body.range.begin}-#{body.range.end}/#{size}"
+      end
     end
 
     def dis_metadata(record, name)

data/lib/dis/response_body.rb

@@ -1,38 +1,73 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 module Dis
   # = Dis Response Body
   #
   # Rack body that streams an open file and closes it once the
   # response has been sent. The file may already be unlinked, so it is
   # read through the open descriptor and never by path.
+  #
+  # Streams only the given ranges when any are given, as a
+  # +multipart/byteranges+ payload if there is more than one.
   class ResponseBody
     CHUNK_SIZE = 16_384
 
     delegate :closed?, to: :@file
 
+    # @return [Array<Range>] the ranges being streamed
+    attr_reader :ranges
+
+    # @return [String, nil] the multipart boundary, when multipart
+    attr_reader :boundary
+
     # @param file [File] an open, readable file
-    def initialize(file)
+    # @param ranges [Array<Range>, nil] byte ranges, or nil for all of it
+    # @param content_type [String, nil] content type of the parts
+    def initialize(file, ranges: nil, content_type: nil)
       @file = file
+      @ranges = Array(ranges)
+      @content_type = content_type
+      @boundary = SecureRandom.hex(16) if multipart?
+    end
+
+    # @return [Boolean] whether more than one range is being streamed
+    def multipart?
+      ranges.length > 1
+    end
+
+    # @return [Range, nil] the range being streamed, unless multipart
+    def range
+      ranges.first unless multipart?
     end
 
-    # Returns the entire contents as a binary string.
+    # Returns the number of bytes that will be written.
+    #
+    # @return [Integer]
+    def length
+      return @file.size if ranges.empty?
+      return multipart_length if multipart?
+
+      range.size
+    end
+
+    # Returns the contents as a binary string.
     #
     # @return [String]
     def body
-      @file.rewind
-      @file.read
+      (+"").b.tap { |out| each { |chunk| out << chunk } }
     end
 
     # Yields the contents in chunks.
     #
     # @yieldparam chunk [String] a chunk of the contents
     # @return [void]
-    def each
-      @file.rewind
-      while (chunk = @file.read(CHUNK_SIZE))
-        yield chunk
-      end
+    def each(&)
+      return stream(0, @file.size, &) if ranges.empty?
+      return stream(range.begin, range.size, &) unless multipart?
+
+      each_part(&)
     end
 
     # Closes the underlying file.
@@ -41,5 +76,40 @@ module Dis
     def close
       @file.close unless @file.closed?
     end
+
+    private
+
+    def each_part(&)
+      ranges.each do |range|
+        yield heading(range)
+        stream(range.begin, range.size, &)
+      end
+      yield terminator
+    end
+
+    def stream(offset, remaining)
+      @file.seek(offset)
+      while remaining.positive? &&
+            (chunk = @file.read([CHUNK_SIZE, remaining].min))
+        remaining -= chunk.bytesize
+        yield chunk
+      end
+    end
+
+    def multipart_length
+      ranges.sum { |range| heading(range).bytesize + range.size } +
+        terminator.bytesize
+    end
+
+    def heading(range)
+      "\r\n--#{boundary}\r\n" \
+        "Content-Type: #{@content_type}\r\n" \
+        "Content-Range: bytes #{range.begin}-#{range.end}/#{@file.size}\r\n" \
+        "\r\n"
+    end
+
+    def terminator
+      "\r\n--#{boundary}--\r\n"
+    end
   end
 end

data/lib/dis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dis
-  VERSION = "2.1.0"
+  VERSION = "2.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dis
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Inge Jørgensen
@@ -71,6 +71,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.4
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement