engineyard-serverside 2.7.0.pre → 2.7.8pre2

data/lib/engineyard-serverside/dependency_manager/npm.rb

@@ -10,18 +10,7 @@ module EY
 
         def install
           shell.status "Installing npm packages (package.json detected)"
-          run "mkdir -p #{paths.shared_node_modules} && ln -nfs #{paths.shared_node_modules} #{paths.active_node_modules}"
-          run %{cd #{paths.active_release} && export GIT_SSH="#{ENV['GIT_SSH']}" && npm install #{npm_install_options.join(" ")}}
-        end
-
-        def npm_install_options
-          options = []
-          options += ['--production'] if npm_production?
-          options
-        end
-
-        def npm_production?
-          ENV['NODE_ENV'] == 'production'
+          run %{cd #{paths.active_release} && export GIT_SSH="#{ENV['GIT_SSH']}" && npm install}
         end
       end
     end

data/lib/engineyard-serverside/deploy.rb

@@ -5,7 +5,6 @@ require 'engineyard-serverside/rails_assets'
 require 'engineyard-serverside/maintenance'
 require 'engineyard-serverside/dependency_manager'
 require 'engineyard-serverside/dependency_manager/legacy_helpers'
-require 'engineyard-serverside/callbacks'
 
 module EY
   module Serverside
@@ -451,9 +450,27 @@ defaults:
       end
 
       def callback(what)
-        load_callbacks
         @callbacks_reached ||= true
-        @callbacks_collection.distribute(self, what)
+
+        if paths.deploy_hook(what).exist?
+          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.to_a.join(' ')
+            per_instance_args << '--current-name'  << server.name.to_s if server.name
+            per_instance_args << '--config'        << config.to_json
+            cmd << " " << Escape.shell_command(per_instance_args)
+          end
+        elsif paths.executable_deploy_hook(what).executable?
+          shell.status "Running deploy hook: deploy/#{what}"
+          run [About.hook_executor, what.to_s].join(' ') do |server, cmd|
+            cmd = hook_env_vars(server).reject{|k,v| v.nil?}.map{|k,v|
+              "#{k}=#{Escape.shell_command([v])}"
+            }.join(' ') + ' ' + config.framework_envs + ' ' + cmd
+          end
+        elsif paths.executable_deploy_hook(what).exist?
+          shell.warning "Skipping possible deploy hook deploy/#{what} because it is not executable."
+        end
       end
 
       def source
@@ -463,6 +480,31 @@ defaults:
 
       protected
 
+      def base_callback_command_for(what)
+        cmd =  [About.binary, 'hook', what.to_s]
+        cmd << '--app'              << config.app
+        cmd << '--environment-name' << config.environment_name
+        cmd << '--account-name'     << config.account_name
+        cmd << '--release-path'     << paths.active_release.to_s
+        cmd << '--framework-env'    << config.framework_env.to_s
+        cmd << '--verbose' if config.verbose
+        cmd
+      end
+
+      def hook_env_vars(server)
+        {
+          'EY_DEPLOY_ACCOUNT_NAME' => config.account_name,
+          'EY_DEPLOY_APP' => config.app,
+          'EY_DEPLOY_CONFIG' => config.to_json,
+          'EY_DEPLOY_CURRENT_ROLES' => server.roles.to_a.join(' '),
+          'EY_DEPLOY_CURRENT_NAME' => server.name ? server.name.to_s : nil,
+          'EY_DEPLOY_ENVIRONMENT_NAME' => config.environment_name,
+          'EY_DEPLOY_FRAMEWORK_ENV' => config.framework_env.to_s,
+          'EY_DEPLOY_RELEASE_PATH' => paths.active_release.to_s,
+          'EY_DEPLOY_VERBOSE' => (config.verbose ? '1' : '0'),
+        }
+      end
+
       # FIXME: Legacy method, warn and remove.
       def serverside_bin
         About.binary
@@ -512,10 +554,6 @@ defaults:
       def compile_assets
         RailsAssets.detect_and_compile(config, shell, self)
       end
-
-      def load_callbacks
-        @callbacks_collection ||= Callbacks.load(paths)
-      end
     end   # DeployBase
 
     class Deploy < DeployBase

data/lib/engineyard-serverside/deploy_hook.rb

@@ -1,6 +1,4 @@
 require 'engineyard-serverside/shell/helpers'
-require 'engineyard-serverside/deploy_hook/callback_context'
-require 'engineyard-serverside/callbacks'
 require 'rbconfig'
 
 module EY
@@ -12,32 +10,36 @@ module EY
         @config, @shell, @hook_name = config, shell, hook_name
       end
 
+      def hook_path
+        config.paths.deploy_hook(hook_name)
+      end
+
+      def callback_context
+        @context ||= CallbackContext.new(config, shell, hook_path)
+      end
+
       def call
-        hooks.each do |hook|
+        if hook_path.exist?
           Dir.chdir(config.paths.active_release.to_s) do
-            if desc = syntax_error(hook.path)
-              hook_name = hook.path.basename
+            if desc = syntax_error(hook_path)
+              hook_name = hook_path.basename
               abort "*** [Error] Invalid Ruby syntax in hook: #{hook_name} ***\n*** #{desc.chomp} ***"
             else
-              eval_hook(hook.read, hook.path)
+              eval_hook(hook_path.read)
             end
           end
         end
       end
 
-      def eval_hook(code, hook_path = nil)
-        hook_path ||= config.paths.deploy_hook(hook_name)
-        shell.info "Executing #{hook_path} ..."
-        display_deprecation_warnings(code, hook_path)
-        CallbackContext.
-          new(config, shell, hook_path).
-          instance_eval(code)
+      def eval_hook(code)
+        display_deprecation_warnings(code)
+        callback_context.instance_eval(code)
       rescue Exception => exception
         display_hook_error(exception, code, hook_path)
         raise exception
       end
 
-      def display_deprecation_warnings(code, hook_path)
+      def display_deprecation_warnings(code)
         if code =~ /@configuration/
           shell.warning("Use of `@configuration` in deploy hooks is deprecated.\nPlease use `config`, which provides access to the same object.\n\tin #{hook_path}")
         end
@@ -66,12 +68,73 @@ Please fix this error before retrying.
         output unless output =~ /Syntax OK/
       end
 
-      private
-      def hooks
-        @hooks ||= Callbacks.
-          load(config.paths).
-          matching(hook_name.to_s).
-          select {|hook| hook.flavor == :ruby}
+      class CallbackContext
+        include EY::Serverside::Shell::Helpers
+
+        attr_reader :shell, :hook_path
+
+        def initialize(config, shell, hook_path)
+          @configuration = config
+          @configuration.set_framework_envs
+          @shell = shell
+          @node = config.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)
+            shell.warning "Use of `#{meth}` (via method_missing) is deprecated in favor of `config.#{meth}` for improved error messages and compatibility.\n\tin #{hook_path}"
+            @configuration.send(meth, *args, &blk)
+          else
+            super
+          end
+        end
+
+        def respond_to?(*a)
+          @configuration.respond_to?(*a) || super
+        end
+
+        def run(cmd)
+          shell.logged_system(Escape.shell_command(["sh", "-l", "-c", cmd])).success?
+        end
+
+        def run!(cmd)
+          run(cmd) or raise("run!: Command failed. #{cmd}")
+        end
+
+        def sudo(cmd)
+          shell.logged_system(Escape.shell_command(["sudo", "sh", "-l", "-c", cmd])).success?
+        end
+
+        def sudo!(cmd)
+          sudo(cmd) or raise("sudo!: Command failed. #{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_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?(config.current_name)
+          end
+        end
+
+        private
+        def on_roles(desired_roles)
+          yield if desired_roles.any? { |role| config.current_roles.include?(role) }
+        end
+
       end
 
     end

data/lib/engineyard-serverside/maintenance.rb

@@ -70,7 +70,15 @@ module EY
         run "mkdir -p #{maintenance_page_dirname}"
         public_system_symlink_warning
         @up = true
-        run "cp #{source_path} #{enabled_maintenance_page_pathname}"
+        maintenance_page_html = File.read(source_path)
+        if source_path == EY::Serverside::Paths::DEFAULT_MAINTENANCE_PAGE
+          #run fans out to all app servers but the serverside version is only isntalled on the server being used to deploy
+          #so if the serveside version being used isn't installed on a given app server the cp command would fail, but this echo will still work
+          run "echo '#{maintenance_page_html}' > #{enabled_maintenance_page_pathname}"
+        else
+          #since other possible paths are in your app, cp should work
+          run "cp #{source_path} #{enabled_maintenance_page_pathname}"
+        end
       end
 
       def disable

data/lib/engineyard-serverside/paths.rb

@@ -68,8 +68,6 @@ module EY
       def_path :shared_log,               [:shared,         'log']
       def_path :shared_tmp,               [:shared,         'tmp']
       def_path :shared_config,            [:shared,         'config']
-      def_path :shared_hooks,             [:shared,         'hooks']
-      def_path :shared_node_modules,      [:shared,         'node_modules']
       def_path :shared_system,            [:shared,         'system']
       def_path :default_repository_cache, [:shared,         'cached-copy']
       def_path :enabled_maintenance_page, [:shared_system,  'maintenance.html']
@@ -92,7 +90,6 @@ module EY
       def_path :composer_lock,            [:active_release, 'composer.lock']
       def_path :active_release_config,    [:active_release, 'config']
       def_path :active_log,               [:active_release, 'log']
-      def_path :active_node_modules,      [:active_release, 'node_modules']
       def_path :active_tmp,               [:active_release, 'tmp']
 
       def initialize(opts)
@@ -131,18 +128,10 @@ module EY
         path(:deploy_hooks, "#{hook_name}.rb")
       end
 
-      def service_hook(service_name, hook_name)
-        path(:shared_hooks, service_name, "#{hook_name}.rb")
-      end
-
       def executable_deploy_hook(hook_name)
         path(:deploy_hooks, "#{hook_name}")
       end
 
-      def executable_service_hook(service_name, hook_name)
-        path(:shared_hooks, service_name, "#{hook_name}")
-      end
-
       def repository_cache
         @repository_cache ||= default_repository_cache
       end

data/lib/engineyard-serverside/rails_assets.rb

@@ -58,8 +58,7 @@ module EY
           # This is a hack right now, but I haven't iterated over it enough for a good solution yet.
           if config.experimental_sync_assets?
             shell.status "Compiling assets once on localhost (experimental_sync_assets: true)"
-            compilation_result = shell.logged_system("sh -l -c '#{cd} && #{task}'")
-            raise "Assets compilation error" unless compilation_result.success?
+            shell.logged_system("sh -l -c '#{cd} && #{task}'")
 
             shell.status "Syncing assets to other remote servers (experimental_sync_assets: true)"
             runner.servers.remote.run_for_each do |server|

data/lib/engineyard-serverside/version.rb

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

data/spec/archive_deploy_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+class EY::Serverside::Source::Archive
+  def fetch_command
+    "cp #{uri} #{source_cache}"
+  end
+end
+
+describe "Deploying a simple application" do
+
+  before(:all) do
+    adapter = EY::Serverside::Adapter.new do |args|
+      args.account_name = "account"
+      args.app = "application_name"
+      args.stack = "nginx_unicorn"
+      args.environment_name = "environment_name"
+      args.framework_env = "production"
+      args.archive = FIXTURES_DIR.join('retwisj.war')
+      args.verbose = true
+      args.instances = [{ :hostname => "localhost", :roles => ["solo"], :name => "single" }]
+      args.serverside_version = Gem::Version.create(EY::Serverside::VERSION.dup).release
+      args.config = {
+        "deploy_to" => deploy_dir.to_s,
+        "group"            => GROUP
+      }
+    end
+    argv = adapter.deploy.commands.last.to_argv[2..-1]
+    with_mocked_commands do
+      capture do
+        EY::Serverside::CLI.start(argv)
+      end
+    end
+  end
+
+  it "exploded the war" do
+    %w(META-INF WEB-INF).each {|dir|
+      File.exists?(deploy_dir.join('current', dir))
+    }
+  end
+
+  it "creates a REVISION file" do
+    path = deploy_dir.join('current', 'REVISION')
+    expect(path).to exist
+    checksum = File.read(path).strip
+    expect(checksum).to match(/7400dc058376745c11a98f768b799c6651428857\s+.*retwisj.war$/)
+  end
+
+  it "restarts the app servers" do
+    restart = deploy_dir.join('current', 'restart')
+    expect(restart).to exist
+    expect(restart.read.chomp).to eq(%|LANG="en_US.UTF-8" /engineyard/bin/app_application_name deploy|)
+  end
+end

data/spec/basic_deploy_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe "Deploying a simple application" do
+  before(:all) do
+    deploy_test_application('not_bundled')
+  end
+
+  it "creates a REVISION file" do
+    expect(deploy_dir.join('current', 'REVISION')).to exist
+  end
+
+  it "restarts the app servers" do
+    restart = deploy_dir.join('current', 'restart')
+    expect(restart).to exist
+    expect(restart.read.chomp).to eq(%|LANG="en_US.UTF-8" /engineyard/bin/app_rails31 deploy|)
+  end
+
+  it "reuses the same active_release directory if a release_path is specified (such as in integrate)" do
+    path = @config.paths.active_release
+    expect(path.parent.children.size).to eq(1)
+
+    redeploy_test_application('config' => {'release_path' => path.to_s})
+
+    expect(path.parent.children.size).to eq(1)
+  end
+end

data/spec/bundler_deploy_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe "Deploying an application that uses Bundler" do
+  VERSION_PATTERN = Regexp.quote(::EY::Serverside::DependencyManager::Bundler.default_version)
+
+  context "with a Gemfile.lock" do
+    before(:all) do
+      deploy_test_application('ey_yml')
+      @install_bundler_command = @deployer.commands.grep(/gem install bundler/).first
+      @bundle_install_command  = @deployer.commands.grep(/bundle _#{VERSION_PATTERN}_ install/).first
+    end
+
+    it "runs the right bundler command" do
+      expect(@install_bundler_command).not_to be_nil
+      expect(@install_bundler_command).to match(/install bundler .* -v "#{VERSION_PATTERN}"/)
+    end
+
+    it "runs 'bundle install' with --deployment" do
+      expect(@bundle_install_command).not_to be_nil
+      expect(@bundle_install_command).to include('--deployment')
+    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
+      clear_bundle_cmd = @deployer.commands.grep(/rm -Rf \S+\/bundled_gems/).first
+      expect(clear_bundle_cmd).not_to be_nil
+    end
+
+    it "has the binstubs in the path when migrating" do
+      expect(deploy_dir.join('path-when-migrating').read).to include('ey_bundler_binstubs')
+    end
+
+    it "creates a ruby version file" do
+      expect(deploy_dir.join('shared', 'bundled_gems', 'RUBY_VERSION')).to exist
+    end
+
+    it "creates a system version file" do
+      expect(deploy_dir.join('shared', 'bundled_gems', 'SYSTEM_VERSION')).to exist
+    end
+
+    it "generates bundler binstubs" do
+      pending "doesn't work with mocked bundler"
+      expect(deploy_dir.join('current', 'ey_bundler_binstubs', 'rake')).to exist
+    end
+  end
+
+  context "with clean option" do
+    before(:all) do
+      deploy_test_application('ey_yml', 'clean' => true)
+    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).to be_nil
+      clear_bundle_cmd = @deployer.commands.grep(/rm -Rf \S+\/bundled_gems/).first
+      expect(clear_bundle_cmd).not_to be_nil
+    end
+
+  end
+
+  context "with bundler disabled in ey.yml" do
+    before(:all) do
+      deploy_test_application('bundler_disabled')
+    end
+
+    it "does not run bundler commands" do
+      expect(@deployer.commands.grep(/gem install bundler/)).to be_empty
+      expect(@deployer.commands.grep(/bundle _.*_ install/)).to be_empty
+    end
+
+    it "still runs the hooks" do
+      expect(deploy_dir.join('current', 'before_bundle.ran' )).to exist
+      expect(deploy_dir.join('current', 'after_bundle.ran' )).to exist
+    end
+  end
+
+  context "without a Gemfile.lock" do
+    before(:all) do
+      deploy_test_application('no_gemfile_lock')
+      @install_bundler_command = @deployer.commands.grep(/gem install bundler/).first
+      @bundle_install_command  = @deployer.commands.grep(/bundle _#{VERSION_PATTERN}_ install/).first
+    end
+
+    it "installs the proper Bundler version" do
+      expect(@install_bundler_command).not_to be_nil
+      expect(@install_bundler_command).to match(/unset RUBYOPT && gem list bundler | grep "bundler " | egrep -q "#{VERSION_PATTERN}[,)]" || gem install bundler -q --no-rdoc --no-ri -v "#{VERSION_PATTERN}"/)
+    end
+
+    it "runs 'bundle install' without --deployment" do
+      expect(@bundle_install_command).not_to be_nil
+      expect(@bundle_install_command).not_to match(/--deployment/)
+    end
+
+    it "exports GIT_SSH for the bundle install" do
+      expect(@bundle_install_command).to match(/export GIT_SSH/)
+    end
+
+    it "puts down RUBY_VERSION and SYSTEM_VERSION" do
+      expect(deploy_dir.join('shared', 'bundled_gems', 'RUBY_VERSION')).to exist
+      expect(deploy_dir.join('shared', 'bundled_gems', 'SYSTEM_VERSION')).to exist
+    end
+
+    it "warns that using a lockfile is idiomatic" do
+      out = read_output
+      expect(out).to match(/WARNING: Gemfile found but Gemfile.lock is missing!/)
+    end
+  end
+
+  context "without a Gemfile.lock and ignoring the warning" do
+    before(:all) do
+      deploy_test_application('no_gemfile_lock', 'config' => {'ignore_gemfile_lock_warning' => true})
+      expect(@config.ignore_gemfile_lock_warning).to be_truthy
+      @install_bundler_command = @deployer.commands.grep(/gem install bundler/).first
+      @bundle_install_command  = @deployer.commands.grep(/bundle _#{VERSION_PATTERN}_ install/).first
+    end
+
+    it "should not warn" do
+      out = read_output
+      expect(out).not_to match(/WARNING/)
+    end
+  end
+
+  context "with a failing Gemfile" do
+    before(:all) do
+      begin
+        deploy_test_application('bundle_fails', 'bundle_install_fails' => true, 'verbose' => false)
+      rescue EY::Serverside::RemoteFailure
+      end
+    end
+
+    it "prints the failure to the log" do
+      out = read_output
+      expect(out).to match(%r|bundle install failure|)
+      expect(deploy_dir.join('current', 'after_bundle.ran' )).not_to exist
+    end
+  end
+end
+