engineyard 1.4.29 → 1.7.0.pre2

data/lib/engineyard/cli/#recipes.rb#

@@ -0,0 +1,32 @@
+module EY
+  class CLI
+    class Recipes < EY::Thor
+X1gx1GGG      desc "recipes apply [ENVIRONMENT]", <<-DESC
+Run uploaded chef recipes on specified environment.
+
+This is similar to '#{banner_base} rebuild' except Engine Yard's main
+configuration step is skipped.
+      DESC
+
+      def apply(name = nil)
+        environment = fetch_environment(name)
+        environment.run_custom_recipes
+        EY.ui.say "Uploaded recipes started for #{environment.name}"
+      end
+
+      desc "recipes upload [ENVIRONMENT]", <<-DESC
+Upload custom chef recipes to specified environment.
+
+The current directory should contain a subdirectory named "cookbooks" to be
+uploaded.
+      DESC
+
+      def upload(name = nil)
+        environment = fetch_environment(name)
+        environment.upload_recipes
+        EY.ui.say "Recipes uploaded successfully for #{environment.name}"
+      end
+    end
+  end
+
+end

data/lib/engineyard/cli/api.rb

@@ -1,44 +1,58 @@
 require 'highline'
-require 'engineyard/api'
+require 'engineyard-cloud-client'
+require 'engineyard/eyrc'
 
 module EY
   class CLI
-    class API < EY::API
-
-      def initialize(token = nil)
-        @token = token
-        if ENV['ENGINEYARD_API_TOKEN']
-          @token = ENV['ENGINEYARD_API_TOKEN']
+    class API
+      def self.authenticate(ui)
+        ui.info("We need to fetch your API token; please log in.")
+        begin
+          email    = ui.ask("Email: ")
+          password = ui.ask("Password: ", true)
+          token    = EY::CloudClient.authenticate(email, password, ui)
+          EY::EYRC.load.api_token = token
+          token
+        rescue EY::CloudClient::InvalidCredentials
+          ui.warn "Invalid username or password; please try again."
+          retry
         end
-        @token ||= EY::EYRC.load.api_token
-        @token ||= self.class.fetch_token
-        raise EY::Error, "Sorry, we couldn't get your API token." unless @token
       end
 
-      def request(*)
-        begin
-          super
-        rescue EY::API::InvalidCredentials
-          EY.ui.warn "Credentials rejected; please authenticate again."
-          refresh
-          retry
+      attr_reader :token
+
+      def initialize(endpoint, ui)
+        @ui = ui
+        EY::CloudClient.endpoint = endpoint
+
+        @token = ENV['ENGINEYARD_API_TOKEN'] if ENV['ENGINEYARD_API_TOKEN']
+        @token ||= EY::EYRC.load.api_token
+        @token ||= self.class.authenticate(ui)
+
+        unless @token
+          raise EY::Error, "Sorry, we couldn't get your API token."
         end
+
+        @api = EY::CloudClient.new(@token, @ui)
       end
 
-      def refresh
-        @token = self.class.fetch_token
+      def respond_to?(*a)
+        super or @api.respond_to?(*a)
       end
 
-      def self.fetch_token
-        EY.ui.info("We need to fetch your API token; please log in.")
-        begin
-          email    = EY.ui.ask("Email: ")
-          password = EY.ui.ask("Password: ", true)
-          super(email, password)
-        rescue EY::API::InvalidCredentials
-          EY.ui.warn "Invalid username or password; please try again."
-          retry
+      protected
+
+      def method_missing(meth, *args, &block)
+        if @api.respond_to?(meth)
+          @api.send(meth, *args, &block)
+        else
+          super
         end
+      rescue EY::CloudClient::InvalidCredentials
+        ui.warn "Authentication failed."
+        @token = self.class.authenticate(@ui)
+        @api = EY::CloudClient.new(@token, @ui)
+        retry
       end
 
     end

data/lib/engineyard/cli/recipes.rb

@@ -12,8 +12,10 @@ module EY
       DESC
 
       method_option :environment, :type => :string, :aliases => %w(-e),
+        :required => true, :default => '',
         :desc => "Environment in which to apply recipes"
       method_option :account, :type => :string, :aliases => %w(-c),
