pd-blender 0.0.1

data/lib/blender/utils/ui.rb

@@ -0,0 +1,51 @@
+#
+# Author:: Ranjib Dey (<ranjib@pagerduty.com>)
+# Copyright:: Copyright (c) 2014 PagerDuty, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'highline'
+
+module Blender
+  module Utils
+    class UI
+      def initialize
+        @mutex = Mutex.new
+        @highline = HighLine.new
+      end
+      def puts(string)
+        @mutex.synchronize do
+          $stdout.puts(string)
+        end
+      end
+
+      def puts_red(string)
+        puts(color(string, :red))
+      end
+
+      def puts_cyan(string)
+        puts(color(string, :cyan))
+      end
+
+      def puts_green(string)
+        puts(color(string, :green))
+      end
+
+      def color(string, *colors)
+        @highline.color(string, *colors)
+      end
+      
+    end
+  end
+end

data/lib/blender/version.rb

@@ -0,0 +1,20 @@
+#
+# Author:: Ranjib Dey (<ranjib@pagerduty.com>)
+# Copyright:: Copyright (c) 2014 PagerDuty, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Blender
+  VERSION = '0.0.1'
+end

data/spec/blender/blender_rspec.rb

@@ -0,0 +1,31 @@
+#
+# Author:: Ranjib Dey (<ranjib@pagerduty.com>)
+# Copyright:: Copyright (c) 2014 PagerDuty, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'blender/rspec'
+require 'rspec'
+require 'rspec/mocks'
+require 'rspec/expectations'
+require 'blender'
+
+describe Blender::RSpec do
+  let(:scheduler) do
+    noop_scheduler_from_file(File.expand_path('../../data/example.rb', __FILE__))
+  end
+  it 'should have 3 tasks' do
+    expect(scheduler.tasks.size).to eq(2)
+  end
+end

data/spec/blender/discovery_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'blender/discovery'
+describe Blender::Scheduler do
+
+  let(:scheduler) do
+    Blender::Scheduler.new('test')
+  end
+
+  it 'should return Chef is type :chef is passed' do
+    class Blender::Discovery::Foo;end
+    disco = double(Blender::Discovery::Foo)
+    allow(disco).to receive(:search).with('name:xx').and_return(['a', 'b', 'c'])
+    allow(Blender::Discovery::Foo).to receive(:new).and_return(disco)
+    expect(scheduler.search(:foo, 'name:xx')).to eq(['a', 'b', 'c'])
+  end
+end

data/spec/blender/drivers/ssh_multi_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Blender::Driver::SshMulti do
+  let(:driver) {described_class.new(events: Object.new, concurrency: 10)}
+  let(:job) do
+    Blender::Job.new(
+      101,
+      nil,
+      %w{h1 h2 h3 h4 h5},
+      Array.new(1){|n| create_task("t#{n}")}
+    )
+  end
+  it '#concurrency' do
+    expect(driver.concurrency).to eq(10)
+  end
+end

data/spec/blender/drivers/ssh_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Blender::Driver::Ssh do
+  let(:hosts) {['h1']}
+  let(:tasks){ Array.new(3){|n| create_task("t#{n}")}}
+  let(:driver) {described_class.new(events: Object.new)}
+  it 'should execute commands over net ssh channel' do
+    channel = double('channel').as_null_object
+    session = double('session', open_channel: channel, loop: true)
+    expect(Net::SSH).to receive(:start).with(
+      'h1',
+      ENV['USER'],
+      {}
+    ).and_return(session)
+    driver.execute(tasks, hosts)
+  end
+end

data/spec/blender/dsl_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe '#dsl' do
+  let(:scheduler) do
+    sched = Blender::Scheduler.new('test')
+    sched.instance_eval do
+      ssh_task 'run' do
+        execute 'sudo /usr/local/sbin/chef-client-cron'
+        members ['a']
+      end
+    end
+    sched
+  end
+
+  it '#check DSL' do
+    allow_any_instance_of(Blender::Driver::Ssh).to receive(:execute)
+    scheduler.run
+  end
+end

data/spec/blender/event_dispatcher_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Blender::EventDispatcher do
+  let(:dispatcher) do
+    described_class.new
+  end
+  subject(:handler){ Object.new}
+  it '#register' do
+    dispatcher.register(handler)
+    expect(dispatcher.handlers).to include(handler)
+  end
+  it 'should forward all methods to the registered handlers' do
+    dispatcher.register(handler)
+    expect(handler).to receive(:run_started)
+    dispatcher.run_started
+  end
+end

