activestorage 6.0.0

data/lib/active_storage/previewer/poppler_pdf_previewer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Previewer::PopplerPDFPreviewer < Previewer
+    class << self
+      def accept?(blob)
+        blob.content_type == "application/pdf" && pdftoppm_exists?
+      end
+
+      def pdftoppm_path
+        ActiveStorage.paths[:pdftoppm] || "pdftoppm"
+      end
+
+      def pdftoppm_exists?
+        return @pdftoppm_exists if defined?(@pdftoppm_exists)
+
+        @pdftoppm_exists = system(pdftoppm_path, "-v", out: File::NULL, err: File::NULL)
+      end
+    end
+
+    def preview
+      download_blob_to_tempfile do |input|
+        draw_first_page_from input do |output|
+          yield io: output, filename: "#{blob.filename.base}.png", content_type: "image/png"
+        end
+      end
+    end
+
+    private
+      def draw_first_page_from(file, &block)
+        # use 72 dpi to match thumbnail dimensions of the PDF
+        draw self.class.pdftoppm_path, "-singlefile", "-r", "72", "-png", file.path, &block
+      end
+  end
+end

data/lib/active_storage/previewer/video_previewer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Previewer::VideoPreviewer < Previewer
+    def self.accept?(blob)
+      blob.video?
+    end
+
+    def preview
+      download_blob_to_tempfile do |input|
+        draw_relevant_frame_from input do |output|
+          yield io: output, filename: "#{blob.filename.base}.jpg", content_type: "image/jpeg"
+        end
+      end
+    end
+
+    private
+      def draw_relevant_frame_from(file, &block)
+        draw ffmpeg_path, "-i", file.path, "-y", "-vframes", "1", "-f", "image2", "-", &block
+      end
+
+      def ffmpeg_path
+        ActiveStorage.paths[:ffmpeg] || "ffmpeg"
+      end
+  end
+end

data/lib/active_storage/reflection.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module Reflection
+    # Holds all the metadata about a has_one_attached attachment as it was
+    # specified in the Active Record class.
+    class HasOneAttachedReflection < ActiveRecord::Reflection::MacroReflection #:nodoc:
+      def macro
+        :has_one_attached
+      end
+    end
+
+    # Holds all the metadata about a has_many_attached attachment as it was
+    # specified in the Active Record class.
+    class HasManyAttachedReflection < ActiveRecord::Reflection::MacroReflection #:nodoc:
+      def macro
+        :has_many_attached
+      end
+    end
+
+    module ReflectionExtension # :nodoc:
+      def add_attachment_reflection(model, name, reflection)
+        model.attachment_reflections = model.attachment_reflections.merge(name.to_s => reflection)
+      end
+
+      private
+        def reflection_class_for(macro)
+          case macro
+          when :has_one_attached
+            HasOneAttachedReflection
+          when :has_many_attached
+            HasManyAttachedReflection
+          else
+            super
+          end
+        end
+    end
+
+    module ActiveRecordExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :attachment_reflections, instance_writer: false, default: {}
+      end
+
+      module ClassMethods
+        # Returns an array of reflection objects for all the attachments in the
+        # class.
+        def reflect_on_all_attachments
+          attachment_reflections.values
+        end
+
+        # Returns the reflection object for the named +attachment+.
+        #
+        #    User.reflect_on_attachment(:avatar)
+        #    # => the avatar reflection
+        #
+        def reflect_on_attachment(attachment)
+          attachment_reflections[attachment.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/active_storage/service.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "active_storage/log_subscriber"
+require "action_dispatch"
+require "action_dispatch/http/content_disposition"
+
+module ActiveStorage
+  # Abstract class serving as an interface for concrete services.
+  #
+  # The available services are:
+  #
+  # * +Disk+, to manage attachments saved directly on the hard drive.
+  # * +GCS+, to manage attachments through Google Cloud Storage.
+  # * +S3+, to manage attachments through Amazon S3.
+  # * +AzureStorage+, to manage attachments through Microsoft Azure Storage.
+  # * +Mirror+, to be able to use several services to manage attachments.
+  #
+  # Inside a Rails application, you can set-up your services through the
+  # generated <tt>config/storage.yml</tt> file and reference one
+  # of the aforementioned constant under the +service+ key. For example:
+  #
+  #   local:
+  #     service: Disk
+  #     root: <%= Rails.root.join("storage") %>
+  #
+  # You can checkout the service's constructor to know which keys are required.
+  #
+  # Then, in your application's configuration, you can specify the service to
+  # use like this:
+  #
+  #   config.active_storage.service = :local
+  #
+  # If you are using Active Storage outside of a Ruby on Rails application, you
+  # can configure the service to use like this:
+  #
+  #   ActiveStorage::Blob.service = ActiveStorage::Service.configure(
+  #     :Disk,
+  #     root: Pathname("/foo/bar/storage")
+  #   )
+  class Service
+    extend ActiveSupport::Autoload
+    autoload :Configurator
+
+    class << self
+      # Configure an Active Storage service by name from a set of configurations,
+      # typically loaded from a YAML file. The Active Storage engine uses this
+      # to set the global Active Storage service when the app boots.
+      def configure(service_name, configurations)
+        Configurator.build(service_name, configurations)
+      end
+
+      # Override in subclasses that stitch together multiple services and hence
+      # need to build additional services using the configurator.
+      #
+      # Passes the configurator and all of the service's config as keyword args.
+      #
+      # See MirrorService for an example.
+      def build(configurator:, service: nil, **service_config) #:nodoc:
+        new(**service_config)
+      end
+    end
+
+    # Upload the +io+ to the +key+ specified. If a +checksum+ is provided, the service will
+    # ensure a match when the upload has completed or raise an ActiveStorage::IntegrityError.
+    def upload(key, io, checksum: nil, **options)
+      raise NotImplementedError
+    end
+
+    # Update metadata for the file identified by +key+ in the service.
+    # Override in subclasses only if the service needs to store specific
+    # metadata that has to be updated upon identification.
+    def update_metadata(key, **metadata)
+    end
+
+    # Return the content of the file at the +key+.
+    def download(key)
+      raise NotImplementedError
+    end
+
+    # Return the partial content in the byte +range+ of the file at the +key+.
+    def download_chunk(key, range)
+      raise NotImplementedError
+    end
+
+    def open(*args, &block)
+      ActiveStorage::Downloader.new(self).open(*args, &block)
+    end
+
+    # Delete the file at the +key+.
+    def delete(key)
+      raise NotImplementedError
+    end
+
+    # Delete files at keys starting with the +prefix+.
+    def delete_prefixed(prefix)
+      raise NotImplementedError
+    end
+
+    # Return +true+ if a file exists at the +key+.
+    def exist?(key)
+      raise NotImplementedError
+    end
+
+    # Returns a signed, temporary URL for the file at the +key+. The URL will be valid for the amount
+    # of seconds specified in +expires_in+. You must also provide the +disposition+ (+:inline+ or +:attachment+),
+    # +filename+, and +content_type+ that you wish the file to be served with on request.
+    def url(key, expires_in:, disposition:, filename:, content_type:)
+      raise NotImplementedError
+    end
+
+    # Returns a signed, temporary URL that a direct upload file can be PUT to on the +key+.
+    # The URL will be valid for the amount of seconds specified in +expires_in+.
+    # You must also provide the +content_type+, +content_length+, and +checksum+ of the file
+    # that will be uploaded. All these attributes will be validated by the service upon upload.
+    def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:)
+      raise NotImplementedError
+    end
+
+    # Returns a Hash of headers for +url_for_direct_upload+ requests.
+    def headers_for_direct_upload(key, filename:, content_type:, content_length:, checksum:)
+      {}
+    end
+
+    private
+      def instrument(operation, payload = {}, &block)
+        ActiveSupport::Notifications.instrument(
+          "service_#{operation}.active_storage",
+          payload.merge(service: service_name), &block)
+      end
+
+      def service_name
+        # ActiveStorage::Service::DiskService => Disk
+        self.class.name.split("::").third.remove("Service")
+      end
+
+      def content_disposition_with(type: "inline", filename:)
+        disposition = (type.to_s.presence_in(%w( attachment inline )) || "inline")
+        ActionDispatch::Http::ContentDisposition.format(disposition: disposition, filename: filename.sanitized)
+      end
+  end
+end

