engineyard 1.4.29 → 1.7.0.pre2

data/README.rdoc

@@ -20,10 +20,15 @@ The ey.yml file allows options to be saved for each environment to which an appl
     ---
     environments:
       env_production:
-        migrate: false
-        migration_command: rake fancy:migrate
-        branch: deploy
-        default: true   # make this environment default
+        migrate: false                            # run migration command on every deploy
+        migration_command: rake fancy:migrate     # default migration command
+        branch: deploy                            # default branch to deploy
+        default: true                             # make this environment default
+        bundle_without: test development mygroup  # exclude groups on bundle install
+        copy_exclude:                             # don't rsync the following dirs
+        - .git
+        verbose: true                             # always run verbose deploy (unless overriden on command line)
+
 
 This ey.yml file will turn off default migrations, set the default command to "rake fancy:migrate" and set the default deploy branch to "deploy".
 
@@ -208,3 +213,133 @@ Command:
 
   Description:
     Remove the current API key from ~/.eyrc or env variable $EYRC
+
+
+== API Client
+
+This library also contains a Ruby ey_api library to the Engine Yard Cloud API.
+
+Setup:
+
+    token  = EY::CloudClient.authenticate("your@email.com", "password")
+    ey_api = EY::CloudClient.new(token)
+
+Current User:
+
+    user = ey_api.current_user
+    user.class # => EY::CloudClient::User
+    user.name  # => "Your Name"
+    user.email # => "your@email.com"
+
+Apps:
+
+    apps = ey_api.apps # loads all your app data at once; caches result
+
+    app = apps.find {|app| app.name == 'myapp'}
+    app.class           # => EY::CloudClient::App
+    app.name            # => 'myapp'
+    app.id              # => 123
+    app.repository_uri  # => git@github.com:myaccount/myapp.git
+
+    app.account.class   # => EY::CloudClient::Account
+
+    app.app_environments.first.class # => EY::CloudClient::AppEnvironment
+    app.app_environments.map {|e| e.environment.name} # => ['myapp_production', 'myapp_staging']
+
+Create a new application (to be booted within Environments):
+
+    account = EY::CloudClient::Account.new(ey_api, {:id => 4212, :name => 'drnic'})
+    app = EY::CloudClient::App.create(ey_api,
+      "account"        => account
+      "name"           => "myapp",
+      "repository_uri" => "git@github.com:mycompany/myapp.git",
+      "app_type_id"    => "rails3",
+    })
+
+Valid `app_type_id` are: `rack, rails2, rails3, rails4, sinatra, nodejs`. For some your account may require an early access feature to be enabled.
+
+Accounts:
+
+    account = app.account
+    account.class   # => EY::CloudClient::Account
+    account.id      # => 1234
+    account.name    # => 'myaccount'
+
+Keypairs:
+
+Upload your SSH public keys before you create Environments.
+
+    keypair = EY::CloudClient::Keypair.create(ey_api, {
+      "name"       => 'laptop',
+      "public_key" => "ssh-rsa OTHERKEYPAIR"
+    })
+
+Environments:
+
+    envs = ey_api.environments # loads all your environment data at once; caches result
+
+    env = envs.find {|e| e.name == 'myapp_production'}
+    env.class             # => EY::CloudClient::Environment
+    env.name              # => 'myapp_production'
+    env.id                # => 2345
+    env.framework_env     # => "production"
+    env.app_server_stack_name     # => "nginx_thin"
+    env.deployment_configurations # => {"myapp"=>{"name"=>"myapp", "uri"=>nil, "migrate"=>{"command"=>"rake db:migrate", "perform"=>false}, "repository_uri"=>"git@github.com:myaccount/myapp.git", "id"=>123, "domain_name"=>"_"}}
+    env.load_balancer_ip_address  # => "1.2.3.4"
+
+    # if environment isn't booted
+    env.instances_count     # => 0
+    env.app_master          # => nil
+    env.instances.count     # => []
+
+    # if environment is booted
+    env.instances_count     # => 1
+    env.app_master.class    # => EY::CloudClient::Instance
+    env.instances.first.class # => EY::CloudClient::Instance
+
+Create a new environment (for a given App):
+
+    app = EY::CloudClient::App.new(ey_api, {:id => 4212, :name => 'drnic'})
+    env = EY::CloudClient::Environment.create(ey_api,
+      "app"                   => app,
+      "name"                  => 'myapp_production',
+      "app_server_stack_name" => 'nginx_thin',       # default: nginx_passenger3
+      "region"                => 'us-west-1',        # default: us-east-1
+      "framework_env"         => 'staging'           # default: production
+    })
+
+
+Valid `app_server_stack_name` values: `nginx_unicorn, nginx_passenger3, nginx_nodejs, nginx_thin, nginx_puma`. For some your account may require an early access feature to be enabled.
+
+Instances:
+
+    instance = env.instances.first
+    instance.class        # => EY::CloudClient::Instance
+    instance.id           # => 12345
+    instance.role         # => "solo"
+    instance.status       # => "running"
+    instance.amazon_id    # => "i-abcdefg"
+    instance.hostname     # => "ec2-1-2-3-4.compute-1.amazonaws.com"
+    instance.public_hostname # => "ec2-1-2-3-4.compute-1.amazonaws.com" # alias of hostname
+
+Debugging:
+
+Setup for debugging:
+
+    ENV['DEBUG']='1'
+    require 'engineyard/cli'
+    EY.ui = EY::CLI::UI.new
+
+The API commands will print internal information:
+
+    app = EY::CloudClient::App.create(ey_api, account, 'myapp2', 'git@github.com:myaccount/myapp2.git', 'rails3')
+           Token  YOURTOKEN
+         Request  POST https://cloud.engineyard.com/api/v2/accounts/1234/apps
+          Params  {"app"=>{"name"=>"myapp2", "app_type_id"=>"rails3", "repository_uri"=>"git@github.com:myaccount/myapp2.git"}}
+        Response
+    {"app"=>
+      {"environments"=>[],
+       "name"=>"myapp2",
+       "repository_uri"=>"git@github.com:myaccount/myapp2.git",
+       "account"=>{"name"=>"myaccount", "id"=>1234},
+       "id"=>12345}}