data/spec/blender/job_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Blender::Job do
+  let(:driver) do
+    Object.new
+  end
+  it '#should use default driver if no tasks are given' do
+    job = Blender::Job.new(1, driver , [] ,[])
+    expect(job.driver).to eq(driver)
+  end
+  describe '#name' do
+    it 'with one host, one task' do
+      t1 = create_task('t1', driver)
+      job = Blender::Job.new(1, Object.new, [t1], ['a'])
+      expect(job.name).to eq('t1 on a')
+    end
+    it 'with one host, many tasks' do
+      t1 = create_task('t1', driver)
+      t2 = create_task('t2', driver)
+      job = Blender::Job.new(1, Object.new,[t1, t2], ['a'])
+      expect(job.name).to eq('2 tasks on a')
+    end
+    it 'with 0 hosts, many tasks' do
+      t1 = create_task('t1', driver)
+      t2 = create_task('t2', driver)
+      t3 = create_task('t3', driver)
+      job = Blender::Job.new(1, Object.new, [t1, t2, t3], [])
+      expect(job.name).to eq('3 tasks on 0 members')
+    end
+    it 'with many hosts, many tasks' do
+      t1 = create_task('t1', driver)
+      t2 = create_task('t2', driver)
+      job = Blender::Job.new(1, Object.new, [t1, t2], ['a', 'b', 'c'])
+      expect(job.name).to eq('2 tasks on 3 members')
+    end
+    it 'with many hosts one task' do
+      t1 = create_task('t1', driver)
+      job = Blender::Job.new(1, Object.new, [t1], ['a', 'b', 'c'])
+      expect(job.name).to eq('t1 on 3 members')
+    end
+  end
+end

data/spec/blender/lock_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Blender::Lock do
+
+  it 'should not allow two blender run with same name to run at the same time' do
+
+    pid1 = fork do
+      Blender.blend('test-1') do |sched|
+        sched.members(['localhost'])
+        sched.ruby_task('date') do
+          execute do
+            sleep 5
+            puts 'This will succeed'
+          end
+        end
+      end
+    end
+
+    pid2 = fork do
+      STDERR.reopen(File::NULL)
+      Blender.blend('test-1') do |sched|
+        sched.members(['localhost'])
+        sched.ruby_task('date') do
+          execute do
+            puts 'This will fail'
+          end
+        end
+      end
+    end
+    status1 = Process.wait2 pid1
+    status2 = Process.wait2 pid2
+    expect(status1.last.exitstatus).to eq(0)
+    expect(status2.last.exitstatus).to_not eq(0)
+  end
+
+  it 'should allow two blender run with different name to run at the same time' do
+    pid1 = fork do
+      Blender.blend('test-1') do |sched|
+        sched.members(['localhost'])
+        sched.ruby_task('date') do
+          execute do
+            sleep 5
+            puts 'This will succeed'
+          end
+        end
+      end
+    end
+
+    pid2 = fork do
+      Blender.blend('test-2') do |sched|
+        sched.members(['localhost'])
+        sched.ruby_task('date') do
+          execute do
+            puts 'This will succeed'
+          end
+        end
+      end
+    end
+    status1 = Process.wait2 pid1
+    status2 = Process.wait2 pid2
+    expect(status1.last.exitstatus).to eq(0)
+    expect(status2.last.exitstatus).to eq(0)
+  end
+
+  context 'File based locking with timeout' do
+
+    it 'should raise lock acquisition error when times out' do
+      pid1 = fork do
+        Blender.blend('test-1') do |sched|
+          sched.members(['localhost'])
+          sched.ruby_task('date') do
+            execute do
+              sleep 5
+              puts 'This will succeed'
+            end
+          end
+        end
+      end
+
+      pid2 = fork do
+        STDERR.reopen(File::NULL)
+        Blender.blend('test-1') do |sched|
+          sched.members(['localhost'])
+          sched.lock_options('flock', timeout: 3)
+          sched.ruby_task('date') do
+            execute do
+              puts 'This will fail'
+            end
+          end
+        end
+      end
+      status1 = Process.wait2 pid1
+      status2 = Process.wait2 pid2
+      expect(status1.last.exitstatus).to eq(0)
+      expect(status2.last.exitstatus).to_not eq(0)
+    end
+
+    it 'should not raise lock acquisition error when  able to acquire lock within timeout period' do
+      pid1 = fork do
+        Blender.blend('test-1') do |sched|
+          sched.members(['localhost'])
+          sched.ruby_task('date') do
+            execute do
+              sleep 5
+              puts 'This will succeed'
+            end
+          end
+        end
+      end
+
+      pid2 = fork do
+        STDERR.reopen(File::NULL)
+        Blender.blend('test-1') do |sched|
+          sched.members(['localhost'])
+          sched.lock_options('flock', timeout: 3)
+          sched.ruby_task('date') do
+            execute do
+              puts 'This will fail'
+            end
+          end
+        end
+      end
+      status1 = Process.wait2 pid1
+      status2 = Process.wait2 pid2
+      expect(status1.last.exitstatus).to eq(0)
+      expect(status2.last.exitstatus).to_not eq(0)
+    end
+  end
+end

data/spec/blender/scheduled_job_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'blender/scheduled_job'
+
+describe Blender::ScheduledJob do
+  let(:scheduled_job) do
+    Blender::ScheduledJob.new('test job')
+  end
+  it '#blender_file' do
+    scheduled_job.blender_file('test.rb')
+    expect(scheduled_job.file).to eq('test.rb')
+  end
+  it '#cron' do
+    time = '*/4 * * * *'
+    scheduled_job.cron(time)
+    expect(scheduled_job.schedule).to eq([:cron, time])
+  end
+  it '#every' do
+    scheduled_job.every(15)
+    expect(scheduled_job.schedule).to eq([:every, 15])
+  end
+  it '#run' do
+    scheduled_job.blender_file('test.rb')
+    scheduled_job.every(15)
+    sched = double(Blender::Scheduler)
+    expect(sched).to receive(:task).with('x')
+    expect(File).to receive(:read).with('test.rb').and_return('task "x"')
+    expect(Blender).to receive(:blend).with('test.rb').and_yield(sched)
+    scheduled_job.run
+  end
+end

