crazy-yard 3.2.2

data/lib/engineyard/cli/api.rb

@@ -0,0 +1,98 @@
+require 'highline'
+require 'engineyard-cloud-client'
+require 'engineyard/eyrc'
+
+module EY
+  class CLI
+    class API
+      USER_AGENT = "EngineYard/#{EY::VERSION}"
+
+      attr_reader :token
+
+      def initialize(endpoint, ui, token = nil)
+        @client = EY::CloudClient.new(endpoint: endpoint, output: ui.out, user_agent: USER_AGENT)
+        @ui = ui
+        @eyrc = EY::EYRC.load
+        token_from('--api-token') { token } ||
+          token_from('$ENGINEYARD_API_TOKEN') { ENV['ENGINEYARD_API_TOKEN'] } ||
+          token_from(@eyrc.path, false) { @eyrc.api_token } ||
+          authenticate ||
+          token_not_loaded
+      end
+
+      def respond_to?(*a)
+        super or @client.respond_to?(*a)
+      end
+
+      protected
+
+      def method_missing(meth, *args, &block)
+        if @client.respond_to?(meth)
+          with_reauthentication { @client.send(meth, *args, &block) }
+        else
+          super
+        end
+      end
+
+      def with_reauthentication
+        begin
+          yield
+        rescue EY::CloudClient::InvalidCredentials
+          if @specified || !@ui.interactive?
+            # If the token is specified, we raise immediately if it is rejected.
+            raise EY::Error, "Authentication failed: Invalid #{@source}."
+          else
+            @ui.warn "Authentication failed: Invalid #{@source}."
+            authenticate
+            retry
+          end
+        end
+      end
+
+      # Get the token from the provided block, saving it if it works.
+      # Specified will help us know what to do if loading the token fails.
+      # Returns true if it gets a token.
+      # Returns false if there is no token.
+      def token_from(source, specified = true)
+        token = yield
+        if token
+          @client.token = token
+          @specified    = specified
+          @source       = "token from #{source}"
+          @token        = token
+          true
+        else
+          false
+        end
+      end
+
+      # Load the token from EY Cloud if interactive and
+      # token wasn't explicitly specified previously.
+      def authenticate
+        if @specified
+          return false
+        end
+
+        @source    = "credentials"
+        @specified = false
+
+        @ui.info "We need to fetch your API token; please log in."
+        begin
+          email  = @ui.ask("Email: ")
+          passwd = @ui.ask("Password: ", true)
+          @token = @client.authenticate!(email, passwd)
+          @eyrc.api_token = @token
+          true
+        rescue EY::CloudClient::InvalidCredentials
+          @ui.warn "Authentication failed. Please try again."
+          retry
+        end
+      end
+
+      # Occurs when all avenues for getting the token are exhausted.
+      def token_not_loaded
+        raise EY::Error, "Sorry, we couldn't get your API token."
+      end
+    end
+  end
+end

data/lib/engineyard/cli/recipes.rb

