asset_sync 2.8.1 → 2.15.2

data/lib/asset_sync/config.rb

@@ -2,7 +2,6 @@
 
 require "active_model"
 require "erb"
-require "yaml"
 
 module AssetSync
   class Config
@@ -26,7 +25,9 @@ module AssetSync
     attr_accessor :cdn_distribution_id
     attr_accessor :cache_asset_regexps
     attr_accessor :include_manifest
-    attr_writer :public_path
+    attr_accessor :concurrent_uploads
+    attr_accessor :concurrent_uploads_max_threads
+    attr_accessor :remote_file_list_cache_file_path
 
     # FOG configuration
     attr_accessor :fog_provider          # Currently Supported ['AWS', 'Rackspace']
@@ -35,7 +36,15 @@ module AssetSync
     attr_reader   :fog_public            # e.g. true, false, "default"
 
     # Amazon AWS
-    attr_accessor :aws_access_key_id, :aws_secret_access_key, :aws_reduced_redundancy, :aws_iam_roles, :aws_signature_version
+    attr_accessor :aws_access_key_id
+    attr_accessor :aws_secret_access_key
+    attr_accessor :aws_session_token
+    attr_accessor :aws_reduced_redundancy
+    attr_accessor :aws_iam_roles
+    attr_accessor :aws_signature_version
+    attr_accessor :aws_acl
+
+    # Fog
     attr_accessor :fog_host              # e.g. 's3.amazonaws.com'
     attr_accessor :fog_port              # e.g. '9000'
     attr_accessor :fog_path_style        # e.g. true
@@ -47,12 +56,18 @@ module AssetSync
     # Google Storage
     attr_accessor :google_storage_secret_access_key, :google_storage_access_key_id  # when using S3 interop
     attr_accessor :google_json_key_location # when using service accounts
+    attr_accessor :google_json_key_string # when using service accounts
     attr_accessor :google_project # when using service accounts
 
     # Azure Blob with Fog::AzureRM
     attr_accessor :azure_storage_account_name
     attr_accessor :azure_storage_access_key
 
+    # Backblaze B2 with Fog::Backblaze
+    attr_accessor :b2_key_id
+    attr_accessor :b2_key_token
+    attr_accessor :b2_bucket_id
+
     validates :existing_remote_files, :inclusion => { :in => %w(keep delete ignore) }
 
     validates :fog_provider,          :presence => true
@@ -64,8 +79,13 @@ module AssetSync
     validates :rackspace_api_key,     :presence => true, :if => :rackspace?
     validates :google_storage_secret_access_key,  :presence => true, :if => :google_interop?
     validates :google_storage_access_key_id,      :presence => true, :if => :google_interop?
-    validates :google_json_key_location,          :presence => true, :if => :google_service_account?
     validates :google_project,                    :presence => true, :if => :google_service_account?
+    validate(:if => :google_service_account?) do
+      unless google_json_key_location.present? || google_json_key_string.present?
+        errors.add(:base, 'must provide either google_json_key_location or google_json_key_string if using Google service account')
+      end
+    end
+    validates :concurrent_uploads,    :inclusion => { :in => [true, false] }
 
     def initialize
       self.fog_region = nil
@@ -84,6 +104,9 @@ module AssetSync
       self.invalidate = []
       self.cache_asset_regexps = []
       self.include_manifest = false
+      self.concurrent_uploads = false
+      self.concurrent_uploads_max_threads = 10
+      self.remote_file_list_cache_file_path = nil
       @additional_local_file_paths_procs = []
 
       load_yml! if defined?(::Rails) && yml_exists?
@@ -136,17 +159,21 @@ module AssetSync
     end
 
     def google_interop?
-      google? && google_json_key_location.nil?
+      google? && google_json_key_location.nil? && google_json_key_string.nil?
     end
 
     def google_service_account?
-      google? && google_json_key_location
+      google? && (google_json_key_location || google_json_key_string)
     end
 
     def azure_rm?
       fog_provider =~ /azurerm/i
     end
 
+    def backblaze?
+      fog_provider =~ /backblaze/i
+    end
+
     def cache_asset_regexp=(cache_asset_regexp)
       self.cache_asset_regexps = [cache_asset_regexp]
     end