data/lib/active_storage/service/azure_storage_service.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/numeric/bytes"
+require "azure/storage"
+require "azure/storage/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
+
+    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
+      @container = container
+    end
+
+    def upload(key, io, checksum: nil, **)
+      instrument :upload, key: key, checksum: checksum do
+        handle_errors do
+          blobs.create_block_blob(container, key, IO.try_convert(io) || io, content_md5: checksum)
+        end
+      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
+          handle_errors do
+            _, io = blobs.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
+        handle_errors 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)
+        end
+      end
+    end
+
+    def delete(key)
+      instrument :delete, key: key do
+        blobs.delete_blob(container, key)
+      rescue Azure::Core::Http::HTTPError => e
+        raise unless e.type == "BlobNotFound"
+        # Ignore files already deleted
+      end
+    end
+
+    def delete_prefixed(prefix)
+      instrument :delete_prefixed, prefix: prefix do
+        marker = nil
+
+        loop do
+          results = blobs.list_blobs(container, prefix: prefix, marker: marker)
+
+          results.each do |blob|
+            blobs.delete_blob(container, blob.name)
+          end
+
+          break unless marker = results.continuation_token.presence
+        end
+      end
+    end
+
+    def exist?(key)
+      instrument :exist, key: key do |payload|
+        answer = blob_for(key).present?
+        payload[:exist] = answer
+        answer
+      end
+    end
+
+    def url(key, expires_in:, filename:, disposition:, content_type:)
+      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
+        ).to_s
+
+        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|
+        generated_url = signer.signed_uri(
+          uri_for(key), false,
+          service: "b",
+          permissions: "rw",
+          expiry: format_expiry(expires_in)
+        ).to_s
+
+        payload[:url] = generated_url
+
+        generated_url
+      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}")
+      end
+
+      def blob_for(key)
+        blobs.get_blob_properties(container, key)
+      rescue Azure::Core::Http::HTTPError
+        false
+      end
+
+      def format_expiry(expires_in)
+        expires_in ? Time.now.utc.advance(seconds: expires_in).iso8601 : nil
+      end
+
+      # Reads the object for the given key in chunks, yielding each to the block.
+      def stream(key)
+        blob = blob_for(key)
+
+        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)
+          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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Service::Configurator #:nodoc:
+    attr_reader :configurations
+
+    def self.build(service_name, configurations)
+      new(configurations).build(service_name)
+    end
+
+    def initialize(configurations)
+      @configurations = configurations.deep_symbolize_keys
+    end
+
+    def build(service_name)
+      config = config_for(service_name.to_sym)
+      resolve(config.fetch(:service)).build(**config, configurator: self)
+    end
+
+    private
+      def config_for(name)
+        configurations.fetch name do
+          raise "Missing configuration for the #{name.inspect} Active Storage service. Configurations available for #{configurations.keys.inspect}"
+        end
+      end
+
+      def resolve(class_name)
+        require "active_storage/service/#{class_name.to_s.underscore}_service"
+        ActiveStorage::Service.const_get(:"#{class_name.camelize}Service")
+      rescue LoadError
+        raise "Missing service adapter for #{class_name.inspect}"
+      end
+  end
+end