engineyard-serverside 2.0.0.pre3 → 2.0.0.pre4

data/lib/engineyard-serverside/deploy.rb

@@ -44,7 +44,7 @@ module EY
 
         callback(:after_symlink)
         run_with_callbacks(:restart)
-        disable_maintenance_page
+        conditionally_disable_maintenance_page
 
         cleanup_old_releases
         shell.status "Finished deploy at #{Time.now.asctime}"
@@ -67,7 +67,7 @@ module EY
       end
 
       def parse_configured_services
-        result = YAML.load_file "#{c.shared_path}/config/ey_services_config_deploy.yml"
+        result = YAML.load_file "#{c.paths.shared_config}/ey_services_config_deploy.yml"
         return {} unless result.is_a?(Hash)
         result
       rescue
@@ -138,6 +138,7 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
           File.exists?(file)
         end
 
+        shell.status "Enabling maintenance page."
         @maintenance_up = true
         roles :app_master, :app, :solo do
           run Escape.shell_command(['mkdir', '-p', File.dirname(c.maintenance_page_enabled_path)])
@@ -148,22 +149,49 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
       def conditionally_enable_maintenance_page
         if c.enable_maintenance_page?
           enable_maintenance_page
+        else
+          explain_not_enabling_maintenance_page
         end
       end
 
-      def disable_maintenance_page
-        if c.enable_maintenance_page?
-          @maintenance_up = false
-          roles :app_master, :app, :solo do
-            run "rm -f #{c.maintenance_page_enabled_path}"
+      def explain_not_enabling_maintenance_page
+        if c.migrate?
+          if !c.maintenance_on_migrate? && !c.maintenance_on_restart?
+            shell.status "Skipping maintenance page. (maintenance_on_migrate is false in ey.yml)"
+            shell.notice "[Caution] No maintenance migrations must be non-destructive!"
+            shell.notice "Requests may be served during a partially migrated state."
           end
         else
-          if File.exists?(c.maintenance_page_enabled_path)
-            shell.notice "[Attention] Maintenance page is still up. You must remove it manually."
+          if c.required_downtime_stack? && !c.maintenance_on_restart?
+            shell.status "Skipping maintenance page. (maintenance_on_restart is false in ey.yml, overriding recommended default)"
+            unless File.exist?(c.maintenance_page_enabled_path)
+              shell.warning <<-WARN
+No maintenance page! Brief downtime may be possible during restart.
+This application stack does not support no-downtime restarts.
+              WARN
+            end
+          elsif !c.required_downtime_stack?
+            shell.status "Skipping maintenance page. (no-downtime restarts supported)"
           end
         end
       end
 
+      def disable_maintenance_page
+        shell.status "Removing maintenance page."
+        @maintenance_up = false
+        roles :app_master, :app, :solo do
+          run "rm -f #{c.maintenance_page_enabled_path}"
+        end
+      end
+
+      def conditionally_disable_maintenance_page
+        if c.disable_maintenance_page?
+          disable_maintenance_page
+        elsif File.exists?(c.maintenance_page_enabled_path)
+          shell.notice "[Attention] Maintenance page is still up.\nYou must remove it manually using `ey web enable`."
+        end
+      end
+
       def run_with_callbacks(task)
         callback("before_#{task}")
         send(task)
@@ -173,7 +201,7 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
       # task
       def push_code
         shell.status "Pushing code to all servers"
-        commands = EY::Serverside::Server.all.reject { |server| server.local? }.map do |server|
+        commands = servers.remote.map do |server|
           cmd = server.sync_directory_command(config.repository_cache)
           proc { shell.logged_system(cmd) }
         end
@@ -229,7 +257,7 @@ chmod 0700 #{path}
       end
 
       def ssh_wrapper_path
-        "#{c.shared_path}/config/#{c.app}-ssh-wrapper"
+        "#{c.paths.shared_config}/#{c.app}-ssh-wrapper"
       end
 
       # task
@@ -260,20 +288,23 @@ chmod 0700 #{path}
 
       # task
       def rollback
