engineyard-serverside 2.0.0.pre3 → 2.0.0.pre4

data/lib/engineyard-serverside/cli.rb

@@ -2,11 +2,13 @@ require 'thor'
 require 'pathname'
 require 'engineyard-serverside/deploy'
 require 'engineyard-serverside/shell'
-require 'engineyard-serverside/server'
+require 'engineyard-serverside/servers'
+require 'engineyard-serverside/cli_helpers'
 
 module EY
   module Serverside
     class CLI < Thor
+      extend CLIHelpers
 
       method_option :migrate,         :type     => :string,
                                       :desc     => "Run migrations with this deploy",
@@ -19,63 +21,20 @@ module EY
       method_option :repo,            :type     => :string,
                                       :desc     => "Remote repo to deploy",
                                       :aliases  => ["-r"]
-
-      method_option :app,             :type     => :string,
-                                      :required => true,
-                                      :desc     => "Application to deploy",
-                                      :aliases  => ["-a"]
-
-      method_option :environment_name,:type     => :string,
-                                      :required => true,
-                                      :desc     => "Environment name"
-
-      method_option :account_name,    :type     => :string,
-                                      :required => true,
-                                      :desc     => "Account name"
-
-      method_option :framework_env,   :type     => :string,
-                                      :desc     => "Ruby web framework environment",
-                                      :aliases  => ["-e"]
-
-      method_option :config,          :type     => :string,
-                                      :desc     => "Additional configuration"
-
-      method_option :stack,           :type     => :string,
-                                      :desc     => "Web stack (so we can restart it correctly)"
-
-      method_option :instances,       :type     => :array,
-                                      :desc     => "Hostnames of instances to deploy to, e.g. --instances localhost app1 app2"
-
-      method_option :instance_roles,  :type     => :hash,
-                                      :default  => {},
-                                      :desc     => "Roles of instances, keyed on hostname, comma-separated. e.g. instance1:app_master,etc instance2:db,memcached ..."
-
-      method_option :instance_names,  :type     => :hash,
-                                      :default  => {},
-                                      :desc     => "Instance names, keyed on hostname. e.g. instance1:name1 instance2:name2"
-
-      method_option :verbose,         :type     => :boolean,
-                                      :desc     => "Verbose output",
-                                      :aliases  => ["-v"]
+      account_app_env_options
+      config_option
+      framework_env_option
+      instances_options
+      stack_option
+      verbose_option
 
       desc "deploy", "Deploy code from /data/<app>"
       def deploy(default_task=:deploy)
-        config, shell = init_and_propagate(options, 'deploy')
-        EY::Serverside::Deploy.new(config, shell).send(default_task)
+        servers, config, shell = init_and_propagate(options, default_task.to_s)
+        EY::Serverside::Deploy.new(servers, config, shell).send(default_task)
       end
 
-      method_option :app,           :type     => :string,
-                                    :required => true,
-                                    :desc     => "Which application's hooks to run",
-                                    :aliases  => ["-a"]
-
-      method_option :environment_name, :type     => :string,
-                                       :required => true,
-                                       :desc     => "Environment name"
 
-      method_option :account_name,  :type     => :string,
-                                    :required => true,
-                                    :desc     => "Account name"
 
       method_option :release_path,  :type     => :string,
                                     :desc     => "Value for #release_path in hooks (mostly for internal coordination)",
@@ -84,126 +43,60 @@ module EY
       method_option :current_roles, :type     => :array,
                                     :desc     => "Value for #current_roles in hooks"
 
-      method_option :framework_env, :type     => :string,
-                                    :required => true,
-                                    :desc     => "Ruby web framework environment",
-                                    :aliases  => ["-e"]
-
-      method_option :config,        :type     => :string,
-                                    :desc     => "Additional configuration"
-
       method_option :current_name,  :type     => :string,
                                     :desc     => "Value for #current_name in hooks"
