activestorage 5.2.7.1 → 6.1.4.6

data/lib/active_storage/service/azure_storage_service.rb

@@ -1,28 +1,30 @@
 # frozen_string_literal: true
 
+gem "azure-storage-blob", ">= 1.1"
+
 require "active_support/core_ext/numeric/bytes"
-require "azure/storage"
-require "azure/storage/core/auth/shared_access_signature"
+require "azure/storage/blob"
+require "azure/storage/common/core/auth/shared_access_signature"
 
 module ActiveStorage
   # Wraps the Microsoft Azure Storage Blob Service as an Active Storage service.
   # See ActiveStorage::Service for the generic API documentation that applies to all services.
   class Service::AzureStorageService < Service
-    attr_reader :client, :blobs, :container, :signer
+    attr_reader :client, :container, :signer
 
-    def initialize(storage_account_name:, storage_access_key:, container:, **options)
-      @client = Azure::Storage::Client.create(storage_account_name: storage_account_name, storage_access_key: storage_access_key, **options)
-      @signer = Azure::Storage::Core::Auth::SharedAccessSignature.new(storage_account_name, storage_access_key)
-      @blobs = client.blob_client
+    def initialize(storage_account_name:, storage_access_key:, container:, public: false, **options)
+      @client = Azure::Storage::Blob::BlobService.create(storage_account_name: storage_account_name, storage_access_key: storage_access_key, **options)
+      @signer = Azure::Storage::Common::Core::Auth::SharedAccessSignature.new(storage_account_name, storage_access_key)
       @container = container
+      @public = public
     end
 
-    def upload(key, io, checksum: nil, **)
+    def upload(key, io, checksum: nil, filename: nil, content_type: nil, disposition: nil, **)
       instrument :upload, key: key, checksum: checksum do
-        begin
-          blobs.create_block_blob(container, key, IO.try_convert(io) || io, content_md5: checksum)
-        rescue Azure::Core::Http::HTTPError
-          raise ActiveStorage::IntegrityError
+        handle_errors do
+          content_disposition = content_disposition_with(filename: filename, type: disposition) if disposition && filename
+
+          client.create_block_blob(container, key, IO.try_convert(io) || io, content_md5: checksum, content_type: content_type, content_disposition: content_disposition)
         end
       end
     end
@@ -34,26 +36,29 @@ module ActiveStorage
         end
       else
         instrument :download, key: key do
-          _, io = blobs.get_blob(container, key)
-          io.force_encoding(Encoding::BINARY)
+          handle_errors do
+            _, io = client.get_blob(container, key)
+            io.force_encoding(Encoding::BINARY)
+          end
         end
       end
     end
 
     def download_chunk(key, range)
       instrument :download_chunk, key: key, range: range do
-        _, io = blobs.get_blob(container, key, start_range: range.begin, end_range: range.exclude_end? ? range.end - 1 : range.end)
-        io.force_encoding(Encoding::BINARY)
+        handle_errors do
+          _, io = client.get_blob(container, key, start_range: range.begin, end_range: range.exclude_end? ? range.end - 1 : range.end)
+          io.force_encoding(Encoding::BINARY)
+        end
       end
     end
 
     def delete(key)
       instrument :delete, key: key do
-        begin
-          blobs.delete_blob(container, key)
-        rescue Azure::Core::Http::HTTPError
-          # Ignore files already deleted
-        end
+        client.delete_blob(container, key)
+      rescue Azure::Core::Http::HTTPError => e
+        raise unless e.type == "BlobNotFound"
+        # Ignore files already deleted
       end
     end
 
@@ -62,10 +67,10 @@ module ActiveStorage
         marker = nil
 
         loop do
-          results = blobs.list_blobs(container, prefix: prefix, marker: marker)
+          results = client.list_blobs(container, prefix: prefix, marker: marker)
 
           results.each do |blob|
-            blobs.delete_blob(container, blob.name)
+            client.delete_blob(container, blob.name)
           end
 
           break unless marker = results.continuation_token.presence
@@ -81,15 +86,13 @@ module ActiveStorage
       end
     end
 
-    def url(key, expires_in:, filename:, disposition:, content_type:)
+    def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:)
       instrument :url, key: key do |payload|
         generated_url = signer.signed_uri(
           uri_for(key), false,
           service: "b",
-          permissions: "r",
-          expiry: format_expiry(expires_in),
-          content_disposition: content_disposition_with(type: disposition, filename: filename),
-          content_type: content_type
+          permissions: "rw",
+          expiry: format_expiry(expires_in)
         ).to_s
 
         payload[:url] = generated_url
