lib/gush/job.rb in gush-0.0.1 vs lib/gush/job.rb in gush-0.1

@@ -1,161 +1,107 @@
-require 'gush/metadata'
-
 module Gush
   class Job
-    include Gush::Metadata
 
-    RECURSION_LIMIT = 1000
+    attr_accessor :workflow_id, :incoming, :outgoing,
+      :finished_at, :failed_at, :started_at, :enqueued_at
 
-    DEFAULTS = {
-      finished: false,
-      enqueued: false,
-      failed: false,
-      running: false
-    }
-
-    attr_accessor :finished, :enqueued, :failed, :workflow_id, :incoming, :outgoing,
-      :finished_at, :failed_at, :started_at, :jid, :running
-
     attr_reader :name
 
-    attr_writer :logger
-
-    def initialize(opts = {})
-      options = DEFAULTS.dup.merge(opts)
+    def initialize(workflow, opts = {})
+      @workflow = workflow
+      options = opts.dup
       assign_variables(options)
     end
 
     def as_json
       {
         name: @name,
         klass: self.class.to_s,
-        finished: @finished,
-        enqueued: @enqueued,
-        failed: @failed,
+        finished: finished?,
+        enqueued: enqueued?,
+        failed: failed?,
         incoming: @incoming,
         outgoing: @outgoing,
-        finished_at: @finished_at,
-        started_at: @started_at,
-        failed_at: @failed_at,
-        running: @running
+        finished_at: finished_at,
+        enqueued_at: enqueued_at,
+        started_at: started_at,
+        failed_at: failed_at,
+        running: running?
       }
     end
 
     def to_json(options = {})
-      Yajl::Encoder.new.encode(as_json)
+      Gush::JSON.encode(as_json)
     end
 
-    def self.from_hash(hash)
-      hash[:klass].constantize.new(
-        name:     hash[:name],
-        finished: hash[:finished],
-        enqueued: hash[:enqueued],
-        failed: hash[:failed],
-        incoming: hash[:incoming],
-        outgoing: hash[:outgoing],
-        failed_at: hash[:failed_at],
-        finished_at: hash[:finished_at],
-        started_at: hash[:started_at],
-        running: hash[:running]
-      )
+    def self.from_hash(flow, hash)
+      hash[:klass].constantize.new(flow, hash)
     end
 
-    def before_work
-    end
-
     def work
     end
 
-    def after_work
-    end
-
     def start!
-      @enqueued = false
-      @running = true
-      @started_at = Time.now.to_i
+      @started_at = current_timestamp
     end
 
     def enqueue!
-      @enqueued = true
-      @running = false
-      @failed = false
+      @enqueued_at = current_timestamp
       @started_at = nil
       @finished_at = nil
       @failed_at = nil
     end
 
     def finish!
-      @running = false
-      @finished = true
-      @enqueued = false
-      @failed = false
-      @finished_at = Time.now.to_i
+      @finished_at = current_timestamp
     end
 
     def fail!
-      @finished = true
-      @running = false
-      @failed = true
-      @enqueued = false
-      @finished_at = Time.now.to_i
-      @failed_at = Time.now.to_i
+      @finished_at = current_timestamp
+      @failed_at = current_timestamp
     end
 
     def enqueued?
-      !!enqueued
+      !!enqueued_at
     end
 
     def finished?
-      !!finished
+      !!finished_at
     end
 
     def failed?
-      !!failed
+      !!failed_at
     end
 
     def succeeded?
       finished? && !failed?
     end
 
     def running?
-      !!running
+      !!started_at && !finished?
     end
 
-    def can_be_started?(flow)
-      !running? &&
-        !enqueued? &&
-          !finished? &&
-            !failed? &&
-              dependencies_satisfied?(flow)
+    def ready_to_start?
+      !running? && !enqueued? && !finished? && !failed?
     end
 
-    def dependencies(flow, level = 0)
-      fail DependencyLevelTooDeep if level > RECURSION_LIMIT
-      (incoming.map {|name| flow.find_job(name) } + incoming.flat_map{ |name| flow.find_job(name).dependencies(flow, level + 1) }).uniq
+    def has_no_dependencies?
+      incoming.empty?
     end
 
-    def logger
-      fail "You cannot log when the job is not running" unless running?
-      @logger
-    end
-
     private
 
+    def current_timestamp
+      Time.now.to_i
+    end
+
     def assign_variables(options)
       @name        = options[:name]
-      @finished    = options[:finished]
-      @enqueued    = options[:enqueued]
-      @failed      = options[:failed]
       @incoming    = options[:incoming] || []
       @outgoing    = options[:outgoing] || []
       @failed_at   = options[:failed_at]
       @finished_at = options[:finished_at]
       @started_at  = options[:started_at]
-      @running     = options[:running]
-    end
-
-    def dependencies_satisfied?(flow)
-      dependencies(flow).all? { |dep| !dep.enqueued? && dep.finished? && !dep.failed? }
+      @enqueued_at = options[:enqueued_at]
     end
   end
 end