-        if c.all_releases.size > 1
-          rolled_back_release = c.latest_release
-          c.release_path = c.previous_release(rolled_back_release)
-
-          revision = File.read(File.join(c.release_path, 'REVISION')).strip
-          shell.status "Rolling back to previous release: #{short_log_message(revision)}"
-
-          run_with_callbacks(:symlink)
-          sudo "rm -rf #{rolled_back_release}"
-          bundle
-          shell.status "Restarting with previous release."
-          with_maintenance_page { run_with_callbacks(:restart) }
+        if c.rollback_paths!
+          begin
+            rolled_back_release = c.paths.latest_release
+            shell.status "Rolling back to previous release: #{short_log_message(c.active_revision)}"
+            run_with_callbacks(:symlink)
+            sudo "rm -rf #{rolled_back_release}"
+            bundle
+            shell.status "Restarting with previous release."
+            with_maintenance_page { run_with_callbacks(:restart) }
+            shell.status "Finished rollback at #{Time.now.asctime}"
+          rescue Exception
+            shell.status "Failed to rollback at #{Time.now.asctime}"
+            puts_deploy_failure
+            raise
+          end
         else
-          shell.status "Already at oldest release, nothing to roll back to."
+          shell.fatal "Already at oldest release, nothing to roll back to."
           exit(1)
         end
       end
@@ -282,8 +313,8 @@ chmod 0700 #{path}
       def migrate
         return unless c.migrate?
         @migrations_reached = true
+        cmd = "cd #{c.release_path} && PATH=#{c.binstubs_path}:$PATH #{c.framework_envs} #{c.migration_command}"
         roles :app_master, :solo do
-          cmd = "cd #{c.release_path} && PATH=#{c.binstubs_path}:$PATH #{c.framework_envs} #{c.migration_command}"
           shell.status "Migrating: #{cmd}"
           run(cmd)
         end
@@ -292,7 +323,8 @@ chmod 0700 #{path}
       # task
       def copy_repository_cache
         shell.status "Copying to #{c.release_path}"
-        run("mkdir -p #{c.release_path} #{c.failed_release_dir} && rsync -aq #{c.exclusions} #{c.repository_cache}/ #{c.release_path}")
+        exclusions = Array(c.copy_exclude).map { |e| %|--exclude="#{e}"| }.join(' ')
+        run("mkdir -p #{c.release_path} #{c.failed_release_dir} #{c.paths.shared_config} && rsync -aq #{exclusions} #{c.repository_cache}/ #{c.release_path}")
 
         shell.status "Ensuring proper ownership."
         sudo("chown -R #{c.user}:#{c.group} #{c.release_path} #{c.failed_release_dir}")
@@ -337,7 +369,7 @@ Deploy again if your services configuration appears incomplete or out of date.
            ["Creating SQLite database if needed", "touch #{c.shared_path}/databases/#{c.framework_env}.sqlite3"],
            ["Create config directory if needed", "mkdir -p #{c.release_path}/config"],
            ["Generating SQLite config", <<-WRAP],
-cat > #{c.shared_path}/config/database.sqlite3.yml<<'YML'
+cat > #{c.paths.shared_config}/database.sqlite3.yml<<'YML'
 #{c.framework_env}:
   adapter: sqlite3
   database: #{c.shared_path}/databases/#{c.framework_env}.sqlite3
@@ -345,7 +377,7 @@ cat > #{c.shared_path}/config/database.sqlite3.yml<<'YML'
   timeout: 5000
 YML
 WRAP
-           ["Symlink database.yml", "ln -nfs #{c.shared_path}/config/database.sqlite3.yml #{c.release_path}/config/database.yml"],
+           ["Symlink database.yml", "ln -nfs #{c.paths.shared_config}/database.sqlite3.yml #{c.release_path}/config/database.yml"],
           ].each do |what, cmd|
             shell.status "#{what}"
             run(cmd)
@@ -373,15 +405,15 @@ WRAP
           ["Set group write permissions", "chmod -R g+w #{release_to_link}"],
           ["Remove revision-tracked shared directories from deployment", "rm -rf #{release_to_link}/log #{release_to_link}/public/system #{release_to_link}/tmp/pids"],
           ["Create tmp directory", "mkdir -p #{release_to_link}/tmp"],
