foreplay 0.0.1 → 0.0.2

data/lib/foreplay/deploy.rb

@@ -0,0 +1,305 @@
+require 'thor/group'
+require 'yaml'
+require 'net/ssh'
+require 'active_support/inflector'
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/hash'
+require 'colorize'
+require 'foreplay/utility'
+
+module Foreplay
+  class Deploy < Thor::Group
+    include Thor::Actions
+
+    argument :mode,         :type => :string, :required => true
+    argument :environment,  :type => :string, :required => true
+    argument :filters,      :type => :hash,   :required => false
+
+    DEFAULTS_KEY = 'defaults'
+
+    def parse
+      # Explain what we're going to do
+      puts '%sing %s environment, %s, %s' % [
+        mode.capitalize,
+        environment.dup.yellow,
+        explanatory_text(filters, 'role'),
+        explanatory_text(filters, 'server')
+      ]
+
+      config_file = "#{Dir.getwd}/config/foreplay.yml"
+
+      begin
+        config_yml = File.read config_file
+      rescue Errno::ENOENT
+        terminate "Can't find configuration file #{config_file}.\nPlease run foreplay setup or create the file manually."
+      end
+
+      config_all = YAML.load(config_yml)
+      config_env = config_all[environment] || {}
+
+      # This environment
+      terminate("No deployment configuration defined for #{environment} environment.\nCheck #{config_file}") unless config_all.has_key? environment
+
+      # Establish defaults
+      # First the default defaults
+      defaults = {
+        :name        => File.basename(Dir.getwd),
+        :environment => environment,
+        :env         => { 'RAILS_ENV' => environment },
+        :port        => 50000
+      }
+
+      defaults = Foreplay::Utility::supermerge(defaults, config_all[DEFAULTS_KEY])  if config_all.has_key? DEFAULTS_KEY  # Then the global defaults
+      defaults = Foreplay::Utility::supermerge(defaults, config_env[DEFAULTS_KEY])  if config_env.has_key? DEFAULTS_KEY  # Then the defaults for this environment
+
+      config_env.each do |role, additional_instructions|
+        next if role == DEFAULTS_KEY # 'defaults' is not a role
+        next if filters.has_key?('role') && filters['role'] != role # Only deploy to the role we've specified (or all roles if none is specified)
+
+        instructions        = Foreplay::Utility::supermerge(defaults, additional_instructions).symbolize_keys
+        instructions[:role] = role
+        required_keys       = [:name, :environment, :role, :servers, :path, :repository]
+        required_keys.each { |key| terminate("Required key #{key} not found in instructions for #{environment} environment.\nCheck #{config_file}") unless instructions.has_key? key }
+
+        deploy_role instructions
+      end
+
+      puts mode == :deploy ? 'Finished deployment' : 'Deployment configuration check was successful'
+    end
+
+    private
+
+    def deploy_role instructions
+      servers     = instructions[:servers]
+      preposition = mode == :deploy ? 'to' : 'for'
+
+      puts "#{mode.capitalize}ing #{instructions[:name].yellow} #{preposition} #{servers.join(', ').yellow} in the #{instructions[:role].dup.yellow} role on the #{environment.dup.yellow} environment..." if servers.length > 1
+      servers.each { |server| deploy_to_server server, instructions }
+    end
+
+    def deploy_to_server server, instructions
+      name        = instructions[:name]
+      role        = instructions[:role]
+      path        = instructions[:path]
+      repository  = instructions[:repository]
+      user        = instructions[:user]
+      port        = instructions[:port]
+      preposition = mode == :deploy ? 'to' : 'for'
+
+      instructions[:server] = server
+
+      puts "#{mode.capitalize}ing #{name.yellow} #{preposition} #{server.yellow} in the #{role.dup.yellow} role on the #{environment.dup.yellow} environment"
+
+      # Substitute variables in the path
+      path.gsub! '%u', user
+      path.gsub! '%a', name
+
+      # Find out which port we're currently running on
+      steps = [ { :command => 'mkdir -p .foreplay && touch .foreplay/current_port && cat .foreplay/current_port', :silent => true } ]
+
+      current_port_string = execute_on_server(steps, instructions).strip!
+      puts current_port_string.blank? ? '    No instance is currently deployed' : "    Current instance is using port #{current_port_string}"
+
+      current_port = current_port_string.to_i
+
+      # Switch ports
+      if current_port == port
+        current_port  = port + 1000
+        former_port   = port
+      else
+        current_port  = port
+        former_port   = port + 1000
+      end
+
+      # Contents of .foreman file
+      current_service = '%s-%s' % [name, current_port]
+      former_service  = '%s-%s' % [name, former_port]
+
+      instructions[:foreman]['app']   = current_service
+      instructions[:foreman]['port']  = current_port
+      instructions[:foreman]['user']  = user
+
+      # Commands to execute on remote server
+      steps = [
+        { :command      => "echo #{current_port} > .foreplay/current_port",
+          :commentary   => "Setting the port for the new instance to #{current_port}" },
+        { :command      => "mkdir -p #{path} && cd #{path} && rm -rf #{current_port} && git clone #{repository} #{current_port}",
+          :commentary   => "Cloning repository #{repository}" },
+        { :command      => "rvm rvmrc trust #{current_port}",
+          :commentary   => 'Trusting the .rvmrc file for the new instance' },
+        { :command      => "cd #{current_port}",
+          :commentary   => 'Configuring the new instance' },
+        { :key          => :env,
+          :delimiter    => '=',
+          :prefix       => '.',
+          :commentary   => 'Building .env' },
+        { :key          => :foreman,
+          :delimiter    => ': ',
+          :prefix       => '.',
+          :commentary   => 'Building .foreman' },
+        { :key          => :database,
+          :delimiter    => ': ',
+          :suffix       => '.yml',
+          :commentary   => 'Building config/database.yml',
+          :before       => '  ',
+          :header       => "#{environment}:",
+          :path         => 'config/' },
+        { :command      => "bundle install",
+          :commentary   => 'Using bundler to install the required gems' },
+        { :command      => "sudo ln -f `which foreman` /usr/bin/foreman",
+          :commentary   => 'Setting the current version of foreman to be the default' },
+        { :command      => "sudo foreman export upstart /etc/init",
+          :commentary   => "Converting #{current_service} to an upstart service" },
+        { :command      => "sudo start #{current_service} || sudo restart #{current_service}",
+          :commentary   => 'Starting the service',
+          :ignore_error => true },
+        { :command      => 'sleep 60',
+          :commentary   => 'Waiting 60s to give service time to start' },
+        { :command      => "sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port #{current_port.to_i + 100}",
+          :commentary   => "Adding firewall rule to direct incoming traffic on port 80 to port #{current_port}" },
+        { :command      => "sudo iptables -t nat -D PREROUTING -p tcp --dport 80 -j REDIRECT --to-port #{former_port.to_i + 100}",
+          :commentary   => "Removing previous firewall directing traffic to port #{former_port}",
+          :ignore_error => true },
+        { :command      => "sudo iptables-save > /etc/iptables/rules.v4",
+          :commentary   => "Saving iptables rules to /etc/iptables/rules.v4" },
+        { :command      => "sudo iptables-save > /etc/iptables.up.rules",
+          :commentary   => "Saving iptables rules to /etc/iptables.up.rules" },
+        { :command      => "sudo iptables-save -c | egrep REDIRECT --color=never",
+          :ignore_error => true,
+          :commentary   => "Current firewall NAT configuration:" },
+        { :command      => "sudo stop #{former_service} || echo 'No previous instance running'",
+          :commentary   => 'Stopping the previous instance',
+          :ignore_error => true },
+      ]
+
+      execute_on_server steps, instructions
+    end
+
+    def execute_on_server steps, instructions
+      server      = instructions[:server]
+      user        = instructions[:user]
+      password    = instructions[:password]
+      keyfile     = instructions[:keyfile]
+      private_key = instructions[:private_key]
+
+      keyfile.sub! '~', ENV['HOME'] || '/' unless keyfile.blank? # Remote shell won't expand this for us
+
+      # SSH authentication methods
+      options = { :verbose => :warn }
+
+      if password.blank?
+        # If there's no password we must supply a private key
+        if private_key.blank?
+          terminate('No authentication methods supplied. You must supply a private key, key file or password in the configuration file') if keyfile.blank?
+          # Get the key from the key file
+          puts "    Using private key from #{keyfile}"
+          private_key = File.read keyfile
+        else
+          puts "    Using private key from the configuration file"
+        end
+
+        options[:key_data] = [private_key]
+      else
+        # Use the password supplied
+        options[:password] = password
+      end
+
+      # Capture output of last command to return to the calling routine
+      output = ''
+
+      if mode == :deploy
+        puts "    Connecting to #{server}"
+
+        # SSH connection
+        begin
+          Net::SSH.start(server, user, options) do |session|
+            puts "    Successfully connected to #{server}"
+
+            session.shell do |sh|
+              steps.each do |step|
+                # Output from this step
+                output    = ''
+                previous  = '' # We don't need or want the final CRLF
+
+                commands = build_commands step, instructions
+
+                commands.each do |command|
+                  process = sh.execute command
+
+                  process.on_output do |p, o|
+                    previous  = o
+                    output    += previous
+                  end
+
+                  sh.wait!
+
+                  if step[:ignore_error] == true || process.exit_status == 0
+                    print output.gsub!(/^/, "        ") unless step[:silent] == true
+                  else
+                    terminate(output)
+                  end
+                end
+              end
+            end
+          end
+        rescue SocketError => e
+          terminate "There was a problem starting an ssh session on #{server}:\n#{e.message}"
+        end
+      else
+        # Deployment check: just say what we would have done
+        steps.each do |step|
+          commands = build_commands step, instructions
+
+          commands.each { |command| puts "        #{command}" unless step[:silent] }
+        end
+      end
+
+      output
+    end
+
+    def build_commands step, instructions
+      puts "    #{(step[:commentary] || step[:command]).yellow}" unless step[:silent] == true
+
+      # Each step can be (1) a command or (2) a series of values to add to a file
+      if step.has_key? :key
+        # Add values from the config file to a file on the remote machine
+        key       = step[:key]
+        prefix    = step[:prefix]     || ''
+        suffix    = step[:suffix]     || ''
+        path      = step[:path]       || ''
+        before    = step[:before]     || ''
+        delimiter = step[:delimiter]  || ''
+        after     = step[:after]      || ''
+
+        step[:silent] = true
+        filename      = '%s%s%s%s' % [path, prefix, key, suffix]
+
+        if step.has_key?(:header)
+          commands  = ['echo "%s" > %s' % [step[:header], filename]]
+          redirect  = '>>'
+        else
+          commands  = []
+          redirect  = '>'
+        end
+
+        instructions[key].each do |k, v|
+          commands << 'echo "%s%s%s%s%s" %s %s' % [before, k, delimiter, v, after, redirect, filename]
+          redirect = '>>'
+        end
+
+        commands
+      else
+        # ...or just execute the command specified
+        [step[:command]]
+      end
+    end
+
+    def explanatory_text(hsh, key)
+      hsh.has_key?(key) ? "#{hsh[key].dup.yellow} #{key}" : "all #{key.pluralize}"
+    end
+
+    def terminate(message)
+      raise message
+    end
+  end
+end