@@ -156,7 +183,7 @@ module AssetSync
     end
 
     def yml
-      @yml ||= ::YAML.load(::ERB.new(IO.read(yml_path)).result)[::Rails.env] || {}
+      @yml ||= ::AssetSync.load_yaml(::ERB.new(IO.read(yml_path)).result)[::Rails.env] || {}
     end
 
     def yml_path
@@ -172,6 +199,19 @@ module AssetSync
       @public_path || ::Rails.public_path
     end
 
+    def public_path=(path)
+      # Generate absolute path even when relative path passed in
+      # Required for generating relative sprockets manifest path
+      pathname = Pathname(path)
+      @public_path = if pathname.absolute?
+        pathname
+      elsif defined?(::Rails.root)
+        ::Rails.root.join(pathname)
+      else
+        Pathname(::Dir.pwd).join(pathname)
+      end
+    end
+
     def load_yml!
       self.enabled                = yml["enabled"] if yml.has_key?('enabled')
       self.fog_provider           = yml["fog_provider"]
@@ -184,9 +224,11 @@ module AssetSync
       self.fog_scheme             = yml["fog_scheme"]
       self.aws_access_key_id      = yml["aws_access_key_id"]
       self.aws_secret_access_key  = yml["aws_secret_access_key"]
+      self.aws_session_token      = yml["aws_session_token"] if yml.has_key?("aws_session_token")
       self.aws_reduced_redundancy = yml["aws_reduced_redundancy"]
       self.aws_iam_roles          = yml["aws_iam_roles"]
       self.aws_signature_version  = yml["aws_signature_version"]
+      self.aws_acl                = yml["aws_acl"]
       self.rackspace_username     = yml["rackspace_username"]
       self.rackspace_auth_url     = yml["rackspace_auth_url"] if yml.has_key?("rackspace_auth_url")
       self.rackspace_api_key      = yml["rackspace_api_key"]
@@ -194,22 +236,31 @@ module AssetSync
       self.google_project = yml["google_project"] if yml.has_key?("google_project")
       self.google_storage_secret_access_key = yml["google_storage_secret_access_key"] if yml.has_key?("google_storage_secret_access_key")
       self.google_storage_access_key_id     = yml["google_storage_access_key_id"] if yml.has_key?("google_storage_access_key_id")
+      self.google_json_key_string           = yml["google_json_key_string"] if yml.has_key?("google_json_key_string")
       self.existing_remote_files  = yml["existing_remote_files"] if yml.has_key?("existing_remote_files")
       self.gzip_compression       = yml["gzip_compression"] if yml.has_key?("gzip_compression")
       self.manifest               = yml["manifest"] if yml.has_key?("manifest")
       self.fail_silently          = yml["fail_silently"] if yml.has_key?("fail_silently")
+      self.log_silently           = yml["log_silently"] if yml.has_key?("log_silently")
       self.always_upload          = yml["always_upload"] if yml.has_key?("always_upload")
       self.ignored_files          = yml["ignored_files"] if yml.has_key?("ignored_files")
-      self.custom_headers          = yml["custom_headers"] if yml.has_key?("custom_headers")
+      self.custom_headers         = yml["custom_headers"] if yml.has_key?("custom_headers")
       self.run_on_precompile      = yml["run_on_precompile"] if yml.has_key?("run_on_precompile")
       self.invalidate             = yml["invalidate"] if yml.has_key?("invalidate")
       self.cdn_distribution_id    = yml['cdn_distribution_id'] if yml.has_key?("cdn_distribution_id")
       self.cache_asset_regexps    = yml['cache_asset_regexps'] if yml.has_key?("cache_asset_regexps")
       self.include_manifest       = yml['include_manifest'] if yml.has_key?("include_manifest")
+      self.concurrent_uploads     = yml['concurrent_uploads'] if yml.has_key?('concurrent_uploads')
+      self.concurrent_uploads_max_threads = yml['concurrent_uploads_max_threads'] if yml.has_key?('concurrent_uploads_max_threads')
+      self.remote_file_list_cache_file_path = yml['remote_file_list_cache_file_path'] if yml.has_key?('remote_file_list_cache_file_path')
 
       self.azure_storage_account_name = yml['azure_storage_account_name'] if yml.has_key?("azure_storage_account_name")
       self.azure_storage_access_key   = yml['azure_storage_access_key'] if yml.has_key?("azure_storage_access_key")
 
