engineyard-serverside 2.7.8pre2 → 2.8.0.pre

data/lib/engineyard-serverside/slug/source.rb

@@ -0,0 +1,16 @@
+require 'engineyard-serverside/slug/source/updater'
+
+module EY
+  module Serverside
+    module Slug
+      module Source
+
+        def self.update(data = {})
+          Updater.new(data).update
+        end
+
+
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/slug/source/updater.rb

@@ -0,0 +1,194 @@
+require 'railway'
+require 'runner'
+
+module EY
+  module Serverside
+    module Slug
+      module Source
+
+        class Updater
+          include Railway
+          include Runner
+
+          step :create_source_cache
+          step :ensure_ssh_wrapper
+          step :determine_if_clone_needed
+          step :clone_if_necessary
+          step :prune_source_cache
+          step :fetch_updates
+          step :clean_local_branch
+          step :calculate_requested_revision
+          step :checkout_requested_revision
+          step :sync_submodules
+          step :update_submodules
+          step :clean_source_cache
+
+          attr_reader :source_cache, :uri, :git, :quiet, :ref, :config
+
+          def initialize(input = {})
+            @input = input
+            @config = input[:config]
+            source = input[:config].source
+            @source_cache = source.source_cache
+            @uri = source.uri
+            @quiet = source.opts[:verbose] ? '' : '--quiet'
+            @ref = source.ref
+            @git = "#{wrapped_git} --git-dir #{source_cache}/.git --work-tree #{source_cache}"
+          end
+
+          def update
+            call(@input)
+          end
+
+          private
+
+          def wrapped_git
+            "GIT_SSH=#{paths.ssh_wrapper} git"
+          end
+
+          def create_source_cache(input = {})
+            begin
+              source_cache.mkpath
+            rescue
+              return Failure(:error => "Could not create #{source_cache}")
+            end
+
+            Success(input)
+          end
+
+          def ensure_ssh_wrapper(input = {})
+            wrapper_location = paths.ssh_wrapper
+
+            return Success(input) if File.executable?(wrapper_location)
+
+            begin
+              wrapper = File.open(wrapper_location, 'w', 0700)
+              wrapper.write <<-WRAPPER
+#!/bin/sh
+
+unset SSH_AUTH_SOCK
+
+command=$(wcho "$*" | sed -e 's/^-batch //')
+
+ssh -o CheckHostIP=no -o StrictHostKeyChecking=no -o PasswordAuthentication=no -o LogLevel=INFO -o IdentityFile=#{paths.deploy_key} -o IdentitiesOnly=yes ${command}
+WRAPPER
+              wrapper.close
+            rescue => e
+              return Failure(input.merge(:error => e))
+            end
+
+            Success(input)
+          end
+
+          def determine_if_clone_needed(input = {})
+
+            check = 
+              source_cache.directory? &&
+              run_and_output("#{git} remote -v | grep original").include?(uri)
+
+            Success(input.merge(:clone_needed => !check))
+          end
+
+          def clone_if_necessary(input = {})
+            if input[:clone_needed]
+              unless run_and_success?("rm -rf #{source_cache} && git clone #{quiet} #{uri} #{source_cache} 2>&1")
+
+                return Failure(
+                  input.merge(:error => "Could not clone #{uri} to #{source_cache}")
+                )
+              end
+            end
+
+            Success(input)
+          end
+
+          def prune_source_cache(input = {})
+            return Failure(
+              input.merge(:error => "Could not prune #{source_cache}")
+            ) unless run_and_success?("#{git} remote prune origin 2>&1")
+
+            Success(input)
+          end
+
+          def fetch_updates(input = {})
+            return Failure(
+              input.merge(:error => "Could not fetch #{source_cache}")
+            ) unless run_and_success?("#{git} fetch --force --prune --update-head-ok #{quiet} origin '+refs/heads/*:refs/remotes/origin/*' '+refs/tags/*:refs/tags/*' 2>&1")
+
+            Success(input)
+          end
+
+          def clean_local_branch(input = {})
+            run_and_success?("#{git} show-branch #{ref} > /dev/null 2>&1 && #{git} branch -D #{ref} > /dev/null 2>&1")
+
+            Success(input)
+          end
+
+          def calculate_requested_revision(input = {})
+            remote_branch = Dir.chdir(source_cache) do
+              run_and_success?("#{git} show-branch origin/#{ref} > /dev/null 2>&1")
+            end
+
+            Success(
+              input.merge(
+                :requested_branch => remote_branch ? "origin/#{ref}" : ref
+              )
+            )
+          end
+
+          def checkout_requested_revision(input = {})
+            requested_branch = input[:requested_branch]
+
+            Dir.chdir(source_cache) {
+              run_and_success?(
+                "git checkout --force #{quiet} '#{requested_branch}'"
+              ) || run_and_success?(
+                "git reset --hard #{quiet} '#{requested_branch}'"
+              )
+            } ?
+              Success(input) :
+              Failure(
+                input.merge(:error => "Could not check out #{requested_branch}")
+              )
+          end
+
+          def sync_submodules(input = {})
+            return Failure(
+              input.merge(:error => "Could not sync submodules")
+            ) unless Dir.chdir(source_cache) {
+              run_and_success?("#{wrapped_git} submodule sync")
+            }
+
+            Success(input)
+          end
+
+          def update_submodules(input = {})
+            return Failure(
+              input.merge(:error => "Could not update submodules")
+            ) unless Dir.chdir(source_cache) {
+              run_and_success?("#{wrapped_git} submodule update --init --recursive")
+            }
+
+            Success(input)
+          end
+
+          def clean_source_cache(input = {})
+            return Failure(
+              input.merge(:error => "Could not clean source")
+            ) unless Dir.chdir(source_cache) {
+              run_and_success?('git clean -dfq')
+            }
+
+            Success(input)
+          end
+
+          def paths
+            config.paths
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Serverside
-    VERSION = '2.7.8pre2'
+    VERSION = '2.8.0.pre'
   end
 end

