paperclip-backblaze 0.2.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 803ce541431482e546f6cf3b99c587444c5c423aa40314b0e97352e42959614f
+  data.tar.gz: dace72d3fe899c3407ac1b2ba1177b551fb43ea1ecded748810d7c3cd6ab2f99
+SHA512:
+  metadata.gz: bb26137d390ba6c217fa389c71fc0ccf792fbebec22953fd1831e461cc4b9f9d80053e7f62f319647c19c19aea350c7ab3f5519b0cfd6e43a7533d778089e769
+  data.tar.gz: e966239867599f732adea915afb5df5f3183211dc3823b55905d56be50099ff11f62cbe9f3ad8d23510948ea1a9076d0485713f4c1ab6c2d9b4c1deb1f930635

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+.b2_login*

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+sudo: false
+rvm:
+  - 2.2.2
+  - 2.4.2
+before_install:
+  - rvm @global do gem install bundler -v 1.12.5
+
+gemfile:
+  - Gemfile
+
+script:
+  bundle exec rake

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Dockerfile

@@ -0,0 +1,9 @@
+FROM ruby:2.4.2
+
+ADD Gemfile* /srv/
+ADD *.gemspec /srv/
+WORKDIR /srv
+
+RUN bundle install
+
+ADD . /srv

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in backblaze.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Alex Tsui
+
+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,105 @@
+# paperclip-backblaze
+
+[![Build Status](https://travis-ci.org/alextsui05/paperclip-backblaze.svg?branch=master)](https://travis-ci.org/alextsui05/paperclip-backblaze)
+
+The `paperclip-backblaze` provides a [Paperclip](https://github.com/thoughtbot/paperclip) storage adapter so that
+attachments can be saved to [Backblaze B2 Cloud Storage API](https://www.backblaze.com/b2/docs/).
+It makes use of Winston Durand's [backblaze](https://github.com/R167/backblaze) gem
+to access the B2 API behind the scenes.
+
+Backblaze B2 Cloud Storage is similar to Amazon's AWS S3 Storage, but it has a few selling points:
+
+1. They run their own hardware (that's open-sourced, including the schematics, and drive reports)
+2. It's $0.005/GB/month vs S3's $0.030/GB/month
+3. You actually get a free GB of bandwidth a day, so it might be nice for personal projects.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'paperclip-backblaze', github: 'alextsui05/paperclip-backblaze'
+```
+And then execute:
+
+    $ bundle
+
+## Usage
+
+You should be familiar with configuring Paperclip attachments for your model.
+If not, please start with the Paperclip documentation
+[here](https://github.com/thoughtbot/paperclip#usage).
+
+Configuring Backblaze storage is very similar to [configuring S3 storage](http://www.rubydoc.info/gems/paperclip/Paperclip/Storage/S3).
+Let's suppose we have a `Note` model with an `image` attachment that we would
+like to be backed by Backblaze storage.
+
+
+
+First, put your credentials and bucket name in a YML file.
+
+```.yml
+# config/b2.yml
+account_id: 123456789abc
+application_key: 0123456789abcdef0123456789abcdef0123456789
+bucket: my_b2_bucket_name
+```
+
+Then let Paperclip know about it. You can put it in your environment config:
+
+```.rb
+# config/environments/production.rb
+
+...
+config.paperclip_defaults = {
+  storage: :backblaze,
+  b2_credentials: YAML.load(ERB.new(File.read("#{Rails.root}/config/b2.yml")).result).with_indifferent_access
+}
+```
+
+Now just specify the attachment in the model, and it will use your backblaze configuration:
+
+```.rb
+# app/models/note.rb
+class Note < ApplicationRecord
+  has_attached_file :image
+  ...
+```
+
+Currently, these are required options:
+
+- `:storage` - This should be set to :backblaze in order to use this
+   storage adapter.
+
+- `:b2_credentials` - Should be a Hash containing required fields listend in config/b2.yml.
+
+## Contributing
+
+This started as a proof of concept for a hobby project, so there's lots of room
+for improvement, and it would be great to have your help.
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/alextsui05/paperclip-backblaze. This project is intended to be a safe,
+welcoming space for collaboration, and contributors are expected to adhere to
+the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Version Log
+
+### 0.2.1
+
+- CI setup and code style improvements
+
+### 0.2.0
+
+- Remove `:b2_bucket` option. It should now be specified in the credentials file with a `bucket` key.
+- Update example that doesn't pollute model with paperclip configuration
+
+### 0.1.0
+
+First release
+
+

data/Rakefile

@@ -0,0 +1,28 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+task :console do
+  require 'pry'
+  require 'backblaze'
+
+  def reload!
+    headers = Backblaze::B2::Base.headers
+    vars = Backblaze::B2.instance_variables.map { |k| [k, Backblaze::B2.instance_variable_get(k)] }.to_h
+    base_uri = Backblaze::B2::Base.base_uri
+    files = $LOADED_FEATURES.select { |feat| feat =~ /\/backblaze\// }
+    files.each { |file| load file }
+    vars.each do |key, value|
+      Backblaze::B2.instance_variable_set(key, value)
+    end
+    Backblaze::B2::Base.base_uri(base_uri)
+    Backblaze::B2::Base.headers(headers)
+    true
+  end
+
+  ARGV.clear
+  Pry.start
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'backblaze'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require 'pry'
+Pry.start
+
+# require "irb"
+# IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/backblaze/b2/base.rb

@@ -0,0 +1,102 @@
+module Backblaze::B2
+  class Base
+    include HTTParty
+    include Backblaze::Utils
+
+    format :json
+
+    # @!method get(path, options={}, &block)
+    # Calls the class level equivalent from HTTParty
+    # @see http://www.rubydoc.info/github/jnunemaker/httparty/HTTParty/ClassMethods HTTParty::ClassMethods
+
+    # @!method head(path, options={}, &block)
+    # (see #get)
+
+    # @!method post(path, options={}, &block)
+    # (see #get)
+
+    # @!method put(path, options={}, &block)
+    # (see #get)
+
+    %i[get head post put].each do |req|
+      define_method(req) do |path, options = {}, &block|
+        self.class.send(req, path, options, &block)
+      end
+    end
+
+    protected
+
+    def file_versions(bucket_id:, convert:, limit:, double_check_server:, file_name: nil, &block)
+      retreive_count = (double_check_server ? 0 : -1)
+      files = file_list(bucket_id: bucket_id, limit: limit, retreived: retreive_count, file_name: file_name, first_file: nil, start_field: 'startFileId'.freeze)
+
+      if convert
+        files.map! do |f|
+          if block.nil?
+            Backblaze::B2::FileVersion.new(f)
+          else
+            yield(f)
+          end
+        end
+      end
+      files.compact
+    end
+
+    def file_list(limit:, retreived:, first_file:, start_field:, bucket_id:, file_name: nil, first: true)
+      params = { 'bucketId'.freeze => bucket_id }
+      if limit == -1
+        params['maxFileCount'.freeze] = 1000
+      elsif limit > 1000
+        params['maxFileCount'.freeze] = 1000
+      elsif limit > 0
+        params['maxFileCount'.freeze] = limit
+      else
+        return []
+      end
+      if first_file.nil?
+        if file_name && start_field == 'startFileId' && first
+          params['startFileName'] = file_name
+        end
+      else
+        params[start_field] = first_file
+      end
+
+      response = post("/b2_list_file_#{start_field == 'startFileName' ? 'names' : 'versions'}", body: params.to_json)
+
+      raise Backblaze::FileError, response unless response.code == 200
+
+      files = response['files'.freeze]
+      halt = false
+      files.map! do |f|
+        if halt
+          nil
+        else
+          ret = Hash[f.map { |k, v| [Backblaze::Utils.underscore(k).to_sym, v] }]
+          halt = true if file_name && file_name != ret[:file_name]
+          halt ? nil : ret
+        end
+      end.compact!
+
+      retreived += files.size if retreived >= 0
+      if limit > 0
+        limit -= (retreived >= 0 ? files.size : 1000)
+        limit = 0 if limit < 0
+      end
+
+      next_item = response[start_field.sub('start'.freeze, 'next'.freeze)]
+
+      if (limit > 0 || limit == -1) && !!next_item && !halt
+        files.concat file_list(
+          first_file: next_item,
+          limit: limit,
+          retreived: retreived,
+          start_field: start_field,
+          bucket_id: bucket_id,
+          first: false
+        )
+      else
+        files
+      end
+    end
+  end
+end

data/lib/backblaze/b2/bucket.rb

@@ -0,0 +1,156 @@
+module Backblaze::B2
+  ##
+  # A class to represent the online buckets. Mostly used for file access
+  class Bucket < Base
+    ##
+    # Creates a bucket from all of the possible parameters. This sould be rarely used and instead use a finder or creator
+    # @param [#to_s] bucket_name the bucket name
+    # @param [#to_s] bucket_id the bucket id
+    # @param [#to_s] bucket_type the bucket publicity type
+    # @param [#to_s] account_id the account to which this bucket belongs
+    def initialize(options)
+      @bucket_name = options.fetch(:bucket_name)
+      @bucket_id = options.fetch(:bucket_id)
+      @bucket_type = options.fetch(:bucket_type)
+      @account_id = options.fetch(:account_id)
+    end
+
+    # @return [String] bucket name
+    attr_reader :bucket_name
+
+    alias name bucket_name
+
+    # @return [String] bucket id
+    attr_reader :bucket_id
+
+    # @return [Boolean] is the bucket public
+    def public?
+      @bucket_type == 'allPublic'
+    end
+
+    # @return [Boolean] is the bucket private
+    def private?
+      !public?
+    end
+
+    # @return [String] account id
+    attr_reader :account_id
+
+    # @return [String] bucket type
+    attr_reader :bucket_type
+
+    # Check if eqivalent. Takes advantage of globally unique names
+    # @return [Boolean] equality
+    def ==(other)
+      bucket_name == other.bucket_name
+    end
+
+    ##
+    # Lists all files that are in the bucket. This is the basic building block for the search.
+    # @param [String] first_file first file in the bucket to start listing from
+    # @param [Integer] limit max number of files to retreive. Set to `-1` to get all files.
+    #   This is not exact as it mainly just throws the limit into max param on the request
+    #   so it will try to grab at least `limit` files, unless there aren't enoungh in the bucket
+    # @param [Boolean] cache if there is no cache, create one. If there is a cache, use it.
+    #   Will check if the previous cache had the same size limit and convert options
+    # @param [Boolean] convert convert the files to Backblaze::B2::File objects
+    # @param [Integer] double_check_server whether or not to assume the server returns the most files possible
+    # @return [Array<Backblaze::B2::File>] when convert is true
+    # @return [Array<Hash>] when convert is false
+    # @note many of these methods are for the recusion
+    def file_names(first_file: nil, limit: 100, cache: false, convert: true, double_check_server: false)
+      if cache && !@file_name_cache.nil?
+        if limit <= @file_name_cache[:limit] && convert == @file_name_cache[:convert]
+          return @file_name_cache[:files]
+        end
+      end
+
+      retreive_count = (double_check_server ? 0 : -1)
+      files = file_list(bucket_id: bucket_id, limit: limit, retreived: retreive_count, first_file: first_file, start_field: 'startFileName'.freeze)
+
+      merge_params = { bucket_id: bucket_id }
+      if convert
+        files.map! do |f|
+          Backblaze::B2::File.new(f.merge(merge_params))
+        end
+      end
+      if cache
+        @file_name_cache = { limit: limit, convert: convert, files: files }
+      end
+      files
+    end
+
+    def file_versions(limit: 100, cache: false, convert: true, double_check_server: false)
+      if cache && !@file_versions_cache.nil?
+        if limit <= @file_versions_cache[:limit] && convert == @file_versions_cache[:convert]
+          return @file_versions_cache[:files]
+        end
+      end
+      file_versions = super(limit: 100, convert: convert, double_check_server: double_check_server, bucket_id: bucket_id)
+      files = file_versions.group_by { |version| convert ? version.file_name : version[:file_name] }
+      if convert
+        files = files.map do |name, versions|
+          File.new(file_name: name, bucket_id: bucket_id, versions: versions)
+        end
+      end
+      @file_versions_cache = if cache
+                               { limit: limit, convert: convert, files: files }
+                             else
+                               {}
+                             end
+      files
+    end
+
+    def upload_url
+      self.class.upload_url(bucket_id: bucket_id)
+    end
+
+    class << self
+      ##
+      # Create a bucket
+      # @param [String] name name of the new bucket
+      #   must be no more than 50 character and only contain letters, digits, "-", and "_".
+      #   must be globally unique
+      # @param [:public, :private] type determines the type of bucket
+      # @raise [Backblaze::BucketError] unable to create the specified bucket
+      def create(name:, type:)
+        body = {
+          accountId: Backblaze::B2.account_id,
+          bucketName: name,
+          bucketType: (type == :public ? 'allPublic' : 'allPrivate')
+        }
+        response = post('/b2_create_bucket', body: body.to_json)
+
+        raise Backblaze::BucketError, response unless response.code / 100 == 2
+
+        params = Hash[response.map { |k, v| [Backblaze::Utils.underscore(k).to_sym, v] }]
+
+        new(params)
+      end
+
+      def upload_url(bucket_id:)
+        response = post('/b2_get_upload_url', body: { bucketId: bucket_id }.to_json)
+        raise Backblaze::BucketError, response unless response.code / 100 == 2
+        { url: response['uploadUrl'], token: response['authorizationToken'] }
+      end
+
+      ##
+      # List buckets for account
+      # @return [Array<Backblaze::Bucket>] buckets for this account
+      def buckets
+        body = {
+          accountId: Backblaze::B2.account_id
+        }
+        response = post('/b2_list_buckets', body: body.to_json)
+        response['buckets'].map do |bucket|
+          params = Hash[bucket.map { |k, v| [Backblaze::Utils.underscore(k).to_sym, v] }]
+          new(params)
+        end
+      end
+
+      def get_bucket(name:)
+        buckets.find { |b| b.bucket_name == name }
+      end
+    end
+  end
+end

data/lib/backblaze/b2/file.rb

@@ -0,0 +1,173 @@
+module Backblaze::B2
+  class File < Base
+    def initialize(file_name:, bucket_id:, versions: nil, **file_version_args)
+      @file_name = file_name
+      @bucket_id = bucket_id
+      if versions
+        @fetched_all = true
+        @versions = versions
+      else
+        @fetched_all = false
+        @versions = [FileVersion.new(file_version_args.merge(file_name: file_name))]
+      end
+    end
+
+    class << self
+      def create(data:, bucket:, name: nil, base_name: '', content_type: 'b2/x-auto', info: {})
+        raise ArgumentError, 'data must not be nil' if data.nil?
+
+        case bucket
+        when String
+          upload_url = Bucket.upload_url(bucket_id: bucket)
+        when Bucket
+          upload_url = bucket.upload_url
+        else
+          raise ArgumentError, 'You must pass a bucket'
+        end
+
+        case data
+        when String
+          data.force_encoding('ASCII-8BIT')
+          raise ArgumentError, 'Must provide a file name for data' if name.nil?
+        when ::File, Tempfile, ::Paperclip::UploadedFileAdapter
+          data.binmode
+          data.rewind
+          if name.nil?
+            raise ArgumentError, 'Must provide a file name with Tempfiles' if data.is_a? Tempfile
+            name = ::File.basename(data)
+          end
+        else
+          raise ArgumentError, 'Must provide a file name with streams' if name.nil?
+          if data.respond_to?(:read)
+            temp = Tempfile.new(name)
+            temp.binmode
+            IO.copy_stream(data, temp)
+            data = temp
+            data.rewind
+          else
+            raise ArgumentError, 'Unsuitable data type. Please read the docs.'
+          end
+        end
+
+        uri = URI(upload_url[:url])
+        req = Net::HTTP::Post.new(uri)
+
+        req.add_field('Authorization', upload_url[:token])
+        req.add_field('X-Bz-File-Name', "#{base_name}/#{name}".tr_s('/', '/').sub(/\A\//, ''))
+        req.add_field('Content-Type', content_type)
+        req.add_field('Content-Length', data.size)
+
+        digest = Digest::SHA1.new
+        if data.is_a? String
+          digest.update(data)
+          req.body = data
+        elsif data.is_a? ::Paperclip::UploadedFileAdapter
+          digest.file(data.path)
+          data.rewind
+          req.body_stream = data
+        else
+          digest.file(data)
+          data.rewind
+          req.body_stream = data
+        end
+
+        req.add_field('X-Bz-Content-Sha1', digest)
+
+        info.first(10).map do |key, value|
+          encoded_key = URI.encode_www_form_component(key)
+          req.add_field("X-Bz-Info-#{encoded_key}", value)
+        end
+
+        http = Net::HTTP.new(req.uri.host, req.uri.port)
+        http.use_ssl = (req.uri.scheme == 'https')
+        res = http.start { |make| make.request(req) }
+
+        response = JSON.parse(res.body)
+
+        raise Backblaze::FileError, response unless res.code.to_i == 200
+
+        params = {
+          file_name: response['fileName'],
+          bucket_id: response['bucketId'],
+          size: response['contentLength'],
+          file_id: response['fileId'],
+          upload_timestamp: Time.now.to_i * 1000,
+          content_length: data.size,
+          content_type: content_type,
+          content_sha1: digest,
+          action: 'upload'
+        }
+
+        File.new(params)
+      end
+    end
+
+    attr_reader :file_name
+    alias name file_name
+
+    def versions
+      unless @fetched_all
+        @versions = file_versions(bucket_id: @bucket_id, convert: true, limit: -1, double_check_server: false, file_name: file_name)
+        @fetched_all = true
+      end
+      @versions
+    end
+
+    def download_url(bucket:)
+      "#{Backblaze::B2.download_url}/file/#{bucket.is_a?(Bucket) ? bucket.name : bucket}/#{file_name}"
+    end
+
+    def file_id_download_url
+      latest.download_url
+    end
+
+    def latest
+      @versions.first
+    end
+
+    def destroy!(thread_count: 4)
+      versions
+      thread_count = @versions.length if thread_count > @versions.length || thread_count < 1
+      lock = Mutex.new
+      errors = []
+      threads = []
+      thread_count.times do
+        threads << Thread.new do
+          version = nil
+          loop do
+            lock.synchronize { version = @versions.pop }
+            break if version.nil?
+            begin
+              version.destroy!
+            rescue Backblaze::FileError => e
+              lock.synchronize { errors << e }
+            end
+          end
+        end
+      end
+      threads.map(&:join)
+      @destroyed = true
+      raise Backblaze::DestroyErrors, errors if errors.any?
+    end
+
+    def exists?
+      !@destroyed
+    end
+
+    def method_missing(m, *args, &block)
+      if latest.respond_to?(m)
+        latest.send(m, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to?(m)
+      if latest.respond_to?(m)
+        true
+      else
+        super
+      end
+    end
+  end
+end

data/lib/backblaze/b2/file_version.rb

@@ -0,0 +1,43 @@
+module Backblaze::B2
+  class FileVersion < Base
+    attr_reader :file_id, :size, :action, :upload_timestamp, :file_name,
+                :content_length, :content_sha1, :content_type, :file_info
+
+    def initialize(file_id:, size:, upload_timestamp:, action:, file_name:,
+                   content_length:, content_sha1:, content_type:, file_info: {}, **unneeded_args)
+      @file_id = file_id
+      @size = size
+      @action = action
+      @file_name = file_name
+      @content_length = content_length
+      @content_sha1 = content_sha1
+      @content_type = content_type
+      @file_info = file_info
+      @upload_timestamp = Time.at(upload_timestamp / 1000.0)
+    end
+
+    def get_info
+      unless defined?(@get_info)
+        response = post('/b2_get_file_info', body: { fileId: file_id }.to_json)
+        raise Backblaze::FileError, response unless response.code == 200
+
+        @get_info = Hash[response.map { |k, v| [Backblaze::Utils.underscore(k).to_sym, v] }]
+      end
+      @get_info
+    end
+
+    def download_url
+      "#{Backblaze::B2.download_url}#{Backblaze::B2.api_path}b2_download_file_by_id?fileId=#{file_id}"
+    end
+
+    def destroy!
+      response = post('/b2_delete_file_version', body: { fileName: file_name, fileId: file_id }.to_json)
+      raise Backblaze::FileError, response unless response.code == 200
+      @destroyed = true
+    end
+
+    def exists?
+      !@destroyed
+    end
+  end
+end

data/lib/backblaze/b2.rb

@@ -0,0 +1,54 @@
+require 'backblaze/b2/base'
+require 'backblaze/b2/bucket'
+require 'backblaze/b2/file'
+require 'backblaze/b2/file_version'
+require 'tempfile'
+require 'digest/sha1'
+require 'base64'
+
+module Backblaze::B2
+  class << self
+    attr_reader :account_id, :token, :api_url, :download_url, :api_path
+
+    ##
+    # Authenticates with the server to get the authorization data. Raises an error if there is a problem
+    #
+    # @param [#to_s] account_id the account id
+    # @param [#to_s] application_key the private app key
+    # @raise [Backblaze::AuthError] when unable to authenticate
+    # @return [void]
+    def login(options)
+      api_path = options.fetch(:api_path) { '/b2api/v1/' }
+
+      params = {
+        headers: {
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json',
+          'Authorization' => bearer(options)
+        }
+      }
+      api_path = "/#{api_path}/".gsub(/\/+/, '/')
+
+      response = HTTParty.get("https://api.backblazeb2.com#{api_path}b2_authorize_account", params)
+
+      raise Backblaze::AuthError, response unless response.success?
+
+      @account_id = response['accountId']
+      @token = response['authorizationToken']
+      @api_url = response['apiUrl']
+      @download_url = response['downloadUrl']
+      @api_path = api_path
+      Backblaze::B2::Base.base_uri("#{@api_url}#{api_path}")
+      Backblaze::B2::Base.headers('Authorization' => token,
+                                  'Content-Type' => 'application/json')
+    end
+
+    def bearer(options)
+      account_id = options.fetch(:account_id)
+      application_key = options.fetch(:application_key)
+      token = Base64.strict_encode64("#{account_id}:#{application_key}")
+
+      "Basic #{token}"
+    end
+  end
+end

data/lib/backblaze/errors.rb

@@ -0,0 +1,80 @@
+module Backblaze
+  ##
+  # Base Backblaze error class
+  # @abstract
+  class Error < StandardError
+  end
+
+  ##
+  # Basic needs for error messages.
+  # @note this could be abstract, but just keeps things simple.
+  class RequestError < Error
+    ##
+    # Creates the Error
+    # @param [HTTParty::Response] response the json response
+    def initialize(response)
+      @response = response
+    end
+
+    ##
+    # The response from the server
+    # @return [HTTParty::Response] the response
+    attr_reader :response
+
+    ##
+    # The Backblaze B2 error code
+    # @return [String] error code
+    def code
+      self['code']
+    end
+
+    ##
+    # The Backblaze B2 request status
+    # @return [Integer] status code
+    def status
+      self['status']
+    end
+
+    ##
+    # The Backblaze B2 error message which is a human explanation
+    # @return [String] the problem in human words
+    def message
+      self['message']
+    end
+
+    ##
+    # Shortcut to access the response keys
+    # @return [Object] the object stored at `key` in the response
+    def [](key)
+      @response[key]
+    end
+  end
+
+  ##
+  # Errors destroying file versions
+  class DestroyErrors < Error
+    ##
+    # Creates the Error
+    # @param [Array<Backblaze::FileError>] errors errors raised destroying files
+    def initialize(errors)
+      @errors = errors
+    end
+
+    ##
+    # The Backblaze B2 error messages which broke things
+    # @return [Array<Backblaze::FileError>] errors errors raised destroying files
+    attr_reader :errors
+  end
+
+  ##
+  # Error class for authentication errors
+  class AuthError < RequestError; end
+
+  ##
+  # Error class for bucket errors
+  class BucketError < RequestError; end
+
+  ##
+  # Error class for file errors
+  class FileError < RequestError; end
+end

data/lib/backblaze/utils.rb

@@ -0,0 +1,26 @@
+module Backblaze::Utils
+  def underscore(word)
+    word.to_s
+        .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr('-', '_')
+        .downcase
+  end
+
+  def camelize(word, capitalize = false)
+    word = word.to_s
+    "#{capitalize ? word[0, 1].upcase : word[0, 1].downcase}#{word.split('_').map(&:capitalize).join('')[1..-1]}"
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    include Backblaze::Utils
+  end
+
+  class << self
+    include Backblaze::Utils
+  end
+end

data/lib/backblaze/version.rb

@@ -0,0 +1,3 @@
+module Backblaze
+  VERSION = '0.3.0'.freeze
+end

data/lib/backblaze.rb

@@ -0,0 +1,9 @@
+require 'httparty'
+
+require 'backblaze/version'
+require 'backblaze/utils'
+require 'backblaze/errors'
+require 'backblaze/b2'
+
+module Backblaze
+end

data/lib/paperclip/backblaze/version.rb

@@ -0,0 +1,5 @@
+module Paperclip
+  module Backblaze
+    VERSION = '0.2.2'.freeze
+  end
+end

data/lib/paperclip/backblaze.rb

@@ -0,0 +1,4 @@
+require_relative '../backblaze'
+
+require 'paperclip/backblaze/version'
+require 'paperclip/storage/backblaze'

data/lib/paperclip/storage/backblaze.rb

@@ -0,0 +1,142 @@
+module Paperclip
+  module Storage
+    # Defines a adapter to use store Paperclip attachments to Backblaze B2
+    # Cloud Storage, which is similar to Amazon's S3 service.
+    #
+    # This allows you to use has_attached_file in your models
+    # with :storage => :backblaze.
+    #
+    # Some required options include:
+    #
+    #   :storage - This should be set to :backblaze in order to use this
+    #     storage adapter.
+    #
+    #   :b2_credentials - This should point to a YAML file containing your B2
+    #     account ID, application key, and bucket. The contents should look
+    #     something like:
+    #
+    #     account_id: 123456789abc
+    #     application_key: 0123456789abcdef0123456789abcdef0123456789
+    #     bucket: my_b2_bucket_name
+    #
+    # So for example, a model might be configured something like this:
+    #
+    #   class Note < ApplicationRecord
+    #     has_attached_file :image,
+    #       storage: :backblaze,
+    #       b2_credentials: YAML.safe_load(ERB.new(File.read("#{Rails.root}/config/back_blaze.yml")).result)[Rails.env],
+    #     ...
+    #
+    # You can put the backblaze config in the environment config file e.g.:
+    #
+    #   # config/environments/production.rb
+    #
+    #   config.paperclip_defaults = {
+    #     storage: :backblaze,
+    #     b2_credentials: [Hash]
+    #   }
+    #
+    # If you do it this way, then you don't need to put it in the model.
+    #
+    module Backblaze
+      def self.extended(base)
+        base.instance_eval do
+          @b2_buckets = {}
+          login
+          unless @options[:url] =~ /\Ab2.*url\z/
+            @options[:url] = ':b2_path_url'.freeze
+          end
+        end
+
+        unless Paperclip::Interpolations.respond_to? :b2_path_url
+          Paperclip.interpolates(:b2_path_url) do |attachment, style|
+            "#{::Backblaze::B2.download_url}/file/#{attachment.b2_bucket_name}/#{attachment.path(style).sub(%r{\A/}, '')}"
+          end
+        end
+      end
+
+      # Reads b2_credentials from the config file
+      # must be a hash
+      #   {
+      #     account_id: 123456789abc
+      #     application_key: 0123456789abcdef0123456789abcdef0123456789
+      #   }
+      # Returns a Hash containing the parsed credentials.
+      def b2_credentials
+        @b2_credentials ||= @options.fetch(:b2_credentials)
+      end
+
+      # Authenticate with Backblaze with the account ID and secret key. This
+      # also caches several variables from the response related to the API, so
+      # it is important that it is executed at the very beginning.
+      def login
+        return if ::Backblaze::B2.token
+        creds = b2_credentials
+        ::Backblaze::B2.login(
+          account_id: creds.fetch(:account_id),
+          application_key: creds.fetch(:application_key)
+        )
+      end
+
+      # Return the Backblaze::B2::Bucket object representing the bucket
+      # specified by the required options[:b2_bucket].
+      def b2_bucket
+        bucket_name = @options[:bucket] || b2_credentials.fetch(:bucket)
+        @b2_buckets[bucket_name] ||= ::Backblaze::B2::Bucket.get_bucket(
+          name: bucket_name
+        )
+      end
+
+      # Return the specified bucket name as a String.
+      def b2_bucket_name
+        b2_bucket.bucket_name
+      end
+
+      # Return whether this attachment exists in the bucket.
+      def exists?(style = default_style)
+        !get_file(filename: get_path(style)).nil?
+      end
+
+      # Return a Backblaze::B2::File object representing the file named in the
+      # filename keyword, if it exists.
+      def get_file(filename:)
+        b2_bucket.file_names(first_file: filename, limit: 1).find do |f|
+          f.file_name == filename
+        end
+      end
+
+      # Return this attachment's bucket file path as a String.
+      def get_path(style = default_style)
+        path(style).sub(%r{\A/}, '')
+      end
+
+      # (Internal) Used by Paperclip to upload local files to storage.
+      def flush_writes
+        @queued_for_write.each do |style, file|
+          base_name = ::File.dirname(get_path(style))
+          name = ::File.basename(get_path(style))
+          ::Backblaze::B2::File.create data: file, bucket: b2_bucket, name: name, base_name: base_name
+        end
+        @queued_for_write = {}
+      end
+
+      # (Internal) Used by Paperclip to remove remote files from storage.
+      def flush_deletes
+        @queued_for_delete.each do |path|
+          file = get_file(filename: path.sub(%r{\A/}, ''))
+          file.destroy! unless file.nil?
+        end
+        @queued_for_delete = []
+      end
+
+      # (Internal)
+      def copy_to_local_file(style, local_dest_path)
+        ::File.open(local_dest_path, 'wb') do |local_file|
+          file = get_file(filename: get_path(style))
+          body = file.get(file.latest.download_url, parse: :plain)
+          local_file.write(body)
+        end
+      end
+    end # module Backblaze
+  end # module Storage
+end # module Paperclip

data/paperclip-backblaze.gemspec

@@ -0,0 +1,28 @@
+
+Gem::Specification.new do |spec|
+  spec.name          = 'paperclip-backblaze'
+  spec.version       = '0.2.4'
+  spec.authors       = ['Alex Tsui', 'Winston Durand']
+  spec.email         = ['alextsui05@gmail.com']
+
+  spec.summary       = 'Paperclip storage adapter for Backblaze B2 Cloud.'
+  spec.description   = 'Allows Paperclip attachments to be backed by Backblaze B2 Cloud storage as an alternative to AWS S3.'
+  spec.homepage      = 'https://github.com/alextsui05/paperclip-backblaze'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop', '~> 0.51.0'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'yard'
+  spec.add_dependency 'httparty'
+
+  spec.required_ruby_version = '>= 2.1.0'
+end

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: paperclip-backblaze
+version: !ruby/object:Gem::Version
+  version: 0.2.4
+platform: ruby
+authors:
+- Alex Tsui
+- Winston Durand
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-12-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.51.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.51.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Allows Paperclip attachments to be backed by Backblaze B2 Cloud storage
+  as an alternative to AWS S3.
+email:
+- alextsui05@gmail.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Dockerfile
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/backblaze.rb
+- lib/backblaze/b2.rb
+- lib/backblaze/b2/base.rb
+- lib/backblaze/b2/bucket.rb
+- lib/backblaze/b2/file.rb
+- lib/backblaze/b2/file_version.rb
+- lib/backblaze/errors.rb
+- lib/backblaze/utils.rb
+- lib/backblaze/version.rb
+- lib/paperclip/backblaze.rb
+- lib/paperclip/backblaze/version.rb
+- lib/paperclip/storage/backblaze.rb
+- paperclip-backblaze.gemspec
+homepage: https://github.com/alextsui05/paperclip-backblaze
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.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: Paperclip storage adapter for Backblaze B2 Cloud.
+test_files: []