crazy-yard 3.2.2

data/lib/engineyard/cli/web.rb

@@ -0,0 +1,85 @@
+module EY
+  class CLI
+    class Web < EY::Thor
+      desc "enable [--environment/-e ENVIRONMENT]",
+        "Remove the maintenance page for this application in the given environment."
+      method_option :environment, type: :string, aliases: %w(-e),
+        required: true, default: '',
+        desc: "Environment on which to take down the maintenance page"
+      method_option :app, type: :string, aliases: %w(-a),
+        required: true, default: '',
+        desc: "Name of the application whose maintenance page will be removed"
+      method_option :account, type: :string, aliases: %w(-c),
+        required: true, default: '',
+        desc: "Name of the account in which the environment can be found"
+      method_option :verbose, type: :boolean, aliases: %w(-v),
+        desc: "Be verbose"
+      def enable
+        app_env = fetch_app_environment(options[:app], options[:environment], options[:account])
+        ui.info "Taking down maintenance page for '#{app_env.app.name}' in '#{app_env.environment.name}'"
+        serverside_runner(app_env, options[:verbose]).take_down_maintenance_page.call(ui.out, ui.err)
+      end
+
+      desc "disable [--environment/-e ENVIRONMENT]",
+        "Put up the maintenance page for this application in the given environment."
+      long_desc <<-DESC
+        The maintenance page is taken from the app currently being deployed. This means
+        that you can customize maintenance pages to tell users the reason for downtime
+        on every particular deploy.
+
+        Maintenance pages searched for in order of decreasing priority:
+        * public/maintenance.html.custom
+        * public/maintenance.html.tmp
+        * public/maintenance.html
+        * public/system/maintenance.html.default
+      DESC
+      method_option :environment, type: :string, aliases: %w(-e),
+        required: true, default: '',
+        desc: "Environment on which to put up the maintenance page"
+      method_option :app, type: :string, aliases: %w(-a),
+        required: true, default: '',
+        desc: "Name of the application whose maintenance page will be put up"
+      method_option :account, type: :string, aliases: %w(-c),
+        required: true, default: '',
+        desc: "Name of the account in which the environment can be found"
+      method_option :verbose, type: :boolean, aliases: %w(-v),
+        desc: "Be verbose"
+      def disable
+        app_env = fetch_app_environment(options[:app], options[:environment], options[:account])
+        ui.info "Putting up maintenance page for '#{app_env.app.name}' in '#{app_env.environment.name}'"
+        serverside_runner(app_env, options[:verbose]).put_up_maintenance_page.call(ui.out, ui.err)
+      end
+
+      desc "restart [--environment ENVIRONMENT]",
+        "Restart the application servers without deploying."
+      long_desc <<-DESC
+        Restarts the application servers (e.g. Passenger, Unicorn, etc).
+
+        Respects the maintenance_on_restart settings in the application's ey.yml.
+
+        Note: Uses the version of the ey.yml currently checked out on the servers.
+      DESC
+      method_option :environment, type: :string, aliases: %w(-e),
+        required: true, default: false,
+        desc: "Environment in which to deploy this application"
+      method_option :app, type: :string, aliases: %w(-a),
+        required: true, default: '',
+        desc: "Name of the application to deploy"
+      method_option :account, type: :string, aliases: %w(-c),
+        required: true, default: '',
+        desc: "Name of the account in which the environment can be found"
+      method_option :verbose, type: :boolean, aliases: %w(-v),
+        desc: "Be verbose"
+      def restart
+        app_env = fetch_app_environment(options[:app], options[:environment], options[:account])
+        ui.info "Restarting servers on #{app_env.hierarchy_name}"
+        if serverside_runner(app_env, options[:verbose]).restart.call(ui.out, ui.err)
+          ui.info "Restart complete"
+        else
+          raise EY::Error, "Restart failed"
+        end
+      end
+
+    end
+  end
+end

data/lib/engineyard/config.rb

