activestorage_database 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f213a1d92a9dc03906153e31d90168d00182923bc09656def364ed09b9458af5
+  data.tar.gz: 2eea5d3eac778060def89c0f4ddac88317a617027f430db6e78186dcc8fd9589
+SHA512:
+  metadata.gz: aa951a310ce883147b9c2ff7e237b8d04d9208034d9e44917e19a38e9d3b4a8d07ad9cf03a42a99b0ce8ec46f5fde18cf532b44c13ca1b702f9ccec050038730
+  data.tar.gz: b072946792d6e3860524714dd73e6d3e3784fbee0d46e7247785d88bf5a7eb7d1480ddaec6c49e55e88fe7c2a65b9556df2339aeb7ef7136763e277ba8b8dbf9

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Dino Maric
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# Active Storage Database
+
+This is `ActiveStorage` engine that allows storing files inside the database.
+
+While storing files on the external services such as `S3, GCS, Azure` is usually better approach, but better approach also
+depends on the context.
+
+There is a group of applications that do store the files, but not a lot of files or they are installed on-premises without
+access to these public services.
+
+This project is aimed more for those type of apps, if you store TBs of files then you should probabbly look into other solutions.
+
+
+# How it works
+
+Every file is stored inside the `activestorage_database_files` table as a `binary/bytea`.
+Since PostgreSQL can't store values that span multiple pages(8kb), binaries will probabbly be stored inside the TOAST table,
+which allows for quick table scan and leaves the main table(`activestorage_database_files`) slim.
+
+**NOTE**: Max size of TOST tuple in PG is 1GB
+
+
+Engine will use your `ActiveRecord` database connection.
+
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activestorage_database'
+```
+
+Install and run the migrations:
+```
+bin/rails activestorage_database:install:migrations
+bin/rails db:migrate
+```
+
+Configure database service:
+```yml
+# config/storage.yml
+
+database:
+  service: Database
+```
+
+```ruby
+config.active_storage.service = :database
+```
+
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  mount ActivestorageDB::Engine => '/activestorage_database'
+  ...
+end
+```
+
+
+After the setup you can work with ActiveStorge API as if it was any other `ActiveStorage` service.
+
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/controllers/activestorage_database/files_controller.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class ActivestorageDatabase::FilesController < ActiveStorage::BaseController
+  skip_forgery_protection
+
+  def show
+    if key = decode_verified_key
+      serve_file(key[:key], content_type: key[:content_type], disposition: key[:disposition])
+    else
+      head :not_found
+    end
+  rescue ActiveStorage::FileNotFoundError
+    head :not_found
+  end
+
+  def update
+    if (token = decode_verified_token)
+      if acceptable_content?(token)
+        database_service.upload(token[:key], request.body, checksum: token[:checksum])
+      else
+        head :unprocessable_entity
+      end
+    else
+      head :not_found
+    end
+  rescue ActiveStorage::IntegrityError
+    head :unprocessable_entity
+  end
+
+  private
+    def database_service
+      ActiveStorage::Blob.service
+    end
+
+    def decode_verified_key
+      ActiveStorage.verifier.verified(params[:encoded_key], purpose: :blob_key)
+    end
+
+    def decode_verified_token
+      ActiveStorage.verifier.verified(params[:encoded_token], purpose: :blob_token)
+    end
+
+    def serve_file(key, content_type:, disposition:)
+      options = {
+          type: content_type || DEFAULT_SEND_FILE_TYPE,
+          disposition: disposition || DEFAULT_SEND_FILE_DISPOSITION
+      }
+
+      send_data database_service.download(key), options
+    end
+
+    def acceptable_content?(token)
+      token[:content_type] == request.content_mime_type && token[:content_length] == request.content_length
+    end
+end

data/app/models/activestorage_database/file.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ActivestorageDatabase::File < ActiveRecord::Base
+  validates :key, presence: true, allow_blank: false, uniqueness: { case_sensitive: false }
+end

data/config/routes.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+ActivestorageDatabase::Engine.routes.draw do
+  get '/files/:encoded_key/*filename', to: 'files#show',   as: :service
+  put '/files/:encoded_token',         to: 'files#update', as: :update_service
+end

data/db/migrate/20210815130342_create_activestorage_database_files.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class CreateActivestorageDatabaseFiles < ActiveRecord::Migration[6.1]
+  def change
+    create_table :activestorage_database_files do |t|
+      t.string :key, null: false, index: { unique: true }
+      t.binary :data, null: false
+      t.datetime :created_at, null: false
+    end
+  end
+end