data/lib/foreplay/setup.rb

@@ -0,0 +1,32 @@
+require 'thor/group'
+
+module Foreplay
+  class Setup < Thor::Group
+    include Thor::Actions
+
+    class_option :name,         :aliases => '-n', :default => File.basename(Dir.getwd)
+    class_option :repository,   :aliases => '-r'
+    class_option :user,         :aliases => '-u'
+    class_option :password
+    class_option :keyfile
+    class_option :private_key,  :aliases => '-k'
+    class_option :port,         :aliases => '-p', :default => 50000
+    class_option :path,         :aliases => '-f'
+    class_option :servers,      :aliases => '-s', :type => :array
+    class_option :db_adapter,   :aliases => '-a', :default => 'postgresql'
+    class_option :db_encoding,  :aliases => '-e', :default => 'utf8'
+    class_option :db_pool,                        :default => 5
+    class_option :db_name,      :aliases => '-d'
+    class_option :db_host,      :aliases => '-h'
+    class_option :db_user
+    class_option :db_password
+
+    def self.source_root
+      File.dirname(__FILE__)
+    end
+
+    def config
+      template('setup/foreplay.yml', 'config/foreplay.yml')
+    end
+  end
+end

data/lib/foreplay/{generators → setup}/foreplay.yml

@@ -43,8 +43,7 @@
 #
 # value         Normally defined as  Notes
 # ------------- -------------------- -------------------------------------------------------------------