@@ -98,32 +101,35 @@ module ActiveStorage
       end
     end
 
-    def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:)
-      instrument :url, key: key do |payload|
-        generated_url = signer.signed_uri(
+    def headers_for_direct_upload(key, content_type:, checksum:, filename: nil, disposition: nil, **)
+      content_disposition = content_disposition_with(type: disposition, filename: filename) if filename
+
+      { "Content-Type" => content_type, "Content-MD5" => checksum, "x-ms-blob-content-disposition" => content_disposition, "x-ms-blob-type" => "BlockBlob" }
+    end
+
+    private
+      def private_url(key, expires_in:, filename:, disposition:, content_type:, **)
+        signer.signed_uri(
           uri_for(key), false,
           service: "b",
-          permissions: "rw",
-          expiry: format_expiry(expires_in)
+          permissions: "r",
+          expiry: format_expiry(expires_in),
+          content_disposition: content_disposition_with(type: disposition, filename: filename),
+          content_type: content_type
         ).to_s
+      end
 
-        payload[:url] = generated_url
-
-        generated_url
+      def public_url(key, **)
+        uri_for(key).to_s
       end
-    end
 
-    def headers_for_direct_upload(key, content_type:, checksum:, **)
-      { "Content-Type" => content_type, "Content-MD5" => checksum, "x-ms-blob-type" => "BlockBlob" }
-    end
 
-    private
       def uri_for(key)
-        blobs.generate_uri("#{container}/#{key}")
+        client.generate_uri("#{container}/#{key}")
       end
 
       def blob_for(key)
-        blobs.get_blob_properties(container, key)
+        client.get_blob_properties(container, key)
       rescue Azure::Core::Http::HTTPError
         false
       end
@@ -139,11 +145,26 @@ module ActiveStorage
         chunk_size = 5.megabytes
         offset = 0
 
+        raise ActiveStorage::FileNotFoundError unless blob.present?
+
         while offset < blob.properties[:content_length]
-          _, chunk = blobs.get_blob(container, key, start_range: offset, end_range: offset + chunk_size - 1)
+          _, chunk = client.get_blob(container, key, start_range: offset, end_range: offset + chunk_size - 1)
           yield chunk.force_encoding(Encoding::BINARY)
           offset += chunk_size
         end
       end
+
+      def handle_errors
+        yield
+      rescue Azure::Core::Http::HTTPError => e
+        case e.type
+        when "BlobNotFound"
+          raise ActiveStorage::FileNotFoundError
+        when "Md5Mismatch"
+          raise ActiveStorage::IntegrityError
+        else
+          raise
+        end
+      end
   end
 end

data/lib/active_storage/service/configurator.rb

@@ -14,7 +14,9 @@ module ActiveStorage
 
     def build(service_name)
       config = config_for(service_name.to_sym)
-      resolve(config.fetch(:service)).build(**config, configurator: self)
+      resolve(config.fetch(:service)).build(
+        **config, configurator: self, name: service_name
+      )
     end
 
     private
@@ -26,7 +28,9 @@ module ActiveStorage
 
       def resolve(class_name)
         require "active_storage/service/#{class_name.to_s.underscore}_service"
-        ActiveStorage::Service.const_get(:"#{class_name}Service")
+        ActiveStorage::Service.const_get(:"#{class_name.camelize}Service")
+      rescue LoadError
+        raise "Missing service adapter for #{class_name.inspect}"
       end
   end
 end

data/lib/active_storage/service/disk_service.rb

@@ -11,8 +11,9 @@ module ActiveStorage
   class Service::DiskService < Service
     attr_reader :root
 
-    def initialize(root:)
+    def initialize(root:, public: false, **options)
       @root = root
+      @public = public
     end
 
     def upload(key, io, checksum: nil, **)
@@ -22,18 +23,16 @@ module ActiveStorage
       end
     end
 
-    def download(key)
+    def download(key, &block)
       if block_given?
         instrument :streaming_download, key: key do
-          File.open(path_for(key), "rb") do |file|
-            while data = file.read(5.megabytes)
-              yield data
-            end
-          end
+          stream key, &block
         end
       else
         instrument :download, key: key do
           File.binread path_for(key)
+        rescue Errno::ENOENT
+          raise ActiveStorage::FileNotFoundError
         end
       end
     end
@@ -44,16 +43,16 @@ module ActiveStorage
           file.seek range.begin
           file.read range.size
         end
+      rescue Errno::ENOENT
+        raise ActiveStorage::FileNotFoundError
       end
     end
 
     def delete(key)
       instrument :delete, key: key do
-        begin
-          File.delete path_for(key)
-        rescue Errno::ENOENT
-          # Ignore files already deleted
-        end
+        File.delete path_for(key)
+      rescue Errno::ENOENT
+        # Ignore files already deleted
       end
     end
 
@@ -73,35 +72,6 @@ module ActiveStorage
       end
     end
 
-    def url(key, expires_in:, filename:, disposition:, content_type:)
-      instrument :url, key: key do |payload|
-        content_disposition = content_disposition_with(type: disposition, filename: filename)
-        verified_key_with_expiration = ActiveStorage.verifier.generate(
-          {
-            key: key,
-            disposition: content_disposition,
-            content_type: content_type
-          },
-          { expires_in: expires_in,
-          purpose: :blob_key }
-        )
-
-        current_uri = URI.parse(current_host)
-
-        generated_url = url_helpers.rails_disk_service_url(verified_key_with_expiration,
-          protocol: current_uri.scheme,
-          host: current_uri.host,
-          port: current_uri.port,
-          disposition: content_disposition,
-          content_type: content_type,
-          filename: filename
-        )
-        payload[:url] = generated_url
-
-        generated_url
-      end
-    end
-
     def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:)
       instrument :url, key: key do |payload|
         verified_token_with_expiration = ActiveStorage.verifier.generate(
@@ -109,10 +79,11 @@ module ActiveStorage
             key: key,
             content_type: content_type,
             content_length: content_length,
-            checksum: checksum
+            checksum: checksum,
+            service_name: name
           },
