fogged 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 265b396d59da61488ba11b7d9ab9ab944f0258a4
-  data.tar.gz: 736569ff7e8fd7627c3a93c04065a9e315447e4b
+  metadata.gz: 1652c7da7ec55c934f3fc5d697afb12fdb213f05
+  data.tar.gz: 2fb8e6d18c73e53dbd8ee738e7a6f02290b821f5
 SHA512:
-  metadata.gz: cef14588abf7d1cac4215e19e412e1da03855b06c04014d3a3fdb70949c6fe912abc3738cb6d2bac92f0f3e15f6c2f4d1c35b2f3ca71cee6a84c8cc0ee53c450
-  data.tar.gz: 64daa48361e73b98826a7916bf40c2d7c6a265db4e041e979634f4ba0313c50eec93d1aee2661368b8bc8e96c20b1f7f66a5b6939b479ac81f7083dc7494d04f
+  metadata.gz: 9d30035530d89f7413089fb1ba9d6e037766ff43a9aa5291bf9d764e42233503baf59eb3b3ad5887dd492b81533c5d0ce73066fa65aa6d1b3d11be5a9867cab0
+  data.tar.gz: af368db4c8394d6e7b4617609d4d4c17038c25c884b1e0d7463be4334112c26733d74364f1d4e0b62c88a362e9a9015e58b7fe85727b90578ddb12350c4f9279

data/app/jobs/fogged/resources/aws_thumbnail_job.rb

@@ -0,0 +1,32 @@
+module Fogged
+  module Resources
+    class AWSThumbnailJob < ActiveJob::Base
+      def perform(resource)
+        return unless Fogged.minimagick_enabled
+
+        step = 100 / Fogged.thumbnail_sizes.size
+        Fogged.thumbnail_sizes.each_with_index do |size, index|
+          Tempfile.open(["thumbnail", ".png"]) do |t|
+            MiniMagick::Tool::Convert.new do |c|
+              c << resource.url
+              c.resize("#{size}^")
+              c.gravity("center")
+              c.extent("#{size}")
+              c << t.path
+            end
+
+            Fogged.resources.files.create(
+              :key => resource.send(:fogged_name_for, :thumbnails, index),
+              :body => File.read(t.path),
+              :public => true,
+              :content_type => Mime::PNG.to_s
+            )
+          end
+
+          resource.increment!(:encoding_progress, step)
+        end
+        resource.update!(:encoding_progress => 100)
+      end
+    end
+  end
+end

data/app/jobs/fogged/resources/zencoder_poll_job.rb

@@ -1,35 +1,33 @@
 module Fogged
   module Resources
-    class ZencoderPollJob < Struct.new(:resource_id)
-      def perform
-        @resource = Fogged::Resource.find(resource_id)
-        update_encoding_progress
+    class ZencoderPollJob < ActiveJob::Base
+      def perform(resource)
+        return unless Fogged.zencoder_enabled
+        update_encoding_progress(resource)
 
-        return if @resource.encoding_progress == 100
+        return if resource.encoding_progress == 100
 
         frequency = Fogged.zencoder_polling_frequency
-        Delayed::Job.enqueue(self, :run_at => frequency.seconds.from_now)
+        retry_job(:wait => frequency.seconds)
       end
 
       private
 
-      def update_encoding_progress
-        job = Zencoder::Job.progress(@resource.encoding_job_id)
+      def update_encoding_progress(resource)
+        job = Zencoder::Job.progress(resource.encoding_job_id)
 
         case job.body["state"]
         when "finished"
-          job = Zencoder::Job.details(@resource.encoding_job_id)
+          job = Zencoder::Job.details(resource.encoding_job_id)
           f = job.body["job"]["output_media_files"][0]
