izanami 0.14.0

data/spec/izanami/app_spec.rb

@@ -0,0 +1,195 @@
+require_relative '../helper'
+require 'izanami/app'
+
+describe Izanami::App do
+  include Rack::Test::Methods
+
+  def app
+    Izanami::App
+  end
+
+  def worker
+    fork { yield }
+  end
+
+  # Simulate Worker::Command
+  def publish(redis_url, id)
+    redis = Redis.new(url: redis_url)
+
+    # wait for a subscriber to connect to a channel
+    loop do
+      subscribers = redis.info['pubsub_channels']
+      break if subscribers != '0'
+    end
+
+    key     = "izanami:commands:#{id}"
+    channel = "izanami:commands:#{id}:channel"
+    output  = 'PONG'
+    status  = 'success'
+
+    redis.publish channel, output
+    redis.multi do
+      redis.publish channel, '--EOC--'
+      redis.hset key, 'status', status
+      redis.hset key, 'output', output
+    end
+  end
+
+  def save_commands(redis, commands)
+    commands.each do |command|
+      # set all the values in redis in one step
+      redis.hmset "izanami:commands:#{command['id']}", *command.to_a.flatten
+      redis.sadd "izanami:commands:ids", command['id']
+    end
+  end
+
+  let!(:redis_url) { ENV['IZANAMI_REDIS_URL'] }
+  let(:redis) { Redis.new(url: redis_url) }
+
+  let(:command_a) do
+    {
+      'tasks'  => 'ping',
+      'id'     => '20130816101418',
+      'output' => 'PONG',
+      'status' => 'success',
+    }
+  end
+  let(:command_b) do
+    {
+      'tasks'  => 'ping2',
+      'id'     => '20130815121400',
+      'output' => 'PONG2',
+      'status' => 'fail',
+    }
+  end
+
+  let(:commands) { [command_a, command_b] }
+  let(:user)     { ENV['IZANAMI_USER'] }
+  let(:password) { ENV['IZANAMI_PASSWORD'] }
+
+  before { authorize(user, password) }
+
+  after { redis.flushdb }
+
+  describe 'GET /' do
+    context 'when there are no command logs' do
+      before { redis.flushdb }
+
+      it 'shows the homepage' do
+        get '/'
+
+        last_response.should be_ok
+        last_response.body.should include('Command history')
+      end
+    end
+
+    context 'when there are command logs' do
+      before { save_commands(redis, commands) }
+
+      it 'shows the homepage with the commands' do
+        get '/'
+
+        last_response.should be_ok
+        last_response.body.should include('Command history')
+        commands.each do |command|
+          last_response.body.should include(command['id'])
+          last_response.body.should include(command['tasks'])
+        end
+      end
+    end
+  end
+
+  describe 'GET /commands' do
+    it 'redirects to home page' do
+      get '/commands'
+
+      last_response.should be_redirect
+      last_response.original_headers['Location'].should == 'http://example.org/'
+    end
+  end
+
+  describe 'DELETE /commands' do
+    before { save_commands(redis, commands) }
+
+    it 'removes all commands' do
+      delete '/commands'
+      last_response.should be_redirect
+
+      follow_redirect!
+
+      last_response.should be_ok
+      last_response.body.should include('Command history')
+      commands.each do |command|
+        last_response.body.should_not include(command['id'])
+        last_response.body.should_not include(command['tasks'])
+      end
+    end
+  end
+
+  describe 'POST /commands' do
+    before do
+      # we don't want to `defer` any worker here.
+      Process.should_receive(:fork).and_return(123)
+    end
+
+    it 'performs the commands' do
+      post '/commands', 'tasks' => 'ping'
+      last_response.should be_redirect
+
+      follow_redirect!
+      last_response.should be_ok
+      last_response.body.should include('ping')
+    end
+  end
+
+  describe 'GET /commands/:id' do
+    let(:id)    { command_a['id'] }
+    let(:tasks) { command_a['tasks'] }
+
+    before { save_commands(redis, commands) }
+
+    it 'shows the command' do
+      get "/commands/#{id}"
+
+      last_response.should be_ok
+      last_response.body.should include(tasks)
+    end
+  end
+
+  describe 'GET /commands/:id/log' do
+    context 'when the output is already saved' do
+      let(:id)     { command_a['id'] }
+      let(:output) { command_a['output'] }
+
+      before { save_commands(redis, commands) }
+
+      it 'gets the log as an event-stream' do
+        get "/commands/#{id}/log"
+
+        last_response.should be_ok
+        last_response.content_type.should include('text/event-stream')
+        last_response.body.should include("data: #{output}\n\n")
+        last_response.body.should include("data: CLOSE\n\n")
+      end
+    end
+
+    context 'when the output is been generated' do
+      let(:command) { { 'id' => '20130716150200', 'tasks' => 'ping' } }
+      let(:id)     { command['id'] }
+
+      before { save_commands(redis, [command]) }
+      after { Process.wait(@pid) if @pid }
+
+      it 'gets the log as an event-stream' do
+        @pid = worker { publish(redis_url, id) }
+
+        get "/commands/#{id}/log"
+
+        last_response.should be_ok
+        last_response.content_type.should include('text/event-stream')
+        last_response.body.should include("data: PONG\n\n")
+        last_response.body.should include("data: CLOSE\n\n")
+      end
+    end
+  end
+end

