engineyard-serverside 2.0.7 → 2.1.0.pre

data/lib/engineyard-serverside.rb

@@ -22,7 +22,6 @@ require 'engineyard-serverside/task'
 require 'engineyard-serverside/server'
 require 'engineyard-serverside/deploy'
 require 'engineyard-serverside/deploy_hook'
-require 'engineyard-serverside/lockfile_parser'
 require 'engineyard-serverside/cli'
 require 'engineyard-serverside/configuration'
 require 'engineyard-serverside/deprecation'

data/lib/engineyard-serverside/cli.rb

@@ -30,8 +30,9 @@ module EY
 
       desc "deploy", "Deploy code from /data/<app>"
       def deploy(default_task=:deploy)
-        servers, config, shell = init_and_propagate(options, default_task.to_s)
-        EY::Serverside::Deploy.new(servers, config, shell).send(default_task)
+        init_and_propagate(options, default_task.to_s) do |servers, config, shell|
+          EY::Serverside::Deploy.new(servers, config, shell).send(default_task)
+        end
       end
 
       account_app_env_options
@@ -40,8 +41,9 @@ module EY
       verbose_option
       desc "enable_maintenance", "Enable maintenance page (disables web access)"
       def enable_maintenance
-        servers, config, shell = init_and_propagate(options, 'enable_maintenance')
-        EY::Serverside::Maintenance.new(servers, config, shell).manually_enable
+        init_and_propagate(options, 'enable_maintenance') do |servers, config, shell|
+          EY::Serverside::Maintenance.new(servers, config, shell).manually_enable
+        end
       end
 
       account_app_env_options
@@ -50,8 +52,9 @@ module EY
       verbose_option
       desc "disable_maintenance", "Disable maintenance page (enables web access)"
       def disable_maintenance
-        servers, config, shell = init_and_propagate(options, 'disable_maintenance')
-        EY::Serverside::Maintenance.new(servers, config, shell).manually_disable
+        init_and_propagate(options, 'disable_maintenance') do |servers, config, shell|
+          EY::Serverside::Maintenance.new(servers, config, shell).manually_disable
+        end
       end
 
       method_option :release_path,  :type     => :string,
@@ -69,8 +72,9 @@ module EY
       verbose_option
       desc "hook [NAME]", "Run a particular deploy hook"
       def hook(hook_name)
-        config, shell = init(options, "hook-#{hook_name}")
-        EY::Serverside::DeployHook.new(config, shell, hook_name).call
+        init(options, "hook-#{hook_name}") do |config, shell|
+          EY::Serverside::DeployHook.new(config, shell, hook_name).call
+        end
       end
 
       account_app_env_options
@@ -91,22 +95,24 @@ module EY
         # we have to deploy the same SHA there as here
         integrate_options[:branch] = current_app_dir.join('REVISION').read.strip
 
-        servers, config, shell = init_and_propagate(integrate_options, 'integrate')
+        init_and_propagate(integrate_options, 'integrate') do |servers, config, shell|
 
-        # We have to rsync the entire app dir, so we need all the permissions to be correct!
-        shell.logged_system "sudo sh -l -c 'find #{app_dir} -not -user #{config.user} -or -not -group #{config.group} -exec chown #{config.user}:#{config.group} {} +'"
+          # We have to rsync the entire app dir, so we need all the permissions to be correct!
+          rsync_command = "find #{app_dir} -not -user #{config.user} -or -not -group #{config.group} -exec chown #{config.user}:#{config.group} {} +"
+          shell.logged_system "sudo sh -l -c '#{rsync_command}'"
 
-        servers.each do |server|
-          shell.logged_system server.sync_directory_command(app_dir)
-          # we're just about to recreate this, so it has to be gone
-          # first. otherwise, non-idempotent deploy hooks could screw
-          # things up, and since we don't control deploy hooks, we must
-          # assume the worst.
-          shell.logged_system server.command_on_server('sh -l -c', "rm -rf #{current_app_dir}")
-        end
+          servers.each do |server|
+            shell.logged_system server.sync_directory_command(app_dir)
+            # we're just about to recreate this, so it has to be gone
+            # first. otherwise, non-idempotent deploy hooks could screw
+            # things up, and since we don't control deploy hooks, we must
+            # assume the worst.
+            shell.logged_system server.command_on_server('sh -l -c', "rm -rf #{current_app_dir}")
+          end
 
