dis 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7c60e34e3af85dabdb54a45edefc614356194ece8f98fefcc85f9245efbba4d
-  data.tar.gz: e9f450a4147cb7af0812f1755a0ecab8c0aea07c4c6cd425e1bb8fc0a9eb2476
+  metadata.gz: d4c3624aed32276988e39638489e694b4755991ec156d6e334013ff3e9f6dcae
+  data.tar.gz: 381f0c8bad7c0895f556d08040b2e83f514a8b52deca71db27740802048b5029
 SHA512:
-  metadata.gz: ddc5e8de5bb8d432d0c16a96c5d3fdae656dc2c5051dc9f728b2b6e7021679a9c9ec16b6be36d63bdc838a38e6fd965a649d56267fba4ec644b9f57aae1a41e3
-  data.tar.gz: c82397e472d58508bb953afb5480721ec6f23aa18e70da28b67ba2edcb92fba55315eeeb4879509079ae6883cbc2aab1caa13832f30a4408c76828b13a5d9e98
+  metadata.gz: 911c9655763e26056cd0a93e32b37a546983798d24271be047d4c720a8a8fcbc5db0152dafabf147cf3cc788e60e6cf7e53222afc414345b0ac483a470967af0
+  data.tar.gz: efe469600850c64269abfbd2fecdf221cb70d8a1de9200022891440cc432d37bde55b0535f88fed462e8fa51c8b90fdd492f0079f7333d28be9b55599487f19a

data/README.md

@@ -125,8 +125,7 @@ document.with_data_file { |path| Vips::Image.new_from_file(path.to_s).avg }
 
 `open_data` returns an open file, valid until you close it — even if
 the content is deleted or evicted from a cache layer meanwhile. Use it
-when the reader outlives the current call stack, such as a response
-body handed to the web server.
+when the reader outlives the current call stack.
 
 ```ruby
 document.open_data { |file| file.read }
@@ -134,6 +133,27 @@ document.open_data { |file| file.read }
 file = document.open_data # caller closes it
 ```
 
+### Sending data from a controller
+
+Include `Dis::Controller` and use `send_dis_data` to stream a record's
+data to the client. It works like `send_file`, but reads through an
+open descriptor rather than a path, so the response is unaffected if
+the content is evicted or deleted while it is being written.
+
+```ruby
+class DocumentsController < ApplicationController
+  include Dis::Controller
+
+  def show
+    send_dis_data(Document.find(params[:id]), disposition: "inline")
+  end
+end
+```
+
+`filename` and `content_type` default to the record's own metadata.
+The full set of options is `filename`, `content_type`, `disposition`
+and `status`.
+
 ## Layers
 
 The underlying storage consists of one or more layers. Each layer

data/lib/dis/controller.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Dis
+  # = Dis Controller
+  #
+  # Adds {#send_dis_data} for serving stored data from a controller.
+  #
+  #   class DocumentsController < ApplicationController
+  #     include Dis::Controller
+  #
+  #     def show
+  #       send_dis_data(Document.find(params[:id]))
+  #     end
+  #   end
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      include ActionController::DataStreaming
+    end
+
+    private
+
+    # Sends the record's data to the client. Works like +send_file+,
+    # but reads through an open descriptor rather than a path, so the
+    # response is unaffected if the content is evicted or deleted
+    # while it is being written.
+    #
+    # +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
+    # @param disposition [String] +"attachment"+ or +"inline"+
+    # @param status [Integer] the HTTP status code
+    # @return [void]
+    # @raise [Dis::Errors::NotFoundError] if the data is not found
+    #
+    # @example
+    #   send_dis_data(document, disposition: "inline")
+    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:, disposition: }.compact
+      )
+    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)
+      attribute = record.class.dis_attributes[name]
+      record[attribute] if attribute
+    end
+  end
+end

data/lib/dis/response_body.rb

@@ -0,0 +1,115 @@
+# 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
+    # @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 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
+      (+"").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(&)
+      return stream(0, @file.size, &) if ranges.empty?
+      return stream(range.begin, range.size, &) unless multipart?
+
+      each_part(&)
+    end
+
+    # Closes the underlying file.
+    #
+    # @return [void]
+    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.0.0"
+  VERSION = "2.2.0"
 end

data/lib/dis.rb

@@ -6,6 +6,7 @@ require "fog/core"
 require "fog/local"
 require "active_job"
 require "concurrent"
+require "dis/controller"
 require "dis/engine"
 require "dis/errors"
 require "dis/jobs"
@@ -13,6 +14,7 @@ require "dis/logging"
 require "dis/layer"
 require "dis/layers"
 require "dis/model"
+require "dis/response_body"
 require "dis/storage"
 require "dis/validations"
 
@@ -27,6 +29,7 @@ require "dis/validations"
 # configure layers via {Dis::Storage.layers}.
 #
 # @see Dis::Model
+# @see Dis::Controller
 # @see Dis::Storage
 # @see Dis::Layer
 module Dis

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dis
 version: !ruby/object:Gem::Version
-  version: 2.0.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
@@ -110,6 +124,7 @@ files:
 - LICENSE
 - README.md
 - lib/dis.rb
+- lib/dis/controller.rb
 - lib/dis/engine.rb
 - lib/dis/errors.rb
 - lib/dis/jobs.rb
@@ -123,6 +138,7 @@ files:
 - lib/dis/model.rb
 - lib/dis/model/class_methods.rb
 - lib/dis/model/data.rb
+- lib/dis/response_body.rb
 - lib/dis/storage.rb
 - lib/dis/validations.rb
 - lib/dis/validations/data_presence.rb