engineyard-serverside 1.2.0

data/lib/engineyard-serverside/deploy_hook.rb

@@ -0,0 +1,80 @@
+module EY
+  class DeployHook < Task
+    def initialize(options)
+      super(EY::Deploy::Configuration.new(options))
+    end
+
+    def callback_context
+      @context ||= CallbackContext.new(config)
+    end
+
+    def run(hook)
+      hook_path = "#{c.release_path}/deploy/#{hook}.rb"
+      if File.exist?(hook_path)
+        Dir.chdir(c.release_path) do
+          puts "~> running deploy hook: deploy/#{hook}.rb"
+          if desc = syntax_error(hook_path)
+            hook_name = File.basename(hook_path)
+            abort "*** [Error] Invalid Ruby syntax in hook: #{hook_name} ***\n*** #{desc.chomp} ***"
+          else
+            callback_context.instance_eval(IO.read(hook_path))
+          end
+        end
+      end
+    end
+
+    def syntax_error(file)
+      valid = Kernel.system("ruby -c #{file} 2>/tmp/ey_invalid_deploy_hook | grep 'Syntax OK' --quiet")
+      File.new("/tmp/ey_invalid_deploy_hook").gets unless valid
+    end
+
+    class CallbackContext
+      def initialize(config)
+        @configuration = config
+        @node = node
+      end
+
+      def method_missing(meth, *args, &blk)
+        if @configuration.respond_to?(meth)
+          @configuration.send(meth, *args, &blk)
+        else
+          super
+        end
+      end
+
+      def respond_to?(meth, include_private=false)
+        @configuration.respond_to?(meth, include_private) || super
+      end
+
+      def run(cmd)
+        system(Escape.shell_command(["sh", "-l", "-c", cmd]))
+      end
+
+      def sudo(cmd)
+        system(Escape.shell_command(["sudo", "sh", "-l", "-c", cmd]))
+      end
+
+      # convenience functions for running on certain instance types
+      def on_app_master(&blk)                 on_roles(%w[solo app_master],          &blk) end
+      def on_app_servers(&blk)                on_roles(%w[solo app_master app],      &blk) end
+      def on_db_master(&blk)                  on_roles(%w[solo db_master],           &blk) end
+      def on_db_slaves(&blk)                  on_roles(%w[db_slave],                 &blk) end
+      def on_db_servers(&blk)                 on_roles(%w[solo db_master db_slave],  &blk) end
+      def on_app_servers_and_utilities(&blk)  on_roles(%w[solo app_master app util], &blk) end
+
+      def on_utilities(*names, &blk)
+        names.flatten!
+        on_roles(%w[util]) do
+          blk.call if names.empty? || names.include?(current_name)
+        end
+      end
+
+      private
+      def on_roles(desired_roles)
+        yield if desired_roles.include?(current_role.to_s)
+      end
+
+    end
+
+  end
+end

data/lib/engineyard-serverside/lockfile_parser.rb

@@ -0,0 +1,55 @@
+require 'yaml'
+module EY
+  class LockfileParser
+
+    attr_reader :bundler_version, :lockfile_version
+
+    def initialize(lockfile_contents)
+      @contents = lockfile_contents
+      @lockfile_version, @bundler_version = parse
+    end
+
+    private
+    def parse
+      from_yaml = safe_yaml_load(@contents)
+      if from_yaml                        # 0.9
+        bundler_version = from_yaml['specs'].map do |spec|
+          # spec is a one-element hash: the key is the gem name, and
+          # the value is {"version" => the-version}.
+          if spec.keys.first == "bundler"
+            spec.values.first["version"]
+          end
+        end.compact.first
+        [:bundler09, bundler_version]
+      else                                # 1.0 or bust
+        dep_section = ""
+        in_dependencies_section = false
+        @contents.each_line do |line|
+          if line =~ /^DEPENDENCIES/
+            in_dependencies_section = true
+          elsif line =~ /^\S/
+            in_dependencies_section = false
+          elsif in_dependencies_section
+            dep_section << line
+          end
+        end
+
+        unless dep_section.length > 0
+          raise "Couldn't parse #{lockfile}; exiting"
+          exit(1)
+        end
+
+        result = dep_section.scan(/^\s*bundler\s*\(=\s*([^\)]+)\)/).first
+        bundler_version = result ? result.first : nil
+        [:bundler10, bundler_version]
+      end
+    end
+
+    def safe_yaml_load(loadable)
+      YAML.load(loadable)
+    rescue ArgumentError   # not yaml
+      nil
+    end
+
+  end
+end

data/lib/engineyard-serverside/logged_output.rb