data/bin/ey

@@ -4,12 +4,6 @@ require 'engineyard/cli'
 
 begin
   EY::CLI.start
-rescue EY::Error => e
-  EY.ui.print_exception(e)
-  exit(1)
-rescue Interrupt => e
-  puts
-  EY.ui.print_exception(e)
-  EY.ui.say("Quitting...")
+rescue
   exit(1)
 end

data/lib/engineyard.rb

@@ -1,32 +1,11 @@
 thor_lib = File.expand_path(File.join(File.dirname(__FILE__), 'vendor', 'thor', 'lib'))
 $:.unshift thor_lib
+require 'engineyard-cloud-client'
 
 module EY
-  require 'engineyard/ruby_ext'
   require 'engineyard/version'
   require 'engineyard/error'
   require 'engineyard/config'
 
-  autoload :API,        'engineyard/api'
-  autoload :Collection, 'engineyard/collection'
-  autoload :Model,      'engineyard/model'
   autoload :Repo,       'engineyard/repo'
-  autoload :Resolver,   'engineyard/resolver'
-
-  class UI
-    # stub debug outside of the CLI
-    def debug(*); end
-  end
-
-  def self.ui
-    @ui ||= UI.new
-  end
-
-  def self.ui=(ui)
-    @ui = ui
-  end
-
-  def self.config
-    @config ||= EY::Config.new
-  end
 end

data/lib/engineyard/cli.rb

@@ -1,6 +1,8 @@
 require 'engineyard'
 require 'engineyard/error'
 require 'engineyard/thor'