+      self.b2_key_id      = yml['b2_key_id']    if yml.has_key?("b2_key_id")
+      self.b2_key_token   = yml['b2_key_token'] if yml.has_key?("b2_key_token")
+      self.b2_bucket_id   = yml['b2_bucket_id'] if yml.has_key?("b2_bucket_id")
+
       # TODO deprecate the other old style config settings. FML.
       self.aws_access_key_id      = yml["aws_access_key"] if yml.has_key?("aws_access_key")
       self.aws_secret_access_key  = yml["aws_access_secret"] if yml.has_key?("aws_access_secret")
@@ -238,6 +289,7 @@ module AssetSync
             :aws_access_key_id => aws_access_key_id,
             :aws_secret_access_key => aws_secret_access_key
           })
+          options.merge!({:aws_session_token => aws_session_token}) if aws_session_token
         end
         options.merge!({:host => fog_host}) if fog_host
         options.merge!({:port => fog_port}) if fog_port
@@ -255,6 +307,8 @@ module AssetSync
       elsif google?
         if google_json_key_location
           options.merge!({:google_json_key_location => google_json_key_location, :google_project => google_project})
+        elsif google_json_key_string
+          options.merge!({:google_json_key_string => google_json_key_string, :google_project => google_project})
         else
           options.merge!({
             :google_storage_secret_access_key => google_storage_secret_access_key,
@@ -269,6 +323,13 @@ module AssetSync
           :azure_storage_access_key   => azure_storage_access_key,
         })
         options.merge!({:environment => fog_region}) if fog_region
+      elsif backblaze?
+        require 'fog/backblaze'
+        options.merge!({
+          :b2_key_id      => b2_key_id,
+          :b2_key_token   => b2_key_token,
+          :b2_bucket_id   => b2_bucket_id,
+        })
       else
         raise ArgumentError, "AssetSync Unknown provider: #{fog_provider} only AWS, Rackspace and Google are supported currently."
       end

data/lib/asset_sync/engine.rb

@@ -23,7 +23,9 @@ module AssetSync
 
           config.aws_access_key_id = ENV['AWS_ACCESS_KEY_ID'] if ENV.has_key?('AWS_ACCESS_KEY_ID')
           config.aws_secret_access_key = ENV['AWS_SECRET_ACCESS_KEY'] if ENV.has_key?('AWS_SECRET_ACCESS_KEY')
+          config.aws_session_token = ENV['AWS_SESSION_TOKEN'] if ENV.has_key?('AWS_SESSION_TOKEN')
           config.aws_signature_version = ENV['AWS_SIGNATURE_VERSION'] if ENV.has_key?('AWS_SIGNATURE_VERSION')
+          config.aws_acl = ENV['AWS_ACL'] if ENV.has_key?('AWS_ACL')
           config.aws_reduced_redundancy = ENV['AWS_REDUCED_REDUNDANCY'] == true  if ENV.has_key?('AWS_REDUCED_REDUNDANCY')
 
           config.rackspace_username = ENV['RACKSPACE_USERNAME'] if ENV.has_key?('RACKSPACE_USERNAME')
@@ -35,6 +37,10 @@ module AssetSync
           config.azure_storage_account_name = ENV['AZURE_STORAGE_ACCOUNT_NAME'] if ENV.has_key?('AZURE_STORAGE_ACCOUNT_NAME')
           config.azure_storage_access_key = ENV['AZURE_STORAGE_ACCESS_KEY'] if ENV.has_key?('AZURE_STORAGE_ACCESS_KEY')
 
+          config.b2_key_id    = ENV['B2_KEY_ID']    if ENV.has_key?('B2_KEY_ID')
+          config.b2_key_token = ENV['B2_KEY_TOKEN'] if ENV.has_key?('B2_KEY_TOKEN')
+          config.b2_bucket_id = ENV['B2_BUCKET_ID'] if ENV.has_key?('B2_BUCKET_ID')
+
           config.enabled = (ENV['ASSET_SYNC_ENABLED'] == 'true') if ENV.has_key?('ASSET_SYNC_ENABLED')
 
           config.existing_remote_files = ENV['ASSET_SYNC_EXISTING_REMOTE_FILES'] || "keep"
