engineyard 1.3.1 → 1.3.2

data/lib/engineyard.rb

@@ -8,6 +8,7 @@ module EY
   autoload :Error,      'engineyard/error'
   autoload :Model,      'engineyard/model'
   autoload :Repo,       'engineyard/repo'
+  autoload :Resolver,   'engineyard/resolver'
 
   class UI
     # stub debug outside of the CLI

data/lib/engineyard/api.rb

@@ -30,20 +30,12 @@ module EY
       @apps ||= EY::Model::App.from_array(request('/apps')["apps"], :api => self)
     end
 
-    def apps_for_repo(repo)
-      apps.find_all {|a| repo.urls.include?(a.repository_uri) }
+    def resolver
+      @resolver ||= Resolver.new(self)
     end
 
-    def app_for_repo(repo)
-      candidates = apps_for_repo(repo)
-      if candidates.size > 1
-        raise EY::AmbiguousGitUriError.new(repo.urls, candidates.map{|x| x.name})
-      end
-      candidates.first
-    end
-
-    def app_for_repo!(repo)
-      app_for_repo(repo) || raise(NoAppError.new(repo))
+    def apps_for_repo(repo)
+      apps.find_all {|a| repo.urls.include?(a.repository_uri) }
     end
 
     class InvalidCredentials < EY::Error; end

data/lib/engineyard/cli.rb

@@ -44,13 +44,14 @@ module EY
       :desc => "Git ref to deploy. May be a branch, a tag, or a SHA."
     method_option :app, :type => :string, :aliases => %w(-a),
       :desc => "Name of the application to deploy"
+    method_option :account, :type => :string, :aliases => %w(-c),
+      :desc => "Name of the account you want to deploy in"
     method_option :verbose, :type => :boolean, :aliases => %w(-v),
       :desc => "Be verbose"
     method_option :extra_deploy_hook_options, :type => :hash, :default => {},
       :desc => "Additional options to be made available in deploy hooks (in the 'config' hash)"
     def deploy
-      app         = fetch_app(options[:app])
-      environment = fetch_environment(options[:environment], app)
+      app, environment = fetch_app_and_environment(options[:app], options[:environment], options[:account])
       environment.ignore_bad_master = options[:ignore_bad_master]
       deploy_ref  = if options[:app]
                       environment.resolve_branch(options[:ref], options[:ignore_default_branch]) ||
@@ -90,8 +91,8 @@ module EY
     def environments
       if options[:all] && options[:simple]
         # just put each env
-        api.environments.each do |env|
-          puts env.name
+        api.environments.each do |environment|
+          puts environment.name
         end
       else
         apps = get_apps(options[:all])
@@ -120,10 +121,12 @@ module EY
 
     method_option :environment, :type => :string, :aliases => %w(-e),
       :desc => "Environment to rebuild"
+    method_option :account, :type => :string, :aliases => %w(-c),
+      :desc => "Name of the account you want to rebuild in"
     def rebuild
-      env = fetch_environment(options[:environment])
-      EY.ui.debug("Rebuilding #{env.name}")
-      env.rebuild
+      environment = fetch_environment(options[:environment], options[:account])
+      EY.ui.debug("Rebuilding #{environment.name}")
+      environment.rebuild
     end
 
     desc "rollback [--environment ENVIRONMENT]", "Rollback to the previous deploy."
@@ -136,18 +139,17 @@ module EY
       :desc => "Environment in which to roll back the application"
     method_option :app, :type => :string, :aliases => %w(-a),
       :desc => "Name of the application to roll back"
+    method_option :account, :type => :string, :aliases => %w(-c),
+      :desc => "Name of the account you want to roll back in"
     method_option :verbose, :type => :boolean, :aliases => %w(-v),
       :desc => "Be verbose"
     method_option :extra_deploy_hook_options, :type => :hash, :default => {},
       :desc => "Additional options to be made available in deploy hooks (in the 'config' hash)"
     def rollback
-      app = fetch_app(options[:app])
-      env = fetch_environment(options[:environment], app)
+      app, environment = fetch_app_and_environment(options[:app], options[:environment], options[:account])
 
-      EY.ui.info("Rolling back '#{app.name}' in '#{env.name}'")
-      if env.rollback(app,
-          options[:extra_deploy_hook_options],
-          options[:verbose])
+      EY.ui.info("Rolling back '#{app.name}' in '#{environment.name}'")
+      if environment.rollback(app, options[:extra_deploy_hook_options], options[:verbose])
         EY.ui.info "Rollback complete"
       else
         raise EY::Error, "Rollback failed"
@@ -167,6 +169,8 @@ module EY
     DESC
     method_option :environment, :type => :string, :aliases => %w(-e),
       :desc => "Environment to ssh into"