-          { expires_in: expires_in,
-          purpose: :blob_token }
+          expires_in: expires_in,
+          purpose: :blob_token
         )
 
         generated_url = url_helpers.update_rails_disk_service_url(verified_token_with_expiration, host: current_host)
@@ -132,6 +103,48 @@ module ActiveStorage
     end
 
     private
+      def private_url(key, expires_in:, filename:, content_type:, disposition:, **)
+        generate_url(key, expires_in: expires_in, filename: filename, content_type: content_type, disposition: disposition)
+      end
+
+      def public_url(key, filename:, content_type: nil, disposition: :attachment, **)
+        generate_url(key, expires_in: nil, filename: filename, content_type: content_type, disposition: disposition)
+      end
+
+      def generate_url(key, expires_in:, filename:, content_type:, disposition:)
+        content_disposition = content_disposition_with(type: disposition, filename: filename)
+        verified_key_with_expiration = ActiveStorage.verifier.generate(
+          {
+            key: key,
+            disposition: content_disposition,
+            content_type: content_type,
+            service_name: name
+          },
+          expires_in: expires_in,
+          purpose: :blob_key
+        )
+
+        current_uri = URI.parse(current_host)
+
+        url_helpers.rails_disk_service_url(verified_key_with_expiration,
+          protocol: current_uri.scheme,
+          host: current_uri.host,
+          port: current_uri.port,
+          filename: filename
+        )
+      end
+
+
+      def stream(key)
+        File.open(path_for(key), "rb") do |file|
+          while data = file.read(5.megabytes)
+            yield data
+          end
+        end
+      rescue Errno::ENOENT
+        raise ActiveStorage::FileNotFoundError
+      end
+
       def folder_for(key)
         [ key[0..1], key[2..3] ].join("/")
       end

data/lib/active_storage/service/gcs_service.rb

@@ -1,31 +1,40 @@
 # frozen_string_literal: true
 
-gem "google-cloud-storage", "~> 1.8"
-
+gem "google-cloud-storage", "~> 1.11"
 require "google/cloud/storage"
-require "net/http"
-
-require "active_support/core_ext/object/to_query"
 
 module ActiveStorage
   # Wraps the Google Cloud Storage as an Active Storage service. See ActiveStorage::Service for the generic API
   # documentation that applies to all services.
   class Service::GCSService < Service
-    def initialize(**config)
+    def initialize(public: false, **config)
       @config = config
+      @public = public
     end
 
     def upload(key, io, checksum: nil, content_type: nil, disposition: nil, filename: nil)
       instrument :upload, key: key, checksum: checksum do
