engineyard 1.4.29 → 1.7.0.pre2

data/lib/engineyard/serverside_runner.rb

@@ -0,0 +1,133 @@
+require 'escape'
+require 'net/ssh'
+require 'engineyard-serverside-adapter'
+
+module EY
+  class ServersideRunner
+    def initialize(bridge, app, environment, verbose)
+      @verbose = verbose || ENV['DEBUG']
+      @adapter = load_adapter(bridge, app, environment)
+      @username = environment.username
+      @hostname = bridge
+      @command = nil
+    end
+
+    def deploy(&block)
+      @command = @adapter.deploy(&block)
+      self
+    end
+
+    def rollback(&block)
+      @command = @adapter.rollback(&block)
+      self
+    end
+
+    def put_up_maintenance_page(&block)
+      @command = @adapter.enable_maintenance_page(&block)
+      self
+    end
+
+    def take_down_maintenance_page(&block)
+      @command = @adapter.disable_maintenance_page(&block)
+      self
+    end
+
+    def call(out, err)
+      raise "No command!" unless @command
+      @command.call do |cmd|
+        run cmd, out, err
+      end
+    end
+
+  private
+
+    def load_adapter(bridge, app, environment)
+      EY::Serverside::Adapter.new("/usr/local/ey_resin/ruby/bin") do |args|
+        args.app              = app.name
+        args.repo             = app.repository_uri
+        args.instances        = instances_data(environment.deploy_to_instances, bridge)
+        args.stack            = environment.app_server_stack_name
+        args.framework_env    = environment.framework_env
+        args.environment_name = environment.name
+        args.account_name     = app.account.name
+        args.verbose          = @verbose
+      end
+    end
+
+    # If we tell engineyard-serverside to use 'localhost', it'll run
+    # commands on the instance directly (#system). If we give it the
+    # instance's actual hostname, it'll SSH to itself.
+    #
+    # Using 'localhost' instead of its EC2 hostname speeds up
+    # deploys on solos and single-app-server clusters significantly.
+    def instances_data(instances, bridge)
+      instances.map do |i|
+        {
+          :hostname => i.hostname == bridge ? 'localhost' : i.hostname,
+          :roles    => [i.role],
+          :name     => i.name,
+        }
+      end
+    end
+
+    def run(remote_command, out, err)
+      cmd = Escape.shell_command(['bash', '-lc', remote_command])
+
+      if cmd.respond_to?(:encoding) && cmd.respond_to?(:force_encoding)
+        out << "Encoding: #{cmd.encoding.name}" if @verbose
+        cmd.force_encoding('binary')
+        out << " => #{cmd.encoding.name}; __ENCODING__: #{__ENCODING__.name}; LANG: #{ENV['LANG']}; LC_CTYPE: #{ENV['LC_CTYPE']}\n" if @verbose
+      end
+
+      out << "Running command on #{@username}@#{@hostname}.\n"
+      out << cmd << "\n" if @verbose
+
+      if ENV["NO_SSH"]
+        out << "NO_SSH is set. No output.\n"
+        true
+      else
+        begin
+          ssh(cmd, @hostname, @username, out, err)
+        rescue Net::SSH::AuthenticationFailed
+          raise EY::Error, "Authentication Failed: Please add your environment's ssh key with: ssh-add path/to/key"
+        end
+      end
+    end
+
+    def ssh(cmd, hostname, username, out, err)
+      exit_code = 1
+      options_for_ssh = {:paranoid => false}
+      options_for_ssh[:verbose] = ENV["DEBUG"].downcase.to_sym if ENV["DEBUG"]
+      Net::SSH.start(hostname, username, options_for_ssh) do |net_ssh|
+        net_ssh.open_channel do |channel|
+          channel.exec cmd do |_, success|
+            unless success
+              err << "Remote command execution failed"
+              return false
+            end
+
+            channel.on_data do |_, data|
+              out << data
+            end
+
+            channel.on_extended_data do |_, _, data|
+              err << data
+            end
+
+            channel.on_request("exit-status") do |_, data|
+              exit_code = data.read_long
+            end
+
+            channel.on_request("exit-signal") do |_, data|
+              exit_code = 255
+            end
+          end
+        end
+
+        net_ssh.loop
+      end
+      exit_code.zero?
+    end
+
+  end
+end

data/lib/engineyard/thor.rb