-# name:         Global default       App name (if omitted then
-#                                    Rails.application.class.parent_name.underscore is used)
+# name:         Global default       App name (if omitted then current folder name is used)
 # user:         Global default       The username to connect with (must have SSH permissions)
 # password:     Global default       The password to use to connect (not necessary if you've set up SSH
 #                                    keys - see below)
@@ -54,6 +53,9 @@
 # path:         Global default       An absolute path to deploy the app on each server. %a will be
 #                                    translated to the application name. %u will be translated to the
 #                                    login user name
+# port:         Global default       The base port for the web app to listen on. Port 80 will be
+#                                    mapped to this port so it's usually OK to leave this at the
+#                                    default value of 50000.
 # database:     Environment default  The database.yml elements to write to the config folder
 #   key: value
 # servers: [server1, server2, server3]
@@ -64,22 +66,22 @@
 #   key: value
 #
 defaults:
-  name: <%= @name %>
-  repository: %q{TODO: Add the git repository path}
-  user: %q{TODO: Add the user to logon to the deployment server}
-  password: %q{TODO: Add the password for the user on the deployment server}
-  path: %q{TODO: Add the path to deploy to on the deployment server}
+  name: <%= @options.name? ? @options.name : 'TODO Put the app name here' %>
+  repository: <%= @options.repository? ? @options.repository : 'TODO Put the git repository path here' %>
+  user: <%= @options.user? ? @options.user : 'TODO Put here the user to logon to the deployment server' %><%= @options.password? ? "\n  password: #{@options.password}" : '' %><%= @options.keyfile? ? "\n  keyfile: #{@options.keyfile}" : '' %><%= @options.private_key? ? "\n  private_key: #{@options.private_key}" : '' %>
+  path: <%= @options.path? ? @options.path : 'TODO Put here the path to deploy to on the deployment server' %>
+  port: <%= @options.port %>
 production:
   defaults:
     database:
-      adapter: postgresql
-      encoding: utf8
-      database: %q{TODO: Add the database name}
-      pool: 5
-      host: %q{TODO: Add the database host name}
-      username: %q{TODO: Add the database user}
-      password: %q{TODO: Add the database user's password}
+      adapter: <%= @options.db_adapter %>
+      encoding: <%= @options.db_encoding %>
+      database: <%= @options.db_name? ? @options.db_name : 'TODO Put the database name here' %>
+      pool: <%= @options.db_pool %>
+      host: <%= @options.db_host? ? @options.db_host : 'TODO Put here the database host name' %>
+      username: <%= @options.db_user? ? @options.db_user : 'TODO Put here the database user' %>
+      password: <%= @options.db_password? ? @options.db_password : 'TODO Put here the database user\'s password' %>
   web:
-    servers: [%q{TODO: Add the name of the production web server}]
+    servers: <%= @options.servers? ? @options.servers : '[TODO Put here the name or names of the production web servers]' %>
     foreman:
       concurrency: 'web=1,worker=0,scheduler=0'

data/lib/foreplay/utility.rb

@@ -0,0 +1,29 @@
+module Foreplay
+  class Utility
+    # Returns a new hash with +hash+ and +other_hash+ merged recursively, including arrays.
+    #
+    #   h1 = { x: { y: [4,5,6] }, z: [7,8,9] }
+    #   h2 = { x: { y: [7,8,9] }, z: 'xyz' }
+    #   h1.supermerge(h2)
+    #   #=> {:x=>{:y=>[4, 5, 6, 7, 8, 9]}, :z=>[7, 8, 9, "xyz"]}
+    def self.supermerge(hash, other_hash)
+      raise 'supermerge only works if you pass two hashes' unless hash.is_a?(Hash) && other_hash.is_a?(Hash)
+
+      new_hash = hash.deep_dup.with_indifferent_access
+
+      other_hash.each_pair do |k,v|
+        tv = new_hash[k]
+
+        if tv.is_a?(Hash) && v.is_a?(Hash)
+          new_hash[k] = Foreplay::Utility::supermerge(tv, v)
+        elsif tv.is_a?(Array) || v.is_a?(Array)
+          new_hash[k] = Array.wrap(tv) + Array.wrap(v)
+        else
+          new_hash[k] = v
+        end
+      end
+
+      new_hash
+    end
+  end
+end

data/lib/foreplay/version.rb

@@ -1,3 +1,3 @@
 module Foreplay
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/lib/foreplay/deploy_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+require 'foreplay'
+require 'net/ssh/shell'
+
+describe Foreplay::Deploy do
+  let (:ssh)      { double(Net::SSH) }
+  let (:session)  { double(Net::SSH::Connection::Session) }
+  let (:shell)    { double(Net::SSH::Shell) }
+  let (:process)  { double(Net::SSH::Shell::Process) }
+
+  before :each do
+    # Setup foreplay
+    `rm -f config/foreplay.yml`
+    `foreplay setup -r git@github.com:Xenapto/foreplay.git -s web.example.com -f apps/%a -u fred --password trollope`
+
+    # Stub all the things
+    Net::SSH.stub(:start).and_yield(session)
+    session.stub(:shell).and_yield(shell)
+    shell.stub(:execute).and_return(process)
+    shell.stub(:wait!).and_return(false)
+    process.stub(:on_output).and_yield(process, "output message\n")
+    process.stub(:exit_status).and_return(0)
+  end
+
+  it "should complain on check if there's no config file" do
+    `rm -f config/foreplay.yml`
+    expect { Foreplay::Deploy.start([:check, 'production', '']) }.to raise_error(RuntimeError, /.*Please run foreplay setup or create the file manually.*/)
+  end
+
+  it "should complain on deploy if there's no config file" do
+    `rm -f config/foreplay.yml`
+    expect { Foreplay::Deploy.start([:deploy, 'production', '']) }.to raise_error(RuntimeError, /.*Please run foreplay setup or create the file manually.*/)
+  end
+
+  it "should complain if there are no authentication methods defined in the config file" do
+    `rm -f config/foreplay.yml`
+    `foreplay setup -r git@github.com:Xenapto/foreplay.git -s web.example.com -f apps/%a -u fred --password ""`
+    expect { Foreplay::Deploy.start([:deploy, 'production', '']) }.to raise_error(RuntimeError, /.*No authentication methods supplied. You must supply a private key, key file or password in the configuration file*/)
+  end
+
+  it "should complain if the private keyfile defined in the config file doesn't exist" do
+    `rm -f config/foreplay.yml`
+    `foreplay setup -r git@github.com:Xenapto/foreplay.git -s web.example.com -f apps/%a -u fred --keyfile "/home/fred/no-such-file"`
+    expect { Foreplay::Deploy.start([:deploy, 'production', '']) }.to raise_error(Errno::ENOENT, /.*No such file or directory - \/home\/fred\/no-such-file*/)
+  end
+
+  it "should terminate if a remote process exits with a non-zero status" do
+    process.stub(:exit_status).and_return(1)
+    expect { Foreplay::Deploy.start([:deploy, 'production', '']) }.to raise_error(RuntimeError, /.*output message*/)
+  end
+
+  it "should terminate if a connection can't be established with the remote server" do
+    Net::SSH.unstub(:start)
+    expect { Foreplay::Deploy.start([:deploy, 'production', '']) }.to raise_error(RuntimeError, /.*There was a problem starting an ssh session on web.example.com*/)
+  end
+
+	it "should check the config" do
+    output = <<OUTPUT
+Checking \e[0;33;49mproduction\e[0m environment, all roles, all servers
+Checking \e[0;33;49mforeplay\e[0m for \e[0;33;49mweb.example.com\e[0m in the \e[0;33;49mweb\e[0m role on the \e[0;33;49mproduction\e[0m environment
+    No instance is currently deployed
+    \e[0;33;49mSetting the port for the new instance to 50000\e[0m
+        echo 50000 > .foreplay/current_port
+    \e[0;33;49mCloning repository git@github.com:Xenapto/foreplay.git\e[0m
+        mkdir -p apps/foreplay && cd apps/foreplay && rm -rf 50000 && git clone git@github.com:Xenapto/foreplay.git 50000
+    \e[0;33;49mTrusting the .rvmrc file for the new instance\e[0m
+        rvm rvmrc trust 50000
+    \e[0;33;49mConfiguring the new instance\e[0m
+        cd 50000
+    \e[0;33;49mBuilding .env\e[0m
+    \e[0;33;49mBuilding .foreman\e[0m
+    \e[0;33;49mBuilding config/database.yml\e[0m
+    \e[0;33;49mUsing bundler to install the required gems\e[0m
+        bundle install
+    \e[0;33;49mSetting the current version of foreman to be the default\e[0m
+        sudo ln -f `which foreman` /usr/bin/foreman
+    \e[0;33;49mConverting foreplay-50000 to an upstart service\e[0m
+        sudo foreman export upstart /etc/init
+    \e[0;33;49mStarting the service\e[0m
+        sudo start foreplay-50000 || sudo restart foreplay-50000
+    \e[0;33;49mWaiting 60s to give service time to start\e[0m
+        sleep 60
+    \e[0;33;49mAdding firewall rule to direct incoming traffic on port 80 to port 50000\e[0m
+        sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 50100
+    \e[0;33;49mRemoving previous firewall directing traffic to port 51000\e[0m
+        sudo iptables -t nat -D PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 51100
+    \e[0;33;49mSaving iptables rules to /etc/iptables/rules.v4\e[0m
+        sudo iptables-save > /etc/iptables/rules.v4
+    \e[0;33;49mSaving iptables rules to /etc/iptables.up.rules\e[0m
+        sudo iptables-save > /etc/iptables.up.rules
+    \e[0;33;49mCurrent firewall NAT configuration:\e[0m
+        sudo iptables-save -c | egrep REDIRECT --color=never
+    \e[0;33;49mStopping the previous instance\e[0m
+        sudo stop foreplay-51000 || echo 'No previous instance running'
+Deployment configuration check was successful
+OUTPUT
+
+    output.split("\n").reverse.each { |line| $stdout.should_receive(:puts).with(line) }
+		Foreplay::Deploy.start [:check, 'production', '']
+	end
+
+  it "should deploy to the environment" do
+    Net::SSH.should_receive(:start).with('web.example.com', 'fred', { :verbose => :warn, :password => 'trollope' }).and_yield(session)
+
+    [
+      'mkdir -p .foreplay && touch .foreplay/current_port && cat .foreplay/current_port',
+      'echo 50000 > .foreplay/current_port',
+      'mkdir -p apps/foreplay && cd apps/foreplay && rm -rf 50000 && git clone git@github.com:Xenapto/foreplay.git 50000',
+      'rvm rvmrc trust 50000',
+      'cd 50000',
+      'echo "RAILS_ENV=production" > .env',
+      'echo "concurrency: web=1,worker=0,scheduler=0" > .foreman',
+      'echo "app: foreplay-50000" >> .foreman',
+      'echo "port: 50000" >> .foreman',
+      'echo "user: fred" >> .foreman',
+      'echo "production:" > config/database.yml',
+      'echo "  adapter: postgresql" >> config/database.yml',
+      'echo "  encoding: utf8" >> config/database.yml',
+      'echo "  database: TODO Put the database name here" >> config/database.yml',
+      'echo "  pool: 5" >> config/database.yml',
+      'echo "  host: TODO Put here the database host name" >> config/database.yml',
+      'echo "  username: TODO Put here the database user" >> config/database.yml',
+      'echo "  password: TODO Put here the database user\'s password" >> config/database.yml',
+      'bundle install',
+      'sudo ln -f `which foreman` /usr/bin/foreman',
+      'sudo foreman export upstart /etc/init',
+      'sudo start foreplay-50000 || sudo restart foreplay-50000',
+      'sleep 60',
+      'sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 50100',
+      'sudo iptables -t nat -D PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 51100',
+      'sudo iptables-save > /etc/iptables/rules.v4',
+      'sudo iptables-save > /etc/iptables.up.rules',
+      'sudo iptables-save -c | egrep REDIRECT --color=never',
+      'sudo stop foreplay-51000 || echo \'No previous instance running\''
+    ].each do |command|
+      shell.should_receive(:execute).with(command).and_return(process)
+    end
+
+    Foreplay::Deploy.start [:deploy, 'production', '']
+  end
+
+  it "should use another port if there's already an installed instance" do
+    process.stub(:on_output).and_yield(process, "50000\n")
+    shell.should_receive(:execute).with('echo 51000 > .foreplay/current_port').and_return(process)
+    Foreplay::Deploy.start [:deploy, 'production', '']
+  end
+
+  it "should use the private key provided in the config file" do
+    `rm -f config/foreplay.yml`
+    `foreplay setup -r git@github.com:Xenapto/foreplay.git -s web.example.com -f apps/%a -u fred -k "top secret private key"`
+    Foreplay::Deploy.start([:deploy, 'production', ''])
+  end
+end