data/lib/active_storage/service/database_service.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Service::DatabaseService < Service
+    CHUNK_SIZE = 1.megabytes.freeze
+
+    def upload(key, io, checksum: nil, **options)
+      instrument :upload, key: key, checksum: checksum do
+        file = ActivestorageDatabase::File.create!(key: key, data: io.read)
+        ensure_integrity_of(key, checksum) if checksum
+
+        file
+      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
+          record = ActivestorageDatabase::File.find_by(key: key)
+          record&.data || raise(ActiveStorage::FileNotFoundError)
+        end
+      end
+    end
+
+    def download_chunk(key, range)
+      instrument :download_chunk, key: key, range: range do
+        chunk_select = "SUBSTRING(data FROM #{range.begin + 1} FOR #{range.size}) AS chunk"
+        ActivestorageDatabase::File.select(chunk_select).find_by(key: key)&.chunk || raise(ActiveStorage::FileNotFoundError)
+      end
+    end
+
+    def delete(key)
+      instrument :delete, key: key do
+        ActivestorageDatabase::File.find_by(key: key)&.destroy
+      end
+    end
+
+    def delete_prefixed(prefix)
+      instrument :delete_prefixed, prefix: prefix do
+        ActivestorageDatabase::File.where("key LIKE ?", "#{prefix}%").destroy_all
+      end
+    end
+
+    def exist?(key)
+      instrument :exist, key: key do |payload|
+        answer = ActivestorageDatabase::File.where(key: key).exists?
+        payload[:exist] = answer
+        answer
+      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.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(
+            {
+                key: key,
+                content_type: content_type,
+                content_length: content_length,
+                checksum: checksum
+            },
+            expires_in: expires_in,
+            purpose: :blob_token
+        )
+        generated_url = url_helpers.update_service_url(
+            verified_token_with_expiration,
+            host: current_host
+        )
+        payload[:url] = generated_url
+
+        generated_url
+      end
+    end
+
+    def headers_for_direct_upload(_key, content_type:, **)
+      { 'Content-Type' => content_type }
+    end
+
+    private
+      def current_host
+        ActiveStorage::Current.host
+      end
+
+
+      def ensure_integrity_of(key, checksum)
+        file = ::ActivestorageDatabase::File.find_by(key: key)
+        return if Digest::MD5.base64digest(file.data) == checksum
+
+        delete(key)
+        raise ActiveStorage::IntegrityError
+      end
+
+      def stream(key)
+        size = ActivestorageDatabase::File.select('OCTET_LENGTH(data) AS size').find_by(key: key)&.size || raise(ActiveStorage::FileNotFoundError)
+
+        (size / CHUNK_SIZE.to_f).ceil.times.each do |i|
+          range = (i * CHUNK_SIZE..(i + 1) * CHUNK_SIZE - 1)
+          yield download_chunk(key, range)
+        end
+      end
+
+      def url_helpers
+        @url_helpers ||= ActivestorageDatabase::Engine.routes.url_helpers
+      end
+  end
+end

data/lib/activestorage_database/engine.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActivestorageDatabase
+  class Engine < ::Rails::Engine
+    isolate_namespace ActivestorageDatabase
+  end
+end

data/lib/activestorage_database/version.rb

@@ -0,0 +1,3 @@
+module ActivestorageDatabase
+  VERSION = "0.1.0"
+end

data/lib/activestorage_database.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "activestorage_database/version"
+require "activestorage_database/engine"
+
+module ActivestorageDatabase
+  # Your code goes here...
+end

data/lib/tasks/activestorage_database_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :activestorage_database do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: activestorage_database
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dino Maric
+- Sinan Mujan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+description: Store ActiveStorage attachments inside the database.
+email:
+- dinom@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/controllers/activestorage_database/files_controller.rb
+- app/models/activestorage_database/file.rb
+- config/routes.rb
+- db/migrate/20210815130342_create_activestorage_database_files.rb
+- lib/active_storage/service/database_service.rb
+- lib/activestorage_database.rb
+- lib/activestorage_database/engine.rb
+- lib/activestorage_database/version.rb
+- lib/tasks/activestorage_database_tasks.rake
+homepage: https://github.com/WizardComputer/activestorage_database
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/WizardComputer/activestorage_database
+  source_code_uri: https://github.com/WizardComputer/activestorage_database
+  changelog_uri: https://github.com/WizardComputer/activestorage_database
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Store ActiveStorage attachments inside the database.
+test_files: []