@@ -0,0 +1,129 @@
+require 'tempfile'
+
+module EY
+  class CLI
+    class Recipes < EY::Thor
+      desc "apply [--environment ENVIRONMENT]",
+        "Run chef recipes uploaded by '#{banner_base} recipes upload' on the specified environment."
+      long_desc <<-DESC
+        This is similar to '#{banner_base} rebuild' except Engine Yard's main
+        configuration step is skipped.
+
+        The cookbook uploaded by the '#{banner_base} recipes upload' command will be run when
+        you run '#{banner_base} recipes apply'.
+      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])
+        apply_recipes(environment)
+      end
+
+      desc "upload [--environment ENVIRONMENT]",
+        "Upload custom chef recipes to specified environment so they can be applied."
+      long_desc <<-DESC
+        Make an archive of the "cookbooks/" subdirectory in your current working
+        directory and upload it to Engine Yard Cloud's recipe storage.
+
+        Alternatively, specify a .tgz of a cookbooks/ directory yourself as follows:
+
+        $ #{banner_base} recipes upload -f path/to/recipes.tgz
+
+        The uploaded cookbooks will be run when executing '#{banner_base} recipes apply'
+        and also automatically each time you update/rebuild your instances.
+      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])
+        upload_recipes(environment, options[:file])
+        if options[:apply]
+          apply_recipes(environment)
+        end
+      end
+
+      no_tasks do
+        def apply_recipes(environment)
+          environment.run_custom_recipes
+          ui.info "Uploaded recipes started for #{environment.name}"
+        end
+
+        def upload_recipes(environment, filename)
+          if filename && filename != ''
+            environment.upload_recipes_at_path(filename)
+            ui.info "Recipes file #{filename} uploaded successfully for #{environment.name}"
+          else
+            path = cookbooks_dir_archive_path
+            environment.upload_recipes_at_path(path)
+            ui.info "Recipes in cookbooks/ uploaded successfully for #{environment.name}"
+          end
+        end
+
+        def cookbooks_dir_archive_path
+          unless FileTest.exist?("cookbooks")
+            raise EY::Error, "Could not find chef recipes. Please run from the root of your recipes repo."
+          end
+
+          recipes_file = Tempfile.new("recipes")
+
+          cmd = "tar czf '#{recipes_file.path}' cookbooks/"
+          if FileTest.exist?("data_bags")
+            cmd = cmd + " data_bags/"
+          end
+
+          unless system(cmd)
+            raise EY::Error, "Could not archive recipes.\nCommand `#{cmd}` exited with an error."
+          end
+          recipes_file.path
+        end
+      end
+
+      desc "download [--environment ENVIRONMENT]",
+        "Download a copy of the custom chef recipes from this environment into the current directory."
+      long_desc <<-DESC
+        The recipes will be unpacked into a directory called "cookbooks" in the
+        current directory. This is the opposite of 'recipes upload'.
+
+        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
+        if File.exist?('cookbooks')
+          raise EY::Error, "Cannot download recipes, cookbooks directory already exists."
+        end
+
+        environment = fetch_environment(options[:environment], options[:account])
+
+        recipes = environment.download_recipes
+        cmd = "tar xzf '#{recipes.path}' cookbooks"
+
+        if system(cmd)
+          ui.info "Recipes downloaded successfully for #{environment.name}"
+        else
+          raise EY::Error, "Could not unarchive recipes.\nCommand `#{cmd}` exited with an error."
+        end
+      end
+
+    end
+  end
+end

data/lib/engineyard/cli/ui.rb