@@ -42,6 +48,8 @@ module AssetSync
           config.gzip_compression = (ENV['ASSET_SYNC_GZIP_COMPRESSION'] == 'true') if ENV.has_key?('ASSET_SYNC_GZIP_COMPRESSION')
           config.manifest = (ENV['ASSET_SYNC_MANIFEST'] == 'true') if ENV.has_key?('ASSET_SYNC_MANIFEST')
           config.include_manifest = (ENV['ASSET_SYNC_INCLUDE_MANIFEST'] == 'true') if ENV.has_key?('ASSET_SYNC_INCLUDE_MANIFEST')
+          config.concurrent_uploads = (ENV['ASSET_SYNC_CONCURRENT_UPLOADS'] == 'true') if ENV.has_key?('ASSET_SYNC_CONCURRENT_UPLOADS')
+          config.remote_file_list_cache_file_path = ENV['ASSET_SYNC_REMOTE_FILE_LIST_CACHE_FILE_PATH'] if ENV.has_key?('ASSET_SYNC_REMOTE_FILE_LIST_CACHE_FILE_PATH')
         end
 
         config.prefix = ENV['ASSET_SYNC_PREFIX'] if ENV.has_key?('ASSET_SYNC_PREFIX')

data/lib/asset_sync/storage.rb

@@ -4,7 +4,7 @@ require "asset_sync/multi_mime"
 
 module AssetSync
   class Storage
-    REGEXP_FINGERPRINTED_FILES = /^(.*)\/([^-]+)-[^\.]+\.([^\.]+)$/
+    REGEXP_FINGERPRINTED_FILES = /\A(.*)\/(.+)-[^\.]+\.([^\.]+)\z/m
     REGEXP_ASSETS_TO_CACHE_CONTROL = /-[0-9a-fA-F]{32,}$/
 
     class BucketNotFound < StandardError;
@@ -22,7 +22,13 @@ module AssetSync
 
     def bucket
       # fixes: https://github.com/rumblelabs/asset_sync/issues/18
-      @bucket ||= connection.directories.get(self.config.fog_directory, :prefix => self.config.assets_prefix)
+
+      @bucket ||= if self.config.backblaze?
+                    connection.directories.get(self.config.fog_directory)
+                  else
+                    connection.directories.get(self.config.fog_directory, :prefix => self.config.assets_prefix)
+                  end
+
     end
 
     def log(msg)
@@ -37,6 +43,10 @@ module AssetSync
       self.config.public_path
     end
 
+    def remote_file_list_cache_file_path
+      self.config.remote_file_list_cache_file_path
+    end
+
     def ignored_files
       expand_file_names(self.config.ignored_files)
     end
@@ -58,6 +68,32 @@ module AssetSync
         (get_local_files + config.additional_local_file_paths).uniq
     end
 
+    def remote_files
+      return [] if ignore_existing_remote_files?
+      return @remote_files if @remote_files
+
+      if remote_file_list_cache_file_path && File.file?(remote_file_list_cache_file_path)
+        begin
+          content = File.read(remote_file_list_cache_file_path)
+          return @remote_files = JSON.parse(content)
+        rescue JSON::ParserError
+          warn "Failed to parse #{remote_file_list_cache_file_path} as json"
+        end
+      end
+
+      @remote_files = get_remote_files
+    end
+
+    def update_remote_file_list_cache(local_files_to_upload)
+      return unless remote_file_list_cache_file_path
+      return if ignore_existing_remote_files?
+
+      File.open(self.remote_file_list_cache_file_path, 'w') do |file|
+        uploaded = local_files_to_upload + remote_files
+        file.write(uploaded.to_json)
+      end
+    end
+
     def always_upload_files
       expand_file_names(self.config.always_upload) + get_manifest_path
     end
@@ -81,7 +117,7 @@ module AssetSync
           return manifest.assets.values.map { |f| File.join(self.config.assets_prefix, f) }
         elsif File.exist?(self.config.manifest_path)
           log "Using: Manifest #{self.config.manifest_path}"
