engineyard 1.2.1 → 1.2.2

data/lib/engineyard/api.rb

@@ -31,7 +31,11 @@ module EY
     end
 
     def app_for_repo(repo)
-      apps.find{|a| repo.urls.include?(a.repository_uri) }
+      candidates = apps.find_all {|a| repo.urls.include?(a.repository_uri) }
+      if candidates.size > 1
+        raise EY::AmbiguousGitUriError.new(repo.urls, candidates.map{|x| x.name})
+      end
+      candidates.first
     end
 
     def app_for_repo!(repo)

data/lib/engineyard/cli.rb

@@ -180,7 +180,7 @@ module EY
       :desc => "Run command on the utility servers with the given names. If no names are given, run on all utility servers."
 
     def ssh(cmd=nil)
-      env   = fetch_environment(options[:environment])
+      env = fetch_environment_without_app(options[:environment])
       hosts = ssh_hosts(options, env)
 
       raise NoCommandError.new if cmd.nil? and hosts.count != 1

data/lib/engineyard/cli/recipes.rb

@@ -11,7 +11,7 @@ module EY
       method_option :environment, :type => :string, :aliases => %w(-e),
         :desc => "Environment in which to apply recipes"
       def apply
-        environment = fetch_environment(options[:environment])
+        environment = fetch_environment_without_app(options[:environment])
         environment.run_custom_recipes
         EY.ui.say "Uploaded recipes started for #{environment.name}"
       end
@@ -26,7 +26,7 @@ module EY
       method_option :environment, :type => :string, :aliases => %w(-e),
         :desc => "Environment that will receive the recipes"
       def upload
-        environment = fetch_environment(options[:environment])
+        environment = fetch_environment_without_app(options[:environment])
         environment.upload_recipes
         EY.ui.say "Recipes uploaded successfully for #{environment.name}"
       end
@@ -42,7 +42,7 @@ module EY
       method_option :environment, :type => :string, :aliases => %w(-e),
         :desc => "Environment for which to download the recipes"
       def download
-        environment = fetch_environment(options[:environment])
+        environment = fetch_environment_without_app(options[:environment])
         environment.download_recipes
         EY.ui.say "Recipes downloaded successfully for #{environment.name}"
       end

data/lib/engineyard/collection/abstract.rb

@@ -3,9 +3,17 @@ require 'engineyard/error'
 module EY
   module Collection
     class Abstract < Array
+      COLLAB_MESSAGE = <<-MSG
+\nThis error is due to having access to another account's resources via the beta collaboration feature.
+We are working on letting you specify the account name to resolve this ambiguity.
+MSG
 
       def named(name)
-        find {|x| x.name == name }
+        candidates = find_all {|x| x.name == name }
+        if candidates.size > 1
+          raise ambiguous_error(name, candidates.map {|e| e.name}, COLLAB_MESSAGE )
+        end
+        candidates.first
       end
 
       def match_one(name_part)

data/lib/engineyard/error.rb

@@ -1,9 +1,9 @@
 module EY
   class Error < RuntimeError
-    def ambiguous(type, name, matches)
+    def ambiguous(type, name, matches, desc="")
       pretty_names = matches.map {|x| "'#{x}'"}.join(', ')
       "The name '#{name}' is ambiguous; it matches all of the following #{type} names: #{pretty_names}.\n" +
-      "Please use a longer, unambiguous substring or the entire #{type} name."
+      "Please use a longer, unambiguous substring or the entire #{type} name." + desc
     end
   end
 
@@ -36,8 +36,20 @@ module EY
   end
 
   class AmbiguousAppNameError < EY::Error
-    def initialize(name, matches)
-      super ambiguous("app", name, matches)
+    def initialize(name, matches, desc="")
+      super ambiguous("app", name, matches, desc)
+    end
+  end
+
+  class AmbiguousGitUriError < EY::Error
+    def initialize(uris, matches)
+      message = "The following Git Remote urls match multiple Applications in AppCloud\n"
+      uris.each { |uri| message << "\t#{uri}\n" }
+
+      message << "Please use -a <appname> to specify one of the following applications:\n"
+      matches.each { |app| message << "\t#{app}\n" }
+
+      super message
     end
   end
 
@@ -63,8 +75,17 @@ module EY
   end
 
   class AmbiguousEnvironmentNameError < EY::EnvironmentError
-    def initialize(name, matches)
-      super ambiguous("environment", name, matches)
+    def initialize(name, matches, desc="")
+      super ambiguous("environment", name, matches, desc)
+    end
+  end
+
+  class AmbiguousEnvironmentGitUriError < EY::EnvironmentError
+    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.each { |env| message << "\t#{env.name}\n" }
+      super message
     end
   end
 