+    method_option :account, :type => :string, :aliases => %w(-c),
+      :desc => "Name of the account you want to deploy in"
     method_option :all, :type => :boolean, :aliases => %(-a),
       :desc => "Run command on all servers"
     method_option :app_servers, :type => :boolean,
@@ -181,13 +185,13 @@ 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_without_app(options[:environment])
-      hosts = ssh_hosts(options, env)
+      environment = fetch_environment(options[:environment], options[:account])
+      hosts = ssh_hosts(options, environment)
 
       raise NoCommandError.new if cmd.nil? and hosts.count != 1
 
       hosts.each do |host|
-        system "ssh #{env.username}@#{host} #{cmd}"
+        system "ssh #{environment.username}@#{host} #{cmd}"
       end
     end
 
@@ -203,7 +207,7 @@ module EY
         return lambda {|instance| %w(solo app_master        ).include?(instance.role) }
       end
 
-      def ssh_hosts(opts, env)
+      def ssh_hosts(opts, environment)
         if opts[:utilities] and not opts[:utilities].respond_to?(:include?)
           includes_everything = []
           class << includes_everything
@@ -214,8 +218,8 @@ module EY
           filter = ssh_host_filter(opts)
         end
 
-        instances = env.instances.select {|instance| filter[instance] }
-        raise NoInstancesError.new(env.name) if instances.empty?
+        instances = environment.instances.select {|instance| filter[instance] }
+        raise NoInstancesError.new(environment.name) if instances.empty?
         return instances.map { |instance| instance.public_hostname }
       end
     end
@@ -228,18 +232,20 @@ module EY
     DESC
     method_option :environment, :type => :string, :aliases => %w(-e),
       :desc => "Environment with the interesting logs"
+    method_option :account, :type => :string, :aliases => %w(-c),
+      :desc => "Name of the account you want to deploy in"
     def logs
-      env = fetch_environment(options[:environment])
-      env.logs.each do |log|
+      environment = fetch_environment(options[:environment], options[:account])
+      environment.logs.each do |log|
         EY.ui.info log.instance_name
 
         if log.main
-          EY.ui.info "Main logs for #{env.name}:"
+          EY.ui.info "Main logs for #{environment.name}:"
           EY.ui.say  log.main
         end
 
         if log.custom
-          EY.ui.info "Custom logs for #{env.name}:"
+          EY.ui.info "Custom logs for #{environment.name}:"
           EY.ui.say  log.custom
         end
       end

data/lib/engineyard/cli/recipes.rb

@@ -10,8 +10,10 @@ module EY
 
       method_option :environment, :type => :string, :aliases => %w(-e),
         :desc => "Environment in which to apply recipes"
+      method_option :account, :type => :string, :aliases => %w(-c),
+        :desc => "Name of the account you want to deploy in"
       def apply
-        environment = fetch_environment_without_app(options[:environment])
+        environment = fetch_environment(options[:environment], options[:account])
         environment.run_custom_recipes
         EY.ui.say "Uploaded recipes started for #{environment.name}"
       end
@@ -25,8 +27,10 @@ module EY
 
       method_option :environment, :type => :string, :aliases => %w(-e),
         :desc => "Environment that will receive the recipes"
+      method_option :account, :type => :string, :aliases => %w(-c),
+        :desc => "Name of the account you want to deploy in"
       def upload
-        environment = fetch_environment_without_app(options[:environment])
+        environment = fetch_environment(options[:environment], options[:account])
         environment.upload_recipes
         EY.ui.say "Recipes uploaded successfully for #{environment.name}"
       end
@@ -41,8 +45,10 @@ module EY
       DESC
       method_option :environment, :type => :string, :aliases => %w(-e),
         :desc => "Environment for which to download the recipes"
+      method_option :account, :type => :string, :aliases => %w(-c),
+        :desc => "Name of the account you want to deploy in"
       def download
-        environment = fetch_environment_without_app(options[:environment])
+        environment = fetch_environment(options[:environment], options[:account])
         environment.download_recipes
         EY.ui.say "Recipes downloaded successfully for #{environment.name}"
       end

data/lib/engineyard/cli/ui.rb

@@ -67,7 +67,7 @@ module EY
           end
         else
           apps.each do |app|
-            puts app.name
+            puts "#{app.name} (#{app.account.name})"
             if app.environments.any?
               app.environments.each do |env|
                 short_name = env.shorten_name_for(app)

data/lib/engineyard/cli/web.rb

@@ -9,9 +9,10 @@ module EY
         :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),
+        :desc => "Name of the account you want to deploy in"
       def enable
-        app         = fetch_app(options[:app])
-        environment = fetch_environment(options[:environment], app)
+        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])
       end
@@ -35,9 +36,10 @@ module EY
         :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),
+        :desc => "Name of the account you want to deploy in"
       def disable