+        :required => true, :default => '',
         :desc => "Name of the account in which the environment can be found"
       def apply
         environment = fetch_environment(options[:environment], options[:account])
@@ -35,12 +37,15 @@ module EY
       DESC
 
       method_option :environment, :type => :string, :aliases => %w(-e),
+        :required => true, :default => '',
         :desc => "Environment that will receive the recipes"
       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 :apply, :type => :boolean,
         :desc => "Apply the recipes immediately after they are uploaded"
       method_option :file, :type => :string, :aliases => %w(-f),
+        :required => true, :default => '',
         :desc => "Specify a gzipped tar file (.tgz) for upload instead of cookbooks/ directory"
       def upload
         environment = fetch_environment(options[:environment], options[:account])
@@ -53,16 +58,16 @@ module EY
       no_tasks do
         def apply_recipes(environment)
           environment.run_custom_recipes
-          EY.ui.say "Uploaded recipes started for #{environment.name}"
+          ui.say "Uploaded recipes started for #{environment.name}"
         end
 
         def upload_recipes(environment, filename)
-          if options[:file]
-            environment.upload_recipes_at_path(options[:file])
-            EY.ui.say "Recipes file #{options[:file]} uploaded successfully for #{environment.name}"
+          if filename && filename != ''
+            environment.upload_recipes_at_path(filename)
+            ui.say "Recipes file #{filename} uploaded successfully for #{environment.name}"
           else
             environment.tar_and_upload_recipes_in_cookbooks_dir
-            EY.ui.say "Recipes in cookbooks/ uploaded successfully for #{environment.name}"
+            ui.say "Recipes in cookbooks/ uploaded successfully for #{environment.name}"
           end
         end
       end
@@ -76,13 +81,15 @@ module EY
         If the cookbooks directory already exists, an error will be raised.
       DESC
       method_option :environment, :type => :string, :aliases => %w(-e),
+        :required => true, :default => '',
         :desc => "Environment for which to download the recipes"
       method_option :account, :type => :string, :aliases => %w(-c),
+        :required => true, :default => '',
         :desc => "Name of the account in which the environment can be found"
       def download
         environment = fetch_environment(options[:environment], options[:account])
         environment.download_recipes
-        EY.ui.say "Recipes downloaded successfully for #{environment.name}"
+        ui.say "Recipes downloaded successfully for #{environment.name}"
       end
 
     end

data/lib/engineyard/cli/ui.rb

@@ -1,29 +1,84 @@
+require 'highline'
+
 module EY
   class CLI
     class UI < Thor::Base.shell
 
+      class Tee
+        def initialize(*ios)
+          @ios = ios
+        end
+
+        def <<(str)
+          @ios.each { |io| io << str }
+          self
+        end
+      end
+
       class Prompter
-        class Mock
-          def next_answer=(arg)
-            @answers ||= []
-            @answers << arg
-          end
-          def ask(*args, &block)
-            @questions ||= []
-            @questions << args.first
-            @answers.pop
-          end
-          attr_reader :questions
+        def self.add_answer(arg)
+          @answers ||= []
+          @answers << arg
         end
+
+        def self.questions
+          @questions
+        end
+
         def self.enable_mock!
-          @backend = Mock.new
+          @questions = []
+          @answers = []
+          @mock = true
         end
-        def self.backend
-          require 'highline'
-          @backend ||= HighLine.new($stdin)
+
+        def self.highline
+          @highline ||= HighLine.new($stdin)
         end
-        def self.ask(*args, &block)
-          backend.ask(*args, &block)
+
+        def self.interactive?
+          @mock || ($stdin && $stdin.tty?)
+        end
+
+        def self.ask(question, password = false, default = nil)
+          if @mock
+            @questions ||= []
+            @questions << question
+            answer = @answers.shift
+            (answer == '' && default) ? default : answer
+          else
+            timeout_if_not_interactive do
+              highline.ask(question) do |q|
+                q.echo = "*"        if password
+                q.default = default if default
+              end
+            end
+          end
+        end
+
+        def self.agree(question, default)
+          if @mock
+            @questions ||= []
+            @questions << question
+            answer = @answers.shift
+            answer == '' ? default : %w[y yes].include?(answer)
+          else
+            timeout_if_not_interactive do
+              answer = highline.agree(question) {|q| q.default = default ? 'Y/n' : 'N/y' }
+              case answer
+              when 'Y/n' then true
+              when 'N/y' then false
+              else            answer
+              end
+            end
+          end
+        end
+
+        def self.timeout_if_not_interactive(&block)
+          if interactive?
+            block.call
+          else
+            Timeout.timeout(5, &block)
+          end
         end
       end
 