-          ["Symlink shared log directory", "ln -nfs #{c.shared_path}/log #{release_to_link}/log"],
+          ["Symlink shared log directory", "ln -nfs #{c.paths.shared_log} #{release_to_link}/log"],
           ["Create public directory if needed", "mkdir -p #{release_to_link}/public"],
           ["Create config directory if needed", "mkdir -p #{release_to_link}/config"],
-          ["Create system directory if needed", "ln -nfs #{c.shared_path}/system #{release_to_link}/public/system"],
+          ["Create system directory if needed", "ln -nfs #{c.paths.shared_system} #{release_to_link}/public/system"],
           ["Symlink shared pids directory", "ln -nfs #{c.shared_path}/pids #{release_to_link}/tmp/pids"],
-          ["Symlink other shared config files", "find #{c.shared_path}/config -type f -not -name 'database.yml' -exec ln -s {} #{release_to_link}/config \\;"],
-          ["Symlink mongrel_cluster.yml", "ln -nfs #{c.shared_path}/config/mongrel_cluster.yml #{release_to_link}/config/mongrel_cluster.yml"],
-          ["Symlink database.yml", "ln -nfs #{c.shared_path}/config/database.yml #{release_to_link}/config/database.yml"],
-          ["Symlink newrelic.yml if needed", "if [ -f \"#{c.shared_path}/config/newrelic.yml\" ]; then ln -nfs #{c.shared_path}/config/newrelic.yml #{release_to_link}/config/newrelic.yml; fi"],
+          ["Symlink other shared config files", "find #{c.paths.shared_config} -type f -not -name 'database.yml' -exec ln -s {} #{release_to_link}/config \\;"],
+          ["Symlink mongrel_cluster.yml", "ln -nfs #{c.paths.shared_config}/mongrel_cluster.yml #{release_to_link}/config/mongrel_cluster.yml"],
+          ["Symlink database.yml", "ln -nfs #{c.paths.shared_config}/database.yml #{release_to_link}/config/database.yml"],
+          ["Symlink newrelic.yml if needed", "if [ -f \"#{c.paths.shared_config}/newrelic.yml\" ]; then ln -nfs #{c.paths.shared_config}/newrelic.yml #{release_to_link}/config/newrelic.yml; fi"],
         ]
       end
 
@@ -402,7 +434,7 @@ WRAP
           shell.status "Running deploy hook: deploy/#{what}.rb"
           run Escape.shell_command(base_callback_command_for(what)) do |server, cmd|
             per_instance_args = []
-            per_instance_args << '--current-roles' << server.roles.join(' ')
+            per_instance_args << '--current-roles' << server.roles.to_a.join(' ')
             per_instance_args << '--current-name'  << server.name.to_s if server.name
             per_instance_args << '--config'        << c.to_json
             cmd << " " << Escape.shell_command(per_instance_args)
@@ -438,7 +470,7 @@ WRAP
         cmd << '--environment-name' << config.environment_name
         cmd << '--account-name'     << config.account_name
         cmd << '--release-path'     << config.release_path.to_s
-        cmd << '--framework-env'    << config.environment.to_s
+        cmd << '--framework-env'    << config.framework_env.to_s
         cmd << '--verbose' if config.verbose
         cmd
       end
@@ -472,7 +504,7 @@ WRAP
       def with_maintenance_page
         conditionally_enable_maintenance_page
         yield if block_given?
-        disable_maintenance_page
+        conditionally_disable_maintenance_page
       end
 
       def with_failed_release_cleanup

data/lib/engineyard-serverside/deploy_hook.rb

@@ -2,15 +2,22 @@ require 'engineyard-serverside/shell/helpers'
 
 module EY
   module Serverside
-    class DeployHook < Task
+    class DeployHook
+      def initialize(config, shell, hook_name)
+        @config, @shell, @hook_name = config, shell, hook_name
+      end
+
+      def hook_path
+        "#{@config.release_path}/deploy/#{@hook_name}.rb"
+      end
+
       def callback_context
-        @context ||= CallbackContext.new(config, shell)
+        @context ||= CallbackContext.new(@config, @shell, hook_path)
       end
 
-      def run(hook)
-        hook_path = "#{c.release_path}/deploy/#{hook}.rb"
+      def call
         if File.exist?(hook_path)
