Active storage add proxying

activestorage/README.md

@@ -106,6 +106,38 @@ Variation of image attachment:
 <%= image_tag user.avatar.variant(resize_to_limit: [100, 100]) %>
 ```
 
+## Delivery methods
+You can change the delivery method to best suit the needs of your application.
+
+### Redirect (default)
+Requests for files will redirect to a temporary service URL.
+
+### Proxy
+Files are proxied through the application server so they appear as though they're being served from your server. Useful for serving images from a CDN or HTML caching.
+
+### Changing delivery method
+globally
+```ruby
+config.active_storage.default_delivery_method = :proxy
+```
+model
+```ruby
+has_one_attached :avatar, delivery_method: :proxy
+```
+view
+```ruby
+user.avatar.variant(resize: "100x100").deliver(:proxy)
+```
+
+### Changing the host of proxied urls
+When using the proxy option to deliver assets you can set the host. This is useful if your CDN is setup to operate on a different domain.
+
+```ruby
+config.active_storage.delivery_methods = {
+  proxy: ActiveStorage::DeliveryMethod::Proxy.new(host: 'cdn.domain.com')
+}
+```
+
 ## Direct uploads
 
 Active Storage, with its included JavaScript library, supports uploading directly from the client to the cloud.

activestorage/app/controllers/active_storage/blobs_controller.rb

@@ -11,4 +11,17 @@ def show
     expires_in ActiveStorage.service_urls_expire_in
     redirect_to @blob.url(disposition: params[:disposition])
   end
+
+  def proxy
+    expires_in ActiveStorage.proxy_urls_expire_in, public: true
+
+    response.headers["Content-Type"] = @blob.content_type
+    response.headers["Content-Disposition"] = @blob.disposition(params[:disposition])
+
+    @blob.download do |chunk|
+      response.stream.write(chunk)
+    end
+  ensure
+    response.stream.close
+  end
 end

activestorage/app/controllers/active_storage/representations_controller.rb

@@ -11,4 +11,19 @@ def show
     expires_in ActiveStorage.service_urls_expire_in
     redirect_to @blob.representation(params[:variation_key]).processed.service_url(disposition: params[:disposition])
   end
+
+  def proxy
+    expires_in params[:proxy_urls_expire_in], public: params[:proxy_urls_public]
+
+    representation = @blob.representation(params[:variation_key]).processed
+
+    response.headers["Content-Disposition"] = representation.image.blob.disposition(params[:disposition])
+    response.headers["Content-Type"] = representation.image.content_type
+
+    @blob.service.download(representation.key) do |chunk|
+      response.stream.write(chunk)
+    end
+  ensure
+    response.stream.close
+  end
 end

activestorage/app/models/active_storage/attachment.rb

@@ -30,6 +30,18 @@ def purge_later
     blob&.purge_later
   end
 
+  def url(override_delivery_method = record.public_send("#{name}_delivery_method"))
+    blob.delivery_method_url(override_delivery_method)
+  end
+
+  def variant(transformations)
+    blob.variant(transformations, record.public_send("#{name}_delivery_method"))
+  end
+
+  def preview(transformations)
+    blob.preview(transformations, record.public_send("#{name}_delivery_method"))
+  end
+
   private
     def identify_blob
       blob.identify

activestorage/app/models/active_storage/blob.rb

@@ -130,6 +130,10 @@ def key
     self[:key] ||= self.class.generate_unique_secure_token(length: MINIMUM_TOKEN_LENGTH)
   end
 
+  def delivery_method_url(method = ActiveStorage.default_delivery_method)
+    ActiveStorage.delivery_methods.fetch(method).blob_url(signed_id, filename)
+  end
+
   # Returns an ActiveStorage::Filename instance of the filename that can be
   # queried for basename, extension, and a sanitized version of the filename
   # that's safe to use in URLs.
@@ -157,6 +161,13 @@ def text?
     content_type.start_with?("text")
   end
 
+  def disposition(disposition_override = nil)
+    ActionDispatch::Http::ContentDisposition.format(
+      disposition: disposition_override || "inline",
+      filename: filename.sanitized
+    )
+  end
+
   # Returns the URL of the blob on the service. This returns a permanent URL for public files, and returns a
   # short-lived URL for private files. Private files are for security and not used directly with users, instead,
   # the URL should only be exposed as a redirect from a stable, possibly authenticated URL. Hiding the

activestorage/app/models/active_storage/blob/representable.rb

@@ -25,9 +25,9 @@ module ActiveStorage::Blob::Representable
   #
   # Raises ActiveStorage::InvariableError if ImageMagick cannot transform the blob. To determine whether a blob is
   # variable, call ActiveStorage::Blob#variable?.
-  def variant(transformations)
+  def variant(transformations, delivery_method = nil)
     if variable?
-      ActiveStorage::Variant.new(self, transformations)
+      ActiveStorage::Variant.new(self, transformations, delivery_method)
     else
       raise ActiveStorage::InvariableError
     end
@@ -53,9 +53,9 @@ def variable?
   #
   # This method raises ActiveStorage::UnpreviewableError if no previewer accepts the receiving blob. To determine
   # whether a blob is accepted by any previewer, call ActiveStorage::Blob#previewable?.
-  def preview(transformations)
+  def preview(transformations, delivery_method = nil)
     if previewable?
-      ActiveStorage::Preview.new(self, transformations)
+      ActiveStorage::Preview.new(self, transformations, delivery_method)
     else
       raise ActiveStorage::UnpreviewableError
     end

activestorage/app/models/active_storage/preview.rb

@@ -30,10 +30,10 @@
 class ActiveStorage::Preview
   class UnprocessedError < StandardError; end
 
-  attr_reader :blob, :variation
+  attr_reader :blob, :variation, :delivery_method
 
-  def initialize(blob, variation_or_variation_key)
-    @blob, @variation = blob, ActiveStorage::Variation.wrap(variation_or_variation_key)
+  def initialize(blob, variation_or_variation_key, delivery_method = nil)
+    @blob, @variation, @delivery_method = blob, ActiveStorage::Variation.wrap(variation_or_variation_key), delivery_method
   end
 
   # Processes the preview if it has not been processed yet. Returns the receiving Preview instance for convenience:
@@ -65,6 +65,16 @@ def service_url(**options)
     end
   end
 
+  # Returns a combination key of the blob and the variation that together identifies a specific variant.
+  def key
+    "variants/#{image.key}/#{Digest::SHA256.hexdigest(variation.key)}"
+  end
+
+  # Proxies the url method to the variation.
+  def url(method = delivery_method)
+    variation.url(method, self)
+  end
+
   private
     def processed?
       image.attached?

activestorage/app/models/active_storage/variant.rb

@@ -55,11 +55,11 @@
 class ActiveStorage::Variant
   WEB_IMAGE_CONTENT_TYPES = %w[ image/png image/jpeg image/jpg image/gif ]
 
-  attr_reader :blob, :variation
+  attr_reader :blob, :variation, :delivery_method
   delegate :service, to: :blob
 
-  def initialize(blob, variation_or_variation_key)
-    @blob, @variation = blob, ActiveStorage::Variation.wrap(variation_or_variation_key)
+  def initialize(blob, variation_or_variation_key, delivery_method = nil)
+    @blob, @variation, @delivery_method = blob, ActiveStorage::Variation.wrap(variation_or_variation_key), delivery_method
   end
 
   # Returns the variant instance itself after it's been processed or an existing processing has been found on the service.
@@ -73,6 +73,10 @@ def key
     "variants/#{blob.key}/#{Digest::SHA256.hexdigest(variation.key)}"
   end
 
+  def url(method = delivery_method)
+    variation.url(method, self)
+  end
+
   # Returns the URL of the variant on the service. This URL is intended to be short-lived for security and not used directly
   # with users. Instead, the +service_url+ should only be exposed as a redirect from a stable, possibly authenticated URL.
   # Hiding the +service_url+ behind a redirect also gives you the power to change services without updating all URLs. And

activestorage/app/models/active_storage/variation.rb

@@ -39,6 +39,10 @@ def encode(transformations)
     end
   end
 
+  def url(method, representation)
+    ActiveStorage.delivery_methods.fetch(method).representation_url(representation)
+  end
+
   def initialize(transformations)
     @transformations = transformations.deep_symbolize_keys
   end

activestorage/config/routes.rb

@@ -3,8 +3,10 @@
 Rails.application.routes.draw do
   scope ActiveStorage.routes_prefix do
     get "/blobs/:signed_id/*filename" => "active_storage/blobs#show", as: :rails_service_blob
+    get "/blobs_proxy/:signed_id/*filename" => "active_storage/blobs#proxy", as: :rails_blob_proxy
 
     get "/representations/:signed_blob_id/:variation_key/*filename" => "active_storage/representations#show", as: :rails_blob_representation
+    get "/representations_proxy/:signed_blob_id/:variation_key/*filename" => "active_storage/representations#proxy", as: :rails_blob_representation_proxy
 
     get  "/disk/public/:key/*filename" => "active_storage/public_disk#show", as: :rails_disk_service_public
     get  "/disk/:encoded_key/*filename" => "active_storage/disk#show", as: :rails_disk_service

activestorage/lib/active_storage.rb

@@ -41,6 +41,7 @@ module ActiveStorage
   autoload :ServiceRegistry
   autoload :Previewer
   autoload :Analyzer
+  autoload :DeliveryMethod
 
   mattr_accessor :logger
   mattr_accessor :verifier
@@ -65,6 +66,13 @@ module ActiveStorage
 
   mattr_accessor :replace_on_assign_to_many, default: false
 
+  mattr_accessor :delivery_methods,        default: {}
+  mattr_accessor :default_delivery_method, default: :redirect
+
+  mattr_accessor :proxy_urls_expire_in, default: 525600.minutes
+
+  mattr_accessor :routes_prefix,          default: "/rails/active_storage"
+
   module Transformers
     extend ActiveSupport::Autoload
 

activestorage/lib/active_storage/attached/model.rb

@@ -40,14 +40,18 @@ module Attached::Model
       #     has_one_attached :avatar, service: :s3
       #   end
       #
-      def has_one_attached(name, dependent: :purge_later, service: nil)
+      def has_one_attached(name, dependent: :purge_later, service: nil, delivery_method: ActiveStorage.default_delivery_method)
         validate_service_configuration(name, service)
 
         generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
           def #{name}
             @active_storage_attached_#{name} ||= ActiveStorage::Attached::One.new("#{name}", self)
           end
 
+          def #{name}_delivery_method
+            :#{delivery_method}
+          end
+
           def #{name}=(attachable)
             attachment_changes["#{name}"] =
               if attachable.nil?
@@ -109,14 +113,18 @@ def #{name}=(attachable)
       #     has_many_attached :photos, service: :s3
       #   end
       #
-      def has_many_attached(name, dependent: :purge_later, service: nil)
+      def has_many_attached(name, dependent: :purge_later, service: nil, delivery_method: ActiveStorage.default_delivery_method)
         validate_service_configuration(name, service)
 
         generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
           def #{name}
             @active_storage_attached_#{name} ||= ActiveStorage::Attached::Many.new("#{name}", self)
           end
 
+          def #{name}_delivery_method
+            :#{delivery_method}
+          end
+
           def #{name}=(attachables)
             if ActiveStorage.replace_on_assign_to_many
               attachment_changes["#{name}"] =

activestorage/lib/active_storage/attached/one.rb

@@ -4,6 +4,7 @@ module ActiveStorage
   # Representation of a single attachment to a model.
   class Attached::One < Attached
     delegate_missing_to :attachment, allow_nil: true
+    attr_accessor :delivery_method
 
     # Returns the associated attachment record.
     #

activestorage/lib/active_storage/delivery_method.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class DeliveryMethod
+    def representation_url(representation, url_options: nil, delivery_method: nil)
+      raise NotImplementedError
+    end
+
+    def blob_url(signed_id, filename, url_options: nil, delivery_method: nil)
+      raise NotImplementedError
+    end
+  end
+end

activestorage/lib/active_storage/delivery_method/proxy.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class DeliveryMethod::Proxy < DeliveryMethod
+    # * :host - Specifies the host the link should be targeted at.
+    def initialize(options = {})
+      @options = options
+
+      @options[:only_path] = true unless options[:host]
+    end
+
+    def representation_url(representation, url_options: {})
+      Rails.application.routes.url_helpers.route_for(
+        :rails_blob_representation_proxy,
+        representation.blob.signed_id,
+        representation.variation.key,
+        representation.blob.filename,
+        @options.merge(url_options)
+      )
+    end
+
+    def blob_url(signed_id, filename, url_options: {})
+      Rails.application.routes.url_helpers.route_for(
+        :rails_blob_proxy,
+        signed_id,
+        filename,
+        @options.merge(url_options)
+      )
+    end
+  end
+end

activestorage/lib/active_storage/delivery_method/redirect.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class DeliveryMethod::Redirect < DeliveryMethod
+    def initialize(options = {})
+      @options = { only_path: true }.merge(options)
+    end
+
+    def representation_url(representation, url_options: {})
+      Rails.application.routes.url_helpers.route_for(
+        :rails_blob_representation,
+        representation.blob.signed_id,
+        representation.variation.key,
+        representation.blob.filename,
+        @options.merge(url_options)
+      )
+    end
+
+    def blob_url(signed_id, filename, url_options: {})
+      Rails.application.routes.url_helpers.route_for(
+        :rails_service_blob,
+        signed_id,
+        filename,
+        @options.merge(url_options)
+      )
+    end
+  end
+end

activestorage/lib/active_storage/engine.rb

@@ -16,6 +16,9 @@
 
 require "active_storage/reflection"
 
+require "active_storage/delivery_method/redirect"
+require "active_storage/delivery_method/proxy"
+
 module ActiveStorage
   class Engine < Rails::Engine # :nodoc:
     isolate_namespace ActiveStorage
@@ -78,10 +81,20 @@ class Engine < Rails::Engine # :nodoc:
         ActiveStorage.variable_content_types = app.config.active_storage.variable_content_types || []
         ActiveStorage.content_types_to_serve_as_binary = app.config.active_storage.content_types_to_serve_as_binary || []
         ActiveStorage.service_urls_expire_in = app.config.active_storage.service_urls_expire_in || 5.minutes
+
         ActiveStorage.content_types_allowed_inline = app.config.active_storage.content_types_allowed_inline || []
         ActiveStorage.binary_content_type = app.config.active_storage.binary_content_type || "application/octet-stream"
 
         ActiveStorage.replace_on_assign_to_many = app.config.active_storage.replace_on_assign_to_many || false
+
+        ActiveStorage.delivery_methods = {
+          redirect: ActiveStorage::DeliveryMethod::Redirect.new,
+          proxy: ActiveStorage::DeliveryMethod::Proxy.new
+        }.merge(app.config.active_storage.delivery_methods || {})
+
+        ActiveStorage.default_delivery_method = app.config.active_storage.default_delivery_method || :redirect
+
+        ActiveStorage.proxy_urls_expire_in = app.config.active_storage.proxy_urls_expire_in || 525600.minutes
       end
     end