data/lib/engineyard/model/#api_struct.rb#

@@ -0,0 +1,31 @@
+module EY
+  module Model
+    class ApiStruct < Struct
+
+      def self.new(*args, &block)
+        super(*args) do |*block_args|
+          block.call(*block_args) if block
+
+          def self.from_array(array, common_values = {})
+            array.map do |values|
+              from_hash(values.merge(common_values))
+            end if array
+          end
+
+          def self.from_hash(hash)
+            return nil unless hash
+            members = new.members
+            values = members.map{|a| hash.has_key?(a.to_sym) ? hash[a.to_sym] : hash[a] }
+            new(*values)
+          end
+
+        end
+      end
+
+      def api_get(uri, options = {})
+        api.request(uri, options.merge(:method => :get))
+      end
+
+    end
+  end
+end

data/lib/engineyard/model/api_struct.rb

@@ -1,6 +1,7 @@
 module EY
   module Model
     class ApiStruct < Struct
+
       def self.new(*args, &block)
         super(*args) do |*block_args|
           block.call(*block_args) if block

data/lib/engineyard/thor.rb

@@ -35,6 +35,12 @@ module EY
       end
     end
 
+    def fetch_environment_without_app(env_name)
+      fetch_environment(env_name)
+    rescue EY::AmbiguousGitUriError
+      raise EY::AmbiguousEnvironmentGitUriError.new(api.environments)
+    end
+
     def fetch_app(app_name = nil)
       if app_name
         api.apps.match_one!(app_name)
@@ -47,7 +53,11 @@ module EY
       if all_apps
         api.apps
       else
-        [api.app_for_repo(repo)].compact
+        begin
+          [api.app_for_repo(repo)].compact
+        rescue EY::AmbiguousGitUriError
+          raise EY::AmbiguousEnvironmentGitUriError.new(api.environments)
+        end
       end
     end
 

data/lib/engineyard/version.rb

@@ -1,3 +1,3 @@
 module EY
-  VERSION = '1.2.1'
+  VERSION = '1.2.2'
 end

data/spec/engineyard/#resolver_spec.rb#

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'engineyard/cli'
+
+describe EY::Resolver do
+
+  let(:repo) { 'git://engineyard/ey-cloud.git' }
+
+  let(:ey) do
+    EY::Deployment.new(:account => 'ey',
+                       :repo => repo,
+                       :app => 'ey-cloud',
+                       :environment => 'production')
+  end
+
+  let(:me) do
+    EY::Deployment.new(:account => 'me',
+                       :repo => repo,
+                       :app => 'my-app',
+                       :environment => 'production')
+  end
+
+  context "ambiguous account" do
+    it do
+      resolver = EY::Resolver.new([one, two], :repo => repo)
+      resolver.resolve.should be_nil
+      resolver.optoins.should == []
+    end
+
+    it do
+      EY::Resolver.new([one, two], :repo => repo, :account => 'me').resolve.should == me
+    end
+
+  end
+
+end
+
+deployments = EY::Deployment::Collection.new(get_deployments)
+matched_deps = deployments.resolve(params)
+
+matched_deps.message.should == "no matches"
+

data/spec/engineyard/api_spec.rb

@@ -53,4 +53,34 @@ describe EY::API do
     }.should raise_error(EY::Error)
   end
 