-        begin
-          # GCS's signed URLs don't include params such as response-content-type response-content_disposition
-          # in the signature, which means an attacker can modify them and bypass our effort to force these to
-          # binary and attachment when the file's content type requires it. The only way to force them is to
-          # store them as object's metadata.
-          content_disposition = content_disposition_with(type: disposition, filename: filename) if disposition && filename
-          bucket.create_file(io, key, md5: checksum, content_type: content_type, content_disposition: content_disposition)
-        rescue Google::Cloud::InvalidArgumentError
-          raise ActiveStorage::IntegrityError
+        # GCS's signed URLs don't include params such as response-content-type response-content_disposition
+        # in the signature, which means an attacker can modify them and bypass our effort to force these to
+        # binary and attachment when the file's content type requires it. The only way to force them is to
+        # store them as object's metadata.
+        content_disposition = content_disposition_with(type: disposition, filename: filename) if disposition && filename
+        bucket.create_file(io, key, md5: checksum, content_type: content_type, content_disposition: content_disposition)
+      rescue Google::Cloud::InvalidArgumentError
+        raise ActiveStorage::IntegrityError
+      end
+    end
+
+    def download(key, &block)
+      if block_given?
+        instrument :streaming_download, key: key do
+          stream(key, &block)
+        end
+      else
+        instrument :download, key: key do
+          file_for(key).download.string
+        rescue Google::Cloud::NotFoundError
+          raise ActiveStorage::FileNotFoundError
         end
       end
     end
@@ -39,49 +48,28 @@ module ActiveStorage
       end
     end
 
-    # FIXME: Download in chunks when given a block.
-    def download(key)
-      instrument :download, key: key do
-        io = file_for(key).download
-        io.rewind
-
-        if block_given?
-          yield io.string
-        else
-          io.string
-        end
-      end
-    end
-
     def download_chunk(key, range)
       instrument :download_chunk, key: key, range: range do
-        file = file_for(key)
-        uri  = URI(file.signed_url(expires: 30.seconds))
-
-        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |client|
-          client.get(uri, "Range" => "bytes=#{range.begin}-#{range.exclude_end? ? range.end - 1 : range.end}").body
-        end
+        file_for(key).download(range: range).string
+      rescue Google::Cloud::NotFoundError
+        raise ActiveStorage::FileNotFoundError
       end
     end
 
     def delete(key)
       instrument :delete, key: key do
-        begin
-          file_for(key).delete
-        rescue Google::Cloud::NotFoundError
-          # Ignore files already deleted
-        end
+        file_for(key).delete
+      rescue Google::Cloud::NotFoundError
+        # Ignore files already deleted
       end
     end
 
     def delete_prefixed(prefix)
       instrument :delete_prefixed, prefix: prefix do
         bucket.files(prefix: prefix).all do |file|
-          begin
-            file.delete
-          rescue Google::Cloud::NotFoundError
-            # Ignore concurrently-deleted files
-          end
+          file.delete
+        rescue Google::Cloud::NotFoundError
+          # Ignore concurrently-deleted files
         end
       end
     end
@@ -94,19 +82,6 @@ module ActiveStorage
       end
     end
 
-    def url(key, expires_in:, filename:, content_type:, disposition:)
-      instrument :url, key: key do |payload|
-        generated_url = file_for(key).signed_url expires: expires_in, query: {
-          "response-content-disposition" => content_disposition_with(type: disposition, filename: filename),
-          "response-content-type" => content_type
-        }
-
-        payload[:url] = generated_url
-
-        generated_url
-      end
-    end
-
     def url_for_direct_upload(key, expires_in:, checksum:, **)
       instrument :url, key: key do |payload|
         generated_url = bucket.signed_url key, method: "PUT", expires: expires_in, content_md5: checksum
@@ -117,23 +92,52 @@ module ActiveStorage
       end
     end
 
-    def headers_for_direct_upload(key, checksum:, **)
-      { "Content-MD5" => checksum }
+    def headers_for_direct_upload(key, checksum:, filename: nil, disposition: nil, **)
+      content_disposition = content_disposition_with(type: disposition, filename: filename) if filename
+
+      { "Content-MD5" => checksum, "Content-Disposition" => content_disposition }
     end
 
     private
+      def private_url(key, expires_in:, filename:, content_type:, disposition:, **)
+        file_for(key).signed_url expires: expires_in, query: {
+          "response-content-disposition" => content_disposition_with(type: disposition, filename: filename),
+          "response-content-type" => content_type
+        }
+      end
+
+      def public_url(key, **)
+        file_for(key).public_url
+      end
+
+
       attr_reader :config
 