-
-      method_option :verbose,       :type     => :boolean,
-                                    :desc     => "Verbose output",
-                                    :aliases  => ["-v"]
-
+      account_app_env_options
+      config_option
+      framework_env_option
+      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).run(hook_name)
+        EY::Serverside::DeployHook.new(config, shell, hook_name).call
       end
 
-
-      method_option :app,             :type     => :string,
-                                      :required => true,
-                                      :desc     => "Application to deploy",
-                                      :aliases  => ["-a"]
-
-      method_option :environment_name,:type     => :string,
-                                      :required => true,
-                                      :desc     => "Environment name"
-
-      method_option :account_name,    :type     => :string,
-                                      :required => true,
-                                      :desc     => "Account name"
-
-      method_option :framework_env,   :type     => :string,
-                                      :required => true,
-                                      :desc     => "Ruby web framework environment",
-                                      :aliases  => ["-e"]
-
-      method_option :stack,           :type     => :string,
-                                      :desc     => "Web stack (so we can restart it correctly)"
-
-      method_option :instances,       :type     => :array,
-                                      :desc     => "Hostnames of instances to deploy to, e.g. --instances localhost app1 app2"
-
-      method_option :instance_roles,  :type     => :hash,
-                                      :default  => {},
-                                      :desc     => "Roles of instances, keyed on hostname, comma-separated. e.g. instance1:app_master,etc instance2:db,memcached ..."
-
-      method_option :instance_names,  :type     => :hash,
-                                      :default  => {},
-                                      :desc     => "Instance names, keyed on hostname. e.g. instance1:name1 instance2:name2"
-
-      method_option :verbose,         :type     => :boolean,
-                                      :desc     => "Verbose output",
-                                      :aliases  => ["-v"]
+      account_app_env_options
+      config_option
+      framework_env_option
+      instances_options
+      stack_option
+      verbose_option
       desc "integrate", "Integrate other instances into this cluster"
       def integrate
-
         app_dir = Pathname.new "/data/#{options[:app]}"
-        current_app_dir = app_dir + "current"
+        current_app_dir = app_dir.join("current")
 
         # so that we deploy to the same place there that we have here
         integrate_options = options.dup
         integrate_options[:release_path] = current_app_dir.realpath.to_s
 
         # we have to deploy the same SHA there as here
-        integrate_options[:branch] = (current_app_dir + 'REVISION').read.strip
+        integrate_options[:branch] = current_app_dir.join('REVISION').read.strip
 
-        config, shell = init_and_propagate(integrate_options, 'integrate')
+        servers, config, shell = init_and_propagate(integrate_options, 'integrate')
 
-        EY::Serverside::Server.all.each do |server|
+        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.
-          run_on_server(server,"rm -rf #{current_app_dir}")
+          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(config, shell).cached_deploy
+        EY::Serverside::Deploy.new(servers, config, shell).cached_deploy
       end
 
-      method_option :app,             :type     => :string,
-                                      :required => true,
-                                      :desc     => "Application to deploy",
-                                      :aliases  => ["-a"]
-
-      method_option :environment_name,:type     => :string,
-                                      :required => true,
-                                      :desc     => "Environment name"
-
-      method_option :account_name,    :type     => :string,
-                                      :required => true,
-                                      :desc     => "Account name"
-
-      method_option :stack,           :type     => :string,
-                                      :desc     => "Web stack (so we can restart it correctly)"
-
-      method_option :instances,       :type     => :array,
-                                      :desc     => "Hostnames of instances to deploy to, e.g. --instances localhost app1 app2"
-
-      method_option :instance_roles,  :type     => :hash,
-                                      :default  => {},
-                                      :desc     => "Roles of instances, keyed on hostname, comma-separated. e.g. instance1:app_master,etc instance2:db,memcached ..."
-
-      method_option :instance_names,  :type     => :hash,
-                                      :default  => {},
-                                      :desc     => "Instance names, keyed on hostname. e.g. instance1:name1 instance2:name2"
-
-      method_option :verbose,         :type     => :boolean,
-                                      :desc     => "Verbose output",
-                                      :aliases  => ["-v"]
+      account_app_env_options
+      instances_options
+      stack_option
+      verbose_option
       desc "restart", "Restart app servers, conditionally enabling maintenance page"
       def restart