-          yml = YAML.load(IO.read(self.config.manifest_path))
+          yml = AssetSync.load_yaml(IO.read(self.config.manifest_path))
 
           return yml.map do |original, compiled|
             # Upload font originals and compiled
@@ -132,9 +168,15 @@ module AssetSync
       from_remote_files_to_delete = remote_files - local_files - ignored_files - always_upload_files
 
       log "Flagging #{from_remote_files_to_delete.size} file(s) for deletion"
-      # Delete unneeded remote files
-      bucket.files.each do |f|
-        delete_file(f, from_remote_files_to_delete)
+      # Delete unneeded remote files, if we are on aws delete in bulk else use sequential delete
+      if self.config.aws? && connection.respond_to?(:delete_multiple_objects)
+        from_remote_files_to_delete.each_slice(500) do |slice|
+          connection.delete_multiple_objects(config.fog_directory, slice)
+        end
+      else
+        bucket.files.each do |f|
+          delete_file(f, from_remote_files_to_delete)
+        end
       end
     end
 
@@ -153,7 +195,9 @@ module AssetSync
 
       # region fog_public
 
-      if config.fog_public.use_explicit_value?
+      if config.aws? && config.aws_acl
+        file[:acl] = config.aws_acl
+      elsif config.fog_public.use_explicit_value?
         file[:public] = config.fog_public.to_bool
       end
 
@@ -237,16 +281,32 @@ module AssetSync
     end
 
     def upload_files
-      # get a fresh list of remote files
-      remote_files = ignore_existing_remote_files? ? [] : get_remote_files
       # fixes: https://github.com/rumblelabs/asset_sync/issues/19
       local_files_to_upload = local_files - ignored_files - remote_files + always_upload_files
       local_files_to_upload = (local_files_to_upload + get_non_fingerprinted(local_files_to_upload)).uniq
-
-      # Upload new files
-      local_files_to_upload.each do |f|
-        next unless File.file? "#{path}/#{f}" # Only files.
-        upload_file f
+      # Only files.
+      local_files_to_upload = local_files_to_upload.select { |f| File.file? "#{path}/#{f}" }
+
+      if self.config.concurrent_uploads
+        jobs = Queue.new
+        local_files_to_upload.each { |f| jobs.push(f) }
+        jobs.close
+
+        num_threads = [self.config.concurrent_uploads_max_threads, local_files_to_upload.length].min
+        # Upload new files
+        workers = Array.new(num_threads) do
+          Thread.new do
+            while f = jobs.pop
+              upload_file(f)
+            end
+          end
+        end
+        workers.map(&:join)
+      else
+        # Upload new files
+        local_files_to_upload.each do |f|
+          upload_file f
+        end
       end
 
       if self.config.cdn_distribution_id && files_to_invalidate.any?
@@ -255,6 +315,8 @@ module AssetSync
         data = cdn.post_invalidation(self.config.cdn_distribution_id, files_to_invalidate)
         log "Invalidation id: #{data.body["Id"]}"
       end
+
+      update_remote_file_list_cache(local_files_to_upload)
     end
 
     def sync

data/lib/asset_sync/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AssetSync
-  VERSION = "2.8.1".freeze
+  VERSION = "2.15.2"
 end

data/lib/generators/asset_sync/install_generator.rb

@@ -5,7 +5,7 @@ module AssetSync
 
     # Commandline options can be defined here using Thor-like options:
     class_option :use_yml,   :type => :boolean, :default => false, :desc => "Use YML file instead of Rails Initializer"
-    class_option :provider,  :type => :string,  :default => "AWS",  :desc => "Generate with support for 'AWS', 'Rackspace', 'Google', or 'AzureRM"
+    class_option :provider,  :type => :string,  :default => "AWS",  :desc => "Generate with support for 'AWS', 'Rackspace', 'Google', 'AzureRM', or 'Backblaze'"
 
     def self.source_root
       @source_root ||= File.join(File.dirname(__FILE__), 'templates')
@@ -27,6 +27,10 @@ module AssetSync
       options[:provider] == 'AzureRM'
     end
 
+    def backblaze?
+      options[:provider] == 'Backblaze'
+    end
+
     def aws_access_key_id
       "<%= ENV['AWS_ACCESS_KEY_ID'] %>"
     end
