gush 0.0.1

data/lib/gush/workflow.rb

@@ -0,0 +1,154 @@
+require 'securerandom'
+require 'gush/metadata'
+
+module Gush
+  class Workflow
+    include Gush::Metadata
+
+    attr_accessor :id, :nodes, :stopped
+
+    def initialize(id, options = {})
+      @id = id
+      @nodes = []
+      @dependencies = []
+      @logger_builder = default_logger_builder
+      @stopped = false
+
+      unless options[:configure] == false
+        configure
+        create_dependencies
+      end
+    end
+
+    def default_logger_builder
+      LoggerBuilder
+    end
+
+    def configure
+    end
+
+    def stop!
+      @stopped = true
+    end
+
+    def start!
+      @stopped = false
+    end
+
+    def logger_builder(klass)
+      @logger_builder = klass
+    end
+
+    def build_logger_for_job(job, jid)
+      @logger_builder.new(self, job, jid).build
+    end
+
+    def create_dependencies
+      @dependencies.each do |dependency|
+        from = find_job(dependency[:from])
+        to   = find_job(dependency[:to])
+
+        to.incoming << dependency[:from]
+        from.outgoing << dependency[:to]
+      end
+    end
+
+    def find_job(name)
+      @nodes.find { |node| node.name == name.to_s || node.class.to_s == name.to_s }
+    end
+
+    def finished?
+      nodes.all?(&:finished)
+    end
+
+    def running?
+      nodes.any? {|j| j.enqueued? || j.running? } && !stopped?
+    end
+
+    def failed?
+      nodes.any?(&:failed)
+    end
+
+    def stopped?
+      stopped
+    end
+
+    def run(klass, deps = {})
+      node = klass.new(name: klass.to_s)
+      @nodes << node
+
+      deps_after = [*deps[:after]]
+      deps_after.each do |dep|
+        @dependencies << {from: dep.to_s, to: klass.to_s }
+      end
+
+      deps_before = [*deps[:before]]
+      deps_before.each do |dep|
+        @dependencies << {from: klass.to_s, to: dep.to_s }
+      end
+    end
+
+    def status
+      case
+        when failed?
+          "Failed"
+        when running?
+          "Running"
+        when finished?
+          "Finished"
+        when stopped?
+          "Stopped"
+        else
+          "Pending"
+      end
+    end
+
+    def started_at
+      first_job ? first_job.started_at : nil
+    end
+
+    def finished_at
+      last_job ? last_job.finished_at : nil
+    end
+
+    def to_hash
+      name = self.class.to_s
+      {
+        name: name,
+        id: @id,
+        total: @nodes.count,
+        finished: @nodes.count(&:finished?),
+        klass: name,
+        nodes: @nodes.map(&:as_json),
+        status: status,
+        stopped: stopped,
+        started_at: started_at,
+        finished_at: finished_at,
+        logger_builder: @logger_builder.to_s
+      }
+    end
+
+    def to_json(options = {})
+      JSON.dump(to_hash)
+    end
+
+    def next_jobs
+      @nodes.select do |job|
+        job.can_be_started?(self)
+      end
+    end
+
+    def self.descendants
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
+
+    private
+    def first_job
+      nodes.min_by{ |n| n.started_at || Time.now.to_i }
+    end
+
+    def last_job
+      nodes.max_by{ |n| n.finished_at || 0 } if nodes.all?(&:finished?)
+    end
+  end
+end

