engineyard-serverside 2.7.8pre2 → 2.8.0.pre

data/lib/engineyard-serverside/cli/workflows/restarting_applications.rb

@@ -0,0 +1,36 @@
+require 'engineyard-serverside/cli/workflows/base'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+
+        # RestartingApplications is a Workflow that restarts the application
+        # specified in the options
+        class RestartingApplications < Base
+          private
+          def procedure
+            restart_options[:release_path] = Pathname.new(
+              "/data/#{options[:app]}/current"
+            )
+
+            propagate_serverside
+
+            EY::Serverside::Deploy.
+              new(servers, config, shell).
+              restart_with_maintenance_page
+
+          end
+
+          def restart_options
+            @restart_options ||= options.dup
+          end
+
+          def task_name
+            'restart'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/workflows/rolling_back_applications.rb

@@ -0,0 +1,28 @@
+require 'engineyard-serverside/cli/workflows/base'
+require 'engineyard-serverside/cli/workflows/helpers'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+
+        # RollingBackApplications is a Workflow that attempts to roll the
+        # application specified in the options back to its previous deployment
+        class RollingBackApplications < Base
+          include Helpers
+
+          private
+          def procedure
+            propagate_serverside
+
+            deployer.rollback
+          end
+
+          def task_name
+            'rollback'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/workflows/showing_maintenance_status.rb

@@ -0,0 +1,28 @@
+require 'engineyard-serverside/cli/workflows/base'
+require 'engineyard-serverside/cli/workflows/helpers'
+require 'engineyard-serverside/maintenance'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+
+        # ShowingMaintenanceStatus is a Workflow that reports the current
+        # enabled/disabled status of the maintenance page for the application
+        # specified in the options
+        class ShowingMaintenanceStatus < Base
+          include Helpers
+
+          private
+          def procedure
+            maintenance.status
+          end
+
+          def task_name
+            'maintenance-status'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/configuration.rb

@@ -101,6 +101,7 @@ module EY
       def_option(:group)                  { user }
       def_option :services_check_command, "which /usr/local/ey_resin/ruby/bin/ey-services-setup >/dev/null 2>&1"
       def_option(:services_setup_command) { "/usr/local/ey_resin/ruby/bin/ey-services-setup #{app}" }
+      def_option :ignore_ey_config_warning, false
 
       DEFAULT_KEEP_RELEASES = 3
 

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

@@ -4,12 +4,19 @@ module EY
   module Serverside
     class DependencyManager
       class Bundler < Base
-        DEFAULT_VERSION = "1.7.9"
+        DEFAULT_VERSION = "1.14.6"
+
+        # Number of Bundler workers (--jobs)
+        JOBS_NUMBER = 4
 
         def self.default_version
           DEFAULT_VERSION
         end
 
+        def self.jobs_number
+          JOBS_NUMBER
+        end
+
         def detected?
           gemfile?
         end
@@ -59,7 +66,7 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
         end
 
         def show_ey_config_instructions
-          if lockfile && !lockfile.has_ey_config?
+          if lockfile && !lockfile.has_ey_config? && !config.ignore_ey_config_warning
             shell.warning "Gemfile.lock does not contain ey_config. Add gem 'ey_config' to your Gemfile to access service configurations through EY::Config."
           end
         end
@@ -87,7 +94,7 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
           # the [,)] is to stop us from looking for e.g. 0.9.2, seeing
           # 0.9.22, and mistakenly thinking 0.9.2 is there
           has_gem_cmd = %{gem list bundler | grep "bundler " | egrep -q "#{egrep_escaped_version}[,)]"}
-          install_cmd = %{gem install bundler -q --no-rdoc --no-ri -v "#{bundler_version}"}
+          install_cmd = %{gem install bundler -q -v "#{bundler_version}"}
           sudo "#{clean_environment} && #{has_gem_cmd} || #{install_cmd}"
         end
 
@@ -103,6 +110,11 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
             "--path",     "#{paths.bundled_gems}",
             "--binstubs", "#{paths.binstubs}",
           ]
+
+          # Install gems in parallel (Bundler.1.5+ only)
+          # @see EYPP-58
+          options += ["--jobs", self.class.jobs_number] if check_version(bundler_version, ">= 1.5")
+
           options += ["--deployment"] if lockfile
           options += config.extra_bundle_install_options
           options
@@ -120,10 +132,9 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
             shell.substatus "Clean bundle forced (--clean)"
             run clean_bundle
           else
-            check_ruby   = "#{config.ruby_version_command} | diff - #{paths.ruby_version} >/dev/null 2>&1"
             check_system = "#{config.system_version_command} | diff - #{paths.system_version} >/dev/null 2>&1"
             shell.substatus "Checking for system version changes"
-            run "#{check_ruby} && #{check_system} || #{clean_bundle}"
+            run "#{check_system} || #{clean_bundle}"
           end
         end
 
@@ -140,9 +151,24 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
           end
         end
 