-        app         = fetch_app(options[:app])
-        environment = fetch_environment(options[:environment], app)
+        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])
       end

data/lib/engineyard/collection/abstract.rb

@@ -8,8 +8,14 @@ module EY
 We are working on letting you specify the account name to resolve this ambiguity.
 MSG
 
-      def named(name)
-        candidates = find_all {|x| x.name == name }
+      def named(name, account_name=nil)
+        candidates = find_all do |x|
+          if account_name
+            x.name == name && x.account.name == account_name
+          else
+            x.name == name
+          end
+        end
         if candidates.size > 1
           raise ambiguous_error(name, candidates.map {|e| e.name}, COLLAB_MESSAGE )
         end

data/lib/engineyard/error.rb

@@ -7,6 +7,10 @@ module EY
     end
   end
 
+  class ResolveError < EY::Error; end
+  class NoMatchesError < ResolveError; end
+  class MultipleMatchesError < ResolveError; end
+
   class NoCommandError < EY::Error
     def initialize
       super "Must specify a command to run via ssh"
@@ -41,18 +45,6 @@ module EY
     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
-
   class NoAppMasterError < EY::Error
     def initialize(env_name)
       super "The environment '#{env_name}' does not have a master instance."
@@ -84,7 +76,13 @@ module EY
     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" }
+      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
@@ -110,15 +108,15 @@ module EY
 
   class BranchMismatchError < EY::Error
     def initialize(default_branch, branch)
-      super %|Your deploy branch is set to "#{default_branch}".\n| +
-        %|If you want to deploy branch "#{branch}", use --ignore-default_branch.|
+      super(%|Your deploy branch is set to "#{default_branch}".\n| +
+        %|If you want to deploy branch "#{branch}", use --ignore-default_branch.|)
     end
   end
 
   class DeployArgumentError < EY::Error
     def initialize
-      super %("deploy" was called incorrectly. Call as "deploy [--environment <env>] [--ref <branch|tag|ref>]"\n) +
-        %|You can set default environments and branches in ey.yml|
+      super(%("deploy" was called incorrectly. Call as "deploy [--environment <env>] [--ref <branch|tag|ref>]"\n) +
+        %|You can set default environments and branches in ey.yml|)
     end
   end
 end

data/lib/engineyard/model.rb

@@ -1,9 +1,10 @@
 module EY
   module Model
-    autoload :ApiStruct,   'engineyard/model/api_struct'
-    autoload :App,         'engineyard/model/app'
-    autoload :Environment, 'engineyard/model/environment'
-    autoload :Log,         'engineyard/model/log'
-    autoload :Instance,    'engineyard/model/instance'
+    autoload :ApiStruct,     'engineyard/model/api_struct'
+    autoload :Account,       'engineyard/model/account'
+    autoload :App,           'engineyard/model/app'
+    autoload :Environment,   'engineyard/model/environment'
+    autoload :Log,           'engineyard/model/log'
+    autoload :Instance,      'engineyard/model/instance'
   end
 end

data/lib/engineyard/model/account.rb

@@ -0,0 +1,8 @@
+require 'escape'
+
+module EY
+  module Model
+    class Account < ApiStruct.new(:id, :name)
+    end
+  end
+end

data/lib/engineyard/model/app.rb

@@ -1,10 +1,11 @@
 module EY
   module Model
-    class App < ApiStruct.new(:name, :repository_uri, :environments, :api)
+    class App < ApiStruct.new(:id, :account, :name, :repository_uri, :environments, :api)
 
       def self.from_hash(hash)
         super.tap do |app|
           app.environments = Environment.from_array(app.environments, :api => app.api)
+          app.account = Account.from_hash(app.account)
         end
       end
 

data/lib/engineyard/model/environment.rb

@@ -1,6 +1,6 @@
 module EY
   module Model
-    class Environment < ApiStruct.new(:id, :name, :framework_env, :instances, :instances_count, :apps, :app_master, :username, :stack_name, :api)
+    class Environment < ApiStruct.new(:id, :account, :name, :framework_env, :instances, :instances_count, :apps, :app_master, :username, :stack_name, :api)
 
       attr_accessor :ignore_bad_master
 
@@ -8,6 +8,7 @@ module EY
         super.tap do |env|
           env.username = hash['ssh_username']
           env.apps = App.from_array(env.apps, :api => env.api)
+          env.account = Account.from_hash(env.account)
           env.instances = Instance.from_array(hash['instances'], :environment => env)
           env.app_master = Instance.from_hash(env.app_master.merge(:environment => env)) if env.app_master
         end

data/lib/engineyard/repo.rb

@@ -7,8 +7,12 @@ module EY
       @path = path
     end
 
+    def exists?
+      File.directory?(File.join(@path, ".git"))
+    end
+
     def current_branch