@@ -0,0 +1,275 @@
+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
+        def self.add_answer(arg)
+          @answers ||= []
+          @answers << arg
+        end
+
+        def self.questions
+          @questions
+        end
+
+        def self.enable_mock!
+          @questions = []
+          @answers = []
+          @mock = true
+        end
+
+        def self.highline
+          @highline ||= HighLine.new($stdin)
+        end
+
+        def self.interactive?
+          @mock || ($stdout && $stdout.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.to_s
+            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(2, &block)
+          end
+        end
+      end
+
+      def error(name, message = nil)
+        $stdout = $stderr
+        say_with_status(name, message, :red)
+      ensure
+        $stdout = STDOUT
+      end
+
+      def warn(name, message = nil)
+        say_with_status(name, message, :yellow)
+      end
+
+      def info(message, color = nil)
+        return if quiet?
+        say_with_status(message, nil, color)
+      end
+
+      def debug(name, message = nil)
+        if ENV["DEBUG"]
+          name    = name.inspect    unless name.nil? or name.is_a?(String)
+          message = message.inspect unless message.nil? or message.is_a?(String)
+          say_with_status(name, message, :blue)
+        end
+      end
+
+      def say_with_status(name, message=nil, color=nil)
+        if message
+          say_status name, message, color
+        elsif name
+          say name, color
+        end
+      end
+
+      def interactive?
+        Prompter.interactive?
+      end
+
+      def agree(message, default)
+        Prompter.agree(message, default)
+      end
+
+      def ask(message, password = false, default = nil)
+        Prompter.ask(message, password, default)
+      rescue EOFError
+        return ''
+      end
+
+      def mute_if(bool, &block)
+        bool ? mute(&block) : yield
+      end
+
+      def server_tuples(servers, username=nil)
+        user = username && "#{username}@"
+
+        servers.map do |server|
+          host = "#{user}#{server.hostname}"
+          [host, server.amazon_id, server.role, server.name]
+        end
+      end
+      private :server_tuples
+
+      def print_hostnames(servers, username=nil)
+        server_tuples(servers, username).each do |server_tuple|
+          puts server_tuple.first
+        end
+      end
+
+      def print_simple_servers(servers, username=nil)
+        server_tuples(servers, username).each do |server_tuple|
+          puts server_tuple.join("\t")
+        end
+      end
+
+      def print_servers(servers, name, username=nil)
+        tuples = server_tuples(servers, username)
+        count = tuples.size
+        puts "# #{count} server#{count == 1 ? '' : 's'} on #{name}"
+
+        host_width = tuples.map {|s| s[0].length }.max
+        host_format = "%-#{host_width}s" # "%-10s" left align
+
+        role_width = tuples.map {|s| s[2].length }.max
+        role_format = "%-#{role_width}s" # "%-10s" left align
+
+        tuples.each do |server_tuple|
+          puts "#{host_format}\t%s\t#{role_format}\t%s" % server_tuple
+        end
+      end
+
+      def print_simple_envs(envs)
+        puts envs.map{|env| env.name }.uniq.sort
+      end
+
+      def print_envs(apps, default_env_name = nil)
+        apps.sort_by {|app| "#{app.account.name}/#{app.name}" }.each do |app|
+          puts "#{app.account.name}/#{app.name}"
+          if app.environments.any?
+            app.environments.sort_by {|env| env.name }.each do |env|
+              icount = env.instances_count
+              iname = case icount
+                      when 0 then "(stopped)"
+                      when 1 then "1 instance"
+                      else "#{icount} instances"
+                      end
+
+              name = env.name == default_env_name ? "#{env.name} (default)" : env.name
+              framework_env = env.framework_env && "[#{env.framework_env.center(12)}]"
+
+              puts "    #{name.ljust(30)} #{framework_env}  #{iname}"
+            end
+          else
+            puts "    (No environments)"
+          end
+
+          puts ""
+        end
+      end
+
+      def deployment_status(deployment)
+        unless quiet?
+          say "# Status of last deployment of #{deployment.app_environment.hierarchy_name}:"
+          say "#"
+          show_deployment(deployment)
+          say "#"
+        end
+        deployment_result(deployment)
+      end
+
+      def show_deployment(dep)
+        return if quiet?
+        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.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.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%-16s %s" % ["#{att}:", val.to_s]
+        end
+      end
+
+      def deployment_result(dep)
+        if dep.successful?
+          say 'Deployment was successful.', :green
+        elsif dep.finished_at.nil?
+          say 'Deployment is not finished.', :yellow
+        else
+          say 'Deployment failed.', :red
+        end
+      end
+
+      def print_exception(e)
+        if e.message.empty? || (e.message == e.class.to_s)
+          message = nil
+        else
+          message = e.message
+        end
+
+        if ENV["DEBUG"]
+          error(e.class, message)
+          e.backtrace.each{|l| say(" "*3 + l) }
+        else
+          error(message || e.class.to_s)
+        end
+      end
+
+      def print_help(table)
+        print_table(table, ident: 2, truncate: true, colwidth: 20)
+      end
+
+      def set_color(string, color, bold=false)
+        ($stdout.tty? || ENV['THOR_SHELL']) ? super : string
+      end
+
+      def err
+        $stderr
+      end
+
+      def out
+        $stdout
+      end
+
+    end
+  end
+end