-        config, shell = init_and_propagate(options, 'restart')
+        servers, config, shell = init_and_propagate(options, 'restart')
 
-        EY::Serverside::Deploy.new(config, shell).restart_with_maintenance_page
+        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)"
@@ -224,14 +117,15 @@ module EY
       private
 
       # Put the same engineyard-serverside on all the servers (Used to be public but is unused as an actual CLI command now)
-      def propagate(shell)
-        config          = EY::Serverside::Deploy::Configuration.new
+      def propagate(servers, config, shell)
         gem_filename    = "engineyard-serverside-#{EY::Serverside::VERSION}.gem"
         local_gem_file  = File.join(Gem.dir, 'cache', gem_filename)
         remote_gem_file = File.join(Dir.tmpdir, gem_filename)
         gem_binary      = File.join(Gem.default_bindir, 'gem')
 
-        servers = EY::Serverside::Server.all.find_all { |server| !server.local? }
+        servers = servers.remote
+
+        return if servers.empty?
 
         shell.status "Propagating engineyard-serverside #{EY::Serverside::VERSION} to #{servers.size} server#{servers.size == 1 ? '' : 's' }."
 
@@ -271,24 +165,23 @@ module EY
 
       def init_and_propagate(*args)
         config, shell = init(*args)
-        load_servers(config)
-        propagate(shell)
-        [config, shell]
+        servers = load_servers(config)
+        propagate(servers, config, shell)
+        [servers, config, shell]
       end
 
       def init(options, action)
         config = EY::Serverside::Deploy::Configuration.new(options)
-        shell  = EY::Serverside::Shell.new(:verbose  => config.verbose, :log_path => File.join(ENV['HOME'], "#{config.app}-#{action}.log"))
+        shell  = EY::Serverside::Shell.new(
+          :verbose  => config.verbose,
+          :log_path => File.join(ENV['HOME'], "#{config.app}-#{action}.log")
+        )
         shell.debug "Initializing engineyard-serverside #{EY::Serverside::VERSION}."
         [config, shell]
       end
 
-      def run_on_server(server, command)
-        shell.logged_system(server.command_on_server('sh -l -c', command))
-      end
-
       def load_servers(config)
-        EY::Serverside::Server.load_all_from_array(assemble_instance_hashes(config))
+        EY::Serverside::Servers.from_hashes(assemble_instance_hashes(config))
       end
 
       def assemble_instance_hashes(config)

data/lib/engineyard-serverside/cli_helpers.rb

@@ -0,0 +1,53 @@
+module EY
+  module Serverside
+    module CLIHelpers
+      def account_app_env_options
+        method_option :app,              :type     => :string,
+                                         :required => true,
+                                         :desc     => "Application to deploy",
+                                         :aliases  => %w[-a --app-name]
+        method_option :environment_name, :type     => :string,
+                                         :required => true,
+                                         :desc     => "Environment name"
+        method_option :account_name,     :type     => :string,
+                                         :required => true,
+                                         :desc     => "Account name"
+      end
+
+      def framework_env_option
+        method_option :framework_env,    :type     => :string,
+                                         :required => true,
+                                         :desc     => "Ruby web framework environment",
+                                         :aliases  => ["-e"]
+      end
+
+      def stack_option
+        method_option :stack,            :type     => :string,
+                                         :desc     => "Web stack (so we can restart it correctly)"
+      end
+
+
+      def config_option
+        method_option :config,           :type     => :string,
+                                         :desc     => "Additional configuration"
+      end
+
+      def instances_options
+        method_option :instances,        :type     => :array,
+                                         :desc     => "Hostnames of instances to deploy to, e.g. --instances localhost app1 app2"
+        method_option :instance_roles,   :type     => :hash,
+                                         :default  => {},
+                                         :desc     => "Roles of instances, keyed on hostname, comma-separated. e.g. instance1:app_master,etc instance2:db,memcached ..."
+        method_option :instance_names,   :type     => :hash,
+                                         :default  => {},
+                                         :desc     => "Instance names, keyed on hostname. e.g. instance1:name1 instance2:name2"
+      end
+
+      def verbose_option
+        method_option :verbose,          :type     => :boolean,
+                                         :desc     => "Verbose output",
+                                         :aliases  => ["-v"]
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/configuration.rb