-      if File.directory?(File.join(@path, ".git"))
+      if exists?
         head = File.read(File.join(@path, ".git/HEAD")).chomp
         if head.gsub!("ref: refs/heads/", "")
           head

data/lib/engineyard/resolver.rb

@@ -0,0 +1,122 @@
+module EY
+  class Resolver
+    attr_reader :api
+    
+    def initialize(api)
+      @api = api
+    end
+
+    def environment(options)
+      raise ArgumentError if options[:app_name]
+      candidates, account_candidates, app_candidates, environment_candidates = filter_candidates(options)
+
+      environments = candidates.map{ |c| [c[:account_name], c[:environment_name]] }.uniq.map do |account_name, environment_name|
+        api.environments.named(environment_name, account_name)
+      end
+
+      if environments.empty?
+        if options[:environment_name]
+          raise EY::NoEnvironmentError.new(options[:environment_name])
+        else
+          raise EY::NoAppError.new(options[:repo])
+        end
+      elsif environments.size > 1
+        if options[:environment_name]
+          message = "Multiple environments possible, please be more specific:\n\n"
+          candidates.map{|e| [e[:account_name], e[:environment_name]]}.uniq.each do |account_name, environment_name|
+            message << "\t#{environment_name} # ey <command> --environment='#{environment_name}' --account='#{account_name}'\n"
+          end
+          raise MultipleMatchesError.new(message)
+        else
+          raise EY::AmbiguousEnvironmentGitUriError.new(environments)
+        end
+      end
+      environments.first
+    end
+
+    def app_and_environment(options)
+      candidates, account_candidates, app_candidates, environment_candidates = filter_candidates(options)
+
+      if candidates.empty?
+        if account_candidates.empty? && options[:account_name]
+          raise NoMatchesError.new("There were no accounts that matched #{options[:account_name]}")
+        elsif app_candidates.empty?
+          if options[:app_name]
+            raise InvalidAppError.new(options[:app_name])
+          else
+            raise NoAppError.new(options[:repo])
+          end
+        elsif environment_candidates.empty?
+          raise NoEnvironmentError.new(options[:environment_name])
+        else
+          message = "The matched apps & environments do not correspond with each other.\n"
+          message << "Applications:\n"
+          app_candidates.map{|ad| [ad[:account_name], ad[:app_name]]}.uniq.each do |account_name, app_name|
+            app = api.apps.named(app_name, account_name)
+            message << "\t#{app.name}\n"
+            app.environments.each do |env|
+              message << "\t\t#{env.name} # ey <command> -e #{env.name} -a #{app.name}\n"
+            end
+          end
+        end
+        raise NoMatchesError.new(message)
+      elsif candidates.size > 1
+        message = "Multiple app deployments possible, please be more specific:\n\n"
+        candidates.map{|c| [c[:account_name], c[:app_name]]}.uniq.each do |account_name, app_name|
+          message << "#{app_name}\n"
+          candidates.select {|x| x[:app_name] == app_name && x[:account_name] == account_name}.map{|x| x[:environment_name]}.uniq.each do |env_name|
+            message << "\t#{env_name} # ey <command> --environment='#{env_name}' --app='#{app_name}' --account='#{account_name}'\n"
+          end
+        end
+        raise MultipleMatchesError.new(message)
+      end
+      result = candidates.first
+      [api.apps.named(result[:app_name], result[:account_name]), api.environments.named(result[:environment_name], result[:account_name])]
+    end
+
+    private
+
+    def app_deployments
+      @app_deployments ||= api.apps.map do |app|
+        app.environments.map do |environment|
+          { 
+            :app_name => app.name,
+            :repository_uri => app.repository_uri,
+            :environment_name => environment.name,
+            :account_name => app.account.name,
+          }
+        end
+      end.flatten
+    end
+
+    def filter_candidates(options)
+      raise ArgumentError if options.empty?
+
+      candidates = app_deployments
+
+      account_candidates = filter_candidates_by(:account_name, options, candidates)
+
+      app_candidates = if options[:app_name]
+                         filter_candidates_by(:app_name, options, candidates)
+                       elsif options[:repo]
+                         candidates.select {|c| options[:repo].urls.include?(c[:repository_uri]) }
+                       else
+                         candidates
+                       end
+
+      environment_candidates = filter_candidates_by(:environment_name, options, candidates)
+      candidates = app_candidates & environment_candidates & account_candidates
+      [candidates, account_candidates, app_candidates, environment_candidates]
+    end
+
+    def filter_candidates_by(type, options, candidates)
+      if options[type] && candidates.any?{|c| c[type] == options[type] }
+        candidates.select {|c| c[type] == options[type] }
+      elsif options[type]
+        candidates.select {|c| c[type][options[type]] }
+      else
+        candidates
+      end
+    end
+  end
+end