-      def file_for(key)
-        bucket.file(key, skip_lookup: true)
+      def file_for(key, skip_lookup: true)
+        bucket.file(key, skip_lookup: skip_lookup)
+      end
+
+      # Reads the file for the given key in chunks, yielding each to the block.
+      def stream(key)
+        file = file_for(key, skip_lookup: false)
+
+        chunk_size = 5.megabytes
+        offset = 0
+
+        raise ActiveStorage::FileNotFoundError unless file.present?
+
+        while offset < file.size
+          yield file.download(range: offset..(offset + chunk_size - 1)).string
+          offset += chunk_size
+        end
       end
 
       def bucket
-        @bucket ||= client.bucket(config.fetch(:bucket))
+        @bucket ||= client.bucket(config.fetch(:bucket), skip_lookup: true)
       end
 
       def client
-        @client ||= Google::Cloud::Storage.new(config.except(:bucket))
+        @client ||= Google::Cloud::Storage.new(**config.except(:bucket))
       end
   end
 end

data/lib/active_storage/service/mirror_service.rb

@@ -4,18 +4,26 @@ require "active_support/core_ext/module/delegation"
 
 module ActiveStorage
   # Wraps a set of mirror services and provides a single ActiveStorage::Service object that will all
-  # have the files uploaded to them. A +primary+ service is designated to answer calls to +download+, +exists?+,
-  # and +url+.
+  # have the files uploaded to them. A +primary+ service is designated to answer calls to:
+  # * +download+
+  # * +exists?+
+  # * +url+
+  # * +url_for_direct_upload+
+  # * +headers_for_direct_upload+
   class Service::MirrorService < Service
     attr_reader :primary, :mirrors
 
-    delegate :download, :download_chunk, :exist?, :url, :path_for, to: :primary
+    delegate :download, :download_chunk, :exist?, :url,
+      :url_for_direct_upload, :headers_for_direct_upload, :path_for, to: :primary
 
     # Stitch together from named services.
-    def self.build(primary:, mirrors:, configurator:, **options) #:nodoc:
-      new \
+    def self.build(primary:, mirrors:, name:, configurator:, **options) #:nodoc:
+      new(
         primary: configurator.build(primary),
-        mirrors: mirrors.collect { |name| configurator.build name }
+        mirrors: mirrors.collect { |mirror_name| configurator.build mirror_name }
+      ).tap do |service_instance|
+        service_instance.name = name
+      end
     end
 
     def initialize(primary:, mirrors:)
@@ -26,7 +34,8 @@ module ActiveStorage
     # ensure a match when the upload has completed or raise an ActiveStorage::IntegrityError.
     def upload(key, io, checksum: nil, **options)
       each_service.collect do |service|
-        service.upload key, io.tap(&:rewind), checksum: checksum, **options
+        io.rewind
+        service.upload key, io, checksum: checksum, **options
       end
     end
 
@@ -40,6 +49,21 @@ module ActiveStorage
       perform_across_services :delete_prefixed, prefix
     end
 
+
+    # Copy the file at the +key+ from the primary service to each of the mirrors where it doesn't already exist.
+    def mirror(key, checksum:)
+      instrument :mirror, key: key, checksum: checksum do
+        if (mirrors_in_need_of_mirroring = mirrors.select { |service| !service.exist?(key) }).any?
+          primary.open(key, checksum: checksum) do |io|
+            mirrors_in_need_of_mirroring.each do |service|
+              io.rewind
+              service.upload key, io, checksum: checksum
+            end
+          end
+        end
+      end
+    end
+
     private
       def each_service(&block)
         [ primary, *mirrors ].each(&block)

data/lib/active_storage/service/registry.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Service::Registry #:nodoc:
+    def initialize(configurations)
+      @configurations = configurations.deep_symbolize_keys
+      @services = {}
+    end
+
+    def fetch(name)
+      services.fetch(name.to_sym) do |key|
+        if configurations.include?(key)
+          services[key] = configurator.build(key)
+        else
+          if block_given?
+            yield key
+          else
+            raise KeyError, "Missing configuration for the #{key} Active Storage service. " \
+              "Configurations available for the #{configurations.keys.to_sentence} services."
+          end
+        end
+      end
+    end
+
+    private
+      attr_reader :configurations, :services
+
+      def configurator
+        @configurator ||= ActiveStorage::Service::Configurator.new(configurations)
+      end
+  end
+end