+require 'engineyard/deploy_config'
+require 'engineyard/serverside_runner'
 
 module EY
   class CLI < EY::Thor
@@ -8,13 +10,25 @@ module EY
     require 'engineyard/cli/web'
     require 'engineyard/cli/api'
     require 'engineyard/cli/ui'
+    require 'engineyard/error'
+    require 'engineyard-cloud-client/errors'
 
     include Thor::Actions
 
     def self.start(*)
-      Thor::Base.shell = EY::CLI::UI
-      EY.ui = EY::CLI::UI.new
+      ui = EY::CLI::UI.new
       super
+    rescue EY::Error, EY::CloudClient::Error => e
+      ui.print_exception(e)
+      raise
+    rescue Interrupt => e
+      puts
+      ui.print_exception(e)
+      ui.say("Quitting...")
+      raise
+    rescue Exception => e
+      ui.print_exception(e)
+      raise
     end
 
     desc "deploy [--environment ENVIRONMENT] [--ref GIT-REF]",
@@ -23,67 +37,95 @@ module EY
       This command must be run with the current directory containing the app to be
       deployed. If ey.yml specifies a default branch then the ref parameter can be
       omitted. Furthermore, if a default branch is specified but a different command
-      is supplied the deploy will fail unless --ignore-default-branch is used.
+      is supplied the deploy will fail unless -R or --force-ref is used.
 
-      Migrations are run based on the 'Migrate?' setting you define in your dashboard
-      for the application. If you want to override these settings, a different
-      command can be specified via --migrate "ruby do_migrations.rb". Migrations
-      can also be skipped entirely by using --no-migrate.
+      Migrations are run based on the settings in your ey.yml file.
+      With each deploy the default migration setting can be overriden by
+      specifying --migrate or --migrate 'rake db:migrate'.
+      Migrations can also be skipped by using --no-migrate.
     DESC
-    method_option :force_ref, :type => :string, :aliases => %w(--ignore-default-branch -R),
-      :lazy_default => true,
-      :desc => "Force a deploy of the specified git ref even if a default is set in ey.yml."
-    method_option :ignore_bad_master, :type => :boolean,
+    method_option :ignore_bad_master, :type => :boolean, :aliases => %w(--ignore-bad-bridge),
       :desc => "Force a deploy even if the master is in a bad state"
     method_option :migrate, :type => :string, :aliases => %w(-m),
       :lazy_default => true,
-      :desc => "Run migrations via [MIGRATE], defaults to 'rake db:migrate'; use --no-migrate to avoid running migrations"
-    method_option :environment, :type => :string, :aliases => %w(-e),
-      :desc => "Environment in which to deploy this application"
+      :desc => "Run migrations via [MIGRATE], defaults to '#{EY::DeployConfig::Migrate::DEFAULT}'; use --no-migrate to avoid running migrations"
     method_option :ref, :type => :string, :aliases => %w(-r --branch --tag),
+      :required => true, :default => '',
       :desc => "Git ref to deploy. May be a branch, a tag, or a SHA. Use -R to deploy a different ref if a default is set."
+    method_option :force_ref, :type => :string, :aliases => %w(--ignore-default-branch -R),
+      :lazy_default => true,
+      :desc => "Force a deploy of the specified git ref even if a default is set in ey.yml."
+    method_option :environment, :type => :string, :aliases => %w(-e),
+      :required => true, :default => false,
+      :desc => "Environment in which to deploy this application"
     method_option :app, :type => :string, :aliases => %w(-a),
+      :required => true, :default => '',
       :desc => "Name of the application to deploy"
     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"
     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