@@ -1,46 +1,108 @@
 require 'json'
 require 'thor'
 require 'pp'
+require 'engineyard-serverside/paths'
 
 module EY
   module Serverside
     class Deploy::Configuration
-      DEFAULT_CONFIG = Thor::CoreExt::HashWithIndifferentAccess.new({
-        "branch"         => "master",
-        "strategy"       => "Git",
-        "bundle_without" => "test development",
-      })
+      include Paths::LegacyHelpers
+
+      # Defines a fetch method for the specified key.
+      # If no default and no block is specified, it means the key is required
+      # and if it's accessed without a value, it should raise.
+      def self.def_option(name, default=nil, key=nil, &block)
+        key ||= name.to_s
+        if block_given?
+          define_method(name) { fetch(key) {instance_eval(&block)} }
+        else
+          define_method(name) { fetch(key, default) }
+        end
+      end
 
-      attr_writer :release_path
+      # Calls def_option and adds a name? predicate method
+      def self.def_boolean_option(name, default=nil, &block)
+        def_option(name, default, &block)
+        alias_method(:"#{name}?", name)
+      end
+
+      # Required options do not have a default value.
+      # An option being required does not mean that it is always supplied,
+      # it just means that if it is accessed and it does not exist, an error
+      # will be raised instead of returning a nil default value.
+      def self.def_required_option(name, key=nil)
+        key ||= name.to_s
+        define_method(name) do
+          fetch(key) { raise "Required configuration option not found: #{key.inspect}" }
+        end
+      end
 
-      def initialize(options={})
-        opts = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
-        @release_path = opts['release_path']
+      def_required_option :app
+      def_required_option :environment_name
+      def_required_option :account_name
+      def_required_option :framework_env
+      def_required_option :instances
+      def_required_option :instance_roles
+      def_required_option :instance_names
+
+      def_option :repo,              nil
+      def_option :migrate,           nil
+      def_option :precompile_assets, nil
+      def_option :stack,             nil
+      def_option :strategy,          'Git'
+      def_option :branch,            'master'
+      def_option :bundle_without,    'test development'
+      def_option :current_roles,     []
+      def_option :copy_exclude,      []
+      def_option(:user)              { ENV['USER'] }
+      def_option(:group)             { user }
+
+      def_boolean_option :verbose,                         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? }
+
+      alias app_name app
+      alias environment framework_env # legacy because it would be nice to have less confusion around "environment"
+      alias migration_command migrate
+
+      def initialize(options)
+        opts = string_keys(options)
         config = JSON.parse(opts.delete("config") || "{}")
-        @configs = [config, opts] # low to high priority
+        append_config_source opts # high priority
+        append_config_source config # lower priority
       end
 
-      def configuration
-        @configuration ||= @configs.inject(DEFAULT_CONFIG) {|low,high| low.merge(high)}
+      def string_keys(hsh)
+        hsh.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
       end
-      alias :c :configuration # FIXME: awful, but someone is probably using it :(
 