data/spec/lib/gush/client_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Gush::Client do
+  describe "#find_workflow" do
+    context "when workflow doesn't exist" do
+      it "returns raises WorkflowNotFound" do
+        expect {
+          client.find_workflow('nope')
+        }.to raise_error(WorkflowNotFound)
+      end
+    end
+
+    context "when given workflow exists" do
+      it "returns Workflow object" do
+        expected_workflow = TestWorkflow.new(SecureRandom.uuid)
+        client.persist_workflow(expected_workflow)
+        workflow = client.find_workflow(expected_workflow.id)
+
+        expect(workflow.id).to eq(expected_workflow.id)
+        expect(workflow.nodes.map(&:name)).to match_array(expected_workflow.nodes.map(&:name))
+      end
+    end
+  end
+
+  describe "#start_workflow" do
+    it "enqueues next jobs from the workflow" do
+      id = SecureRandom.uuid
+      workflow = TestWorkflow.new(id)
+      client.persist_workflow(workflow)
+      expect {
+        client.start_workflow(id)
+      }.to change{Gush::Worker.jobs.count}.from(0).to(1)
+    end
+
+    it "removes stopped flag when the workflow is started" do
+      id = SecureRandom.uuid
+      workflow = TestWorkflow.new(id)
+      workflow.stop!
+      client.persist_workflow(workflow)
+      expect {
+        client.start_workflow(id)
+      }.to change{client.find_workflow(id).stopped?}.from(true).to(false)
+    end
+
+    it "marks the enqueued jobs as enqueued" do
+      id = SecureRandom.uuid
+      workflow = TestWorkflow.new(id)
+      client.persist_workflow(workflow)
+      client.start_workflow(id)
+      job = client.find_workflow(id).find_job("Prepare")
+      expect(job.enqueued?).to eq(true)
+    end
+  end
+
+  describe "#stop_workflow" do
+    it "marks the workflow as stopped" do
+      id = SecureRandom.uuid
+      workflow = TestWorkflow.new(id)
+      client.persist_workflow(workflow)
+      expect {
+        client.stop_workflow(id)
+      }.to change{client.find_workflow(id).stopped?}.from(false).to(true)
+    end
+  end
+
+  describe "#persist_workflow" do
+    it "persists JSON dump of the Workflow and its jobs" do
+      job = double("job", to_json: 'json')
+      workflow = double("workflow", id: 'abcd', nodes: [job, job, job], to_json: '"json"')
+      expect(client).to receive(:persist_job).exactly(3).times.with(workflow.id, job)
+      client.persist_workflow(workflow)
+      expect(redis.keys("gush.workflows.abcd").length).to eq(1)
+    end
+  end
+
+  describe "#destroy_workflow" do
+    it "removes all Redis keys related to the workflow" do
+      id = SecureRandom.uuid
+      workflow = TestWorkflow.new(id)
+      client.persist_workflow(workflow)
+      expect(redis.keys("gush.workflows.#{id}").length).to eq(1)
+      expect(redis.keys("gush.jobs.#{id}.*").length).to eq(5)
+
+      client.destroy_workflow(workflow)
+
+      expect(redis.keys("gush.workflows.#{id}").length).to eq(0)
+      expect(redis.keys("gush.jobs.#{id}.*").length).to eq(0)
+    end
+  end
+
+  describe "#persist_job" do
+    it "persists JSON dump of the job in Redis" do
+      job = double("job", to_json: 'json')
+      client.persist_job('deadbeef', job)
+      expect(redis.keys("gush.jobs.deadbeef.*").length).to eq(1)
+    end
+  end
+
+  describe "#all_workflows" do
+    it "returns all registered workflows" do
+      workflow = TestWorkflow.new(SecureRandom.uuid)
+      client.persist_workflow(workflow)
+      workflows = client.all_workflows
+      expect(workflows.map(&:id)).to eq([workflow.id])
+    end
+  end
+
+  it "should be able to handle outdated data format" do
+    workflow_id = SecureRandom.uuid
+    workflow = TestWorkflow.new(workflow_id)
+    client.persist_workflow(workflow)
+
+    # malform the data
+    hash = Yajl::Parser.parse(redis.get("gush.workflows.#{workflow_id}"), symbolize_keys: true)
+    hash.delete(:logger_builder)
+    hash.delete(:stopped)
+    redis.set("gush.workflows.#{workflow_id}", Yajl::Encoder.new.encode(hash))
+
+    expect {
+      workflow = client.find_workflow(workflow_id)
+      expect(workflow.stopped?).to be false
+      expect(workflow.instance_variable_get(:@logger_builder)).to be Gush::LoggerBuilder
+    }.not_to raise_error
+  end
+end

data/spec/lib/gush/configuration_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Gush::Configuration do
+
+  it "has defaults set" do
+    subject.gushfile = GUSHFILE
+    expect(subject.redis_url).to eq("redis://localhost:6379")
+    expect(subject.concurrency).to eq(5)
+    expect(subject.namespace).to eq('gush')
+    expect(subject.gushfile).to eq(GUSHFILE.realpath)
+    expect(subject.environment).to eq('development')
+  end
+
+  describe "#configure" do
+    it "allows setting options through a block" do
+      Gush.configure do |config|
+        config.redis_url = "redis://localhost"
+        config.concurrency = 25
+        config.environment = 'production'
+      end
+
+      expect(Gush.configuration.redis_url).to eq("redis://localhost")
+      expect(Gush.configuration.concurrency).to eq(25)
+      expect(Gush.configuration.environment).to eq('production')
+    end
+  end
+end

