carrierwave_backgrounder_revived 1.0.0

data/lib/backgrounder/orm/base.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+require 'backgrounder/workers'
+
+module CarrierWave
+  module Backgrounder
+    module ORM
+
+      ##
+      # Base class for all things orm
+      module Base
+
+        ##
+        # User#process_in_background will process and create versions in a background process.
+        #
+        # class User < ActiveRecord::Base
+        #   mount_uploader :avatar, AvatarUploader
+        #   process_in_background :avatar
+        # end
+        #
+        # The above adds a User#process_upload method which can be used at times when you want to bypass
+        # background storage and processing.
+        #
+        #   @user.process_avatar = true
+        #   @user.save
+        #
+        # You can also pass in your own workers using the second argument in case you need other things done
+        # during processing.
+        #
+        #   class User < ActiveRecord::Base
+        #     mount_uploader :avatar, AvatarUploader
+        #     process_in_background :avatar, CustomWorker
+        #   end
+        #
+        # In addition you can also add a column to the database appended by _processing with a type of boolean
+        # which can be used to check if processing is complete.
+        #
+        #   def self.up
+        #     add_column :users, :avatar_processing, :boolean
+        #   end
+        #
+        def process_in_background(column, worker=::CarrierWave::Workers::ProcessAsset)
+          attr_accessor :"process_#{column}_upload"
+
+          mod = Module.new
+          include mod
+
+          _define_shared_backgrounder_methods(mod, column, worker)
+        end
+
+        ##
+        # #store_in_background  will process, version and store uploads in a background process.
+        #
+        # class User < ActiveRecord::Base
+        #   mount_uploader :avatar, AvatarUploader
+        #   store_in_background :avatar
+        # end
+        #
+        # The above adds a User#process_<column>_upload method which can be used at times when you want to bypass
+        # background storage and processing.
+        #
+        #   @user.process_avatar_upload = true
+        #   @user.save
+        #
+        # You can also pass in your own workers using the second argument in case you need other things done
+        # during processing.
+        #
+        #   class User < ActiveRecord::Base
+        #     mount_uploader :avatar, AvatarUploader
+        #     store_in_background :avatar, CustomWorker
+        #   end
+        #
+        def store_in_background(column, worker=::CarrierWave::Workers::StoreAsset)
+          attr_accessor :"process_#{column}_upload"
+
+          mod = Module.new
+          include mod
+          mod.class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            def remove_#{column}=(value)
+              super
+              self.process_#{column}_upload = true
+            end
+
+            def write_#{column}_identifier
+              super and return if process_#{column}_upload
+              self.#{column}_tmp = _mounter(:#{column}).cache_name if _mounter(:#{column}).cache_name
+            end
+
+            def store_#{column}!
+              super if process_#{column}_upload
+            end
+
+          RUBY
+
+          _define_shared_backgrounder_methods(mod, column, worker)
+        end
+
+        private
+
+        def _define_shared_backgrounder_methods(mod, column, worker)
+          mod.class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            def #{column}_updated?; true; end
+
+            def set_#{column}_processing
+              self.#{column}_processing = true if respond_to?(:#{column}_processing)
+            end
+
+            def enqueue_#{column}_background_job?
+              !remove_#{column}? && !process_#{column}_upload && #{column}_updated?
+            end
+
+            def enqueue_#{column}_background_job
+              CarrierWave::Backgrounder.enqueue_for_backend(#{worker}, self.class.name, id.to_s, #{column}.mounted_as)
+            end
+          RUBY
+        end
+      end # Base
+
+    end #ORM
+  end #Backgrounder
+end #CarrierWave

data/lib/backgrounder/orm/data_mapper.rb

@@ -0,0 +1,63 @@
+module CarrierWave
+  module Backgrounder
+    module ORM
+
+      module DataMapper
+        include CarrierWave::Backgrounder::ORM::Base
+
+        def process_in_background(column, worker=::CarrierWave::Workers::ProcessAsset)
+          super
+
+          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            def set_#{column}_processing
+              @#{column}_changed = attribute_dirty?(:#{column})
+              self.#{column}_processing = true if respond_to?(:#{column}_processing)
+            end
+          RUBY
+        end
+
+        def store_in_background(column, worker=::CarrierWave::Workers::StoreAsset)
+          super
+
+          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            def set_#{column}_changed
+              @#{column}_changed = attribute_dirty?(:#{column})
+            end
+
+            def write_#{column}_identifier
+              super and return if process_#{column}_upload
+              self.#{column}_tmp = _mounter(:#{column}).cache_name
+            end
+          RUBY
+        end
+
+        private
+
+        def _define_shared_backgrounder_methods(mod, column, worker)
+          before :save, :"set_#{column}_changed"
+          after  :save, :"enqueue_#{column}_background_job"
+
+          super
+
+          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            attr_reader :#{column}_changed
+
+            def enqueue_#{column}_background_job
+              if enqueue_#{column}_background_job?
+                CarrierWave::Backgrounder.enqueue_for_backend(#{worker}, self.class.name, id, #{column}.mounted_as)
+                @#{column}_changed = false
+              end
+            end
+
+            def #{column}_updated?
+              #{column}_changed
+            end
+          RUBY
+        end
+      end # DataMapper
+
+    end #ORM
+  end #Backgrounder
+end #CarrierWave
+
+DataMapper::Model.append_extensions ::CarrierWave::Backgrounder::ORM::DataMapper

data/lib/backgrounder/railtie.rb

@@ -0,0 +1,25 @@
+module CarrierWave
+  module Backgrounder
+    class Railtie < Rails::Railtie
+
+      initializer "carrierwave_backgrounder.active_record" do
+        ActiveSupport.on_load :active_record do
+          require 'backgrounder/orm/activemodel'
+          ::ActiveRecord::Base.extend CarrierWave::Backgrounder::ORM::ActiveModel
+        end
+      end
+
+      initializer "carrierwave_backgrounder.data_mapper", :before =>"data_mapper.add_to_prepare" do
+        require 'backgrounder/orm/data_mapper' if defined?(DataMapper)
+      end
+
+      initializer "carrierwave_backgrounder.mongoid" do
+        if defined?(Mongoid)
+          require 'backgrounder/orm/activemodel'
+          ::Mongoid::Document::ClassMethods.send(:include, ::CarrierWave::Backgrounder::ORM::ActiveModel)
+        end
+      end
+
+    end
+  end
+end

data/lib/backgrounder/support/backends.rb

@@ -0,0 +1,94 @@
+module CarrierWave
+  module Backgrounder
+    module Support
+      module Backends
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          attr_reader :queue_options
+
+          def backend(queue_name=nil, args={})
+            return @backend if @backend
+            @queue_options = args
+            @backend = queue_name
+          end
+
+          def enqueue_for_backend(worker, class_name, subject_id, mounted_as)
+            self.send :"enqueue_#{backend}", worker, class_name, subject_id, mounted_as
+          end
+
+          private
+
+          def enqueue_active_job(worker, *args)
+            worker.perform(*args.map(&:to_s))
+          end
+
+          def enqueue_delayed_job(worker, *args)
+            worker_args = {}
+            if ::Delayed::Job.new.respond_to?(:queue)
+              worker_args[:queue] = queue_options[:queue] if queue_options[:queue]
+              worker_args[:priority] = queue_options[:priority] if queue_options[:priority]
+              ::Delayed::Job.enqueue worker.new(*args), worker_args
+            else
+              worker_args[:priority] = queue_options[:priority] if queue_options[:priority]
+              ::Delayed::Job.enqueue worker.new(*args), worker_args
+              if queue_options[:queue]
+                ::Rails.logger.warn("Queue name given but no queue column exists for Delayed::Job")
+              end
+            end
+          end
+
+          def enqueue_resque(worker, *args)
+            worker.instance_variable_set('@queue', queue_options[:queue] || :carrierwave)
+            ::Resque.enqueue worker, *args
+          end
+
+          def enqueue_sidekiq(worker, *args)
+            override_queue_name = worker.sidekiq_options['queue'] == 'default' || worker.sidekiq_options['queue'].nil?
+            args = sidekiq_queue_options(override_queue_name, 'class' => worker, 'args' => args)
+            worker.client_push(args)
+          end
+
+          def enqueue_girl_friday(worker, *args)
+            @girl_friday_queue ||= GirlFriday::WorkQueue.new(queue_options.delete(:queue) || :carrierwave, queue_options) do |msg|
+              worker = msg[:worker]
+              worker.perform
+            end
+            @girl_friday_queue << { :worker => worker.new(*args) }
+          end
+
+          def enqueue_sucker_punch(worker, *args)
+            worker.new.async.perform(*args)
+          end
+
+          def enqueue_qu(worker, *args)
+            worker.instance_variable_set('@queue', queue_options[:queue] || :carrierwave)
+            ::Qu.enqueue worker, *args
+          end
+
+          def enqueue_qc(worker, *args)
+            class_name, subject_id, mounted_as = args
+            ::QC.enqueue "#{worker.name}.perform", class_name, subject_id, mounted_as.to_s
+          end
+
+          def enqueue_immediate(worker, *args)
+            worker.new(*args).perform
+          end
+
+          def sidekiq_queue_options(override_queue_name, args)
+            if override_queue_name && queue_options[:queue]
+              args['queue'] = queue_options[:queue]
+            end
+            args['retry'] = queue_options[:retry] unless queue_options[:retry].nil?
+            args['timeout'] = queue_options[:timeout] if queue_options[:timeout]
+            args['backtrace'] = queue_options[:backtrace] if queue_options[:backtrace]
+            args
+          end
+        end
+      end
+    end
+  end
+end

data/lib/backgrounder/version.rb

@@ -0,0 +1,5 @@
+module CarrierWave
+  module Backgrounder
+    VERSION = "1.0.0"
+  end
+end

data/lib/backgrounder/workers.rb

@@ -0,0 +1,6 @@
+require 'backgrounder/workers/base'
+require 'backgrounder/workers/class_methods'
+require 'backgrounder/workers/process_asset_mixin'
+require 'backgrounder/workers/store_asset_mixin'
+require 'backgrounder/workers/process_asset'
+require 'backgrounder/workers/store_asset'

data/lib/backgrounder/workers/base.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module CarrierWave
+  module Workers
+
+    module Base
+      attr_accessor :klass, :id, :column, :record
+
+      def initialize(*args)
+        super(*args) unless self.class.superclass == Object
+        set_args(*args) if args.present?
+      end
+
+      def perform(*args)
+        set_args(*args) if args.present?
+        self.record = constantized_resource.find id
+      rescue *not_found_errors
+      end
+
+      private
+
+      def not_found_errors
+        [].tap do |errors|
+          errors << ::ActiveRecord::RecordNotFound      if defined?(::ActiveRecord)
+          errors << ::Mongoid::Errors::DocumentNotFound if defined?(::Mongoid)
+        end
+      end
+
+      def set_args(klass, id, column)
+        self.klass, self.id, self.column = klass, id, column
+      end
+
+      def constantized_resource
+        klass.is_a?(String) ? klass.constantize : klass
+      end
+
+      def when_not_ready
+      end
+
+    end # Base
+
+  end # Workers
+end # CarrierWave

data/lib/backgrounder/workers/class_methods.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+module CarrierWave
+  module Workers
+
+    module ClassMethods
+
+      def perform(*args)
+        new(*args).perform
+      end
+
+    end # ClassMethods
+
+  end # Workers
+end # Backgrounder

data/lib/backgrounder/workers/process_asset.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module CarrierWave
+  module Workers
+
+    class ProcessAsset
+      include CarrierWave::Workers::ProcessAssetMixin
+    end # ProcessAsset
+
+  end # Workers
+end # Backgrounder

data/lib/backgrounder/workers/process_asset_mixin.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module CarrierWave
+  module Workers
+
+    module ProcessAssetMixin
+      include CarrierWave::Workers::Base
+
+      def self.included(base)
+        base.extend CarrierWave::Workers::ClassMethods
+      end
+
+      def perform(*args)
+        record = super(*args)
+
+        if record && record.send(:"#{column}").present?
+          record.send(:"process_#{column}_upload=", true)
+          if record.send(:"#{column}").recreate_versions! && record.respond_to?(:"#{column}_processing")
+            record.update_attribute :"#{column}_processing", false
+          end
+        else
+          when_not_ready
+        end
+      end
+
+    end # ProcessAssetMixin
+
+  end # Workers
+end # Backgrounder

data/lib/backgrounder/workers/store_asset.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module CarrierWave
+  module Workers
+
+    class StoreAsset
+      include CarrierWave::Workers::StoreAssetMixin
+    end # StoreAsset
+
+  end # Workers
+end # Backgrounder

data/lib/backgrounder/workers/store_asset_mixin.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+module CarrierWave
+  module Workers
+
+    module StoreAssetMixin
+      include CarrierWave::Workers::Base
+
+      def self.included(base)
+        base.extend CarrierWave::Workers::ClassMethods
+      end
+
+      attr_reader :cache_path, :tmp_directory
+
+      def perform(*args)
+        record = super(*args)
+
+        if record && record.send(:"#{column}_tmp")
+          store_directories(record)
+          record.send :"process_#{column}_upload=", true
+          record.send :"#{column}_tmp=", nil
+          record.send :"#{column}_processing=", false if record.respond_to?(:"#{column}_processing")
+          File.open(cache_path) { |f| record.send :"#{column}=", f }
+          if record.save!
+            FileUtils.rm_r(tmp_directory, :force => true)
+          end
+        else
+          when_not_ready
+        end
+      end
+
+      private
+
+      def store_directories(record)
+        asset, asset_tmp = record.send(:"#{column}"), record.send(:"#{column}_tmp")
+        cache_directory  = File.expand_path(asset.cache_dir, asset.root)
+        @cache_path      = File.join(cache_directory, asset_tmp)
+        @tmp_directory   = File.join(cache_directory, asset_tmp.split("/").first)
+      end
+
+    end # StoreAssetMixin
+
+  end # Workers
+end # Backgrounder