-          Dir.chdir(c.release_path) do
+          Dir.chdir(@config.release_path) do
             if desc = syntax_error(hook_path)
               hook_name = File.basename(hook_path)
               abort "*** [Error] Invalid Ruby syntax in hook: #{hook_name} ***\n*** #{desc.chomp} ***"
@@ -23,6 +30,19 @@ module EY
 
       def eval_hook(code)
         callback_context.instance_eval(code)
+      rescue Exception => exception
+        display_hook_error(exception, code, hook_path)
+        raise exception
+      end
+
+      def display_hook_error(exception, code, hook_path)
+        @shell.fatal <<-ERROR
+Exception raised in deploy hook #{hook_path.inspect}.
+
+#{exception.class}: #{exception.to_s}
+
+Please fix this error before retrying.
+        ERROR
       end
 
       def syntax_error(file)
@@ -35,17 +55,22 @@ module EY
 
         attr_reader :shell
 
-        def initialize(config, shell)
+        def initialize(config, shell, hook_path)
           @configuration = config
           @configuration.set_framework_envs
           @shell = shell
           @node = node
+          @hook_path = hook_path
         end
 
         def config
           @configuration
         end
 
+        def inspect
+          "#<DeployHook::CallbackContext #{hook_path.inspect}>"
+        end
+
         def method_missing(meth, *args, &blk)
           if @configuration.respond_to?(meth)
             @configuration.send(meth, *args, &blk)

data/lib/engineyard-serverside/paths.rb

@@ -0,0 +1,106 @@
+require 'pathname'
+
+module EY
+  module Serverside
+    class Paths
+
+      module LegacyHelpers
+        def deploy_to()                     paths.deploy_root.to_s                      end
+        def release_dir()                   paths.releases.to_s                         end
+        def failed_release_dir()            paths.releases_failed.to_s                  end
+        def release_path()                  paths.active_release.to_s                   end
+        def all_releases()                  paths.all_releases.map { |path| path.to_s } end
+        def previous_release(*a)            paths.previous_release(*a).to_s             end
+        def latest_release()                paths.latest_release.to_s                   end
+        def current_path()                  paths.current.to_s                          end
+        def shared_path()                   paths.shared.to_s                           end
+        def maintenance_page_enabled_path() paths.enabled_maintenance_page.to_s         end
+        def repository_cache()              paths.repository_cache.to_s                 end
+        def bundled_gems_path()             paths.bundled_gems.to_s                     end
+        def ruby_version_file()             paths.ruby_version.to_s                     end
+        def system_version_file()           paths.system_version.to_s                   end
+        def binstubs_path()                 paths.binstubs.to_s                         end
+        def gemfile_path()                  paths.gemfile.to_s                          end
+        def active_revision()               paths.active_revision.read.strip            end
+        def latest_revision()               paths.latest_revision.read.strip            end
+        alias revision latest_revision
+        def ssh_identity_file()             paths.ssh_identity.to_s                     end
+      end
+
+      def self.def_path(name, parts)
+        define_method(name.to_sym) { path(*parts) }
+      end
+
+      def path(root, *parts)
+        send(root).join(*parts)
+      end
+
+      attr_reader :home, :deploy_root
+
+      def_path :current,                  [:deploy_root,    'current']
+      def_path :releases,                 [:deploy_root,    'releases']
+      def_path :releases_failed,          [:deploy_root,    'releases_failed']
+      def_path :shared,                   [:deploy_root,    'shared']
+      def_path :shared_log,               [:shared,         'log']
+      def_path :shared_config,            [:shared,         'config']
+      def_path :shared_system,            [:shared,         'system']
+      def_path :enabled_maintenance_page, [:shared_system,  'maintenance.html']
+      def_path :bundled_gems,             [:shared,         'bundled_gems']
+      def_path :ruby_version,             [:bundled_gems,   'RUBY_VERSION']
+      def_path :system_version,           [:bundled_gems,   'SYSTEM_VERSION']
+      def_path :latest_revision,          [:latest_release, 'REVISION']
+      def_path :active_revision,          [:active_release, 'REVISION']
+      def_path :binstubs,                 [:active_release, 'ey_bundler_binstubs']
+      def_path :gemfile,                  [:active_release, 'Gemfile']
+
+      def initialize(opts)
+        @opts             = opts
+        @home             = Pathname.new(@opts[:hame] || ENV['HOME'])
+        @app_name         = @opts[:app_name]
+        @active_release   = Pathname.new(@opts[:active_release])   if @opts[:active_release]
+        @repository_cache = Pathname.new(@opts[:repository_cache]) if @opts[:repository_cache]
+        @deploy_root      = Pathname.new(@opts[:deploy_root] || "/data/#{@app_name}")
+      end
+
+      def ssh_identity
+        path(:home, '.ssh', "#{@app_name}-deploy-key")
+      end
+
+      def repository_cache
+        @repository_cache ||= path(:shared, 'cached-copy')
+      end
+
+      def active_release
+        @active_release ||= path(:releases, Time.now.utc.strftime("%Y%m%d%H%M%S"))
+      end
+
+      def all_releases
+        @all_releases ||= Pathname.glob(releases.join('*')).sort
+      end
+
+      # deploy_root/releases/<release before argument release path>
+      def previous_release(current=latest_release)
+        index = all_releases.index(current)
+        if index && index > 0
+          all_releases[index-1]
+        else
+          nil
+        end
+      end
+
+      # deploy_root/releases/<latest timestamp>
+      def latest_release
+        all_releases.last
+      end
+
+      def rollback
+        if previous_release
+          self.class.new(@opts.dup.merge(:active_release => previous_release))
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+