@@ -35,6 +39,10 @@ module AssetSync
       "<%= ENV['AWS_SECRET_ACCESS_KEY'] %>"
     end
 
+    def aws_session_token
+      "<%= ENV['AWS_SESSION_TOKEN'] %>"
+    end
+
     def google_storage_access_key_id
       "<%= ENV['GOOGLE_STORAGE_ACCESS_KEY_ID'] %>"
     end
@@ -59,6 +67,18 @@ module AssetSync
       "<%= ENV['AZURE_STORAGE_ACCESS_KEY'] %>"
     end
 
+    def b2_key_id
+      "<%= ENV['B2_KEY_ID'] %>"
+    end
+
+    def b2_key_token
+      "<%= ENV['B2_KEY_TOKEN'] %>"
+    end
+
+    def b2_bucket_id
+      "<%= ENV['B2_BUCKET_ID'] %>"
+    end
+
     def app_name
       @app_name ||= Rails.application.is_a?(Rails::Application) && Rails.application.class.name.sub(/::Application$/, "").downcase
     end

data/lib/generators/asset_sync/templates/asset_sync.rb

@@ -4,12 +4,18 @@ if defined?(AssetSync)
     config.fog_provider = 'AWS'
     config.aws_access_key_id = ENV['AWS_ACCESS_KEY_ID']
     config.aws_secret_access_key = ENV['AWS_SECRET_ACCESS_KEY']
+    config.aws_session_token = ENV['AWS_SESSION_TOKEN'] if ENV.key?('AWS_SESSION_TOKEN')
     # To use AWS reduced redundancy storage.
     # config.aws_reduced_redundancy = true
     #
     # Change AWS signature version. Default is 4
     # config.aws_signature_version = 4
     #
+    # Change canned ACL of uploaded object. Default is unset. Will override fog_public if set.
+    # Choose from: private | public-read | public-read-write | aws-exec-read |
+    #              authenticated-read | bucket-owner-read | bucket-owner-full-control 
+    # config.aws_acl = nil 
+    #
     # Change host option in fog (only if you need to)
     # config.fog_host = "s3.amazonaws.com"
     #
@@ -34,6 +40,12 @@ if defined?(AssetSync)
     config.azure_storage_account_name = ENV['AZURE_STORAGE_ACCOUNT_NAME']
     config.azure_storage_access_key = ENV['AZURE_STORAGE_ACCESS_KEY']
 
+    <%- elsif backblaze? -%>
+    config.fog_provider = 'Backblaze'
+    config.b2_key_id      = ENV['B2_KEY_ID']
+    config.b2_key_token   = ENV['B2_KEY_TOKEN']
+    config.b2_bucket_id   = ENV['B2_BUCKET_ID']
+
     # config.fog_directory specifies container name of Azure Blob storage
     <%- end -%>
     config.fog_directory = ENV['FOG_DIRECTORY']
@@ -63,6 +75,12 @@ if defined?(AssetSync)
     # Upload the manifest file also.
     # config.include_manifest = false
     #
+    # Upload files concurrently
+    # config.concurrent_uploads = false
+    #
+    # Path to cache file to skip scanning remote
+    # config.remote_file_list_cache_file_path = './.asset_sync_remote_file_list_cache.json'
+    #
     # Fail silently.  Useful for environments such as Heroku
     # config.fail_silently = true
     #

data/lib/generators/asset_sync/templates/asset_sync.yml

@@ -10,11 +10,16 @@ defaults: &defaults
   # Change AWS signature version. Default is 4
   # aws_signature_version: 4
   #
+  # Change canned ACL of uploaded object. Default is unset. Will override fog_public if set.
+  # Choose from: private | public-read | public-read-write | aws-exec-read |
+  #              authenticated-read | bucket-owner-read | bucket-owner-full-control 
+  # aws_acl: null
+  #
   # Change host option in fog (only if you need to)
   # fog_host: "s3.amazonaws.com"
   #
   # Change port option in fog (only if you need to)
-  # config.fog_port = "9000"
+  # fog_port: "9000"
   #
   # Use http instead of https. Default should be "https" (at least for fog-aws)
   # fog_scheme: "http"
@@ -32,8 +37,13 @@ defaults: &defaults
   fog_provider: 'AzureRM'
   azure_storage_account_name: "<%= azure_storage_account_name %>"
   azure_storage_access_key: "<%= azure_storage_access_key %>"