-      EY.ui.info "Loading application data from EY Cloud..."
-
-      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[:force_ref]) ||
-                        raise(EY::Error, "When specifying the application, you must also specify the ref to deploy\nUsage: ey deploy --app <app name> --ref <branch|tag|ref>")
-                    else
-                      environment.resolve_branch(options[:ref], options[:force_ref]) ||
-                        repo.current_branch ||
-                        raise(DeployArgumentError)
-                    end
-
-      EY.ui.info "Beginning deploy of ref '#{deploy_ref}' for '#{app.name}' in '#{environment.name}' on server..."
-
-      deploy_options = {'extras' => {'deployed_by' => api.user.name}.merge(options[:extra_deploy_hook_options])}
-      if options.has_key?('migrate') # thor set migrate => nil when --no-migrate
-        deploy_options['migrate'] = options['migrate'].respond_to?(:to_str) ? options['migrate'] : !!options['migrate']
-      end
-      deploy_options['verbose'] = options['verbose'] if options.has_key?('verbose')
-
-
-      if environment.deploy(app, deploy_ref, deploy_options)
-        EY.ui.info "Deploy complete"
-        EY.ui.info "Now you can run `ey launch' to open the application in a browser."
-      else
-        raise EY::Error, "Deploy failed"
+      ui.info "Loading application data from EY Cloud..."
+
+      app_env = fetch_app_environment(options[:app], options[:environment], options[:account])
+      app_env.environment.ignore_bad_bridge = options[:ignore_bad_master]
+
+      env_config    = config.environment_config(app_env.environment_name)
+      deploy_config = EY::DeployConfig.new(options, env_config, repo, ui)
+
+      deployment = app_env.new_deployment({
+        :ref             => deploy_config.ref,
+        :migrate         => deploy_config.migrate,
+        :migrate_command => deploy_config.migrate_command,
+        :extra_config    => deploy_config.extra_config,
+      })
+
+      runner = serverside_runner(app_env, deploy_config.verbose)
+
+      out = EY::CLI::UI::Tee.new(ui.out, deployment.out)
+      err = EY::CLI::UI::Tee.new(ui.err, deployment.err)
+
+      ui.info  "Beginning deploy..."
+      begin
+        deployment.start
+        ui.show_deployment(deployment)
+        out << "Deploy initiated.\n"
+
+        runner.deploy do |args|
+          args.config  = deployment.config          if deployment.config
+          if deployment.migrate
+            args.migrate = deployment.migrate_command
+          else
+            args.migrate = false
+          end
+          args.ref     = deployment.resolved_ref
+        end
+        deployment.successful = runner.call(out, err)
+      rescue Interrupt
+        err << "Interrupted. Deployment halted.\n"
+        ui.warn "Recording canceled deployment in EY Cloud..."
+        ui.warn "WARNING: Interrupting again may result in a never-finished deployment in the deployment history on EY Cloud."
+        raise
+      rescue StandardError => e
+        deployment.err << "Error encountered during deploy.\n#{e.class} #{e}\n"
+        ui.print_exception(e)
+        raise
+      ensure
+        deployment.finished
+
+        if deployment.successful?
+          ui.info "Successful deployment recorded on EY Cloud"
+          ui.info "Deploy complete"
+          ui.info "Now you can run `ey launch' to open the application in a browser."
+        else
+          ui.info "Failed deployment recorded on EY Cloud"
+          raise EY::Error, "Deploy failed"
+        end
       end
-
-    rescue NoEnvironmentError => e
-      # Give better feedback about why we couldn't find the environment.
-      exists = api.environments.named(options[:environment])
-      raise exists ? EnvironmentUnlinkedError.new(options[:environment]) : e
     end
 
     desc "status", "Show the deployment status of the app"
@@ -92,18 +134,25 @@ module EY
       application and environment.
     DESC
     method_option :environment, :type => :string, :aliases => %w(-e),
+      :required => true, :default => '',
       :desc => "Environment where the application is deployed"
     method_option :app, :type => :string, :aliases => %w(-a),
+      :required => true, :default => '',
       :desc => "Name of the application"
     method_option :account, :type => :string, :aliases => %w(-c),