data/lib/railway.rb

@@ -0,0 +1,43 @@
+require 'result'
+
+module Railway
+  include Result::DSL
+
+  module DSL
+    def step(name, options = {})
+      with = options.delete(:with)
+      steps.push(:name => name, :with => with)
+    end
+
+    def steps
+      @steps ||= []
+    end
+  end
+
+  def self.included(base)
+    base.send :extend, DSL
+  end
+
+  def call(input = {})
+    steps = self.class.steps
+
+    return Failure('No steps') if steps.empty?
+
+    steps.
+      inject(Success(input)) {|result, step|
+        result.and_then {|data|
+          dispatch_step(step, data)
+        }
+      }
+  end
+
+  private
+  def dispatch_step(step, data)
+    begin
+      result = (step[:with] || self).send(step[:name], data)
+      result.is_a?(Result::Base) ? result : Success(result)
+    rescue => error
+      Failure(error)
+    end
+  end
+end

data/lib/result.rb

@@ -0,0 +1,7 @@
+require 'result/dsl'
+require 'result/success'
+require 'result/failure'
+
+module Result
+  extend DSL
+end

data/lib/result/base.rb

@@ -0,0 +1,41 @@
+module Result
+
+  class Base
+    def initialize(to_wrap)
+      @wrapped = to_wrap
+    end
+
+    def success?
+      false
+    end
+
+    def failure?
+      false
+    end
+
+    def value
+      raise "not present"
+    end
+
+    def error
+      raise "not present"
+    end
+
+    def and_then
+      self
+    end
+
+    def or_else
+      self
+    end
+
+    def on_success
+      self
+    end
+
+    def on_failure
+      self
+    end
+  end
+
+end

data/lib/result/dsl.rb

@@ -0,0 +1,16 @@
+require 'result/success'
+require 'result/failure'
+
+module Result
+
+  module DSL
+    def Success(value)
+      Success.new(value)
+    end
+
+    def Failure(error)
+      Failure.new(error)
+    end
+  end
+
+end

data/lib/result/failure.rb