@@ -0,0 +1,78 @@
+require 'open4'
+
+module EY
+  module LoggedOutput
+
+    class Tee
+      def initialize(*streams)
+        @streams = streams.flatten
+      end
+
+      def <<(output)
+        @streams.each do |s|
+          s << output
+          s.flush
+        end
+        self
+      end
+    end # Tee
+
+    @@logfile = File.join(ENV['HOME'], 'ey.log')
+    def self.logfile=(filename)
+      File.unlink filename if File.exist?(filename)  # start fresh
+      @@logfile = filename
+    end
+
+    def self.logfile
+      @@logfile
+    end
+
+    @@verbose = false
+    def self.verbose=(v)
+      @@verbose = !!v
+    end
+
+    def self.verbose?
+      @@verbose
+    end
+
+    def verbose?
+      EY::LoggedOutput.verbose?
+    end
+
+    def info(msg)
+      with_logfile do |log|
+        Tee.new($stdout, log) << (msg + "\n")
+      end
+    end
+
+    def debug(msg)
+      with_logfile do |log|
+        log << "#{msg}\n"
+      end
+    end
+
+    def logged_system(cmd)
+      with_logfile do |log|
+        out = verbose? ? Tee.new($stdout, log) : log
+        err = Tee.new($stderr, log)    # we always want to see errors
+
+        out <<  ":: running #{cmd}\n"
+
+        # :quiet means don't raise an error on nonzero exit status
+        status = Open4.spawn cmd, 0 => '', 1 => out, 2 => err, :quiet => true
+        status.exitstatus == 0
+      end
+    end
+
+    private
+    def with_logfile
+      File.open(logfile, 'a') {|f| yield f }
+    end
+
+    def logfile
+      EY::LoggedOutput.logfile
+    end
+
+  end
+end

data/lib/engineyard-serverside/server.rb