-
   # fog_directory specifies container name of Azure Blob storage
+  <%- elsif backblaze? -%>
+  fog_provider:   Backblaze
+  b2_key_id:      "<%= b2_key_id %>"
+  b2_key_token:   "<%= b2_key_token %>"
+  b2_bucket_id:   "<%= b2_bucket_id %>"
+  # fog_directory specifies container name of Backblaze B2 Bucket
   <%- end -%>
   fog_directory: "<%= app_name %>-assets"
 
@@ -43,7 +53,7 @@ defaults: &defaults
   # Set `public` option when uploading file depending on value,
   # Setting to "default" makes asset sync skip setting the option
   # Possible values: true, false, "default" (default: true)
-  # config.fog_public = true
+  # fog_public: "true"
 
   existing_remote_files: keep
   # To delete existing remote files.

data/spec/fixtures/backblaze_with_yml/config/asset_sync.yml

@@ -0,0 +1,20 @@
+defaults: &defaults
+  fog_provider: "Backblaze"
+  b2_key_id: 'xxxx'
+  b2_key_token: 'zzzz'
+  b2_bucket_id: '1234'
+
+development:
+  <<: *defaults
+  fog_directory: "rails_app_development"
+  existing_remote_files: keep
+
+test:
+  <<: *defaults
+  fog_directory: "rails_app_test"
+  existing_remote_files: keep
+
+production:
+  <<: *defaults
+  fog_directory: "rails_app_production"
+  existing_remote_files: delete

data/spec/integration/backblaze_intergration_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require "fog/backblaze"
+
+def bucket(name)
+  options = {
+    :provider       => 'Backblaze',
+    :b2_key_id      => ENV['B2_KEY_ID'],
+    :b2_key_token   => ENV['B2_KEY_TOKEN'],
+    :b2_bucket_id   => ENV['B2_BUCKET_ID']
+  }
+  options.merge!({ :environment => ENV['FOG_REGION'] }) if ENV.has_key?('FOG_REGION')
+
+  connection = Fog::Storage.new(options)
+  connection.directories.get(ENV['FOG_DIRECTORY'])
+end
+
+def execute(command)
+  app_path = File.expand_path("../../dummy_app", __FILE__)
+  Dir.chdir app_path
+  `#{command}`
+end
+
+describe "AssetSync" do
+
+  before(:each) do
+    @prefix = SecureRandom.hex(6)
+  end
+
+  let(:app_js_regex){
+    /#{@prefix}\/application-[a-zA-Z0-9]*.js$/
+  }
+
+  let(:app_js_gz_regex){
+    /#{@prefix}\/application-[a-zA-Z0-9]*.js.gz$/
+  }
+
+  let(:files){ bucket(@prefix).files }
+
+
+  after(:each) do
+    @directory = bucket(@prefix)
+    @directory.files.each do |f|
+      f.destroy
+    end
+  end
+
+  it "sync" do
+    execute "rake ASSET_SYNC_PREFIX=#{@prefix} assets:precompile"
+
+    files = bucket(@prefix).files
+
+    app_js = files.select{ |f| f.key =~ app_js_regex }.first
+    expect(app_js.content_type).to eq("application/javascript")
+
+    app_js_gz = files.select{ |f| f.key =~ app_js_gz_regex }.first
+    expect(app_js_gz.content_type).to eq("application/javascript")
+    expect(app_js_gz.content_encoding).to eq("gzip")
+  end
+
+  it "sync with enabled=false" do
+    execute "rake ASSET_SYNC_PREFIX=#{@prefix} ASSET_SYNC_ENABLED=false assets:precompile"
+    expect(bucket(@prefix).files.size).to eq(0)
+  end
+
+  it "sync with gzip_compression=true" do
+    execute "rake ASSET_SYNC_PREFIX=#{@prefix} ASSET_SYNC_GZIP_COMPRESSION=true assets:precompile"
+    # bucket(@prefix).files.size.should == 3
+
+    app_js_path = files.select{ |f| f.key =~ app_js_regex }.first
+    app_js = files.get( app_js_path.key )
+    expect(app_js.content_type).to eq("application/javascript")
+  end
+
+end