@@ -0,0 +1,29 @@
+require 'result/base'
+
+module Result
+
+  class Failure < Base
+    def initialize(to_wrap)
+      super
+      freeze
+    end
+
+    def error
+      @wrapped
+    end
+
+    def failure?
+      true
+    end
+
+    def or_else
+      yield error
+    end
+
+    def on_failure
+      yield error
+      super
+    end
+  end
+
+end

data/lib/result/success.rb

@@ -0,0 +1,24 @@
+require 'result/base'
+
+module Result
+
+  class Success < Base
+    def value
+      @wrapped
+    end
+
+    def success?
+      true
+    end
+
+    def and_then
+      yield value
+    end
+
+    def on_success
+      yield value
+      super
+    end
+  end
+
+end

data/lib/runner.rb

@@ -0,0 +1,34 @@
+require 'engineyard-serverside/spawner'
+
+module Runner
+  def runner
+    EY::Serverside::Spawner
+  end
+
+  # Internal: Run a command.
+  #
+  # cmd - A string command.
+  #
+  # Returns an instance of Spawner.
+  def run(cmd)
+    runner.run(cmd, shell, nil)
+  end
+
+  # Internal: Run a command and return the output.
+  #
+  # cmd - A string command.
+  #
+  # Returns the output of the command.
+  def run_and_output(cmd)
+    run(cmd).output
+  end
+
+  # Internal: Run a command and check if it was successful.
+  #
+  # cmd - A string command.
+  #
+  # Returns success.
+  def run_and_success?(cmd)
+    run(cmd).success?
+  end
+end

data/spec/archive_deploy_spec.rb

@@ -27,7 +27,7 @@ describe "Deploying a simple application" do
     argv = adapter.deploy.commands.last.to_argv[2..-1]
     with_mocked_commands do
       capture do
-        EY::Serverside::CLI.start(argv)
+        EY::Serverside::CLI::App.start(argv)
       end
     end
   end

data/spec/bundler_deploy_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe "Deploying an application that uses Bundler" do
   VERSION_PATTERN = Regexp.quote(::EY::Serverside::DependencyManager::Bundler.default_version)
+  PARALLEL_JOBS = ::EY::Serverside::DependencyManager::Bundler.jobs_number
 
   context "with a Gemfile.lock" do
     before(:all) do
@@ -20,6 +21,11 @@ describe "Deploying an application that uses Bundler" do
       expect(@bundle_install_command).to include('--deployment')
     end
 
+    it "runs 'bundle install' with --jobs #{PARALLEL_JOBS}" do
+      expect(@bundle_install_command).not_to be_nil
+      expect(@bundle_install_command).to include("--jobs #{PARALLEL_JOBS}")
+    end
+
     it "removes bundled_gems directory if the ruby or system version changed" do
       should_run_clear_bundle_cmd = @deployer.commands.grep(/diff/).first
       expect(should_run_clear_bundle_cmd).not_to be_nil
@@ -92,6 +98,11 @@ describe "Deploying an application that uses Bundler" do
       expect(@bundle_install_command).not_to match(/--deployment/)
     end
 
+    it "runs 'bundle install' with --jobs #{PARALLEL_JOBS}" do
+      expect(@bundle_install_command).not_to be_nil
+      expect(@bundle_install_command).to include("--jobs #{PARALLEL_JOBS}")
+    end
+
     it "exports GIT_SSH for the bundle install" do
       expect(@bundle_install_command).to match(/export GIT_SSH/)
     end
@@ -135,5 +146,15 @@ describe "Deploying an application that uses Bundler" do
       expect(deploy_dir.join('current', 'after_bundle.ran' )).not_to exist
     end
   end
-end
 
+  context "with outdated bundler" do
+    before :all do
+      deploy_test_application( "bundler_old" )
+      @bundle_install_command = @deployer.commands.grep( /bundle _1.3.6_ install/ ).first
+    end
+
+    it "doesn't run 'bundle install' with --jobs" do
+      expect( @bundle_install_command ).to_not include "--jobs"
+    end
+  end
+end