engineyard-serverside 2.7.0.pre → 2.7.8pre2

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

@@ -1,16 +0,0 @@
-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

@@ -1,194 +0,0 @@
-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/railway.rb

@@ -1,43 +0,0 @@
-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

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

data/lib/result/base.rb

@@ -1,41 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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