data/spec/lib/gush/job_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Gush::Job do
+
+  describe "#fail!" do
+    it "sets finished and failed to true and records time" do
+      job = described_class.new(name: "a-job")
+      job.fail!
+      expect(job.failed_at).to eq(Time.now.to_i)
+      expect(job.failed).to eq(true)
+      expect(job.finished).to eq(true)
+      expect(job.running).to eq(false)
+      expect(job.enqueued).to eq(false)
+    end
+  end
+
+  describe "#finish!" do
+    it "sets finished to false and failed to false and records time" do
+      job = described_class.new(name: "a-job")
+      job.finish!
+      expect(job.finished_at).to eq(Time.now.to_i)
+      expect(job.failed).to eq(false)
+      expect(job.running).to eq(false)
+      expect(job.finished).to eq(true)
+      expect(job.enqueued).to eq(false)
+    end
+  end
+
+  describe "#enqueue!" do
+    it "resets flags to false and sets enqueued to true" do
+      job = described_class.new(name: "a-job")
+      job.finished_at = 123
+      job.failed_at = 123
+      job.enqueue!
+      expect(job.started_at).to eq(nil)
+      expect(job.finished_at).to eq(nil)
+      expect(job.failed_at).to eq(nil)
+      expect(job.failed).to eq(false)
+      expect(job.finished).to eq(false)
+      expect(job.enqueued).to eq(true)
+      expect(job.running).to eq(false)
+    end
+  end
+
+  describe "#start!" do
+    it "resets flags to false and sets running to true" do
+      job = described_class.new(name: "a-job")
+      job.enqueue!
+      job.start!
+      expect(job.started_at).to eq(Time.now.to_i)
+      expect(job.enqueued).to eq(false)
+      expect(job.running).to eq(true)
+    end
+  end
+
+  describe "#as_json" do
+    context "finished and enqueued set to true" do
+      it "returns correct hash" do
+        job = described_class.new(name: "a-job", finished: true, enqueued: true)
+        expected = {
+          name: "a-job",
+          klass: "Gush::Job",
+          finished: true,
+          enqueued: true,
+          failed: false,
+          incoming: [],
+          outgoing: [],
+          failed_at: nil,
+          started_at: nil,
+          finished_at: nil,
+          running: false
+        }
+        expect(job.as_json).to eq(expected)
+      end
+    end
+  end
+
+  describe ".from_hash" do
+    it "properly restores state of the job from hash" do
+      job = described_class.from_hash({
+        klass: 'Gush::Job',
+        name: 'gob',
+        finished: true,
+        failed: true,
+        enqueued: true,
+        incoming: ['a', 'b'],
+        outgoing: ['c'],
+        failed_at: 123,
+        finished_at: 122,
+        started_at: 55
+      })
+
+      expect(job.name).to eq('gob')
+      expect(job.class).to eq(Gush::Job)
+      expect(job.finished).to eq(true)
+      expect(job.failed).to eq(true)
+      expect(job.enqueued).to eq(true)
+      expect(job.incoming).to eq(['a', 'b'])
+      expect(job.outgoing).to eq(['c'])
+      expect(job.failed_at).to eq(123)
+      expect(job.finished_at).to eq(122)
+      expect(job.started_at).to eq(55)
+    end
+  end
+
+  describe "#logger" do
+    it "returns a logger for the job" do
+      job = described_class.new(name: "a-job", finished: true, running: true)
+      job.logger = TestLoggerBuilder.new(:workflow, job, 1234).build
+      expect(job.logger).to be_a TestLogger
+      expect(job.logger.name).to eq(job.name)
+    end
+  end
+end

data/spec/lib/gush/logger_builder_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Gush::LoggerBuilder do
+  it 'takes a job as an argument' do
+    builder = Gush::LoggerBuilder.new(:workflow, :job, :jid)
+    expect(builder.job).to eq(:job)
+  end
+
+  it 'takes a workflow as an argument' do
+    builder = Gush::LoggerBuilder.new(:workflow, :job, :jid)
+    expect(builder.workflow).to eq(:workflow)
+  end
+
+  it 'takes a jid as an argument' do
+    builder = Gush::LoggerBuilder.new(:workflow, :job, :jid)
+    expect(builder.jid).to eq(:jid)
+  end
+
+  describe "#build" do
+    it 'returns a logger for a job' do
+      expect(Gush::LoggerBuilder.new(:workflow, :job, :jid).build).to be_a Gush::NullLogger
+    end
+  end
+end
+