@@ -58,27 +113,27 @@ module EY
         end
       end
 
-      def ask(message, password = false)
-        begin
-          if !$stdin || !$stdin.tty?
-            Prompter.ask(message)
-          elsif password
-            Prompter.ask(message) {|q| q.echo = "*" }
-          else
-            Prompter.ask(message) {|q| q.readline = true }
-          end
-        rescue EOFError
-          return ''
-        end
+      def interactive?
+        Prompter.interactive?
+      end
+
+      def agree(message, default)
+        Prompter.agree(message, default)
       end
 
-      def print_envs(apps, default_env_name = nil, simple = false)
+      def ask(message, password = false, default = nil)
+        Prompter.ask(message, password, default)
+      rescue EOFError
+        return ''
+      end
+
+      def print_envs(apps, default_env_name = nil, simple = false, endpoint = 'https://cloud.engineyard.com')
         if simple
           envs = apps.map{ |app| app.environments.to_a }
           puts envs.flatten.map{|env| env.name }.uniq
         else
           apps.each do |app|
-            puts "#{app.name} (#{app.account.name})"
+            puts "#{app.account.name}/#{app.name}"
             if app.environments.any?
               app.environments.each do |env|
                 short_name = env.shorten_name_for(app)
@@ -91,7 +146,7 @@ module EY
                 puts "  #{short_name}#{default_text} (#{icount} #{iname})"
               end
             else
-              puts "  (This application is not in any environments; you can make one at #{EY.config.endpoint})"
+              puts "  (This application is not in any environments; you can make one at #{endpoint})"
             end
 
             puts ""
@@ -100,27 +155,25 @@ module EY
       end
 
       def show_deployment(dep)
-        puts "# Status of last deployment of #{dep.app.account.name}/#{dep.app.name}/#{dep.environment.name}:"
-        puts "#"
-
         output = []
         output << ["Account",         dep.app.account.name]
         output << ["Application",     dep.app.name]
         output << ["Environment",     dep.environment.name]
         output << ["Input Ref",       dep.ref]
-        output << ["Resolved Ref",    dep.ref]
-        output << ["Commit",          dep.commit || '(Unable to resolve)']
+        output << ["Resolved Ref",    dep.resolved_ref]
+        output << ["Commit",          dep.commit || '(not resolved)']
         output << ["Migrate",         dep.migrate]
         output << ["Migrate command", dep.migrate_command] if dep.migrate
-        output << ["Deployed by",     dep.user_name]
-        output << ["Created at",      dep.created_at]
-        output << ["Finished at",     dep.finished_at]
+        output << ["Deployed by",     dep.deployed_by]
+        output << ["Started at",      dep.created_at] if dep.created_at
+        output << ["Finished at",     dep.finished_at] if dep.finished_at
 
         output.each do |att, val|
-          puts "#\t%-15s %s" % ["#{att}:", val.to_s]
+          puts "#\t%-16s %s" % ["#{att}:", val.to_s]
         end
-        puts "#"
+      end
 
+      def deployment_result(dep)
         if dep.successful?
           info 'This deployment was successful.'
         elsif dep.finished_at.nil?
@@ -153,6 +206,14 @@ module EY
         ($stdout.tty? || ENV['THOR_SHELL']) ? super : string
       end
 
+      def err
+        $stderr
+      end
+
+      def out
+        $stdout
+      end
+
     end
   end
 end

data/lib/engineyard/cli/web.rb

@@ -4,17 +4,20 @@ module EY
       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 :verbose, :type => :boolean, :aliases => %w(-v),
-        :desc => "Be verbose"
       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, environment = fetch_app_and_environment(options[:app], options[:environment], options[:account])
-        EY.ui.info "Taking down maintenance page for '#{app.name}' in '#{environment.name}'"
-        environment.take_down_maintenance_page(app, options[:verbose])
+        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]",
@@ -31,17 +34,20 @@ module EY
         * 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 :verbose, :type => :boolean, :aliases => %w(-v),