@@ -0,0 +1,158 @@
+require 'uri'
+require 'yaml'
+require 'pathname'
+require 'engineyard/error'
+
+module EY
+  class Config
+    # This order is important.
+    CONFIG_FILES = ["config/ey.yml", "ey.yml"].map {|path| Pathname.new(path)}.freeze
+    TEMPLATE_PATHNAME = Pathname.new(__FILE__).dirname.join('templates','ey.yml').freeze
+
+    def self.pathname_for_write
+      pathname || CONFIG_FILES.find{|pathname| pathname.dirname.exist? }
+    end
+
+    def self.pathname
+      CONFIG_FILES.find{|pathname| pathname.exist? }
+    end
+
+    def self.template_pathname
+      TEMPLATE_PATHNAME
+    end
+
+    def self.load_config(path = pathname)
+      config = YAML.load_file(path.to_s) if path && path.exist?
+      config ||= {} # load_file returns `false' when the file is empty
+
+      unless Hash === config
+        raise "ey.yml load error: Expected a Hash but a #{config.class.name} was returned."
+      end
+      config
+    end
+
+    attr_reader :path
+
+    def initialize(file = nil)
+      @path = file ? Pathname.new(file) : self.class.pathname
+      @config = self.class.load_config(@path)
+      @config["environments"] ||= {}
+    end
+
+    def method_missing(meth, *args, &blk)
+      key = meth.to_s.downcase
+      if @config.key?(key)
+        @config[key]
+      else
+        super
+      end
+    end
+
+    def respond_to?(meth)
+      key = meth.to_s.downcase
+      @config.key?(key) || super
+    end
+
+    def fetch(key, default = nil, &block)
+      block ? @config.fetch(key.to_s, &block) : @config.fetch(key.to_s, default)
+    end
+
+    def fetch_from_defaults(key, default=nil, &block)
+      block ? defaults.fetch(key.to_s, &block) : defaults.fetch(key.to_s, default)
+    end
+
+    def [](key)
+      @config[key.to_s.downcase]
+    end
+
+    def endpoint
+      env_var_endpoint || default_endpoint
+    end
+
+    def env_var_endpoint
+      ENV["CLOUD_URL"]
+    end
+
+    def default_endpoint
+      "https://cloud.engineyard.com/"
+    end
+
+    def default_endpoint?
+      default_endpoint == endpoint
+    end
+
+    def default_environment
+      d = environments.find do |name, env|
+        env && env["default"]
+      end
+      d && d.first
+    end
+
+    def defaults
+      @config['defaults'] ||= {}
+    end
+
+    def environment_config(environment_name)
+      environments[environment_name] ||= {}
+      EnvironmentConfig.new(environments[environment_name], environment_name, self)
+    end
+
+    class EnvironmentConfig
+      attr_reader :name
+
+      def initialize(config, name, parent)
+        @config = config || {}
+        @name = name
+        @parent = parent
+      end
+
+      def path
+        @parent.path
+      end
+
+      def ensure_exists
+        unless path && path.exist?
+          raise EY::Error, "Please initialize this application with the following command:\n\tey init"
+        end
+      end
+
+      def fetch(key, default = nil, &block)
+        @config.fetch(key.to_s) do
+          @parent.fetch_from_defaults(key.to_s, default, &block)
+        end
+      end
+
+      def branch
+        fetch('branch', nil)
+      end
+
+      def migrate
+        ensure_exists
+        fetch('migrate') do
+          raise EY::Error, "'migrate' not found in #{path}. Reinitialize with:\n\tey init"
+        end
+      end
+
+      def migration_command
+        ensure_exists
+        fetch('migration_command') do
+          raise EY::Error, "'migration_command' not found in #{path}. Reinitialize with:\n\tey init"
+        end
+      end
+
+      alias migrate_command migration_command
+
+      def verbose
+        fetch('verbose', false)
+      end
+    end
+
+    private
+
+    class ConfigurationError < EY::Error
+      def initialize(key, value, source, message=nil)
+        super %|"#{key}" from #{source} has invalid value: #{value.inspect}#{": #{message}" if message}|
+      end
+    end
+  end
+end

data/lib/engineyard/deploy_config.rb

@@ -0,0 +1,65 @@
+module EY
+  class DeployConfig
+    MIGRATE = 'rake db:migrate --trace'
+
+    def initialize(cli_opts, env_config, repo, ui)
+      @cli_opts = cli_opts
+      @env_config = env_config
+      @repo = repo
+      @ui = ui
+    end
+
+    def ref
+      @ref ||= decide_ref
+    end
+
+    def migrate
+      @migrate ||= @cli_opts.fetch('migrate') do
+        if in_repo?
+          @env_config.migrate
+        else
+          raise RefAndMigrateRequiredOutsideRepo.new(@cli_opts)
+        end
+      end
+    end
+
+    def migrate_command
+      return @command if defined? @command
+
+      if migrate
+        @command = migrate.respond_to?(:to_str) && migrate.to_str
+        @command ||= in_repo? ? @env_config.migration_command : MIGRATE
+      else
+        @command = nil
+      end
+
+      @command
+    end
+
+    def verbose
+      @cli_opts.fetch('verbose') { in_repo? && @env_config.verbose }
+    end
+
+    def extra_config
+      @cli_opts.fetch('config', {})
+    end
+
+    private
+
+    # passing an app means we assume PWD is not the app.
+    def in_repo?
+      @cli_opts['app'].nil? || @cli_opts['app'] == ''
+    end
+
+    def decide_ref
+      ref_decider = EY::DeployConfig::Ref.new(@cli_opts, @env_config, @repo, @ui)
+      if in_repo?
+        ref_decider.when_inside_repo
+      else
+        ref_decider.when_outside_repo
+      end
+    end
+  end
+end
+
+require 'engineyard/deploy_config/ref'