@@ -0,0 +1,70 @@
+require 'open-uri'
+require 'engineyard-serverside/logged_output'
+
+module EY
+  class Server < Struct.new(:hostname, :role, :name)
+    include LoggedOutput
+
+    def initialize(*fields)
+      super
+      self.role = self.role.to_sym
+    end
+
+    def self.config=(config)
+      @@config = config
+    end
+
+    def config
+      @@config
+    end
+
+    attr_writer :default_task
+
+    def self.from_roles(*roles)
+      roles = roles.flatten.compact
+      return all if !roles || roles.include?(:all) || roles.empty?
+
+      all.select do |s|
+        roles.include?(s.role) || roles.include?(s.name)
+      end
+    end
+
+    def self.from_hash(h)
+      new(h[:hostname], h[:role], h[:name])
+    end
+
+    def self.all
+      @all
+    end
+
+    def self.all=(server_hashes)
+      @all = server_hashes.map { |s| from_hash(s) }
+    end
+
+    def self.current
+      all.find {|s| s.local? }
+    end
+
+    def local?
+      [:app_master, :solo].include?(role)
+    end
+
+    def push_code
+      return if local?
+      run "mkdir -p #{config.repository_cache}"
+      logged_system(%|rsync --delete -aq -e "#{ssh_command}" #{config.repository_cache}/ #{config.user}@#{hostname}:#{config.repository_cache}|)
+    end
+
+    def run(command)
+      if local?
+        logged_system(command)
+      else
+        logged_system(ssh_command + " " + Escape.shell_command(["#{config.user}@#{hostname}", command]))
+      end
+    end
+
+    def ssh_command
+      "ssh -i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o PasswordAuthentication=no"
+    end
+  end
+end

data/lib/engineyard-serverside/strategies/git.rb

@@ -0,0 +1,136 @@
+require 'engineyard-serverside/logged_output'
+
+module EY
+  module Strategies
+    class Git
+      module Helpers
+        def update_repository_cache
+          strategy.fetch
+          unless strategy.checkout
+            abort "*** [Error] Git could not checkout (#{strategy.to_checkout}) ***"
+          end
+        end
+
+        def create_revision_file_command
+          strategy.create_revision_file_command(c.release_path)
+        end
+
+        def short_log_message(revision)
+          strategy.short_log_message(revision)
+        end
+
+        def strategy
+          klass = Module.nesting[1]
+          # Use [] to access attributes instead of calling methods so
+          # that we get nils instead of NoMethodError.
+          #
+          # Rollback doesn't know about the repository location (nor
+          # should it need to), but it would like to use #short_log_message.
+          klass.new(
+            :repository_cache => c[:repository_cache],
+            :app => c[:app],
+            :repo => c[:repo],
+            :ref => c[:branch]
+          )
+        end
+      end
+
+      include LoggedOutput
+
+      attr_reader :opts
+
+      def initialize(opts)
+        @opts = opts
+        set_up_git_ssh(@opts[:app])
+      end
+
+      def usable_repository?
+        File.directory?(opts[:repository_cache]) && `#{git} remote -v | grep origin`[opts[:repo]]
+      end
+
+      def fetch
+        if usable_repository?
+          logged_system("#{git} fetch -q origin 2>&1")
+        else
+          FileUtils.rm_rf(opts[:repository_cache])
+          logged_system("git clone -q #{opts[:repo]} #{opts[:repository_cache]} 2>&1")
+        end
+      end
+
+      def checkout
+        info "~> Deploying revision #{short_log_message(to_checkout)}"
+        in_git_work_tree do
+          (logged_system("git checkout -q '#{to_checkout}'") ||
+            logged_system("git reset -q --hard '#{to_checkout}'")) &&
+            logged_system("git submodule update --init") &&
+            logged_system("git clean -dfq")
+        end
+      end
+
+      def to_checkout
+        return @to_checkout if @opts_ref == opts[:ref]
+        @opts_ref = opts[:ref]
+        @to_checkout = if branch?(opts[:ref])
+          "origin/#{opts[:ref]}"
+        else
+          opts[:ref]
+        end
+      end
+
+      def create_revision_file_command(dir)
+        %Q{#{git} show --pretty=format:"%H" | head -1 > "#{dir}/REVISION"}
+      end
+
+      def short_log_message(rev)
+        `#{git} log --pretty=oneline --abbrev-commit '#{rev}^..#{rev}'`.strip
+      end
+
+    private
+      def in_git_work_tree
+        Dir.chdir(git_work_tree) { yield }
+      end
+
+      def git_work_tree
+        opts[:repository_cache]
+      end
+
+      def git
+        "git --git-dir #{git_work_tree}/.git --work-tree #{git_work_tree}"
+      end
+
+      def branch?(ref)
+        `#{git} branch -r`.map { |x| x.strip }.include?("origin/#{ref}")
+      end
+
+      def set_up_git_ssh(app)
+        # hold references to the tempfiles so they don't get finalized
+        # unexpectedly; tempfile finalization unlinks the files
+        @git_ssh = Tempfile.open("git-ssh")
+        @config = Tempfile.open("git-ssh-config")
+
+        @config.write "StrictHostKeyChecking no\n"
+        @config.write "CheckHostIP no\n"
+        @config.write "PasswordAuthentication no\n"
+        @config.write "LogLevel DEBUG\n"
+        @config.write "IdentityFile ~/.ssh/#{app}-deploy-key\n"
+        @config.chmod(0600)
+        @config.close
+
+        @git_ssh.write "#!/bin/sh\n"
+        @git_ssh.write "unset SSH_AUTH_SOCK\n"
+        @git_ssh.write "ssh -F \"#{@config.path}\" $*\n"
+        @git_ssh.chmod(0700)
+        # NB: this file _must_ be closed before git looks at it.
+        #
+        # Linux won't let you execve a file that's open for writing,
+        # so if this file stays open, then git will complain about
+        # being unable to exec it and will exit with a message like
+        #
+        # fatal: exec /tmp/git-ssh20100417-21417-d040rm-0 failed.
+        @git_ssh.close
+
+        ENV['GIT_SSH'] = @git_ssh.path
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/task.rb

@@ -0,0 +1,62 @@
+module EY
+  class Task
+    include Dataflow
+
+    attr_reader :config
+    alias :c :config
+
+    def initialize(conf)
+      @config = conf
+      @roles = :all
+    end
+
+    def require_custom_tasks
+      deploy_file = ["config/eydeploy.rb", "eydeploy.rb"].map do |short_file|
+        File.join(c.repository_cache, short_file)
+      end.detect do |file|
+        File.exist?(file)
+      end
+
+      if deploy_file
+        puts "~> Loading deployment task overrides from #{deploy_file}"
+        instance_eval(File.read(deploy_file))
+        true
+      else
+        false
+      end
+    end
+
+    def roles(*task_roles)
+      raise "Roles must be passed a block" unless block_given?
+
+      begin
+        @roles = task_roles
+        yield
+      ensure
+        @roles = :all
+      end
+    end
+
+    def run(cmd, &blk)
+      run_on_roles(cmd, &blk)
+    end
+
+    def sudo(cmd, &blk)
+      run_on_roles(cmd, %w[sudo sh -l -c], &blk)
+    end
+
+    private
+
+    def run_on_roles(cmd, wrapper=%w[sh -l -c])
+      results = EY::Server.from_roles(@roles).map do |server|
+        to_run = block_given? ? yield(server, cmd.dup) : cmd
+        need_later { server.run(Escape.shell_command(wrapper + [to_run])) }
+      end
+      barrier *results
+      # MRI's truthiness check is an internal C thing that does not call
+      # any methods... so Dataflow cannot proxy it & we must "x == true"
+      # Rubinius, wherefore art thou!?
+      results.all?{|x| x == true } || raise(EY::RemoteFailure)
+    end
+  end
+end