-        # deploy local-ref to other instances into /data/$app/local-current
-        EY::Serverside::Deploy.new(servers, config, shell).cached_deploy
+          # deploy local-ref to other instances into /data/$app/local-current
+          EY::Serverside::Deploy.new(servers, config, shell).cached_deploy
+        end
       end
 
       account_app_env_options
@@ -115,32 +121,19 @@ module EY
       verbose_option
       desc "restart", "Restart app servers, conditionally enabling maintenance page"
       def restart
-        servers, config, shell = init_and_propagate(options, 'restart')
-        EY::Serverside::Deploy.new(servers, config, shell).restart_with_maintenance_page
-      end
-
-      desc "install_bundler [VERSION]", "Make sure VERSION of bundler is installed (in system ruby)"
-      def install_bundler(version)
-        egrep_escaped_version = version.gsub(/\./, '\.')
-        # the grep "bundler " is so that gems like bundler08 don't get
-        # their versions considered too
-        #
-        # 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_bundler_cmd = "gem list bundler | grep \"bundler \" | egrep -q '#{egrep_escaped_version}[,)]'"
-
-        unless system(has_bundler_cmd)
-          system("gem install bundler -q --no-rdoc --no-ri -v '#{version}'")
+        init_and_propagate(options, 'restart') do |servers, config, shell|
+          EY::Serverside::Deploy.new(servers, config, shell).restart_with_maintenance_page
         end
       end
 
       private
 
       def init_and_propagate(*args)
-        config, shell = init(*args)
-        servers = load_servers(config)
-        Propagator.call(servers, config, shell)
-        [servers, config, shell]
+        init(*args) do |config, shell|
+          servers = load_servers(config)
+          Propagator.call(servers, config, shell)
+          yield servers, config, shell
+        end
       end
 
       def init(options, action)
@@ -150,7 +143,15 @@ module EY
           :log_path => File.join(ENV['HOME'], "#{config.app}-#{action}.log")
         )
         shell.debug "Initializing #{About.name_with_version}."
-        [config, shell]
+        begin
+          yield config, shell
+        rescue EY::Serverside::RemoteFailure => e
+          shell.exception "#{e.message}"
+          raise
+        rescue Exception => e
+          shell.exception "#{e.backtrace[0]}: #{e.message} (#{e.class})"
+          raise
+        end
       end
 
       def load_servers(config)
@@ -166,6 +167,7 @@ module EY
           }
         }
       end
+
     end
   end
 end

data/lib/engineyard-serverside/configuration.rb

@@ -1,6 +1,7 @@
 require 'multi_json'
 require 'thor'
 require 'pp'
+require 'yaml'
 require 'engineyard-serverside/paths'
 
 module EY
@@ -56,7 +57,10 @@ module EY
 
       def_option :repo,              nil
       def_option :migrate,           nil
-      def_option :precompile_assets, nil
+      def_option :precompile_assets, 'detect'
+      def_option :precompile_assets_task, 'assets:precompile'
+      def_option :asset_strategy,    'shifting'
+      def_option :asset_dependencies, %w[app/assets lib/assets vendor/assets Gemfile.lock config/routes.rb]
       def_option :stack,             nil
       def_option :strategy,          'Git'
       def_option :branch,            'master'
@@ -64,11 +68,15 @@ module EY
       def_option :current_name,      nil
       def_option :asset_roles,       [:app_master, :app, :solo]
       def_option :copy_exclude,      []
-      def_option(:bundle_without)    { (%w[test development] - [framework_env]).join(' ') }
+      def_option :bundle_options,    nil
+      def_option(:bundle_without)    { %w[test development] - [framework_env] }
       def_option(:user)              { ENV['USER'] }
       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_boolean_option :verbose,                         false
+      def_boolean_option :precompile_unchanged_assets,     false
       def_boolean_option :ignore_database_adapter_warning, false
       def_boolean_option :maintenance_on_migrate,          true
       def_boolean_option(:maintenance_on_restart)          { required_downtime_stack? }
@@ -106,6 +114,8 @@ module EY
       end
 
       def load_ey_yml_data(data, shell)