-      # Delegate to the configuration objects
-      def method_missing(meth, *args, &blk)
-        configuration.key?(meth.to_s) ? configuration[meth.to_s] : super
+      def append_config_source(config_source)
+        @config_sources ||= []
+        @config_sources.unshift(config_source.dup)
+        reload_configuration!
       end
 
-      def respond_to?(meth, include_private=false)
-        configuration.key?(meth.to_s) ? true : super
+      def configuration
+        @configuration ||= @config_sources.inject({}) {|low,high| low.merge(high)}
+      end
+      # FIXME: single letter variable is of very questionable value
+      alias :c :configuration
+
+      # reset cached configuration hash
+      def reload_configuration!
+        @configuration = nil
       end
 
       def load_ey_yml_data(data, shell)
         environments = data['environments']
-        if environments && (env_data = environments[environment_name])
+        if environments && environments[environment_name]
           shell.substatus "ey.yml configuration loaded for environment #{environment_name.inspect}."
-          shell.debug "#{environment_name}: #{env_data.pretty_inspect}"
-          @configuration = nil # reset cached configuration hash
-          @configs.unshift(env_data) # insert just above default configuration
+
+          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
           true
         else
           shell.info "No matching ey.yml configuration found for environment #{environment_name.inspect}."
@@ -49,6 +111,12 @@ module EY
         end
       end
 
+      # Fetch a key from the config.
+      # You must supply either a default second argument, or a default block
+      def fetch(key, *args, &block)
+        configuration.fetch(key.to_s, *args, &block)
+      end
+
       def [](key)
         if respond_to?(key.to_sym)
           send(key.to_sym)
@@ -61,202 +129,104 @@ module EY
         respond_to?(key.to_sym) || configuration.has_key?(key)
       end
 
-      def to_json
-        configuration.to_json
-      end
-
-      def node
-        EY::Serverside.node
-      end
-
-      def verbose
-        configuration['verbose']
+      # Delegate to the configuration objects
+      def method_missing(meth, *args, &blk)
+        configuration.key?(meth.to_s) ? configuration.fetch(meth.to_s) : super
       end
 
-      def app
-        configuration['app'].to_s
-      end
-      alias app_name app
-
-      def environment_name
-        configuration['environment_name'].to_s
+      def respond_to?(meth, include_private=false)
+        configuration.key?(meth.to_s) || super
       end
 
-      def account_name
-        configuration['account_name'].to_s
+      def to_json
+        configuration.to_json
       end
 
-      def ssh_identity_file
-        "~/.ssh/#{c.app}-deploy-key"
+      def node
+        EY::Serverside.node
       end
 
       def strategy_class
         EY::Serverside::Strategies.const_get(strategy)
       end
 
-      def revision
-        IO.read(File.join(latest_release, 'REVISION'))
+      def paths
+        @paths ||= Paths.new({
+          :home             => configuration['home_path'],
+          :app_name         => app_name,
+          :deploy_root      => configuration['deploy_to'],
+          :active_release   => configuration['release_path'],
+          :repository_cache => configuration['repository_cache'],
+        })
       end
 
-      def repository_cache
-        configuration['repository_cache'] || File.join(deploy_to, 'shared', 'cached-copy')
-      end
-
-      def deploy_to
-        configuration['deploy_to'] || "/data/#{app}"
-      end
-
-      def migrate?
-        !!configuration['migrate']
-      end
-
-      def migration_command
-        configuration['migrate'] == "migrate" ? DEFAULT_CONFIG["migrate"] : configuration['migrate']
+      def rollback_paths!
+        rollback_paths = paths.rollback
+        if rollback_paths
+          @paths = rollback_paths
+          true
+        else
+          false
+        end
       end
 
-      def bundle_without
-        configuration['bundle_without']
+      def ruby_version_command
+        "ruby -v"
       end
 
-      def user
-        configuration['user'] || ENV['USER']
+      def system_version_command
+        "uname -m"
       end
 