+  it "raises an error when using a git repo that is attached to multiple applications" do
+    repo = mock("repo", :urls => %w[git://github.com/engineyard/dup.git])
+    apps = {"apps" => [
+                      {"id" => 1234, "name" => "app_production", :repository_uri => 'git://github.com/engineyard/prod.git'},
+                      {"id" => 4532, "name" => "app_dup1", :repository_uri => 'git://github.com/engineyard/dup.git'},
+                      {"id" => 4533, "name" => "app_dup2", :repository_uri => 'git://github.com/engineyard/dup.git'},
+                     ]}
+
+    FakeWeb.register_uri(:get, "https://cloud.engineyard.com/api/v2/apps", :status => 200, :content_type => 'application/json',
+                         :body => apps.to_json)
+
+    lambda do
+      EY::API.new("asdf").app_for_repo(repo)
+    end.should raise_error(EY::AmbiguousGitUriError)
+  end
+
+  it "returns the application when given a unique git repo" do
+    repo = mock("repo", :urls => %w[git://github.com/engineyard/prod.git])
+    apps = {"apps" => [
+                      {"id" => 1234, "name" => "app_production", :repository_uri => 'git://github.com/engineyard/prod.git'},
+                      {"id" => 4532, "name" => "app_dup1", :repository_uri => 'git://github.com/engineyard/dup.git'},
+                      {"id" => 4533, "name" => "app_dup2", :repository_uri => 'git://github.com/engineyard/dup.git'},
+                     ]}
+
+    FakeWeb.register_uri(:get, "https://cloud.engineyard.com/api/v2/apps", :status => 200, :content_type => 'application/json',
+                         :body => apps.to_json)
+
+    EY::API.new("asdf").app_for_repo(repo).name.should == "app_production"
+  end
+
 end

data/spec/engineyard/collection/apps_spec.rb

@@ -7,6 +7,8 @@ describe EY::Collection::Apps do
       EY::Model::App.from_hash("id" => 1234, "name" => "app_production"),
       EY::Model::App.from_hash("id" => 4321, "name" => "app_staging"),
       EY::Model::App.from_hash("id" => 8765, "name" => "bigapp_staging"),
+      EY::Model::App.from_hash("id" => 4532, "name" => "app_duplicate"),
+      EY::Model::App.from_hash("id" => 4533, "name" => "app_duplicate"),
     ])
   end
 

data/spec/engineyard/collection/environments_spec.rb

@@ -7,6 +7,8 @@ describe EY::Collection::Environments do
       EY::Model::Environment.from_hash("id" => 1234, "name" => "app_production"),
       EY::Model::Environment.from_hash("id" => 4321, "name" => "app_staging"),
       EY::Model::Environment.from_hash("id" => 8765, "name" => "bigapp_staging"),
+      EY::Model::Environment.from_hash("id" => 4532, "name" => "app_duplicate"),
+      EY::Model::Environment.from_hash("id" => 4533, "name" => "app_duplicate"),
     ])
   end
 

data/spec/ey/list_environments_spec.rb

@@ -39,3 +39,9 @@ describe "ey environments" do
   end
 
 end
+
+describe "ey environments with an ambiguous git repo" do
+  given "integration"
+  def command_to_run(_) "ssh environments" end
+  it_should_behave_like "it requires an unambiguous git repo"
+end

data/spec/ey/recipes/apply_spec.rb

@@ -15,3 +15,9 @@ describe "ey recipes apply" do
 
   it_should_behave_like "it takes an environment name"
 end
+
+describe "ey recipes apply with an ambiguous git repo" do
+  given "integration"
+  def command_to_run(_) "recipes apply" end
+  it_should_behave_like "it requires an unambiguous git repo"
+end

data/spec/ey/recipes/download_spec.rb

@@ -27,3 +27,9 @@ describe "ey recipes download" do
     @err.should match(/cookbooks.*already exists/i)
   end
 end
+
+describe "ey recipes download with an ambiguous git repo" do
+  given "integration"
+  def command_to_run(_) "recipes download" end
+  it_should_behave_like "it requires an unambiguous git repo"
+end

data/spec/ey/recipes/upload_spec.rb

@@ -21,3 +21,9 @@ describe "ey recipes upload" do
 
   it_should_behave_like "it takes an environment name"
 end
+
+describe "ey recipes upload with an ambiguous git repo" do
+  given "integration"
+  def command_to_run(_) "recipes upload" end
+  it_should_behave_like "it requires an unambiguous git repo"
+end

data/spec/ey/ssh_spec.rb

@@ -66,6 +66,12 @@ describe "ey ssh" do
 
 end
 
+describe "ey ssh with an ambiguous git repo" do
+  it_should_behave_like "running ey ssh"
+  def command_to_run(_) "ssh ls" end
+  it_should_behave_like "it requires an unambiguous git repo"
+end
+
 describe "ey ssh without a command" do
   it_should_behave_like "running ey ssh"
 

data/spec/spec_helper.rb

@@ -3,12 +3,8 @@ if self.class.const_defined?(:EY_ROOT)
 end
 
 EY_ROOT = File.expand_path("../..", __FILE__)
-begin
-  require File.join(EY_ROOT, ".bundle/environment.rb")
-rescue LoadError
-  puts "Can't load bundler environment. You need to run `bundle lock`."
-  exit
-end
+require 'rubygems'
+require 'bundler/setup'
 
 # Bundled gems
 require 'fakeweb'

data/spec/support/#shared_behavior.rb#