+        ##
+        # Checks that given version is satisfies give requirement.
+        #
+        # @param [String] version
+        # @param [String] requirement
+        # @return [true, false]
+        #
+        def check_version(version, requirement)
+          Gem::Requirement.new( requirement ).satisfied_by? Gem::Version.new( version )
+        end
+
         class Lockfile
           attr_reader :bundler_version
 
+          METADATA     = 'METADATA'.freeze
+          BUNDLED      = 'BUNDLED WITH'.freeze
+          DEPENDENCIES = 'DEPENDENCIES'.freeze
+
           def initialize(lockfile_contents, default = EY::Serverside::DependencyManager::Bundler.default_version)
             @contents = lockfile_contents
             @default = default
@@ -180,9 +206,8 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
           end
 
           def parse
-            parse_from_metadata ||
-              parse_from_dependencies ||
-              raise("Malformed or pre bundler-1.0.0 Gemfile.lock: #{@contents[0,50]}...")
+            @bundler_version = parse_from_metadata || parse_from_bundled_with || parse_from_dependencies
+            raise("Malformed or pre bundler-1.0.0 Gemfile.lock: #{@contents[0,50]}...") unless @bundler_version
           end
 
           def slice_section(header)
@@ -195,25 +220,28 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
           end
 
           def parse_from_metadata
-            section = slice_section('METADATA')
-
-            if section.empty?
-              return nil
-            end
+            section = slice_section(METADATA)
+            return if section.empty?
 
             result = section.scan(/^\s*version:\s*(.*)$/).first
-            @bundler_version = result ? result.first : @default
+            result ? result.first : @default
+          end
+
+          def parse_from_bundled_with
+            section = slice_section(BUNDLED)
+            return if section.empty?
+
+            result = section.scan(/^#{BUNDLED}\s*(.*)$/).first
+            result ? result.first : @default
           end
 
           def dependencies_section
-            @dependencies_section ||= slice_section('DEPENDENCIES')
+            @dependencies_section ||= slice_section(DEPENDENCIES)
           end
 
           def parse_from_dependencies
             section = dependencies_section
-            if section.empty?
-              return nil
-            end
+            return if section.empty?
 
             result = scan_gem('bundler', section)
             bundler_version = result ? result.last : nil

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

@@ -10,7 +10,18 @@ module EY
 
         def install
           shell.status "Installing npm packages (package.json detected)"
-          run %{cd #{paths.active_release} && export GIT_SSH="#{ENV['GIT_SSH']}" && npm install}
+          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'
         end
       end
     end

data/lib/engineyard-serverside/deploy.rb

@@ -5,6 +5,7 @@ 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
@@ -450,27 +451,9 @@ defaults:
       end
 
       def callback(what)
+        load_callbacks
         @callbacks_reached ||= true
-
-        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
+        @callbacks_collection.distribute(self, what)
       end
 
       def source
@@ -480,31 +463,6 @@ 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
@@ -554,6 +512,10 @@ 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/maintenance.rb

@@ -70,15 +70,7 @@ module EY
         run "mkdir -p #{maintenance_page_dirname}"
         public_system_symlink_warning
         @up = true
-        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
+        run "cp #{source_path} #{enabled_maintenance_page_pathname}"
       end
 
       def disable

data/lib/engineyard-serverside/paths.rb

@@ -68,6 +68,8 @@ 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']
@@ -90,6 +92,7 @@ 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)
@@ -128,10 +131,18 @@ 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/propagator.rb

@@ -0,0 +1,59 @@
+require 'forwardable'
+require 'engineyard-serverside/about'
+
+module EY
+  module Serverside
+
+    # Propagator ensures that a proper version of the engineyard-serverside
+    # gem is installed on a given set of servers
+    class Propagator
+      def self.propagate(servers, shell)
+        new(servers, shell).propagate
+      end
+
+      extend Forwardable
+
+      def_delegators About, :gem_binary, :gem_file, :gem_filename, :gem_name,
+        :name_with_version, :version
+
+      attr_reader :servers, :shell
+
+      def initialize(servers, shell)
+        @servers = servers
+        @shell = shell
+      end
+
+      def propagate
+        shell.status "Verifying and propagating #{name_with_version} to all servers."
+
+        servers.remote.run_for_each! do |server|
+          propagation_command_for(server)
+        end
+      end
+
+      private
+      def propagation_command_for(server)
+        check = server.command_on_server('sh -l -c', check_command)
+        scp = server.scp_command(About.gem_file, remote_gem_file)
+        install = server.command_on_server('sudo sh -l -c', install_command)
+
+        "(#{check}) || ((#{scp}) && (#{install}))"
+      end
+
+      def remote_gem_file
+        @remote_gem_file ||= File.join(Dir.tmpdir, gem_filename)
+      end
+
+      def check_command
+        # the [,)] is to stop us from looking for e.g. 0.5.1, seeing
+        # 0.5.11, and mistakenly thinking 0.5.1 is there
+
+         %{#{gem_binary} list #{gem_name} | grep "#{gem_name}" | egrep -q "#{version.gsub(/\./, '\.')}[,)]"}
+      end
+
+      def install_command
+        "#{gem_binary} install --no-rdoc --no-ri '#{remote_gem_file}'"
+      end
+    end
+  end
+end