captivate 0.0.1

data/lib/captivate.rb

@@ -0,0 +1,199 @@
+require 'tempfile'
+module Captivate
+  class Command
+    attr_reader :path
+
+    def initialize(args = nil)
+      @args = args
+    end
+
+    def invoke
+      config = Config.new(config_options).to_hash
+      @host = config['host']
+      @path = config['working_path']
+      @remote_dir = RemoteDir.new(:host => @host, :path => @path)
+      @remote_dir.upload('Capfile')
+      @remote_config_dir = @remote_dir.new_subdir('config')
+      @remote_config_dir.upload('config/deploy.rb')
+      @remote_config_dir.upload('config/deploy') if File.directory?('config/deploy')
+      @remote_script = RemoteScript.new(:command => command, :remote_path => @path)
+      remote_script_path = @remote_script.local_path
+      File.chmod(0555, remote_script_path)
+      @remote_dir.upload(remote_script_path, 'captivate-remote.sh')
+      SystemCall.new(%{ssh -t #{@host} screen #{@path}/captivate-remote.sh})
+    end
+  
+  private
+    
+    def self.remote_script_path
+      File.join(File.dirname(__FILE__), '/../bin/captivate-remote.sh')
+    end
+    
+    def command
+      @args * ' '
+    end
+    
+    def config_options
+      {:command => command, :rails_root => rails_root}
+    end
+    
+    def rails_root
+      FileUtils.pwd
+    end
+  end
+
+  class Config
+    def initialize(options = {})
+      @command    = options[:command]    or raise(ConfigError, "Missing 'command' option")
+      @rails_root = options[:rails_root] or raise(ConfigError, "Missing 'rails_root' option")
+    end
+    
+    def to_hash
+      validate_yaml_config
+      { 'working_path' => working_path }.merge(yaml_config[environment])
+    end
+  
+  private
+    
+    def working_path
+      '/tmp/captivate.%s' % [timestamp, app_name, environment, user].join('.')
+    end
+    
+    def timestamp
+      Time.now.to_i
+    end
+    
+    def app_name
+      File.basename(@rails_root)
+    end
+    
+    def environment
+      if config_stages.include?(commands.first) && multistage_stages.include?(commands.first)
+        commands.first
+      else
+        'production'
+      end
+    end
+    
+    def config_stages
+      yaml_config.keys
+    end
+    
+    def multistage_stages
+      if multistage?
+        set_stages_code = deploy_file_contents[/set :stages,\s?([^\n]+)\n/, 1] or
+          raise(ConfigError, "'set :stages' definition not found")
+        stages_array = eval(set_stages_code)
+      else
+        []
+      end
+    end
+    
+    def deploy_file_contents
+      File.read(deploy_file_path)
+    end
+    
+    def deploy_file_path
+      "#{@rails_root}/config/deploy.rb"
+    end
+    
+    def multistage?
+      deploy_file_contents.match(%r(\A\s*require (['"])capistrano/ext/multistage\1)) ||
+      deploy_file_contents.match(%r(\n\s*require (['"])capistrano/ext/multistage\1))
+    end
+    
+    def commands
+      @command.split(/\s+/)
+    end
+    
+    def user
+      Etc.getlogin
+    end
+    
+    def validate_yaml_config
+      raise(ConfigError, yaml_config_path) unless File.exists?(yaml_config_path)
+      raise(ConfigError, "Missing #{environment} environment") unless yaml_config.keys.include?(environment)
+      unless yaml_config[environment].keys.include?('host')
+        raise(ConfigError, "Missing 'host' for #{environment} environment")
+      end
+    end
+    
+    def yaml_config
+      @yaml_config ||= YAML.load_file(yaml_config_path)
+    end
+    
+    def yaml_config_path
+      File.join(@rails_root, 'config/captivate.yml')
+    end
+  end
+
+  class RemoteDir
+    def initialize(options)
+      @host, @path = options[:host], options[:path]
+      SystemCall.new("ssh #{@host} mkdir #{@path}")
+    end
+    
+    def upload(file_path, dest_filename = file_path)
+      raise(Errno::ENOENT, file_path) unless File.exists?(file_path)
+      if File.directory?(file_path)
+        SystemCall.new("scp -r #{file_path} #{@host}:#{@path}/#{File.basename(dest_filename)}")
+      else
+        SystemCall.new("scp #{file_path} #{@host}:#{@path}/#{File.basename(dest_filename)}")
+      end
+    end
+    
+    def new_subdir(dirname)
+      self.class.new(:host => @host, :path => "#{@path}/#{dirname}")
+    end
+  end
+  
+  class RemoteScript
+    attr_reader :local_path, :remote_path, :command
+    def initialize(options)
+      @command = options[:command]
+      @remote_path = options[:remote_path]
+      Tempfile.open('captivate_remote_script') do |f|
+        @local_path = f.path
+        f.write(converted_template)
+      end
+    end
+    
+  private
+    
+    def converted_template
+      template.gsub('### CAP COMMANDS ###', command).gsub('### REMOTE PATH ###', remote_path)
+    end
+    
+    def template
+      <<-EOS
+#!/usr/bin/env bash
+# Deploys app. Executed remotely from deploy host.
+if [ -f ~/.bashrc ]; then
+  . ~/.bashrc
+fi
+if [ -f ~/.profile ]; then
+  . ~/.profile
+fi
+if [ -f ~/.bash_profile ]; then
+  . ~/.bash_profile
+fi
+trap 'echo "-->  Aborted.  Press Enter to continue..."; read; exit' ERR
+cd ### REMOTE PATH ###
+echo "-->  Executing:  "
+echo "cap ### CAP COMMANDS ###"
+cap ### CAP COMMANDS ###
+echo "-->  Completed.  Press Enter to continue..."
+read
+      EOS
+    end
+  end
+  
+  class SystemCall
+    def initialize(command)
+      system(command)
+    end
+  end
+  
+  class ConfigError < StandardError
+  end
+end

data/spec/acceptance_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Captivate do
+  FIXTURES_PATH = File.expand_path(File.join(File.dirname(__FILE__), '/fixtures'))
+  
+  before do
+    # FIXME: FileUtils.rm_rf isn't deleting.
+    # FileUtils.rm_rf('/tmp/captivate*')
+    system('rm -fr /tmp/captivate*')
+    @file_to_appear      = '/tmp/captivate-test-file'
+    @touched_file_exists = lambda { File.exists?(@file_to_appear) }
+    @command             = Captivate::Command.new([%{ROLES=app COMMAND='touch #{@file_to_appear}' invoke}])
+  end
+  
+  context 'when non-multistage rails app' do
+    before do
+      @rails_root  = File.join(FIXTURES_PATH, 'rails_apps/single_stage')
+    end
+
+    it "should execute cap task and write log file" do
+      lambda do
+        FileUtils.cd(@rails_root)
+        @command.invoke
+      end.should change(@touched_file_exists, :call).from(false).to(true)
+    end
+
+    it "should write log file" do
+      pending
+      FileUtils.cd(@rails_root)
+      @command.invoke
+      log_file_path = File.join(@command.path, 'captivate.log')
+      File.exists?(log_file_path).should be_true
+    end
+  end
+
+  context 'when multistage rails app' do
+    before do
+      @rails_root  = File.join(FIXTURES_PATH, 'rails_apps/multi_stage')
+    end
+    
+    it "should fail when attempting cap task to nonexistent server" do
+      lambda do
+        FileUtils.cd(@rails_root)
+        Captivate::Command.new([%{ROLES=nonexistent COMMAND='touch #{@file_to_appear}' invoke}]).invoke
+      end.should_not raise_error
+    end
+
+    it "should execute cap task via screen" do
+      lambda do
+        FileUtils.cd(@rails_root)
+        Captivate::Command.new([%{staging ROLES=app COMMAND='touch #{@file_to_appear}' invoke}]).invoke
+      end.should change(@touched_file_exists, :call).from(false).to(true)
+    end
+  end
+end

data/spec/captivate_spec.rb

@@ -0,0 +1,269 @@
+require 'spec_helper'
+
+describe  Captivate::Command do
+  before do
+    Captivate::Config.stub!(:new).and_return('host' => 'the_host', 'working_path' => 'the_path')
+    @remote_dir = mock('remote_dir')
+    @remote_dir.stub!(:upload)
+    @remote_subdir = mock('subdir')
+    @remote_subdir.stub!(:upload)
+    @remote_dir.stub!(:new_subdir).and_return(@remote_subdir)
+    Captivate::RemoteDir.stub!(:new).and_return(@remote_dir)
+    Captivate::SystemCall.stub!(:new)
+    @remote_script = mock('remote_script')
+    @remote_script.stub!(:local_path)
+    Captivate::RemoteScript.stub!(:new).and_return(@remote_script)
+    @command = Captivate::Command.new(['some cap commands'])
+    File.stub!(:chmod)
+  end
+  
+  it "should pass rails_root and command to config" do
+    FileUtils.stub!(:pwd).and_return('path_to_my_app')
+    Captivate::Config.should_receive(:new).with(:command => 'some cap commands', :rails_root => 'path_to_my_app')
+    @command.invoke
+  end
+  
+  it "should create a remote working directory" do
+    Captivate::Config.should_receive(:new).and_return('host' => 'the_host', 'working_path' => 'the_path')
+    Captivate::RemoteDir.should_receive(:new).with(:host => 'the_host', :path => 'the_path').and_return(@remote_dir)
+    @command.invoke
+  end
+  
+  it "should upload Capfile" do
+    @remote_dir.should_receive(:upload).with('Capfile')
+    @command.invoke
+  end
+  
+  it "should create a config subdirectory" do
+    @remote_dir.should_receive(:new_subdir).with('config')
+    @command.invoke
+  end
+  
+  it "should upload deploy.rb to config" do
+    @remote_subdir.should_receive(:upload).with('config/deploy.rb')
+    @command.invoke
+  end
+  
+  it "shouldn't upload config/deploy if doesn't exist" do
+    File.should_receive(:directory?).with('config/deploy').and_return(false)
+    @remote_subdir.should_not_receive(:upload).with('config/deploy')
+    @command.invoke
+  end
+  
+  it "should upload config/deploy if exists" do
+    File.should_receive(:directory?).with('config/deploy').and_return(true)
+    @remote_subdir.should_receive(:upload).with('config/deploy')
+    @command.invoke
+  end
+  
+  it "should write remote script locally" do
+    Captivate::RemoteScript.should_receive(:new).with(:command => 'some cap commands', :remote_path => 'the_path')
+    @command.invoke
+  end
+  
+  it "should upload remote script" do
+    @remote_script.should_receive(:local_path).and_return('path_to_local_script')
+    @remote_dir.should_receive(:upload).with('path_to_local_script', 'captivate-remote.sh')
+    @command.invoke
+  end
+  
+  it "should invoke remote script" do
+    Captivate::SystemCall.should_receive(:new).with(%{ssh -t the_host screen the_path/captivate-remote.sh})
+    @command.invoke
+  end
+  
+  it "should make remote script executable" do
+    @remote_script.should_receive(:local_path).and_return('some_path')
+    File.should_receive(:chmod).with(0555, 'some_path')
+    @command.invoke
+  end
+end
+
+describe Captivate::Config do
+  before do
+    @rails_root       = 'path/to/my_app'
+    @config           = Captivate::Config.new(:command => 'some cap commands', :rails_root => @rails_root)
+    @yaml_config_path = 'path/to/my_app/config/captivate.yml'
+  end
+  
+  it "should raise an error when 'command' not passed in" do
+    lambda do
+      Captivate::Config.new(:rails_root => 'the_path').invoke.should
+    end.should raise_error(Captivate::ConfigError, "Missing 'command' option")
+  end
+
+  it "should raise an error when 'rails_root' not passed in" do
+    lambda do
+      Captivate::Config.new(:command => 'the_command').invoke.should
+    end.should raise_error(Captivate::ConfigError, "Missing 'rails_root' option")
+  end
+  
+  context 'without YAML' do
+    it "should raise error" do
+      lambda { @config.to_hash }.should raise_error(Captivate::ConfigError, @yaml_config_path)
+    end
+  end
+  
+  context 'with YAML' do
+    before do
+      File.should_receive(:exists?).with(@yaml_config_path).and_return(true)
+      @multistage_config = {
+        'production' => {'host' => 'the_host'},
+        'staging'    => {'host' => 'another_host'},
+      }
+      YAML.stub!(:load_file).with(@yaml_config_path).and_return(@multistage_config)
+    end
+
+    it "should return a hash" do
+      @config.to_hash.should be_a(Hash)
+    end
+    
+    it "should retrieve host from YAML config, defaulting to production" do
+      @config.to_hash['host'].should == 'the_host'
+    end
+    
+    it "should not accept non-production stages if multistage gem not present" do
+      @config = Captivate::Config.new(:command => 'staging some cap commands', :rails_root => @rails_root)
+      @config.stub!(:deploy_file_contents).and_return('deploy_config')
+      @config.to_hash['host'].should == 'the_host'
+    end
+    
+    it "should raise error if multistage gem present but stages not found" do
+      @config = Captivate::Config.new(:command => 'staging some cap commands', :rails_root => @rails_root)
+      @config.stub!(:deploy_file_contents).and_return(<<-EOS)
+      require 'capistrano/ext/multistage'
+      some cap commands
+      EOS
+      lambda { @config.to_hash }.should raise_error(Captivate::ConfigError, "'set :stages' definition not found")
+    end
+
+    it "should detect valid stage as first parameter if valid stage and multistage gem present" do
+      @config = Captivate::Config.new(:command => 'staging some cap commands', :rails_root => @rails_root)
+      @config.stub!(:deploy_file_contents).and_return(<<-EOS)
+      require 'capistrano/ext/multistage'
+      set :stages, %w(production staging showcase)
+      some cap commands
+      EOS
+      @config.to_hash['host'].should == 'another_host'
+    end
+
+    it "should detect valid stage as first parameter if valid stage and multistage gem present but commented out" do
+      @config = Captivate::Config.new(:command => 'staging some cap commands', :rails_root => @rails_root)
+      @config.stub!(:deploy_file_contents).and_return(<<-EOS)
+      # require 'capistrano/ext/multistage'
+      some cap commands
+      EOS
+      @config.to_hash['host'].should == 'the_host'
+    end
+
+    # Not defined in YAML config (@multistage_config['showcase'])
+    it "should ignore invalid stage as first parameter" do
+      @config = Captivate::Config.new(:command => 'showcase some cap commands', :rails_root => @rails_root)
+      @config.to_hash['host'].should == 'the_host'
+    end
+  
+    it "should contain timestamp, app_name, environment, user in remote working directory name" do
+      Etc.stub!(:getlogin).and_return('the_user')
+      @config.to_hash['working_path'].should == "/tmp/captivate.#{Time.now.to_i}.my_app.production.the_user"
+    end
+  
+    it "should merge YAML config" do
+      @config.stub!(:yaml_config).and_return('production' => {'host' => 'the_host', 'working_path' => 'custom_path'})
+      @config.to_hash['working_path'].should == 'custom_path'
+    end
+  
+    it "should raise an error if missing config for environment" do
+      YAML.stub!(:load_file).with(@yaml_config_path).and_return({})
+      lambda do
+        @config.to_hash
+      end.should raise_error(Captivate::ConfigError, 'Missing production environment')
+    end
+
+    it "should raise an error if host missing from config" do
+      YAML.stub!(:load_file).with(@yaml_config_path).and_return('production' => {})
+      lambda do
+        @config.to_hash
+      end.should raise_error(Captivate::ConfigError, "Missing 'host' for production environment")
+    end
+  end
+end
+
+describe Captivate::RemoteDir do
+  before do
+    Captivate::SystemCall.stub!(:new)
+  end
+  
+  it "should create a directory" do
+    Captivate::SystemCall.should_receive(:new).with('ssh the_host mkdir the_path')
+    Captivate::RemoteDir.new(:host => 'the_host', :path => 'the_path')
+  end
+  
+  it "should raise an error if missing file" do
+    @remote_dir = Captivate::RemoteDir.new(:host => 'the_host', :path => 'the_path')
+    lambda do
+      @remote_dir.upload('local_path/a_file')
+    end.should raise_error(Errno::ENOENT, 'No such file or directory - local_path/a_file')
+  end
+  
+  it "should create a subdirectory" do
+    @remote_dir = Captivate::RemoteDir.new(:host => 'the_host', :path => 'the_path')
+    Captivate::RemoteDir.should_receive(:new).with(:host => 'the_host', :path => 'the_path/a_dir')
+    @remote_dir.new_subdir('a_dir')
+  end
+
+  context 'when uploading file which exists' do
+    before do
+      File.stub!(:exists?).and_return(true)
+    end
+
+    it "should upload a file" do
+      @remote_dir = Captivate::RemoteDir.new(:host => 'the_host', :path => 'the_path')
+      Captivate::SystemCall.should_receive(:new).with('scp local_path/a_file the_host:the_path/a_file')
+      @remote_dir.upload('local_path/a_file')
+    end
+
+    it "should upload a file and rename" do
+      @remote_dir = Captivate::RemoteDir.new(:host => 'the_host', :path => 'the_path')
+      Captivate::SystemCall.should_receive(:new).with('scp a_file the_host:the_path/new_name')
+      @remote_dir.upload('a_file', 'new_name')
+    end
+
+    it "should upload a directory" do
+      @remote_dir = Captivate::RemoteDir.new(:host => 'the_host', :path => 'the_path')
+      Captivate::SystemCall.should_receive(:new).with('scp -r local_path/a_dir the_host:the_path/a_dir')
+      File.should_receive(:directory?).with('local_path/a_dir').and_return(true)
+      @remote_dir.upload('local_path/a_dir')
+    end
+  end
+end
+
+describe Captivate::RemoteScript do
+  before do
+    @file = mock('file')
+    @file.stub!(:path)
+    @file.stub!(:write)
+    Tempfile.should_receive(:open).and_yield(@file)
+    @remote_script = lambda do
+      Captivate::RemoteScript.new(:command => 'some cap commands', :remote_path => 'the_remote_path')
+    end
+  end
+  
+  it "should contain cap command in script" do
+    @file.should_receive(:write) do |shell_script|
+      shell_script.should include('some cap commands')
+    end
+    @remote_script.call
+  end
+
+  it "should contain remote script path in script" do
+    @file.should_receive(:write) do |shell_script|
+      shell_script.should include('the_remote_path')
+    end
+    @remote_script.call
+  end
+  
+  it "should return path" do
+    @file.should_receive(:path).and_return('some_path')
+    @remote_script.call
+  end
+end