data/spec/blender/scheduler_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe Blender::Scheduler do
+  let(:scheduler) do
+    described_class.new('test')
+  end
+  describe '#DSL' do
+    subject(:task){scheduler.tasks.first}
+    it '#ask' do
+      tui = double(HighLine)
+      allow(HighLine).to receive(:new).and_return(tui)
+      expect(tui).to receive(:ask).with('foo')
+      scheduler.ask('foo')
+    end
+    it '#register_handler' do
+      handler = Object.new
+      scheduler.register_handler(handler)
+      expect(scheduler.events.handlers).to include(handler)
+    end
+    describe '#task' do
+      before do
+        scheduler.task('whoa')
+      end
+      it 'should belong to base class' do
+        expect(task).to be_kind_of(Blender::Task::Base)
+      end
+      it 'should use shellout driver' do
+        expect(task.driver).to be_kind_of(Blender::Driver::ShellOut)
+      end
+      it 'should contain only one task' do
+        expect(scheduler.tasks.size).to eq(1)
+      end
+    end
+    describe '#ssh_task' do
+      before do
+        scheduler.ssh_task('test') do
+          members ['a']
+          execute('ls -l')
+        end
+      end
+      it 'should have correct hosts list' do
+        expect(task.hosts).to eq(['a'])
+      end
+      it 'should have correct command' do
+        expect(task.command).to eq('ls -l')
+      end
+      it 'should use ssh task subclass' do
+        expect(task).to be_kind_of(Blender::Task::Ssh)
+      end
+      it 'should use the ssh driver' do
+        expect(task.driver).to be_kind_of(Blender::Driver::Ssh)
+      end
+    end
+    describe '#on' do
+      it 'should invoke custom block on specific events' do
+        test = 1
+        Blender.blend('do it') do |sched|
+          sched.on :run_finished do |x|
+            test = 2
+          end
+          sched.task 'ls -alh'
+        end
+        expect(test).to eq(2)
+      end
+    end
+    describe '#ruby_task' do
+      before do
+        scheduler.ruby_task('test') do |t|
+          t.members ['c']
+          t.execute do
+            raise 'Fail'
+          end
+        end
+      end
+      it 'should setup correct hosts' do
+        expect(task.hosts).to eq(['c'])
+      end
+      it 'should use the ruby task subclass' do
+        expect(task).to be_kind_of(Blender::Task::Base)
+      end
+      it 'should assign the proc as command' do
+        expect(task.command).to be_kind_of(Proc)
+      end
+      it 'should the ruby driver subclass' do
+        expect(task.driver).to be_kind_of(Blender::Driver::Ruby)
+      end
+    end
+    describe '#strategy' do
+      it '#should raise error for non-existent strategy' do
+        expect do
+          scheduler.strategy(:foo)
+        end.to raise_error(Blender::UnknownSchedulingStrategy)
+      end
+      it '#get default' do
+        expect(scheduler.strategy(:default)).to be_kind_of(Blender::SchedulingStrategy::Default)
+      end
+      it '#get per_host' do
+        expect(scheduler.strategy(:per_host)).to be_kind_of(Blender::SchedulingStrategy::PerHost)
+      end
+    end
+    it '#concurrency' do
+      scheduler.concurrency(112)
+      expect(scheduler.metadata[:concurrency]).to be(112)
+    end
+    it '#ignore_failure' do
+      scheduler.ignore_failure true
+      expect(scheduler.metadata[:ignore_failure]).to be(true)
+    end
+    it '#members' do
+      scheduler.members(['a', 'b'])
+      expect(scheduler.metadata[:members]).to eq(['a', 'b'])
+    end
+    it '#driver' do
+      d = scheduler.driver(:ssh, foo: :bar)
+      expect(d).to be_kind_of(Blender::Driver::Ssh)
+      expect(d.config[:foo]).to be(:bar)
+    end
+    it 'should have no tasks' do
+      expect(scheduler.tasks).to be_empty
+    end
+    it 'should have no hosts' do
+      expect(scheduler.metadata[:members]).to be_empty
+    end
+    describe '#run' do
+      it 'should use serial_run when concurrency is not set' do
+        expect(scheduler).to receive(:serial_run)
+        scheduler.task 'echo HelloWorld'
+        scheduler.run
+      end
+      it 'should use concurrent_run when concurrency is used' do
+        expect(scheduler).to receive(:concurrent_run)
+        scheduler.task 'echo HelloWorld1'
+        scheduler.task 'echo HelloWorld2'
+        scheduler.task 'echo HelloWorld3'
+        scheduler.concurrency(2)
+        scheduler.run
+      end
+    end
+  end
+end