@@ -4,33 +4,125 @@ module EY
   module UtilityMethods
     protected
     def api
-      @api ||= EY::CLI::API.new
+      @api ||= EY::CLI::API.new(config.endpoint, ui)
+    end
+
+    def config
+      @config ||= EY::Config.new
+    end
+
+    def ui
+      @ui ||= load_ui
+    end
+
+    def load_ui
+      Thor::Base.shell = EY::CLI::UI
+      EY::CLI::UI.new
+    end
+
+    def in_repo?
+      EY::Repo.exist?
     end
 
     def repo
       @repo ||= EY::Repo.new
     end
 
-    def fetch_environment(environment_name, account_name=nil)
-      environment_name ||= EY.config.default_environment
-      options = {
+    def serverside_runner(app_env, verbose)
+      ServersideRunner.new(app_env.environment.bridge!.hostname, app_env.app, app_env.environment, verbose)
+    end
+
+    def use_default_environment
+      if env = config.default_environment
+        ui.say "Using default environment #{config.default_environment.inspect} from ey.yml."
+        env
+      end
+    end
+
+    def fetch_environment(environment_name, account_name)
+      environment_name ||= use_default_environment
+      remotes = repo.remotes if in_repo?
+      constraints = {
         :environment_name => environment_name,
-        :account_name => account_name
+        :account_name     => account_name,
+        :remotes          => remotes,
       }
-      options.merge! :repo => repo if repo.exist?
-      api.resolver.environment(options)
+
+      resolver = api.resolve_environments(constraints)
+
+      resolver.one_match { |match| return match  }
+
+      resolver.no_matches do |errors, suggestions|
+        raise_no_matches(errors, suggestions)
+      end
+
+      resolver.many_matches do |matches|
+        if environment_name
+          message = "Multiple environments possible, please be more specific:\n\n"
+          matches.each do |env|
+            message << "\t#{env.name.ljust(25)} # ey <command> --environment='#{env.name}' --account='#{env.account.name}'\n"
+          end
+          raise EY::MultipleMatchesError.new(message)
+        else
+          raise EY::AmbiguousEnvironmentGitUriError.new(matches)
+        end
+      end
     end
 
-    def fetch_app_and_environment(app_name = nil, environment_name = nil, account_name=nil)
-      options = {
-        :app_name => app_name,
+    def fetch_app_environment(app_name, environment_name, account_name)
+      environment_name ||= use_default_environment
+      remotes = repo.remotes if in_repo?
+      constraints = {
+        :app_name         => app_name,
         :environment_name => environment_name,
-        :account_name => account_name
+        :account_name     => account_name,
+        :remotes          => remotes,
       }
-      options.merge! :repo => repo if repo.exist?
-      api.resolver.app_and_environment(options)
+
+      if constraints.all? { |k,v| v.nil? || v.empty? || v.to_s.empty? }
+        raise EY::NoMatchesError.new <<-ERROR
+Unable to find application without a git remote URI or app name.
+
+Please specify --app app_name or add this application at #{config.endpoint}"
+        ERROR
+      end
+
+      resolver = api.resolve_app_environments(constraints)
+
+      resolver.one_match { |match| return match }
+      resolver.no_matches do |errors, suggestions|
+        raise_no_matches(errors, suggestions)
+      end
+      resolver.many_matches do |app_envs|
+        raise EY::MultipleMatchesError.new(too_many_app_environments_error(app_envs))
+      end
+    end
+
+    def raise_no_matches(errors, suggestions)
+      message = "We found the following suggestions:\n" if suggestions.any?
+
+      suggestions.each do |suggest|
+        message << " # ey <command> --account='#{suggest['account_name']}' --app='#{suggest['app_name']}' --environment='#{suggest['env_name']}'\n"
+      end
+
+      raise EY::NoMatchesError.new([errors,message].compact.join("\n").strip)
     end
 
+      def too_many_app_environments_error(app_envs)
+        message = "Multiple application environments possible, please be more specific:\n\n"
+
+        app_envs.group_by do |app_env|
+          [app_env.account_name, app_env.app_name]
+        end.sort_by { |k,v| k.join }.each do |(account_name, app_name), grouped_app_envs|
+          message << "\n"
+          message << account_name << "/" << app_name << "\n"
+          grouped_app_envs.map { |ae| ae.environment_name }.uniq.sort.each do |env_name|
+            message << "\t#{env_name.ljust(25)}"
+            message << " # ey <command> --account='#{account_name}' --app='#{app_name}' --environment='#{env_name}'\n"
+          end
+        end
+        message
+      end
   end # UtilityMethods
 
   class Thor < ::Thor
@@ -44,13 +136,13 @@ module EY
         class_eval <<-RUBY
           def help(*args)
             if args.empty?
-              EY.ui.say "usage: #{banner_base} #{cmd} COMMAND"
-              EY.ui.say
+              ui.say "usage: #{banner_base} #{cmd} COMMAND"
+              ui.say
               subcommands = self.class.printable_tasks.sort_by{|s| s[0] }
               subcommands.reject!{|t| t[0] =~ /#{cmd} help$/}
-              EY.ui.print_help(subcommands)
-              EY.ui.say self.class.send(:class_options_help, EY.ui)
-              EY.ui.say "See #{banner_base} #{cmd} help COMMAND" +
+              ui.print_help(subcommands)
+              ui.say self.class.send(:class_options_help, ui)
+              ui.say "See #{banner_base} #{cmd} help COMMAND" +
                 " for more information on a specific subcommand." if args.empty?
             else
               super

data/lib/engineyard/version.rb

@@ -1,3 +1,3 @@
 module EY
-  VERSION = '1.4.29'
+  VERSION = '1.7.0.pre2'
 end

data/spec/engineyard/cli/api_spec.rb

@@ -2,42 +2,36 @@ require 'spec_helper'
 require 'engineyard/cli'
 
 describe EY::CLI::API do
-  before(:all) do
-    EY.ui = EY::CLI::UI.new
-  end
-
-  after(:all) do
-    EY.ui = EY::UI.new
-  end
-
   it "gets the api token from ~/.eyrc if possible" do
     write_eyrc({"api_token" => "asdf"})
-    EY::CLI::API.new.should == EY::CLI::API.new("asdf")
+    EY::CLI::API.new('http://fake.local', EY::CLI::UI.new).token.should == "asdf"
+    clean_eyrc
   end
 
   it "uses the token from $ENGINEYARD_API_TOKEN if set" do
     ENV['ENGINEYARD_API_TOKEN'] = 'envtoken'
-    EY::CLI::API.new.token.should == 'envtoken'
+    EY::CLI::API.new('http://fake.local', EY::CLI::UI.new).token.should == 'envtoken'
     ENV.delete('ENGINEYARD_API_TOKEN')
   end
 
   context "without saved api token" do
     before(:each) do
-      FakeWeb.register_uri(:post, "https://cloud.engineyard.com/api/v2/authenticate", :body => %|{"api_token": "asdf"}|, :content_type => 'application/json')
+      clean_eyrc
+      FakeWeb.register_uri(:post, "http://fake.local/api/v2/authenticate", :body => %|{"api_token": "asdf"}|, :content_type => 'application/json')
 
       EY::CLI::UI::Prompter.enable_mock!
-      EY::CLI::UI::Prompter.backend.next_answer = "my@email.example.com"
-      EY::CLI::UI::Prompter.backend.next_answer = "secret"
+      EY::CLI::UI::Prompter.add_answer "my@email.example.com"
+      EY::CLI::UI::Prompter.add_answer "secret"
 
-      @api = EY::CLI::API.new
+      @api = EY::CLI::API.new('http://fake.local', EY::CLI::UI.new)
     end
 
     it "asks you for your credentials" do
-      EY::CLI::UI::Prompter.backend.questions.should == ["Email: ","Password: "]
+      EY::CLI::UI::Prompter.questions.should == ["Email: ","Password: "]
     end
 
     it "gets the api token" do
-      @api.should == EY::CLI::API.new("asdf")
+      @api.token.should == "asdf"
     end
 
     it "saves the api token to ~/.eyrc" do

data/spec/engineyard/cli_spec.rb

@@ -3,15 +3,6 @@ require 'engineyard/cli'
 
 describe EY::CLI do
 
-  it "sets up EY.ui" do
-    EY.instance_eval{ @ui = nil }
-    EY.ui.should be_an(EY::UI)
-    capture_stdout do
-      EY::CLI.start(["help"])
-    end
-    EY.ui.should be_an(EY::CLI::UI)
-  end
-
   it "provides help" do
     out = capture_stdout do
       EY::CLI.start(["help"])
@@ -31,8 +22,6 @@ describe EY::CLI do
   end
 
   it "provides error classes" do
-    EY::EnvironmentError.should be
-    EY::BranchMismatchError.should be
     EY::DeployArgumentError.should be
   end
 

data/spec/engineyard/config_spec.rb

@@ -23,14 +23,7 @@ describe EY::Config do
 
     it "loads the endpoint from $CLOUD_URL" do
       ENV['CLOUD_URL'] = "http://fake.local/"
-      EY::Config.new.endpoint.should == URI.parse('http://fake.local')
-      ENV.delete('CLOUD_URL')
-    end
-
-    it "raises on an invalid endpoint" do
-      ENV['CLOUD_URL'] = "non/absolute"
-      lambda { EY::Config.new.endpoint }.
-        should raise_error(EY::Config::ConfigurationError)
+      EY::Config.new.endpoint.should == 'http://fake.local/'
       ENV.delete('CLOUD_URL')
     end
   end

data/spec/engineyard/deploy_config_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe EY::DeployConfig::Migrate do
+  before do
+    @parent = mock('parent config mock')
+    @parent.stub!(:set_environment_option)
+    @parent.stub!(:path).and_return('path')
+    @ui = EY::CLI::UI.new
+    EY::CLI::UI::Prompter.enable_mock!
+    @repo = mock('repo')
+  end
+
+  def env_config(opts=nil)
+    @env_config ||= EY::Config::EnvironmentConfig.new(opts, 'envname', @parent)
+  end
+
+  def deploy_config(cli_options)
+    EY::DeployConfig.new(cli_options, env_config, @repo, @ui)
+  end
+
+  context "inside a repository" do
+    context "no migrate options set (interactive)" do
+      it "prompts migrate and command by default" do
+        EY::CLI::UI::Prompter.add_answer "" # default
+        EY::CLI::UI::Prompter.add_answer ""
+        @parent.should_receive(:set_environment_option).with('envname', 'migrate', true)
+        @parent.should_receive(:set_environment_option).with('envname', 'migration_command', 'rake db:migrate')
+        dc = deploy_config({})
+        dc.migrate.should be_true
+        dc.migrate_command.should == 'rake db:migrate'
+      end
+
+      it "prompts migration_command if first answer is yes" do
+        EY::CLI::UI::Prompter.add_answer "yes" # default
+        EY::CLI::UI::Prompter.add_answer "ruby script/migrate"
+        @parent.should_receive(:set_environment_option).with('envname', 'migrate', true)
+        @parent.should_receive(:set_environment_option).with('envname', 'migration_command', 'ruby script/migrate')
+        dc = deploy_config({})
+        dc.migrate.should be_true
+        dc.migrate_command.should == 'ruby script/migrate'
+      end
+
+      it "doesn't prompt migration_command if first answer is no" do
+        EY::CLI::UI::Prompter.add_answer "no" # default
+        @parent.should_receive(:set_environment_option).with('envname', 'migrate', false)
+        dc = deploy_config({})
+        dc.migrate.should be_false
+        dc.migrate_command.should be_nil
+      end
+    end
+
+    context "with the migrate cli option" do
+      it "returns the default migration command when is true" do
+        dc = deploy_config({'migrate' => true})
+        dc.migrate.should be_true
+        dc.migrate_command.should == 'rake db:migrate'
+      end
+
+      it "returns false when nil" do
+        dc = deploy_config({'migrate' => nil})
+        dc.migrate.should be_false
+        dc.migrate_command.should be_nil
+      end
+
+      it "return the custom migration command when is a string" do
+        dc = deploy_config({'migrate' => 'foo migrate'})
+        dc.migrate.should be_true
+        dc.migrate_command.should == 'foo migrate'
+      end
+    end
+
+    context "with the migrate option in the global configuration" do
+      it "return the default migration command when the option is true" do
+        env_config('migrate' => true, 'migration_command' => 'bar migrate')
+        dc = deploy_config({})
+        dc.migrate.should be_true
+        dc.migrate_command.should == 'bar migrate'
+      end
+
+      it "return the false when migrate is false" do
+        env_config('migrate' => false, 'migration_command' => 'bar migrate')
+        dc = deploy_config({})
+        dc.migrate.should be_false
+        dc.migrate_command.should be_nil
+      end
+
+      it "return the default migration command when the option is true" do
+        env_config('migrate' => true)
+        dc = deploy_config({})
+        dc.migrate.should be_true
+        dc.migrate_command.should == 'rake db:migrate'
+      end
+
+      it "return the ey.yml migration_command when command line option --migrate is passed" do
+        env_config('migrate' => false, 'migration_command' => 'bar migrate')
+        dc = deploy_config({'migrate' => true})
+        dc.migrate.should be_true
+        dc.migrate_command.should == 'bar migrate'
+      end
+    end
+
+    describe "ref" do
+      it "returns the passed ref" do
+        deploy_config({'ref' => 'master'}).ref.should == 'master'
+      end
+
+      it "returns the passed force_ref" do
+        deploy_config({'force_ref' => 'force'}).ref.should == 'force'
+      end
+
+      it "returns the ref if force_ref is true" do
+        deploy_config({'ref' => 'master', 'force_ref' => true}).ref.should == 'master'
+      end
+
+      it "overrides the ref if force_ref is set to a string" do
+        deploy_config({'ref' => 'master', 'force_ref' => 'force'}).ref.should == 'force'
+      end
+
+      context "with a default branch" do
+        before { env_config('branch' => 'default') }
+
+        it "uses the configured default if ref is not passed" do
+          deploy_config({}).ref.should == 'default'
+        end
+
+        it "raises if a default is set and --ref is passed on the cli (and they don't match)" do
+          lambda { deploy_config({'ref' => 'master'}).ref }.should raise_error(EY::BranchMismatchError)
+        end
+
+        it "returns the default if a default is set and --ref is the same" do
+          deploy_config({'ref' => 'default'}).ref.should == 'default'
+        end
+
+        it "returns the ref if force_ref is set" do
+          deploy_config({'ref' => 'master', 'force_ref' => true}).ref.should == 'master'
+        end
+
+        it "returns the ref if force_ref is a branch" do
+          deploy_config({'force_ref' => 'master'}).ref.should == 'master'
+        end
+      end
+
+      context "no options, no default" do
+        it "uses the repo's current branch" do
+          @repo.should_receive(:current_branch).and_return('current')
+          deploy_config({}).ref.should == 'current'
+        end
+      end
+    end
+  end
+
+  context "when outside of a repo" do
+    describe "migrate" do
+      it "returns the default migration command when migrate is true" do
+        dc = deploy_config({'app' => 'app', 'migrate' => true})
+        dc.migrate.should be_true
+        dc.migrate_command.should == 'rake db:migrate'
+      end
+
+      it "returns false when nil" do
+        dc = deploy_config({'app' => 'app', 'migrate' => nil})
+        dc.migrate.should be_false
+        dc.migrate_command.should be_nil
+      end
+
+      it "return the custom migration command when is a string" do
+        dc = deploy_config({'app' => 'app', 'migrate' => 'foo migrate'})
+        dc.migrate.should be_true
+        dc.migrate_command.should == 'foo migrate'
+      end
+
+      it "raises if migrate is not passed" do
+        lambda { deploy_config({'app' => 'app'}).migrate }.should raise_error(EY::RefAndMigrateRequiredOutsideRepo)
+      end
+    end
+
+    describe "ref" do
+      it "returns the passed ref" do
+        dc = deploy_config({'app' => 'app', 'ref' => 'master'})
+        dc.ref.should == 'master'
+      end
+
+      it "returns the passed force_ref" do
+        dc = deploy_config({'app' => 'app', 'force_ref' => 'force'})
+        dc.ref.should == 'force'
+      end
+
+      it "returns the ref if force_ref is true" do
+        dc = deploy_config({'app' => 'app', 'ref' => 'master', 'force_ref' => true})
+        dc.ref.should == 'master'
+      end
+
+      it "overrides the ref if force_ref is set to a string" do
+        dc = deploy_config({'app' => 'app', 'ref' => 'master', 'force_ref' => 'force'})
+        dc.ref.should == 'force'
+      end
+
+      it "raises if ref is not passed" do
+        lambda { deploy_config({'app' => 'app'}).ref }.should raise_error(EY::RefAndMigrateRequiredOutsideRepo)
+      end
+    end
+  end
+end