+      :required => true, :default => '',
       :desc => "Name of the account in which the application can be found"
     def status
-      app, environment = fetch_app_and_environment(options[:app], options[:environment], options[:account])
-      deployment = app.last_deployment_on(environment)
+      app_env = fetch_app_environment(options[:app], options[:environment], options[:account])
+      deployment = app_env.last_deployment
       if deployment
-        EY.ui.show_deployment(deployment)
+        ui.say "# Status of last deployment of #{app_env.to_hierarchy_str}:"
+        ui.say "#"
+        ui.show_deployment(deployment)
+        ui.say "#"
+        ui.deployment_result(deployment)
       else
-        raise EY::Error, "Application #{app.name} hass not been deployed on #{environment.name}."
+        raise EY::Error, "Application #{app_env.app.name} has not been deployed on #{app_env.environment.name}."
       end
     end
 
@@ -113,27 +162,55 @@ module EY
       display all environments, including those for this app.
     DESC
 
-    method_option :all, :type => :boolean, :aliases => %(-a)
-    method_option :simple, :type => :boolean, :aliases => %(-s)
+    method_option :all, :type => :boolean, :aliases => %(-A),
+      :desc => "Show all environments (ignores --app, --account, and --environment arguments)"
+    method_option :simple, :type => :boolean, :aliases => %(-s),
+      :desc => "Display one environment per line with no extra output"
+    method_option :app, :type => :string, :aliases => %w(-a),
+      :required => true, :default => '',
+      :desc => "Show environments for this application"
+    method_option :account, :type => :string, :aliases => %w(-c),
+      :required => true, :default => '',
+      :desc => "Show environments in this account"
+    method_option :environment, :type => :string, :aliases => %w(-e),
+      :required => true, :default => '',
+      :desc => "Show environments matching environment name"
     def environments
       if options[:all] && options[:simple]
         # just put each env
         puts api.environments.map {|env| env.name}
       elsif options[:all]
-        EY.ui.print_envs(api.apps, EY.config.default_environment, options[:simple])
+        ui.print_envs(api.apps, config.default_environment, options[:simple], config.endpoint)
       else
-        apps = api.apps_for_repo(repo)
+        remotes = nil
+        if options[:app] == ''
+          repo.fail_on_no_remotes!
+          remotes = repo.remotes
+        end
+
+        resolver = api.resolve_app_environments({
+          :account_name     => options[:account],
+          :app_name         => options[:app],
+          :environment_name => options[:environment],
+          :remotes          => remotes,
+        })
+
+        resolver.no_matches do |errors|
+          messages = errors
+          messages << "Use #{self.class.send(:banner_base)} environments --all to see all environments."
+          raise EY::NoMatchesError.new(messages.join("\n"))
+        end
+
+        apps = resolver.matches.map { |app_env| app_env.app }.uniq
 
         if apps.size > 1
           message = "This git repo matches multiple Applications in EY Cloud:\n"
           apps.each { |app| message << "\t#{app.name}\n" }
           message << "The following environments contain those applications:\n\n"
-          EY.ui.warn(message)
-        elsif apps.empty?
-          EY.ui.warn(NoAppError.new(repo).message + "\nUse #{self.class.send(:banner_base)} environments --all to see all environments.")
+          ui.warn(message)
         end
 
-        EY.ui.print_envs(apps, EY.config.default_environment, options[:simple])
+        ui.print_envs(apps, config.default_environment, options[:simple], config.endpoint)
       end
     end
     map "envs" => :environments
@@ -150,12 +227,14 @@ module EY
     DESC
 
     method_option :environment, :type => :string, :aliases => %w(-e),
+      :required => true, :default => '',
       :desc => "Environment to rebuild"
     method_option :account, :type => :string, :aliases => %w(-c),