data/lib/engineyard-serverside/server.rb

@@ -1,69 +1,27 @@
-require 'open-uri'
+require 'set'
 
 module EY
   module Serverside
     class Server < Struct.new(:hostname, :roles, :name, :user)
-      class DuplicateHostname < StandardError
-        def initialize(hostname)
-          super "There is already an EY::Serverside::Server with hostname '#{hostname}'"
-        end
+      def self.from_hash(server_hash)
+        new(server_hash[:hostname], Set.new(server_hash[:roles].map{|r|r.to_sym}), server_hash[:name], server_hash[:user])
       end
 
       def initialize(*fields)
         super
-        self.roles = self.roles.map { |r| r.to_sym } if self.roles
-      end
-
-      attr_writer :default_task
-
-      def self.from_roles(*want_roles)
-        want_roles = want_roles.flatten.compact.map{|r| r.to_sym}
-        return all if !want_roles || want_roles.include?(:all) || want_roles.empty?
-
-        all.select do |s|
-          !(s.roles & want_roles).empty?
-        end
       end
 
       def role
         roles.first
       end
 
-      def self.load_all_from_array(server_hashes)
-        server_hashes.each do |instance_hash|
-          add(instance_hash)
-        end
-      end
-
-      def self.all
-        @all
-      end
-
-      def self.by_hostname(hostname)
-        all.find{|s| s.hostname == hostname}
-      end
-
-      def self.add(server_hash)
-        hostname = server_hash[:hostname]
-        if by_hostname(hostname)
-          raise DuplicateHostname.new(hostname)
-        end
-        server = new(hostname, server_hash[:roles], server_hash[:name], server_hash[:user])
-        @all << server
-        server
-      end
-
-      def self.current
-        all.find {|s| s.local? }
+      def matches_roles?(set)
+        (roles & set).any?
       end
 
-      def self.reset
-        @all = []
-      end
-      reset
-
       def roles=(roles)
-        super(roles.map{|r| r.to_sym})
+        roles_set = Set.new roles.map{|r| r.to_sym}
+        super roles_set
       end
 
       def local?
@@ -102,16 +60,6 @@ module EY
         @known_hosts_file ||= Tempfile.new('ey-ss-known-hosts')
       end
 
-      # Make a known hosts tempfile to absorb host fingerprints so we don't show
-      #
-      #     Warning: Permanently added 'xxx' (RSA) to the list of known hosts.
-      #
-      # for every ssh command.
-      # (even with StrictHostKeyChecking=no, the warning output is annoying)
-      def self.known_hosts_file
-        @known_hosts_file ||= Tempfile.new('ey-ss-known-hosts')
-      end
-
       def ssh_command
         "ssh -i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o UserKnownHostsFile=#{self.class.known_hosts_file.path} -o PasswordAuthentication=no "
       end