data/lib/engineyard/deploy_config/ref.rb

@@ -0,0 +1,56 @@
+require 'engineyard/error'
+
+module EY
+  class DeployConfig
+    class Ref
+
+      def initialize(cli_opts, env_config, repo, ui)
+        @cli_opts  = cli_opts
+        @default   = env_config.branch
+        @repo      = repo
+        @force_ref = @cli_opts.fetch('force_ref', false)
+        @ui        = ui
+
+        if @force_ref.kind_of?(String)
+          @ref, @force_ref = @force_ref, true
+        else
+          @ref = @cli_opts.fetch('ref', nil)
+          @ref = nil if @ref == ''
+        end
+      end
+
+      def when_inside_repo
+        if !@force_ref && @ref && @default && @ref != @default
+          raise BranchMismatchError.new(@default, @ref)
+        elsif @force_ref && @ref && @default
+          @ui.say "Default ref overridden with #{@ref.inspect}."
+        end
+
+        @ref || use_default || use_current_branch || raise(RefRequired.new(@cli_opts))
+      end
+
+      def use_default
+        if @default
+          @ui.say "Using default branch #{@default.inspect} from ey.yml."
+          @default
+        end
+      end
+
+      def use_current_branch
+        if current = @repo.current_branch
+          @ui.say "Using current HEAD branch #{current.inspect}."
+          current
+        end
+      end
+
+      # a.k.a. not in the correct repo
+      #
+      # returns the ref if it was passed in the cli opts.
+      # or raise
+      def when_outside_repo
+        @ref or raise RefAndMigrateRequiredOutsideRepo.new(@cli_opts)
+      end
+
+    end
+  end
+end

data/lib/engineyard/error.rb

@@ -0,0 +1,82 @@
+module EY
+  class Error < RuntimeError
+  end
+
+  class NoCommandError < EY::Error
+    def initialize
+      super "Specify a command to run via ssh or use --each to cycle through each server one at a time."
+    end
+  end
+
+  class NoInstancesError < EY::Error
+    def initialize(env_name)
+      super "The environment '#{env_name}' does not have any matching instances."
+    end
+  end
+
+  class ResolverError        < Error; end
+  class NoMatchesError       < ResolverError; end
+  class MultipleMatchesError < ResolverError; end
+
+  class AmbiguousEnvironmentGitUriError < ResolverError
+    def initialize(environments)
+      message = "The repository url in this directory is ambiguous.\n"
+      message << "Please use -e <envname> to specify one of the following environments:\n"
+      environments.sort do |a, b|
+        if a.account == b.account
+          a.name <=> b.name
+        else
+          a.account.name <=> b.account.name
+        end
+      end.each { |env| message << "\t#{env.name} (#{env.account.name})\n" }
+      super message
+    end
+  end
+
+
+  class DeployArgumentError < EY::Error; end
+  class BranchMismatchError < DeployArgumentError
+    def initialize(default, ref)
+      super <<-ERR
+Your default branch is set to #{default.inspect} in ey.yml.
+To deploy #{ref.inspect} you can:
+  * Delete the line 'branch: #{default}' in ey.yml
+OR
+  * Use the -R [REF] or --force-ref [REF] options as follows:
+Usage: ey deploy -R #{ref}
+       ey deploy --force-ref #{ref}
+      ERR
+    end
+  end
+
+  class RefAndMigrateRequiredOutsideRepo < DeployArgumentError
+    def initialize(options)
+      super <<-ERR
+Because defaults are stored in a file in your application dir, when specifying
+--app you must also specify the --ref and the --migrate or --no-migrate options.
+Usage: ey deploy --app #{options[:app]} --ref [ref] --migrate [COMMAND]
+       ey deploy --app #{options[:app]} --ref [branch] --no-migrate
+      ERR
+    end
+  end
+
+  class RefRequired < DeployArgumentError
+    def initialize(options)
+      super <<-ERR
+Unable to determine the branch or ref to deploy
+Usage: ey deploy --ref [ref]
+      ERR
+    end
+  end
+
+  class MigrateRequired < DeployArgumentError
+    def initialize(options)
+      super <<-ERR
+Unable to determine migration choice. ey deploy no longer migrates by default.
+Usage: ey deploy --migrate
+       ey deploy --no-migrate
+      ERR
+    end
+  end
+
+end