+        loaded = false
+
         environments = data['environments']
         if environments && environments[environment_name]
           shell.substatus "ey.yml configuration loaded for environment #{environment_name.inspect}."
@@ -113,7 +123,19 @@ module EY
           env_data = string_keys(environments[environment_name])
           shell.debug "#{environment_name}:\n#{env_data.pretty_inspect}"
 
-          append_config_source(string_keys(env_data)) # insert at lowest priority so as not to disturb important config
+          append_config_source(env_data) # insert at higher priority than defaults
+          loaded = true
+        end
+
+        defaults = data['defaults']
+        if defaults
+          shell.substatus "ey.yml configuration loaded."
+          append_config_source(string_keys(defaults)) # insert at lowest priority so as not to disturb important config
+          shell.debug "defaults:\n#{defaults.pretty_inspect}"
+          loaded = true
+        end
+
+        if loaded
           true
         else
           shell.info "No matching ey.yml configuration found for environment #{environment_name.inspect}."
@@ -198,6 +220,22 @@ module EY
       end
       alias revision latest_revision
 
+      def previous_revision
+        prev = paths.previous_revision
+        prev && prev.readable? && prev.read.strip
+      end
+
+      # The nodatabase.yml file is dropped by server configuration when there is
+      # no database in the cluster.
+      def has_database?
+        paths.shared_config.join('database.yml').exist? &&
+          !paths.shared_config.join('nodatabase.yml').exist?
+      end
+
+      def check_database_adapter?
+        !ignore_database_adapter_warning? && has_database?
+      end
+
       def migrate?
         !!migration_command
       end
@@ -222,8 +260,15 @@ module EY
         framework_env_names.each { |e| ENV[e] = environment }
       end
 
+      def extra_bundle_install_options
+        opts = []
+        opts += ["--without", bundle_without] if bundle_without
+        opts += [bundle_options] if bundle_options
+        opts.flatten
+      end
+
       def precompile_assets_inferred?
-        !precompile_assets? && !skip_precompile_assets?
+        precompile_assets.nil? || precompile_assets == "detect"
       end
 
       def precompile_assets?
@@ -249,6 +294,12 @@ module EY
         enable_maintenance_page?
       end
 
+      def configured_services
+        services = YAML.load_file(paths.shared_services_yml.to_s)
+        services.respond_to?(:keys) && !services.empty? ? services.keys : nil
+      rescue
+        nil
+      end
     end
   end
 end

data/lib/engineyard-serverside/dependency_manager.rb