-          @resource.update!(
+          resource.update!(
             :encoding_progress => 100,
             :width => f["width"],
             :height => f["height"],
             :duration => f["duration_in_ms"].to_f / 1000.0
           )
         when "processing", "waiting"
-          @resource.update!(
-            :encoding_progress => job.body["progress"].to_i
-          )
+          resource.update!(:encoding_progress => job.body["progress"].to_i)
         else
           fail(ArgumentError, "Unknown Zencoder job state #{job.body["state"]}")
         end

data/app/models/fogged/resource.rb

@@ -29,33 +29,36 @@ module Fogged
     end
 
     def url
-      storage = Fogged.resources
-      storage.service.try(
-        :request_url,
-        :bucket_name => storage.key,
-        :object_name => fogged_name
-      )
+      Fogged.file_public_url(fogged_name)
     end
 
     def h264_url
-      return unless video?
+      return unless video? && Fogged.zencoder_enabled
       url.gsub(fogged_name, fogged_name_for(:h264))
     end
 
     def mpeg_url
-      return unless video?
+      return unless video? && Fogged.zencoder_enabled
       url.gsub(fogged_name, fogged_name_for(:mpeg))
     end
 
     def webm_url
-      return unless video?
+      return unless video? && Fogged.zencoder_enabled
       url.gsub(fogged_name, fogged_name_for(:webm))
     end
 
     def thumbnail_urls
-      return unless video?
-      5.times.map do |n|
-        url.gsub(fogged_name, fogged_name_for(:thumbnails, n))
+      return unless Fogged.active_job_enabled
+
+      case
+      when video? && Fogged.zencoder_enabled
+        5.times.map do |n|
+          url.gsub(fogged_name, fogged_name_for(:thumbnails, n))
+        end
+      when image? && Fogged.minimagick_enabled
+        Fogged.thumbnail_sizes.size.times.map do |n|
+          url.gsub(fogged_name, fogged_name_for(:thumbnails, n))
+        end
       end
     end
 
@@ -68,13 +71,16 @@ module Fogged
     end
 
     def encoding?
-      return false unless video? && encoding_progress.present?
+      unless encoding_progress.present? &&
+             (video? || (image? && Fogged.active_job_enabled))
+        return
+      end
       encoding_progress < 100
     end
 
     def process!
       find_size! if image?
-      encode! if video?
+      encode!
     end
 
     def write(content)
@@ -82,28 +88,38 @@ module Fogged
       fogged_file.save
     end
 
-    private
+    def fogged_file
+      return @fogged_file if defined?(@fogged_file)
+
+      files = Fogged.resources.files
+      @fogged_file = files.get(fogged_name) || files.create(
+        :key => fogged_name,
+        :body => "",
+        :public => true,
+        :content_type => content_type
+      )
+    end
 
     def find_size!
       if Fogged.test_enabled
-        update!(
+        return update!(
           :width => 800,
           :height => 600
         )
-      else
-        size = FastImage.size(url)
-        update!(
-          :width => size.first,
-          :height => size.second
-        ) unless size.blank?
       end
+      size = FastImage.size(url)
+      update!(
+        :width => size.first,
+        :height => size.second
+      ) unless size.blank?
     end
 
     def encode!
-      return unless Fogged.zencoder_enabled
       Resources::Encoder.for(self).encode!
     end
 
+    private
+
     def ensure_token
       self.token = generate_token if token.blank?
     end
@@ -115,18 +131,6 @@ module Fogged
       end
     end
 
-    def fogged_file
-      return @fogged_file if defined?(@fogged_file)
-
-      files = Fogged.resources.files
-      @fogged_file = files.get(fogged_name) || files.create(
-        :key => fogged_name,
-        :body => "",
-        :public => true,
-        :content_type => content_type
-      )
-    end
-
     def fogged_name
       "#{token}.#{extension}"
     end

data/app/models/fogged/resources/aws_encoder.rb

@@ -2,27 +2,39 @@ module Fogged
   module Resources
     class AWSEncoder < Struct.new(:resource)
       def encode!
+        return unless Fogged.active_job_enabled
         encode_video if resource.video?
+        encode_image if resource.image?
       end
 
       private
 
-      def encode_video
-        fail(ArgumentError, "Zencoder gem needed") unless defined?(Zencoder)
-        fail(ArgumentError, "Delayed Job gem needed") unless defined?(Delayed::Job)
+      def encode_image
+        return unless Fogged.minimagick_enabled
+        AWSThumbnailJob.perform_later(resource)
+        resource.update!(:encoding_progress => 0)
+      end
 
+      def encode_video
+        return unless Fogged.zencoder_enabled
+        outputs = output
+        if Fogged.zencoder_additional_outputs_block
+          additional_outputs = Fogged.zencoder_additional_outputs_block.call(bucket, resource)
+          outputs << additional_outputs
+          outputs.flatten!
+        end
         job = Zencoder::Job.create(
           :input => resource.url,
           :region => "europe",
           :download_connections => 5,
-          :output => output
+          :output => outputs
         )
         resource.update!(
           :encoding_job_id => job.body["id"].to_s,
           :encoding_progress => 0
         )
 
-        Delayed::Job.enqueue(ZencoderPollJob.new(resource.id))
+        ZencoderPollJob.perform_later(resource)
       end
 
       def output
@@ -53,11 +65,11 @@ module Fogged
       end
 
       def bucket
-        resource.send(:fogged_file).directory.key
+        resource.fogged_file.directory.key
       end
 
-      def fogged_name_for(type)
-        resource.send(:fogged_name_for, type)
+      def fogged_name_for(type, number = 0)
+        resource.send(:fogged_name_for, type, number)
       end
     end
   end

data/app/models/fogged/resources/encoder.rb

@@ -6,7 +6,7 @@ module Fogged
       end
 
       def self.provider_for(resource)
-        return :AWS if resource.send(:fogged_file).class.to_s.include?("AWS")
+        return :AWS if resource.fogged_file.class.to_s.include?("AWS")
       end
     end
   end

data/lib/fogged.rb

@@ -3,86 +3,101 @@ Gem.loaded_specs["fogged"].dependencies.select { |d| d.type == :runtime }.each d
 end
 
 require "fogged/engine"
-require "fogged/acts_as_having_one_resource"
-require "fogged/acts_as_having_many_resources"
+require "fogged/has_one_resource"
+require "fogged/has_many_resources"
+require "fogged/with_directory"
+require "fogged/utils"
+require "fogged/zencoder_additional_outputs"
 
 module Fogged
-  mattr_accessor :provider
-  @@provider = nil
+  mattr_accessor :provider, :_resources, :storage
 
-  mattr_accessor :resources
-  @@resources = nil
-
-  mattr_accessor :test_enabled
-  @@test_enabled = false
+  mattr_accessor :test_enabled do
+    false
+  end
 
   # controller
-  mattr_accessor :parent_controller
-  @@parent_controller = "ApplicationController"
+  mattr_accessor :parent_controller do
+    "ApplicationController"
+  end
 
   # aws
-  mattr_accessor :aws_key
-  @@aws_key = nil
-  mattr_accessor :aws_secret
-  @@aws_secret = nil
-  mattr_accessor :aws_bucket
-  @@aws_bucket = nil
-  mattr_accessor :aws_region
-  @@aws_region = nil
+  mattr_accessor :aws_key, :aws_secret, :aws_bucket, :aws_region
 
   # zencoder
-  mattr_accessor :zencoder_enabled
-  @@zencoder_enabled = false
-  mattr_accessor :zencoder_polling_frequency
-  @@zencoder_polling_frequency = 10
+  mattr_accessor :zencoder_polling_frequency do
+    10
+  end
+
+  # thumbnail sizes
+  mattr_accessor :thumbnail_sizes do
+    []
+  end
+
+  # libs support
+  mattr_accessor :zencoder_enabled, :minimagick_enabled, :active_job_enabled do
+    false
+  end
 
   def self.configure
-    yield self
+    yield self if block_given?
+    check_config
+    self.zencoder_enabled = defined?(Zencoder)
+    self.minimagick_enabled = defined?(MiniMagick)
+    self.active_job_enabled = (Rails.application.config.active_job.queue_adapter != :inline)
   end
 
   def self.resources
-    return @@resources if @@resources
-    return @@resources = test_resources if Fogged.test_enabled
+    return Fogged._resources if Fogged._resources
 
     case Fogged.provider
     when :aws
-      Fogged.resources = aws_resources
+      Fogged._resources = aws_resources
     else
       fail(ArgumentError, "Provider #{Fogged.provider} is not available!")
     end
   end
 
   def self.test_mode!
-    self.test_enabled = true
+    Fogged.test_enabled = true
+    Fogged._resources = test_resources
   end
 
   private
 
   def self.test_resources
     Fog.mock!
-    storage = Fog::Storage.new(
+    Fogged.storage = Fog::Storage.new(
       :provider => "AWS",
       :aws_access_key_id => "XXX",
       :aws_secret_access_key => "XXX"
     )
-    @@aws_key = "XXX"
-    @@aws_secret = "XXX"
-    @@aws_bucket = "test"
-    storage.directories.create(:key => "test")
+    Fogged.aws_key = "XXX"
+    Fogged.aws_secret = "XXX"
+    Fogged.aws_bucket = "test"
+    Fogged.storage.directories.create(:key => "test")
   end
 
   def self.aws_resources
-    fail(ArgumentError, "AWS key is mandatory") unless Fogged.aws_key
-    fail(ArgumentError, "AWS secret is mandatory") unless Fogged.aws_secret
-    fail(ArgumentError, "AWS bucket is mandatory") unless Fogged.aws_bucket
     storage_options = {
       :provider => "AWS",
       :aws_access_key_id => Fogged.aws_key,
       :aws_secret_access_key => Fogged.aws_secret
     }
     storage_options.merge!(:region => Fogged.aws_region) if Fogged.aws_region
-    storage = Fog::Storage.new(storage_options)
+    Fogged.storage = Fog::Storage.new(storage_options)
 
-    storage.directories.get(Fogged.aws_bucket)
+    Fogged.storage.directories.get(Fogged.aws_bucket)
+  end
+
+  def self.check_config
+    case Fogged.provider
+    when :aws
+      fail(ArgumentError, "AWS key is mandatory") unless Fogged.aws_key
+      fail(ArgumentError, "AWS secret is mandatory") unless Fogged.aws_secret
+      fail(ArgumentError, "AWS bucket is mandatory") unless Fogged.aws_bucket
+    else
+      fail(ArgumentError, "Provider #{Fogged.provider} is not available!")
+    end
   end
 end

data/lib/fogged/engine.rb

@@ -2,11 +2,5 @@ module Fogged
   class Engine < ::Rails::Engine
     isolate_namespace Fogged
     config.fogged = Fogged
-
-    initializer "fogged.detect_zencoder" do
-      if defined?(Zencoder) && defined?(Delayed::Job)
-        Fogged.zencoder_enabled = true
-      end
-    end
   end
 end