-      def group
-        configuration['group'] || user
+      def migrate?
+        !!migration_command
       end
 
       def role
         node['instance_role']
       end
 
-      def current_roles
-        configuration['current_roles'] || []
-      end
-
       def current_role
         current_roles.first
       end
 
-      def copy_exclude
-        @copy_exclude ||= Array(configuration.fetch("copy_exclude", []))
-      end
-
-      def environment
-        configuration['framework_env']
-      end
-
-      def latest_release
-        all_releases.last
-      end
-
-      def previous_release(current=latest_release)
-        index = all_releases.index(current)
-        all_releases[index-1]
-      end
-
-      def all_releases
-        Dir.glob("#{release_dir}/*").sort
-      end
-
-      def binstubs_path
-        release_path + '/ey_bundler_binstubs'
-      end
-
       def framework_env_names
         %w[RAILS_ENV RACK_ENV NODE_ENV MERB_ENV]
       end
 
       def framework_envs
-        framework_env_names.map { |e| "#{e}=#{environment}" }.join(' ')
+        framework_env_names.map { |e| "#{e}=#{framework_env}" }.join(' ')
       end
 
       def set_framework_envs
         framework_env_names.each { |e| ENV[e] = environment }
       end
 
-      def current_path
-        File.join(deploy_to, "current")
-      end
-
-      def shared_path
-        File.join(deploy_to, "shared")
-      end
-
-      def bundled_gems_path
-        File.join(shared_path, "bundled_gems")
-      end
-
-      def gemfile_path
-        File.join(release_path, "Gemfile")
-      end
-
-      def ruby_version_file
-        File.join(bundled_gems_path, "RUBY_VERSION")
-      end
-
-      def ruby_version_command
-        "ruby -v"
-      end
-
-      def system_version_file
-        File.join(bundled_gems_path, "SYSTEM_VERSION")
-      end
-
-      def system_version_command
-        "uname -m"
-      end
-
-      def release_dir
-        File.join(deploy_to, "releases")
-      end
-
-      def failed_release_dir
-        File.join(deploy_to, "releases_failed")
-      end
-
-      def release_path
-        @release_path ||= File.join(release_dir, Time.now.utc.strftime("%Y%m%d%H%M%S"))
-      end
-
       def precompile_assets_inferred?
         !precompile_assets? && !skip_precompile_assets?
       end
 
       def precompile_assets?
-        configuration['precompile_assets'] == true
+        precompile_assets == true
       end
 
       def skip_precompile_assets?
-        configuration['precompile_assets'] == false
+        precompile_assets == false
       end
 
+      # Assume downtime required if stack is not specified (nil) just in case.
       def required_downtime_stack?
-        %w[ nginx_mongrel glassfish ].include? stack
-      end
-
-      def enable_maintenance_page_on_restart?
-        configuration.fetch('maintenance_on_restart', required_downtime_stack?)
-      end
-
-      def enable_maintenance_page_on_migrate?
-        configuration.fetch('maintenance_on_migrate', true)
+        [nil, 'nginx_mongrel', 'glassfish'].include? stack
       end
 
+      # Enable if stack requires it or if overridden in the ey.yml config.
       def enable_maintenance_page?
-        enable_maintenance_page_on_restart? || (migrate? && enable_maintenance_page_on_migrate?)
-      end
-
-      def maintenance_page_enabled_path
-        File.join(shared_path, "system", "maintenance.html")
-      end
-
-      def exclusions
-        copy_exclude.map { |e| %|--exclude="#{e}"| }.join(' ')
+        maintenance_on_restart? || (migrate? && maintenance_on_migrate?)
       end
 
-      def ignore_database_adapter_warning?
-        configuration.fetch('ignore_database_adapter_warning', false)
+      # We disable the maintenance page if we would have enabled.
+      def disable_maintenance_page?
+        enable_maintenance_page?
       end
 
     end