active_encode 0.1.1 → 0.2

data/lib/active_encode/engine.rb

@@ -0,0 +1,7 @@
+require 'rails'
+
+module ActiveEncode
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveEncode
+  end
+end

data/lib/active_encode/engine_adapter.rb

@@ -10,7 +10,7 @@ module ActiveEncode
 
     included do
       class_attribute :_engine_adapter, instance_accessor: false, instance_predicate: false
-      self.engine_adapter = :inline
+      self.engine_adapter = :test
     end
 
     # Includes the setter method for changing the active engine adapter.
@@ -38,7 +38,7 @@ module ActiveEncode
           end
         end
 
-        ENGINE_ADAPTER_METHODS = %i[create find list cancel purge remove_output].freeze
+        ENGINE_ADAPTER_METHODS = %i[create find cancel].freeze
 
         def engine_adapter?(object)
           ENGINE_ADAPTER_METHODS.all? { |meth| object.respond_to?(meth) }

data/lib/active_encode/engine_adapters/active_job_adapter.rb

@@ -1,13 +1,17 @@
 module ActiveEncode
   module EngineAdapters
     class ActiveJobAdapter
-      def create(_encode) end
+      def initialize
+        ActiveSupport::Deprecation.warn("The ActiveJobAdapter is deprecated and will be removed in ActiveEncode 0.3.")
+      end
 
-      def find(_id, _opts = {}) end
+      def create(_input_url, _options) end
+
+      def find(_id) end
 
       def list(*_filters) end
 