+      :required => true, :default => '',
       :desc => "Name of the account in which the environment can be found"
     def rebuild
       environment = fetch_environment(options[:environment], options[:account])
-      EY.ui.debug("Rebuilding #{environment.name}")
+      ui.debug("Rebuilding #{environment.name}")
       environment.rebuild
     end
     map "update" => :rebuild
@@ -167,21 +246,32 @@ module EY
     DESC
 
     method_option :environment, :type => :string, :aliases => %w(-e),
+      :required => true, :default => '',
       :desc => "Environment in which to roll back the application"
     method_option :app, :type => :string, :aliases => %w(-a),
+      :required => true, :default => '',
       :desc => "Name of the application to roll back"
     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"
     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, environment = fetch_app_and_environment(options[:app], options[:environment], options[:account])
+      app_env = fetch_app_environment(options[:app], options[:environment], options[:account])
+      env_config    = config.environment_config(app_env.environment_name)
+      deploy_config = EY::DeployConfig.new(options, env_config, repo, ui)
+
+      ui.info("Rolling back #{app_env.to_hierarchy_str}")
 
-      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"
+      runner = serverside_runner(app_env, deploy_config.verbose)
+      runner.rollback do |args|
+        args.config = deploy_config.extra_config if deploy_config.extra_config
+      end
+
+      if runner.call(ui.out, ui.err)
+        ui.info "Rollback complete"
       else
         raise EY::Error, "Rollback failed"
       end
@@ -199,8 +289,10 @@ module EY
       $ #{banner_base} ssh "rm -f /some/file" -e my-environment --all
     DESC
     method_option :environment, :type => :string, :aliases => %w(-e),
+      :required => true, :default => '',
       :desc => "Environment to ssh into"
     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 :all, :type => :boolean, :aliases => %(-a),
       :desc => "Run command on all servers"
@@ -235,8 +327,7 @@ module EY
         return lambda {|instance| %w(solo db_master db_slave).include?(instance.role) } if opts[:db_servers ]
         return lambda {|instance| %w(solo db_master         ).include?(instance.role) } if opts[:db_master  ]
         return lambda {|instance| %w(db_slave               ).include?(instance.role) } if opts[:db_slaves  ]
-        return lambda {|instance| %w(util                   ).include?(instance.role) &&
-                                             opts[:utilities].include?(instance.name) } if opts[:utilities  ]
+        return lambda {|instance| %w(util).include?(instance.role) && opts[:utilities].include?(instance.name) } if opts[:utilities]
         return lambda {|instance| %w(solo app_master        ).include?(instance.role) }
       end
 
@@ -264,22 +355,24 @@ module EY
       displayed beneath the main configuration logs.
     DESC
     method_option :environment, :type => :string, :aliases => %w(-e),
+      :required => true, :default => '',
       :desc => "Environment with the interesting logs"
     method_option :account, :type => :string, :aliases => %w(-c),
+      :required => true, :default => '',
       :desc => "Name of the account in which the environment can be found"
     def logs
       environment = fetch_environment(options[:environment], options[:account])
       environment.logs.each do |log|
-        EY.ui.info log.instance_name
+        ui.info log.instance_name
 
         if log.main
-          EY.ui.info "Main logs for #{environment.name}:"
-          EY.ui.say  log.main
+          ui.info "Main logs for #{environment.name}:"
+          ui.say  log.main
         end
 
         if log.custom
-          EY.ui.info "Custom logs for #{environment.name}:"
-          EY.ui.say  log.custom
+          ui.info "Custom logs for #{environment.name}:"
+          ui.say  log.custom
         end
       end
     end
@@ -292,7 +385,7 @@ module EY
 
     desc "version", "Print version number."
     def version