data/spec/izanami/channel/input_spec.rb

@@ -0,0 +1,38 @@
+require_relative '../../helper'
+require 'izanami/channel'
+
+describe Izanami::Channel::Input do
+  let(:mapper) { double('mapper') }
+  let(:id) { '123' }
+
+  subject { Izanami::Channel::Input.new(mapper, id) }
+
+  describe '#<<' do
+    let(:payload_a) { 'ping' }
+    let(:payload_b) { 'pong' }
+
+    before do
+      mapper.should_receive(:publish).with(id, payload_a)
+      mapper.should_receive(:publish).with(id, payload_b)
+    end
+
+    it 'publishes the content and keeps it' do
+      subject << payload_a
+      subject << payload_b
+
+      subject.to_s.
+        should == "#{payload_a}#{Izanami::Channel::SEPARATOR}#{payload_b}"
+    end
+  end
+
+  describe '#close' do
+    before do
+      mapper.should_receive(:update).with(id, 'output', '')
+      mapper.should_receive(:publish).with(id, Izanami::Channel::EOC)
+    end
+
+    it 'closes the channel, stores and returns the content' do
+      subject.close.should == ''
+    end
+  end
+end

data/spec/izanami/channel_spec.rb

@@ -0,0 +1,66 @@
+require_relative '../helper'
+require 'izanami/channel'
+
+module Mock
+  class On < Struct.new(:buffer)
+    def message
+      buffer.each do |output|
+        yield 'channel-id', output
+      end
+    end
+  end
+end
+
+shared_examples 'Channel#read' do
+  it 'reads the command output' do
+    output = []
+    subject.read(id) { |line| output << line }
+
+    output.should == expected
+  end
+end
+
+describe Izanami::Channel do
+  let(:mapper) { double('mapper') }
+  let(:id) { '123' }
+
+  subject { Izanami::Channel.new(mapper) }
+
+  describe '#write' do
+    it 'initiates a channel output instance' do
+      subject.write(id).should be_instance_of(Izanami::Channel::Input)
+    end
+  end
+
+  describe '#read' do
+    let(:expected) { %w[ping pong] }
+
+    context 'when the command has an output' do
+      let(:command) do
+        {
+          'id'     => id,
+          'output' => "ping#{Izanami::Channel::SEPARATOR}pong"
+        }
+      end
+
+      before do
+        mapper.should_receive(:find).with(id).and_return(command)
+      end
+
+      it_should_behave_like 'Channel#read'
+    end
+
+    context 'when the command is been executed' do
+      let(:command) { { 'id' => id, } }
+      let(:on) { Mock::On.new(%W[ping pong #{Izanami::Channel::EOC}]) }
+
+      before do
+        mapper.should_receive(:find).with(id).and_return(command)
+        mapper.should_receive(:subscribe).with(id).and_yield(on)
+        mapper.should_receive(:unsubscribe).with(id)
+      end
+
+      it_should_behave_like 'Channel#read'
+    end
+  end
+end

data/spec/izanami/mapper_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../helper'
+require 'izanami/mapper'
+
+describe Izanami::Mapper do
+  let(:redis)   { double('redis') }
+  let(:options) { { redis: redis } }
+
+  subject { Izanami::Mapper.new(options) }
+
+  describe '#redis' do
+    context 'with redis instance' do
+      it 'uses the given redis instance' do
+        subject.redis.should == redis
+      end
+    end
+
+    context 'with redis options' do
+      let(:redis_url) { ENV['IZANAMI_REDIS_URL'] }
+      let(:options) { { url: redis_url } }
+
+      it 'initializes a new redis instance' do
+        subject.redis.should be_instance_of(Redis)
+      end
+    end
+  end
+
+  describe '#namespace' do
+    context 'with a namespace' do
+      let(:options) { { namespace: 'spec' } }
+
+      it 'uses that namespace' do
+        subject.namespace.should == 'spec'
+      end
+    end
+
+    context 'without a namespace' do
+      it 'uses the default namespace' do
+        subject.namespace.should == 'izanami'
+      end
+    end
+  end
+
+  describe '#client' do
+    it 'uses redis namespace as a proxy' do
+      subject.client.should be_instance_of(Redis::Namespace)
+    end
+  end
+end

data/spec/izanami/mappers/command_spec.rb

@@ -0,0 +1,154 @@
+require_relative '../../helper'
+require 'izanami/mappers/command'
+
+describe Izanami::Mappers do
+  let(:redis_url) { ENV['IZANAMI_REDIS_URL'] }
+  let(:redis) { Redis.new(url: redis_url) }
+
+  let(:options) { { redis: redis } }
+
+  let(:commands) do
+    [
+      { 'id' => '20130804160130', 'tasks' => 'ping', },
+      { 'id' => '20130804150130', 'tasks' => 'check', },
+      { 'id' => '20130804140130', 'tasks' => 'deploy', },
+      { 'id' => '20130803160130', 'tasks' => 'reboot', },
+      { 'id' => '20130802160130', 'tasks' => 'ping', },
+    ]
+  end
+
+  subject { Izanami::Mappers::Command.new(options) }
+
+  describe '#namespace' do
+    context 'with a namespace' do
+      let(:options) { { redis: redis, namespace: 'spec' } }
+
+      it 'uses that namespace' do
+        subject.namespace.should == 'spec:commands'
+      end
+    end
+
+    context 'without a namespace' do
+      it 'uses the default namespace' do
+        subject.namespace.should == 'izanami:commands'
+      end
+    end
+  end
+
+  describe '#ttl' do
+    context 'with a ttl option' do
+      let(:options) { { redis: redis, ttl: 1 } }
+
+      it 'uses that ttl' do
+        subject.ttl.should == 1
+      end
+    end
+
+    context 'without a ttl option' do
+      let(:options) { { redis: redis } }
+
+      it 'uses the default ttl' do
+        subject.ttl.should == 604800
+      end
+    end
+  end
+
+  context 'redis interaction' do
+    before do
+      commands.each do |command|
+        subject.save command
+      end
+    end
+
+    after { redis.flushdb }
+
+    describe '#find' do
+      let(:command) { { 'id' => '1234', 'tasks' => 'test' } }
+
+      context 'when the command exists' do
+        before { subject.save(command) }
+
+        it 'retrieves the content' do
+          subject.find(command['id']).should == command
+        end
+      end
+
+      context "when the command doesn't exist" do
+        it 'returns nil' do
+          subject.find(command['id']).should be_nil
+        end
+      end
+    end
+
+    describe '#take' do
+      it 'takes the elements sorted by their ids' do
+        subject.take(3).should == commands.take(3)
+      end
+    end
+
+    describe '#count' do
+      it 'counts all the records' do
+        subject.count.should == commands.count
+      end
+    end
+
+    describe '#delete_all' do
+      it 'deletes all the commands stored in redis' do
+        subject.delete_all
+
+        subject.count.should == 0
+        commands.each do |command|
+          subject.exists?(command['id']).should be_false
+        end
+      end
+    end
+
+    describe '#delete' do
+      let(:ids) { commands.take(2).map { |c| c['id'] } }
+
+      it 'deletes the ids stored in redis' do
+        subject.delete(ids)
+
+        ids.each do |id|
+          subject.exists?(id).should be_false
+        end
+      end
+    end
+
+    describe '#save' do
+      context 'with an id' do
+        let(:command) { { 'id' => '123', 'tasks' => 'ping' } }
+
+        it 'saves the record with the given key' do
+          subject.save(command)
+
+          subject.find(command['id']).should == command
+        end
+      end
+
+      context 'without an id' do
+        let(:command) { { 'tasks' => 'ping' } }
+
+        it 'saves the record with a new key' do
+          hash = subject.save(command)
+
+          hash['id'].should_not be_nil
+          subject.find(hash['id'])['tasks'].should == command['tasks']
+        end
+      end
+    end
+
+    describe '#update' do
+      let(:command) { { 'id' => '123', 'tasks' => 'ping' } }
+
+      before { subject.save(command) }
+
+      it 'updates the record with the given key' do
+        subject.update('123', 'tasks', 'pong')
+
+        subject.find('123').should_not == command
+        subject.find('123').should == { 'id' => '123', 'tasks' => 'pong' }
+      end
+    end
+  end
+end

data/spec/izanami/workers/command_spec.rb

@@ -0,0 +1,122 @@
+require_relative '../../helper'
+require 'izanami/workers/command'
+require 'izanami/mappers/command'
+
+shared_context 'mapper' do
+  let(:mapper) { Izanami::Mappers::Command.new(redis_options) }
+
+  before { mapper.client.flushdb }
+  after { mapper.client.flushdb }
+end
+
+shared_examples '#handle_streams' do
+  include_context 'mapper'
+
+  let(:stdin)  { StringIO.new }
+  let(:stdout) { StringIO.new(output) }
+  let(:thread) { Thread.new { double('status', success?: status) } }
+
+  it 'handles the shell command IO objects and stores the result' do
+    subject.handle_streams(stdin, stdout, thread)
+
+    c = mapper.find(command['id'])
+    c['output'].should == output
+    c['status'].should == status_string
+  end
+end
+
+describe Izanami::Workers::Command do
+  describe 'worker class methods' do
+    subject { Izanami::Workers::Command }
+
+    describe '.defer' do
+      it { should respond_to(:defer) }
+    end
+
+    describe '.call' do
+      it { should respond_to(:call) }
+    end
+
+    describe '.run' do
+      it { should respond_to(:run) }
+    end
+  end
+
+  describe 'worker instance methods' do
+    let(:command) { { 'id' => '123', 'tasks' => 'ping' } }
+    let(:redis_options) { { url: ENV['IZANAMI_REDIS_URL'] } }
+    subject { Izanami::Workers::Command.new(redis_options, command) }
+
+    describe '#defer' do
+      it { should respond_to(:defer) }
+
+      context 'calling #defer' do
+        let(:pid) { 123 }
+
+        it 'forks the process to detach the execution' do
+          Process.should_receive(:fork).and_return(pid)
+          Process.should_receive(:detach).with(pid)
+          subject.defer.should == pid
+        end
+      end
+    end
+
+    describe '#call' do
+      it { should respond_to(:call) }
+
+      context 'calling #call' do
+        include_context 'mapper'
+
+        it 'executes the `cap` command' do
+          subject.call
+
+          c = mapper.find(command['id'])
+          c['output'].should include('PONG')
+        end
+      end
+    end
+
+    describe '#run' do
+      it { should respond_to(:run) }
+    end
+
+    describe '#shell_env' do
+      before { ENV['BUNDLE_IZANAMI_STUB'] = 'spec' }
+
+      it 'cleans all bundler environment variables' do
+        subject.shell_env['BUNDLE_IZANAMI_STUB'].should be_nil
+      end
+    end
+
+    describe '#shell_options' do
+      it 'changes the dir for with the sandbox' do
+        subject.shell_options[:chdir].should == ENV['IZANAMI_SANDBOX']
+      end
+    end
+
+    describe '#cmd' do
+      it 'calls the `cap` command using `bundler`' do
+        subject.cmd.should == "bundle exec cap #{command['tasks']}"
+      end
+    end
+
+    describe '#handle_streams' do
+
+      context 'with successful status' do
+        let(:output) { "  * 2013-08-14 15:47:06 executing `ping'`\nPONG" }
+        let(:status) { true }
+        let(:status_string) { 'success' }
+
+        it_should_behave_like '#handle_streams'
+      end
+
+      context 'with failed status' do
+        let(:output) { "the task `ping' does not exist" }
+        let(:status) { false }
+        let(:status_string) { 'fail' }
+
+        it_should_behave_like '#handle_streams'
+      end
+    end
+  end
+end

data/spec/sandbox/Capfile

@@ -0,0 +1,4 @@
+
+task :ping do
+  $stdout.puts 'PONG'
+end

data/spec/sandbox/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem 'capistrano'

data/views/_commands_panel.erb

@@ -0,0 +1,12 @@
+<div class="panel panel-<%= type %>">
+  <div class="panel-heading"><%= title %></div>
+
+  <ul class="list-group">
+    <% commands.each do |command| %>
+      <li class="list-group-item">
+        <% time = id_to_time(command['id']) %>
+        <abbr title="<%= time %>" class="initialism"><%= abbr_time(time) %></abbr> <a href="<%= "/commands/#{command['id']}" %>"><%= command['tasks'] %></a>
+      </li>
+    <% end %>
+  </ul>
+</div>

data/views/command.erb

@@ -0,0 +1,10 @@
+<div class="row">
+  <div class="col-lg-12">
+    <h2><%= command['tasks'] %> <span class="label label-<%= label_status(command['status']) %>"><%= format_status(command['status']) %></span></h2>
+    <p>Command started at <%= id_to_time(command['id']) %></p>
+  </div>
+</div>
+
+<div class="row">
+  <pre id="log" data-id="<%= command['id'] %>" class="col-lg-12"></pre>
+</div>