-        :desc => "Be verbose"
       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, environment = fetch_app_and_environment(options[:app], options[:environment], options[:account])
-        EY.ui.info "Putting up maintenance page for '#{app.name}' in '#{environment.name}'"
-        environment.put_up_maintenance_page(app, options[:verbose])
+        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
     end
   end

data/lib/engineyard/config.rb

@@ -1,15 +1,17 @@
 require 'uri'
+require 'yaml'
 require 'engineyard/error'
 
 module EY
   class Config
-    CONFIG_FILES = ["config/ey.yml", "ey.yml"]
+    CONFIG_FILES = ["config/ey.yml", "ey.yml"].map {|path| Pathname.new(path)}.freeze
+
+    attr_reader :path
 
     def initialize(file = nil)
-      require 'yaml'
-      @file = file || CONFIG_FILES.find{|f| File.exists?(f) }
-      @config = (@file ? YAML.load_file(@file) : {}) || {} # load_file returns `false' when the file is empty
-      @config["environments"] = {} unless @config["environments"]
+      @path = file || CONFIG_FILES.find{|pathname| pathname.exist? }
+      @config = (@path ? YAML.load_file(@path.to_s) : {}) || {} # load_file returns `false' when the file is empty
+      @config["environments"] ||= {}
     end
 
     def method_missing(meth, *args, &blk)
@@ -27,17 +29,15 @@ module EY
     end
 
     def endpoint
-      @endpoint ||= env_var_endpoint || default_endpoint
+      env_var_endpoint || default_endpoint
     end
 
     def env_var_endpoint
-      if endpoint = ENV["CLOUD_URL"]
-        assert_valid_endpoint endpoint, "CLOUD_URL"
-      end
+      ENV["CLOUD_URL"]
     end
 
     def default_endpoint
-      URI.parse("https://cloud.engineyard.com/")
+      "https://cloud.engineyard.com/"
     end
 
     def default_endpoint?
@@ -51,20 +51,94 @@ module EY
       d && d.first
     end
 
-    def default_branch(environment = default_environment)
-      env = environments[environment]
-      env && env["branch"]
+    def environment_config(environment_name)
+      environments[environment_name] ||= {}
+      EnvironmentConfig.new(environments[environment_name], environment_name, self)
     end
 
-    private
+    def set_environment_option(environment_name, key, value)
+      environments[environment_name] ||= {}
+      environments[environment_name][key] = value
+      ensure_path
+      @path.open('w') do |f|
+        YAML.dump(@config, f)
+      end
+    end
 
-    def assert_valid_endpoint(endpoint, source)
-      endpoint = URI.parse(endpoint) if endpoint.is_a?(String)
-      return endpoint if endpoint.absolute?
+    def ensure_path
+      return if @path && @path.exist?
+      unless EY::Repo.exist?
+        raise "Not in application directory. Unable to save configuration."
+      end
+      @path = Pathname.new('config/ey.yml')
+      @path.dirname.mkpath
+      @path
+    end
 
-      raise ConfigurationError.new('endpoint', endpoint.to_s, source, "endpoint must be an absolute URI")
+    class EnvironmentConfig
+      attr_reader :name
+
+      def initialize(config, name, parent)
+        @config = config || {}
+        @name = name
+        @parent = parent
+      end
+
+      def path
+        @parent.path
+      end
+
+      def fetch(key, default = nil, &block)
+        if block
+          @config.fetch(key.to_s, &block)
+        else
+          @config.fetch(key.to_s, default)
+        end
+      end
+
+      def set(key, val)
+        @config[key.to_s] = val
+        @parent.set_environment_option(@name, key, val)
+        val
+      end
+
+      def merge(other)
+        to_clean_hash.merge(other)
+      end
+
+      def to_clean_hash
+        @config.reject { |k,v| %w[branch migrate migration_command verbose].include?(k) }
+      end
+
+      def branch
+        fetch('branch', nil)
+      end
+
+      def migrate(&block)
+        fetch('migrate', &block)
+      end
+
+      def migrate=(mig)
+        set('migrate', mig)
+      end
+
+      def migration_command
+        fetch('migration_command', nil)
+      end
+
+      def migration_command=(cmd)
+        set('migration_command', cmd)
+      end
+      alias migrate_command migration_command
+      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}|