-      EY.ui.say %{engineyard version #{EY::VERSION}}
+      ui.say %{engineyard version #{EY::VERSION}}
     end
     map ["-v", "--version"] => :version
 
@@ -302,38 +395,38 @@ module EY
         base = self.class.send(:banner_base)
         list = self.class.printable_tasks
 
-        EY.ui.say "Usage:"
-        EY.ui.say "  #{base} [--help] [--version] COMMAND [ARGS]"
-        EY.ui.say
+        ui.say "Usage:"
+        ui.say "  #{base} [--help] [--version] COMMAND [ARGS]"
+        ui.say
 
-        EY.ui.say "Deploy commands:"
+        ui.say "Deploy commands:"
         deploy_cmds = %w(deploy environments logs rebuild rollback status)
         deploy_cmds.map! do |name|
           list.find{|task| task[0] =~ /^#{base} #{name}/ }
         end
         list -= deploy_cmds
 
-        EY.ui.print_help(deploy_cmds)
-        EY.ui.say
+        ui.print_help(deploy_cmds)
+        ui.say
 
         self.class.subcommands.each do |name|
           klass = self.class.subcommand_class_for(name)
           list.reject!{|cmd| cmd[0] =~ /^#{base} #{name}/}
-          EY.ui.say "#{name.capitalize} commands:"
+          ui.say "#{name.capitalize} commands:"
           tasks = klass.printable_tasks.reject{|t| t[0] =~ /help$/ }
-          EY.ui.print_help(tasks)
-          EY.ui.say
+          ui.print_help(tasks)
+          ui.say
         end
 
         %w(help version).each{|n| list.reject!{|c| c[0] =~ /^#{base} #{n}/ } }
         if list.any?
-          EY.ui.say "Other commands:"
-          EY.ui.print_help(list)
-          EY.ui.say
+          ui.say "Other commands:"
+          ui.print_help(list)
+          ui.say
         end
 
         self.class.send(:class_options_help, shell)
-        EY.ui.say "See '#{base} help COMMAND' for more information on a specific command."
+        ui.say "See '#{base} help COMMAND' for more information on a specific command."
       elsif klass = self.class.subcommand_class_for(cmds.first)
         klass.new.help(*cmds[1..-1])
       else
@@ -341,20 +434,25 @@ module EY
       end
     end
 
-    desc "launch [--environment ENVIRONMENT] [--account ACCOUNT]", "Open application in browser."
+    desc "launch [--app APP] [--environment ENVIRONMENT] [--account ACCOUNT]", "Open application in browser."
     method_option :environment, :type => :string, :aliases => %w(-e),
-      :desc => "Name of the environment"
+      :required => true, :default => '',
+      :desc => "Environment where the application is deployed"
+    method_option :app, :type => :string, :aliases => %w(-a),
+      :required => true, :default => '',
+      :desc => "Name of the application"
     method_option :account, :type => :string, :aliases => %w(-c),
-      :desc => "Name of the account in which the environment can be found"
+      :required => true, :default => '',
+      :desc => "Name of the account in which the application can be found"
     def launch
-      environment = fetch_environment(options[:environment], options[:account])
-      environment.launch
+      app_env = fetch_app_environment(options[:app], options[:environment], options[:account])
+      Launchy.open(app_env.uri)
     end
 
     desc "whoami", "Who am I logged in as?"
     def whoami
-      user = api.user
-      EY.ui.say "#{user.name} (#{user.email})"
+      current_user = api.current_user
+      ui.say "#{current_user.name} (#{current_user.email})"
     end
 
     desc "login", "Log in and verify access to EY Cloud."
@@ -366,10 +464,10 @@ module EY
     def logout
       eyrc = EYRC.load
       if eyrc.delete_api_token
-        EY.ui.say "API token removed: #{eyrc.path}"
-        EY.ui.say "Run any other command to login again."
+        ui.say "API token removed: #{eyrc.path}"
+        ui.say "Run any other command to login again."
       else
-        EY.ui.say "Already logged out. Run any other command to login again."
+        ui.say "Already logged out. Run any other command to login again."
       end
     end