@@ -0,0 +1,17 @@
+require 'engineyard-serverside/dependency_manager/base'
+require 'engineyard-serverside/dependency_manager/bundler'
+require 'engineyard-serverside/dependency_manager/bundler_lock'
+require 'engineyard-serverside/dependency_manager/npm'
+
+module EY
+  module Serverside
+    module DependencyManager
+      def self.detect(servers, config, shell, runner)
+        Bundler.detect(servers, config, shell, runner) ||
+        BundlerLock.detect(servers, config, shell, runner) ||
+          Npm.detect(servers, config, shell, runner) ||
+          Base.new(servers, config, shell, runner)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module EY
+  module Serverside
+    module DependencyManager
+      class Base
+        def self.detect(servers, config, shell, runner)
+          manager = new(servers, config, shell, runner)
+          manager.detected? && manager
+        end
+
+        attr_reader :servers, :config, :shell, :runner
+
+        def initialize(servers, config, shell, runner)
+          @servers, @config, @shell = servers, config, shell
+          @runner = runner
+        end
+
+        # Public interface
+        #
+
+        def detected?() true end
+        def check() end
+        def install() end
+
+        # assume not using sqlite3 unless a dependency system says so
+        def uses_sqlite3?() false end
+        def rails_version() end
+        def check_ey_config() end
+
+        # Legacy methods, this should not be public API to this class
+        # With proper warning, cut these methods off
+        def gemfile?() end
+        def bundler_config
+          raise "This method has been removed. Use bundle_options in ey.yml"
+        end
+        def lockfile() end
+        def check_ruby_bundler() end
+        def check_node_npm() end
+        def clean_bundle_on_system_version_change() end
+        def write_system_version() end
+
+        protected
+
+        def paths
+          config.paths
+        end
+
+        def on_roles
+          [:app_master, :app, :solo, :util]
+        end
+
+        def run(cmd)
+          runner.roles(on_roles) do
+            runner.run(cmd)
+          end
+        end
+
+        def sudo(cmd)
+          runner.roles(on_roles) do
+            runner.sudo(cmd)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+module EY
+  module Serverside
+    module DependencyManager
+      class Bundler < Base
+        DEFAULT_VERSION = "1.3.4"
+
+        def self.default_version
+          DEFAULT_VERSION
+        end
+
+        def detected?
+          gemfile? && !lockfile?
+        end
+
+        def gemfile?
+          paths.gemfile.exist?
+        end
+
+        def lockfile?
+          lockfile_path.exist?
+        end
+
+        def check
+          shell.warning <<-WARN
+Gemfile found but Gemfile.lock is missing!
+You can get different versions of gems in production than what you tested with.
+You can get different versions of gems on every deployment even if your Gemfile hasn't changed.
+Deploying will take longer and some deploy options will be limited.
+
+To fix this problem, commit your Gemfile.lock to your repository and redeploy.
+          WARN
+        end
+
+        def install
+          check_ruby_bundler
+        end
+
+        # Without Gemfile.lock, don't do anything with sqlite3
+        def uses_sqlite3?
+          false
+        end
+
+        # Without Gemfile.lock, don't do anything about ey_config
+        def check_ey_config
+        end
+
+        # Without Gemfile.lock, there is no determining the rails version.
+        def rails_version
+          nil
+        end
+
+        private
+
+        def lockfile_path
+          paths.gemfile_lock
+        end
+
+        def write_system_version
+          store_ruby_version   = "#{config.ruby_version_command} > #{paths.ruby_version}"
+          store_system_version = "#{config.system_version_command} > #{paths.system_version}"
+
+          run "mkdir -p #{paths.bundled_gems} && chown #{config.user}:#{config.group} #{paths.bundled_gems}"
+          run "#{store_ruby_version} && #{store_system_version}"
+        end
+
+        def check_ruby_bundler
+          shell.status "Bundling gems..."
+          clean_bundle_on_system_version_change
+          install_bundler_gem
+          run "#{clean_environment} && cd #{paths.active_release} && #{bundle_install_command}"
+          write_system_version
+        end
+
+        # Install bundler in the system ruby
+        def install_bundler_gem
+          egrep_escaped_version = bundler_version.gsub(/\./, '\.')
+          # the grep "bundler " is so that gems like bundler08 don't get
+          # their versions considered too
+          #
+          # 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
+          clean_ruby  = %{unset RUBYOPT}
+          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}"}
+          sudo "#{clean_ruby} && #{has_gem_cmd} || #{install_cmd}"
+        end
+
+        # GIT_SSH needs to be defined in the environment for customers with private bundler repos in their Gemfile.
+        # It seems redundant to declare the env var again, but I'm hesitant to remove it right now.
+        def clean_environment
+          %{export GIT_SSH="#{ENV['GIT_SSH']}" && export LANG="en_US.UTF-8" && unset RUBYOPT BUNDLE_PATH BUNDLE_FROZEN BUNDLE_WITHOUT BUNDLE_BIN BUNDLE_GEMFILE}
+        end
+
+        def bundle_install_options
+          options = [
+            "--gemfile",  "#{paths.gemfile}",
+            "--path",     "#{paths.bundled_gems}",
+            "--binstubs", "#{paths.binstubs}",
+          ]
+          options += config.extra_bundle_install_options
+          options
+        end
+
+        def bundle_install_command
+          "ruby -S bundle _#{bundler_version}_ install #{bundle_install_options.join(" ")}"
+        end
+
+        def clean_bundle_on_system_version_change
+          # diff exits with 0 for same and 1/2 for different/file not found.
+          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"
+          clean_bundle = "rm -Rf #{paths.bundled_gems}"
+
+          shell.substatus "Checking for system version changes"
+          run "#{check_ruby} && #{check_system} || #{clean_bundle}"
+        end
+
+        def bundler_version
+          self.class.default_version
+        end
+      end
+    end
+  end
+end