@@ -0,0 +1,275 @@
+module Spec
+  module Helpers
+    module SharedIntegrationTestUtils
+
+      def run_ey(command_options, ey_options={})
+        if respond_to?(:extra_ey_options)   # needed for ssh tests
+          ey_options.merge!(extra_ey_options)
+        end
+
+        ey(command_to_run(command_options), ey_options)
+      end
+
+      def make_scenario(hash)
+        # since nil will silently turn to empty string when interpolated,
+        # and there's a lot of string matching involved in integration
+        # testing, it would be nice to have early notification of typos.
+        scenario = Hash.new { |h,k| raise "Tried to get key #{k.inspect}, but it's missing!" }
+        scenario.merge!(hash)
+      end
+
+    end
+  end
+end
+
+shared_examples_for "it requires an unambiguous git repo" do
+  include Spec::Helpers::SharedIntegrationTestUtils
+
+  define_git_repo("dup test") do
+    system("git remote add dup git://github.com/engineyard/dup.git")
+  end
+
+  use_git_repo("dup test")
+
+  before(:all) do
+    api_scenario "two apps, same git uri"
+  end
+
+  it "lists disambiguating environments to choose from" do
+    run_ey({}, {:expect_failure => true})
+    @err.should =~ /ambiguous/
+    @err.should =~ /specify one of the following environments/
+    @err.should =~ /giblets/
+    @err.should =~ /keycollector_production/
+  end
+end
+
+shared_examples_for "it takes an environment name" do
+  include Spec::Helpers::SharedIntegrationTestUtils
+
+  it "operates on the current environment by default" do
+    api_scenario "one app, one environment"
+    run_ey({:env => nil}, {:debug => true})
+    verify_ran(make_scenario({
+          :environment      => 'giblets',
+          :application      => 'rails232app',
+          :master_hostname  => 'app_master_hostname.compute-1.amazonaws.com',
+          :ssh_username     => 'turkey',
+        }))
+  end
+
+  it "complains when you specify a nonexistent environment" do
+    api_scenario "one app, one environment"
+    run_ey({:env => 'typo-happens-here'}, {:expect_failure => true})
+    @err.should match(/no environment named 'typo-happens-here'/i)
+  end
+
+  context "given a piece of the environment name" do
+    before(:all) do
+      api_scenario "one app, many similarly-named environments"
+    end
+
+    it "complains when the substring is ambiguous" do
+      run_ey({:env => 'staging'}, {:expect_failure => true})
+      @err.should match(/'staging' is ambiguous/)
+    end
+
+    it "works when the substring is unambiguous" do
+      api_scenario "one app, many similarly-named environments"
+      run_ey({:env => 'prod'}, {:debug => true})
+      verify_ran(make_scenario({
+            :environment      => 'railsapp_production',
+            :application      => 'rails232app',
+            :master_hostname  => 'app_master_hostname.compute-1.amazonaws.com',
+            :ssh_username     => 'turkey',
+          }))
+    end
+  end
+
+  it "complains when it can't guess the environment and its name isn't specified" do
+    api_scenario "one app, one environment, not linked"
+    run_ey({:env => nil}, {:expect_failure => true})
+    @err.should =~ /single environment/i
+  end
+end
+
+shared_examples_for "it takes an app name" do
+  include Spec::Helpers::SharedIntegrationTestUtils
+
+  it "allows you to specify a valid app" do
+    api_scenario "one app, one environment"
+    Dir.chdir(Dir.tmpdir) do
+      run_ey({:env => 'giblets', :app => 'rails232app', :ref => 'master'}, {})
+      verify_ran(make_scenario({
+            :environment      => 'giblets',
+            :application      => 'rails232app',
+            :master_hostname  => 'app_master_hostname.compute-1.amazonaws.com',
+            :ssh_username     => 'turkey',
+          }))
+    end
+  end
+
+  it "can guess the environment from the app" do
+    api_scenario "two apps"
+    Dir.chdir(Dir.tmpdir) do
+      run_ey({:app => 'rails232app', :ref => 'master'}, {})
+      verify_ran(make_scenario({
+            :environment      => 'giblets',
+            :application      => 'rails232app',
+            :master_hostname  => 'app_master_hostname.compute-1.amazonaws.com',
+            :ssh_username     => 'turkey',
+          }))
+    end
+  end
+
+  it "complains when you specify a nonexistant app" do
+    api_scenario "one app, one environment"
+    run_ey({:env => 'giblets', :app => 'P-time-SAT-solver', :ref => 'master'},
+      {:expect_failure => true})
+    @err.should =~ /no app.*P-time-SAT-solver/i
+  end
+
+end
+
+shared_examples_for "it invokes engineyard-serverside" do
+  include Spec::Helpers::SharedIntegrationTestUtils
+
+  context "with arguments" do
+    before(:all) do
+      api_scenario "one app, one environment"
+      run_ey({:env => 'giblets', :verbose => true})
+    end
+
+    it "passes --verbose to engineyard-serverside" do
+      @ssh_commands.should have_command_like(/engineyard-serverside.*deploy.*--verbose/)
+    end
+
+    it "passes along instance information to engineyard-serverside" do
+      instance_args = [
+        Regexp.quote("app_master_hostname.compute-1.amazonaws.com,app_master"),
+        Regexp.quote("app_hostname.compute-1.amazonaws.com,app"),
+        Regexp.quote("util_fluffy_hostname.compute-1.amazonaws.com,util,fluffy"),
+      ]
+
+      db_instance = Regexp.quote("db_master_hostname.compute-1.amazonaws.com,db_master")
+
+      # apps + utilities are all mentioned
+      instance_args.each do |i|
+        @ssh_commands.last.should =~ /#{i}/
+      end
+
+      # but not database instances
+      @ssh_commands.last.should_not =~ /#{db_instance}/
+
+      # and it's all after the option '--instances'
+      @ssh_commands.last.should match(/--instances (#{instance_args.join('|')})/)
+    end
+
+    it "passes the framework environment" do
+      @ssh_commands.last.should match(/--framework-env production/)
+    end
+
+  end
+
+
+  context "engineyard-serverside installation" do
+    before(:all) do
+      api_scenario "one app, one environment"
+    end
+
+    before(:each) do
+      ENV.delete "NO_SSH"
+    end
+
+    after(:each) do
+      ENV['NO_SSH'] = "true"
+    end
+
+    def exiting_ssh(exit_code)
+      "#!/usr/bin/env ruby\n exit!(#{exit_code}) if ARGV.to_s =~ /gem list engineyard-serverside/"
+    end
+
+    it "raises an error if SSH fails" do
+      run_ey({:env => 'giblets'},
+        {:prepend_to_path => {'ssh' => exiting_ssh(255)}, :expect_failure => true})
+      @err.should =~ /SSH connection to \S+ failed/
+    end
+
+    it "installs engineyard-serverside if it's missing" do
+      run_ey({:env => 'giblets'}, {:prepend_to_path => {'ssh' => exiting_ssh(1)}})
+
+      gem_install_command = @ssh_commands.find do |command|
+        command =~ /gem install engineyard-serverside/
+      end
+      gem_install_command.should_not be_nil
+      gem_install_command.should =~ %r{/usr/local/ey_resin/ruby/bin/gem install.*engineyard-serverside}
+    end
+
+    it "does not try to install engineyard-serverside if it's already there" do
+      run_ey({:env => 'giblets'}, {:prepend_to_path => {'ssh' => exiting_ssh(0)}})
+      @ssh_commands.should_not have_command_like(/gem install engineyard-serverside/)
+      ver = Regexp.quote(EY::ENGINEYARD_SERVERSIDE_VERSION)
+      @ssh_commands.should have_command_like(/engineyard-serverside _#{ver}_ deploy/)
+    end
+  end  
+end
+
+shared_examples_for "model collections" do
+  describe "#match_one" do
+    it "works when given an unambiguous substring" do
+      @collection.match_one("prod").name.should == "app_production"
+    end
+
+    it "raises an error when given an ambiguous substring" do
+      lambda {
+        @collection.match_one("staging")
+      }.should raise_error(@collection_class.ambiguous_error)
+    end
+
+    it "returns an exact match if one exists" do
+      @collection.match_one("app_staging").name.should == "app_staging"
+    end
+
+    it "returns nil when it can't find anything" do
+      @collection.match_one("dev-and-production").should be_nil
+    end
+ end
+
+  describe "#match_one!" do
+    it "works when given an unambiguous substring" do
+      @collection.match_one!("prod").name.should == "app_production"
+    end
+
+    it "raises an error when given an ambiguous substring" do
+      lambda {
+        @collection.match_one!("staging")
+      }.should raise_error(@collection_class.ambiguous_error)
+    end
+
+    it "returns an exact match if one exists" do
+      @collection.match_one!("app_staging").name.should == "app_staging"
+    end
+
+    it "raises an error when given an ambiguous exact string" do
+      lambda {
+        @collection.match_one!("app_duplicate")
+      }.should raise_error(@collection_class.ambiguous_error)
+    end
+
+    it "raises an error when it can't find anything" do
+      lambda {
+        @collection.match_one!("dev-and-production")
+      }.should raise_error(@collection_class.invalid_error)
+    end
+  end
+
+  describe "#named" do
+    it "finds matching by name" do
+      @collection.named("app_staging").name.should == "app_staging"
+    end
+
+    it "returns nil when no name matches" do
+      @collection.named("something else").should be_nil
+    end
+  end
+end