-      def cancel(_encode) end
+      def cancel(_id end
 
       def purge(_encode) end
 

data/lib/active_encode/engine_adapters/elastic_transcoder_adapter.rb

@@ -2,20 +2,20 @@ module ActiveEncode
   module EngineAdapters
     class ElasticTranscoderAdapter
       # TODO: add a stub for an input helper (supplied by an initializer) that transforms encode.input into a zencoder accepted url
-      def create(encode)
+      def create(input_url, options = {})
         job = client.create_job(
-          input: { key: encode.input },
-          pipeline_id: encode.options[:pipeline_id],
-          output_key_prefix: encode.options[:output_key_prefix],
-          outputs: encode.options[:outputs],
-          user_metadata: encode.options[:user_metadata]
+          input: { key: input_url },
+          pipeline_id: options[:pipeline_id],
+          output_key_prefix: options[:output_key_prefix],
+          outputs: options[:outputs],
+          user_metadata: options[:user_metadata]
         ).job
 
-        build_encode(get_job_details(job.id), encode.class)
+        build_encode(job)
       end
 
       def find(id, opts = {})
-        build_encode(get_job_details(id), opts[:cast])
+        build_encode(get_job_details(id))
       end
 
       # TODO: implement list_jobs_by_pipeline and list_jobs_by_status
@@ -24,9 +24,9 @@ module ActiveEncode
       end
 
       # Can only cancel jobs with status = "Submitted"
-      def cancel(encode)
-        response = client.cancel_job(id: encode.id)
-        build_encode(get_job_details(encode.id), encode.class) if response.successful?
+      def cancel(id)
+        response = client.cancel_job(id: id)
+        build_encode(get_job_details(id)) if response.successful?
       end
 
       def purge(_encode)
@@ -48,9 +48,9 @@ module ActiveEncode
           client.read_job(id: job_id).job
         end
 
-        def build_encode(job, cast)
+        def build_encode(job)
           return nil if job.nil?
-          encode = cast.new(convert_input(job), convert_options(job))
+          encode = ActiveEncode::Base.new(convert_input(job), convert_options(job))
           encode.id = job.id
           encode.state = convert_state(job)
           encode.current_operations = convert_current_operations(job)
@@ -66,7 +66,7 @@ module ActiveEncode
 
         def convert_time(time_millis)
           return nil if time_millis.nil?
-          Time.at(time_millis / 1000).iso8601
+          Time.at(time_millis / 1000)
         end
 
         def convert_state(job)
@@ -91,7 +91,7 @@ module ActiveEncode
           case job.status
           when "Submitted"
             10
-          when "Progressing"
+          when "Progressing", "Canceled", "Error"
             50
           when "Complete"
             100

data/lib/active_encode/engine_adapters/inline_adapter.rb

@@ -4,7 +4,12 @@ module ActiveEncode
       class_attribute :encodes, instance_accessor: false, instance_predicate: false
       InlineAdapter.encodes ||= {}
 
-      def create(encode)
+      def initialize
+        ActiveSupport::Deprecation.warn("The InlineAdapter is deprecated and will be removed in ActiveEncode 0.3.")
+      end
+
+      def create(input_url, options = {})
+        encode = ActiveEncode::Base.new(input_url, options)
         encode.id = SecureRandom.uuid
         self.class.encodes[encode.id] = encode
         # start encode

data/lib/active_encode/engine_adapters/matterhorn_adapter.rb

@@ -5,27 +5,27 @@ module ActiveEncode
     class MatterhornAdapter
       DEFAULT_ARGS = { 'flavor' => 'presenter/source' }.freeze
 
-      def create(encode)
-        workflow_id = encode.options[:preset] || "full"
-        workflow_om = if encode.input.is_a? Hash
-                        create_multiple_files(encode.input, workflow_id)
-                      else
-                        Rubyhorn.client.addMediaPackageWithUrl(DEFAULT_ARGS.merge('workflow' => workflow_id, 'url' => encode.input, 'filename' => File.basename(encode.input), 'title' => File.basename(encode.input)))
-                      end
-        build_encode(get_workflow(workflow_om), encode.class)
+      def create(input_url, options = {})
+        workflow_id = options[:preset] || "full"
+        # workflow_om = if encode.input.is_a? Hash
+        #                 create_multiple_files(encode.input, workflow_id)
+        #               else
+                        workflow_om = Rubyhorn.client.addMediaPackageWithUrl(DEFAULT_ARGS.merge('workflow' => workflow_id, 'url' => input_url, 'filename' => File.basename(input_url), 'title' => File.basename(input_url)))
+                      # end
+        build_encode(get_workflow(workflow_om))
       end
 
       def find(id, opts = {})
-        build_encode(fetch_workflow(id), opts[:cast])
+        build_encode(fetch_workflow(id))
       end
 
       def list(*_filters)
         raise NotImplementedError # TODO: implement this
       end
 
-      def cancel(encode)
-        workflow_om = Rubyhorn.client.stop(encode.id)
-        build_encode(get_workflow(workflow_om), encode.class)
+      def cancel(id)
+        workflow_om = Rubyhorn.client.stop(id)
+        build_encode(get_workflow(workflow_om))
       end
 
       def purge(encode)
@@ -41,7 +41,7 @@ module ActiveEncode
                         end
         purged_workflow = purge_outputs(get_workflow(workflow_om))
         # Rubyhorn.client.delete_instance(encode.id) #Delete is not working so workflow instances can always be retrieved later!
-        build_encode(purged_workflow, encode.class)
+        build_encode(purged_workflow)
       end
 
       def remove_output(encode, output_id)
@@ -79,9 +79,9 @@ module ActiveEncode
           end
         end
 
-        def build_encode(workflow, cast)
+        def build_encode(workflow)
           return nil if workflow.nil?
-          encode = cast.new(convert_input(workflow), convert_options(workflow))
+          encode = ActiveEncode::Base.new(convert_input(workflow), convert_options(workflow))
           encode.id = convert_id(workflow)
           encode.state = convert_state(workflow)
           encode.current_operations = convert_current_operations(workflow)
@@ -146,17 +146,17 @@ module ActiveEncode
 
         def convert_created_at(workflow)
           created_at = workflow.xpath('mediapackage/@start').last.to_s
-          created_at.present? ? Time.parse(created_at).iso8601 : nil
+          created_at.present? ? Time.parse(created_at) : nil
         end
 
         def convert_updated_at(workflow)
           updated_at = workflow.xpath('//operation[@state!="INSTANTIATED"]/completed/text()').last.to_s
-          updated_at.present? ? Time.strptime(updated_at, "%Q").utc.iso8601 : nil
+          updated_at.present? ? Time.strptime(updated_at, "%Q") : nil
         end
 
         def convert_finished_at(workflow)
           finished_at = workflow.xpath('//operation[@state!="INSTANTIATED"]/completed/text()').last.to_s
-          finished_at.present? ? Time.strptime(finished_at, "%Q").utc.iso8601 : nil
+          finished_at.present? ? Time.strptime(finished_at, "%Q") : nil
         end
 
         def convert_options(workflow)

data/lib/active_encode/engine_adapters/shingoncoder_adapter.rb

@@ -4,23 +4,27 @@ require 'active_support/core_ext'
 module ActiveEncode
   module EngineAdapters
     class ShingoncoderAdapter < ZencoderAdapter
+      def initialize
+        ActiveSupport::Deprecation.warn("The ShingoncoderAdapter is deprecated and will be removed in ActiveEncode 0.3.")
+      end
+
       # @param [ActiveEncode::Base] encode
-      def create(encode)
-        response = Shingoncoder::Job.create(input: encode.input)
-        build_encode(job_details(response.body["id"]), encode.class)
+      def create(input_url, options = {})
+        response = Shingoncoder::Job.create(input: input_url)
+        build_encode(job_details(response.body["id"]))
       end
 
       # @param [Fixnum] id
       # @param [Hash] opts
       # @option opts :cast the class to cast the encoding job to.
       def find(id, opts = {})
-        build_encode(job_details(id), opts[:cast])
+        build_encode(job_details(id))
       end
 
       # @param [ActiveEncode::Base] encode
-      def cancel(encode)
-        response = Shingoncoder::Job.cancel(encode.id)
-        build_encode(job_details(encode.id), encode.class) if response.success?
+      def cancel(id)
+        response = Shingoncoder::Job.cancel(id)
+        build_encode(job_details(id)) if response.success?
       end
 
       private
@@ -38,9 +42,9 @@ module ActiveEncode
 
         # @param [Shingoncoder::Response] job_details
         # @param [Class] cast the class of object to instantiate and return
-        def build_encode(job_details, cast)
+        def build_encode(job_details)
           return nil if job_details.nil?
-          encode = cast.new(convert_input(job_details), convert_options(job_details))
+          encode = ActiveEncode::Base.new(convert_input(job_details), convert_options(job_details))
           encode.id = job_details.body["job"]["id"].to_s
           encode.state = convert_state(job_details)
           progress = job_progress(encode.id)

data/lib/active_encode/engine_adapters/test_adapter.rb

@@ -5,25 +5,32 @@ module ActiveEncode
         @encodes = {}
       end
 
-      def create(encode)
-        encode.id = SecureRandom.uuid
-        @encodes[encode.id] = encode
-        encode.state = :running
-        encode
+      def create(input_url, options = {})
+        new_encode = ActiveEncode::Base.new(input_url, options)
+        new_encode.id = SecureRandom.uuid
+        new_encode.state = :running
+        new_encode.created_at = Time.now
+        new_encode.updated_at = Time.now
+        @encodes[new_encode.id] = new_encode
+        new_encode
       end
 
       def find(id, _opts = {})
-        @encodes[id]
+        new_encode = @encodes[id]
+        # Update the updated_at time to simulate changes
+        new_encode.updated_at = Time.now
+        new_encode
       end
 
-      def list(*_filters)
-        raise NotImplementedError
+      def cancel(id)
+        new_encode = @encodes[id]
+        new_encode.state = :cancelled
+        new_encode.updated_at = Time.now
+        new_encode
       end
 
-      def cancel(encode)
-        e = @encodes[encode.id]
-        e.state = :cancelled
-        e
+      def list(*_filters)
+        raise NotImplementedError
       end
 
       def purge(encode)

data/lib/active_encode/engine_adapters/zencoder_adapter.rb

@@ -1,23 +1,23 @@
 module ActiveEncode
   module EngineAdapters
     class ZencoderAdapter
-      # TODO: add a stub for an input helper (supplied by an initializer) that transforms encode.input into a zencoder accepted url
-      def create(encode)
-        response = Zencoder::Job.create(input: encode.input.to_s)
-        build_encode(get_job_details(response.body["id"]), encode.class)
+      # TODO: add a stub for an input helper (supplied by an initializer) that transforms encode.input.url into a zencoder accepted url
+      def create(input_url, options = {})
+        response = Zencoder::Job.create(input: input_url.to_s)
+        build_encode(get_job_details(response.body["id"]))
       end
 
       def find(id, opts = {})
-        build_encode(get_job_details(id), opts[:cast])
+        build_encode(get_job_details(id))
       end
 
       def list(*_filters)
         raise NotImplementedError
       end
 
-      def cancel(encode)
-        response = Zencoder::Job.cancel(encode.id)
-        build_encode(get_job_details(encode.id), encode.class) if response.success?
+      def cancel(id)
+        response = Zencoder::Job.cancel(id)
+        build_encode(get_job_details(id)) if response.success?
       end
 
       def purge(_encode)
@@ -38,9 +38,9 @@ module ActiveEncode
           Zencoder::Job.progress(job_id)
         end
 
-        def build_encode(job_details, cast)
+        def build_encode(job_details)
           return nil if job_details.nil?
-          encode = cast.new(convert_input(job_details), convert_options(job_details))
+          encode = ActiveEncode::Base.new(convert_input(job_details), convert_options(job_details))
           encode.id = job_details.body["job"]["id"].to_s
           encode.state = convert_state(job_details)
           job_progress = get_job_progress(encode.id)

data/lib/active_encode/global_id.rb

@@ -0,0 +1,16 @@
+require 'globalid'
+
+module ActiveEncode
+  module GlobalID
+    extend ActiveSupport::Concern
+    include ::GlobalID::Identification
+
+    def ==(other)
+      other.is_a?(ActiveEncode::Base) && to_global_id == other.to_global_id
+    end
+
+    def to_global_id(options = {})
+      super(app: 'ActiveEncode')
+    end
+  end
+end

data/lib/active_encode/input.rb

@@ -0,0 +1,9 @@
+module ActiveEncode
+  class Input
+    include Status
+    include TechnicalMetadata
+
+    attr_accessor :id
+    attr_accessor :url
+  end
+end

data/lib/active_encode/output.rb

@@ -0,0 +1,9 @@
+module ActiveEncode
+  class Output
+    include Status
+    include TechnicalMetadata
+
+    attr_accessor :id
+    attr_accessor :url
+  end
+end

data/lib/active_encode/persistence.rb

@@ -0,0 +1,45 @@
+require 'active_support'
+
+module ActiveEncode
+  module Persistence
+    extend ActiveSupport::Concern
+
+    included do
+      after_find do |encode|
+        persist(persistence_model_attributes(encode))
+      end
+
+      after_create do |encode|
+        persist(persistence_model_attributes(encode))
+      end
+
+      after_cancel do |encode|
+        persist(persistence_model_attributes(encode))
+      end
+
+      after_reload do |encode|
+        persist(persistence_model_attributes(encode))
+      end
+    end
+
+    private
+
+      def persist(encode_attributes)
+        model = ActiveEncode::EncodeRecord.find_or_initialize_by(global_id: encode_attributes[:global_id])
+        model.update(encode_attributes) # Don't fail if persisting doesn't succeed?
+      end
+
+      def persistence_model_attributes(encode)
+        {
+          global_id: encode.to_global_id.to_s,
+          state: encode.state,
+          adapter: encode.class.engine_adapter.class.name,
+          title: encode.input.url.to_s,
+          # FIXME: Need to ensure that these values come through or else validations will fail
+          created_at: encode.created_at,
+          updated_at: encode.updated_at,
+          raw_object: encode.to_json
+        }
+      end
+  end
+end

data/lib/active_encode/polling.rb

@@ -0,0 +1,24 @@
+require 'active_support'
+require 'active_model/callbacks'
+
+module ActiveEncode
+  module Polling
+    extend ActiveSupport::Concern
+
+    POLLING_WAIT_TIME = 10.seconds.freeze
+
+    CALLBACKS = [
+        :after_status_update, :after_error, :after_cancelled, :after_complete
+    ].freeze
+
+    included do
+      extend ActiveModel::Callbacks
+
+      define_model_callbacks :status_update, :error, :cancelled, :complete, only: :after
+
+      after_create do |encode|
+        ActiveEncode::PollingJob.set(wait: POLLING_WAIT_TIME).perform_later(encode)
+      end
+    end
+  end
+end