artofmission-heroku 1.6.3

data/lib/heroku/command.rb

@@ -0,0 +1,96 @@
+require 'helpers'
+require 'plugin'
+require 'commands/base'
+
+Dir["#{File.dirname(__FILE__)}/commands/*"].each { |c| require c }
+
+module Heroku
+	module Command
+		class InvalidCommand < RuntimeError; end
+		class CommandFailed  < RuntimeError; end
+
+		class << self
+			def run(command, args, retries=0)
+				Heroku::Plugin.load!
+				begin
+					run_internal 'auth:reauthorize', args.dup if retries > 0
+					run_internal(command, args.dup)
+				rescue InvalidCommand
+					error "Unknown command. Run 'heroku help' for usage information."
+				rescue RestClient::Unauthorized
+					if retries < 3
+						STDERR.puts "Authentication failure"
+						run(command, args, retries+1)
+					else
+						error "Authentication failure"
+					end
+				rescue RestClient::ResourceNotFound => e
+					error extract_not_found(e.http_body)
+				rescue RestClient::RequestFailed => e
+					error extract_error(e.http_body) unless e.http_code == 402
+					retry if run_internal('account:confirm_billing', args.dup)
+				rescue RestClient::RequestTimeout
+					error "API request timed out. Please try again, or contact support@heroku.com if this issue persists."
+				rescue CommandFailed => e
+					error e.message
+				rescue Interrupt => e
+					error "\n[canceled]"
+				end
+			end
+
+			def run_internal(command, args, heroku=nil)
+				klass, method = parse(command)
+				runner = klass.new(args, heroku)
+				raise InvalidCommand unless runner.respond_to?(method)
+				runner.send(method)
+			end
+
+			def error(msg)
+				STDERR.puts(msg)
+				exit 1
+			end
+
+			def parse(command)
+				parts = command.split(':')
+				case parts.size
+					when 1
+						begin
+							return eval("Heroku::Command::#{command.capitalize}"), :index
+						rescue NameError, NoMethodError
+							return Heroku::Command::App, command
+						end
+					when 2
+						begin
+							return Heroku::Command.const_get(parts[0].capitalize), parts[1]
+						rescue NameError
+							raise InvalidCommand
+						end
+					else
+						raise InvalidCommand
+				end
+			end
+
+			def extract_not_found(body)
+				body =~ /^[\w\s]+ not found$/ ? body : "Resource not found"
+			end
+
+			def extract_error(body)
+				msg = parse_error_xml(body) || parse_error_json(body) || 'Internal server error'
+				msg.split("\n").map { |line| ' !   ' + line }.join("\n")
+			end
+
+			def parse_error_xml(body)
+				xml_errors = REXML::Document.new(body).elements.to_a("//errors/error")
+				msg = xml_errors.map { |a| a.text }.join(" / ")
+				return msg unless msg.empty?
+			rescue Exception
+			end
+
+			def parse_error_json(body)
+				json = JSON.parse(body)
+				json['error']
+			rescue JSON::ParserError
+			end
+		end
+	end
+end

data/lib/heroku/commands/account.rb

@@ -0,0 +1,13 @@
+module Heroku::Command
+	class Account < Base
+		def confirm_billing
+			display("  This action will cause your account to be billed at the end of the month")
+			display("  For more information, see http://docs.heroku.com/billing")
+			display("  Are you sure you want to do this? (y/n) ", false)
+			if ask.downcase == 'y'
+				heroku.confirm_billing
+				return true
+			end
+		end
+	end
+end

data/lib/heroku/commands/addons.rb

@@ -0,0 +1,109 @@
+module Heroku::Command
+	class Addons < BaseWithApp
+		def index
+			installed = heroku.installed_addons(app)
+			if installed.empty?
+				display "No addons installed"
+			else
+				available, pending = installed.partition { |a| a['configured'] }
+				available.map { |a| a['name'] }.sort.each do |addon|
+					display addon
+				end
+				unless pending.empty?
+					display "\n--- not configured ---"
+					pending.map { |a| a['name'] }.sort.each do |addon|
+						display addon.ljust(24) + "http://#{heroku.host}/myapps/#{app}/addons/#{addon}"
+					end
+				end
+			end
+		end
+
+		def info
+			addons = heroku.addons
+			if addons.empty?
+				display "No addons available currently"
+			else
+				available, beta = addons.partition { |a| !a['beta'] }
+				display_addons(available)
+				if !beta.empty?
+					display "\n--- beta ---"
+					display_addons(beta)
+				end
+			end
+		end
+
+		def add
+			addon = args.shift
+			config = {}
+			args.each do |arg|
+				key, value = arg.strip.split('=', 2)
+				if value.nil?
+					error("Non-config value \"#{arg}\".\nEverything after the addon name should be a key=value pair")
+				else
+					config[key] = value
+				end
+			end
+
+			display "Adding #{addon} to #{app}... ", false
+			display addon_run { heroku.install_addon(app, addon, config) }
+		end
+
+		def remove
+			args.each do |name|
+				display "Removing #{name} from #{app}... ", false
+				display addon_run { heroku.uninstall_addon(app, name) }
+			end
+		end
+
+		def clear
+			heroku.installed_addons(app).each do |addon|
+				display "Removing #{addon['description']} from #{app}... ", false
+				display addon_run { heroku.uninstall_addon(app, addon['name']) }
+			end
+		end
+
+		def confirm_billing
+			Heroku::Command.run_internal 'account:confirm_billing', []
+		end
+
+		private
+			def display_addons(addons)
+				grouped = addons.inject({}) do |base, addon|
+					group, short = addon['name'].split(':')
+					base[group] ||= []
+					base[group] << addon.merge('short' => short)
+					base
+				end
+				grouped.keys.sort.each do |name|
+					addons = grouped[name]
+					row = name.dup
+					if addons.any? { |a| a['short'] }
+						row << ':'
+						size = row.size
+						stop = false
+						row << addons.map { |a| a['short'] }.sort.map do |short|
+							size += short.size
+							if size < 31
+								short
+							else
+								stop = true
+								nil
+							end
+						end.compact.join(', ')
+						row << '...' if stop
+					end
+					display row.ljust(34) + (addons.first['url'] || '')
+				end
+			end
+
+			def addon_run
+				yield
+				'done'
+			rescue RestClient::ResourceNotFound => e
+				"FAILED\nno addon by that name"
+			rescue RestClient::RequestFailed => e
+				retry if e.http_code == 402 && confirm_billing
+				"FAILED\n" + Heroku::Command.extract_error(e.http_body)
+			end
+	end
+end

data/lib/heroku/commands/app.rb

@@ -0,0 +1,239 @@
+require 'readline'
+require 'launchy'
+
+module Heroku::Command
+	class App < Base
+		def list
+			list = heroku.list
+			if list.size > 0
+				display list.map {|name, owner|
+					if heroku.user == owner
+						name
+					else
+						"#{name.ljust(25)} #{owner}"
+					end
+				}.join("\n")
+			else
+				display "You have no apps."
+			end
+		end
+
+		def create
+			remote  = extract_option('--remote', 'heroku')
+			name    = args.shift.downcase.strip rescue nil
+			name    = heroku.create(name, {})
+			display "Created #{app_urls(name)}"
+			if remote || File.exists?(Dir.pwd + '/.git')
+				remote ||= 'heroku'
+				return if shell('git remote').split("\n").include?(remote)
+				shell "git remote add #{remote} git@#{heroku.host}:#{name}.git"
+				display "Git remote #{remote} added"
+			end
+		end
+
+		def rename
+			name    = extract_app
+			newname = args.shift.downcase.strip rescue ''
+			raise(CommandFailed, "Invalid name.") if newname == ''
+
+			heroku.update(name, :name => newname)
+			display app_urls(newname)
+
+			if remotes = git_remotes(Dir.pwd)
+				remotes.each do |remote_name, remote_app|
+					next if remote_app != name
+					shell "git remote rm #{remote_name}"
+					shell "git remote add #{remote_name} git@#{heroku.host}:#{newname}.git"
+					display "Git remote #{remote_name} updated"
+				end
+			else
+				display "Don't forget to update your Git remotes on any local checkouts."
+			end
+		end
+
+		def info
+			name = (args.first && !args.first =~ /^\-\-/) ? args.first : extract_app
+			attrs = heroku.info(name)
+			
+			attrs[:web_url] ||= "http://#{attrs[:name]}.#{heroku.host}/"
+			attrs[:git_url] ||= "git@#{heroku.host}:#{attrs[:name]}.git"
+			
+			display "=== #{attrs[:name]}"
+			display "Web URL:        #{attrs[:web_url]}"
+			display "Domain name:    http://#{attrs[:domain_name]}/" if attrs[:domain_name]
+			display "Git Repo:       #{attrs[:git_url]}"
+			display "Dynos:          #{attrs[:dynos]}"
+			display "Workers:        #{attrs[:workers]}"
+			display "Repo size:      #{format_bytes(attrs[:repo_size])}" if attrs[:repo_size]
+			display "Slug size:      #{format_bytes(attrs[:slug_size])}" if attrs[:slug_size]
+			if attrs[:database_size]
+				data = format_bytes(attrs[:database_size])
+				if tables = attrs[:database_tables]
+					data = data.gsub('(empty)', '0K') + " in #{tables} table#{'s' if tables.to_i > 1}"
+				end
+				display "Data size:      #{data}"
+			end
+
+			if attrs[:cron_next_run]
+				display "Next cron:      #{format_date(attrs[:cron_next_run])} (scheduled)"
+			end
+			if attrs[:cron_finished_at]
+				display "Last cron:      #{format_date(attrs[:cron_finished_at])} (finished)"
+			end
+
+			unless attrs[:addons].empty?
+				display "Addons:         " + attrs[:addons].map { |a| a['description'] }.join(', ')
+			end
+
+			display "Owner:          #{attrs[:owner]}"
+			collaborators = attrs[:collaborators].delete_if { |c| c[:email] == attrs[:owner] }
+			unless collaborators.empty?
+				first = true
+				lead = "Collaborators:"
+				attrs[:collaborators].each do |collaborator|
+					display "#{first ? lead : ' ' * lead.length}  #{collaborator[:email]}"
+					first = false
+				end
+			end
+		end
+
+		def open
+			app = extract_app
+
+			url = web_url(app)
+			puts "Opening #{url}"
+			Launchy.open url
+		end
+
+		def rake
+			app = extract_app
+			cmd = args.join(' ')
+			if cmd.length == 0
+				display "Usage: heroku rake <command>"
+			else
+				heroku.start(app, "rake #{cmd}", attached=true).each do |chunk|
+					display chunk, false
+				end
+			end
+		rescue Heroku::Client::AppCrashed => e
+			error "Couldn't run rake\n#{e.message}"
+		end
+
+		def console
+			app = extract_app
+			cmd = args.join(' ').strip
+			if cmd.empty?
+				console_session(app)
+			else
+				display heroku.console(app, cmd)
+			end
+		rescue RestClient::RequestTimeout
+			error "Timed out. Long running requests are not supported on the console.\nPlease consider creating a rake task instead."
+		rescue Heroku::Client::AppCrashed => e
+			error "Couldn't run console command\n#{e.message}"
+		end
+
+		def console_session(app)
+			heroku.console(app) do |console|
+				console_history_read(app)
+
+				display "Ruby console for #{app}.#{heroku.host}"
+				while cmd = Readline.readline('>> ')
+					unless cmd.nil? || cmd.strip.empty?
+						console_history_add(app, cmd)
+						break if cmd.downcase.strip == 'exit'
+						display console.run(cmd)
+					end
+				end
+			end
+		end
+
+		def restart
+			app_name = extract_app
+			heroku.restart(app_name)
+			display "Servers restarted"
+		end
+
+		def dynos
+			app = extract_app
+			if dynos = args.shift
+				current = heroku.set_dynos(app, dynos)
+				display "#{app} now running on #{current} dyno#{'s' if current > 1}"
+			else
+				info = heroku.info(app)
+				display "#{app} is running on #{info[:dynos]} dyno#{'s' if info[:dynos].to_i > 1}"
+			end
+		end
+
+		def workers
+			app = extract_app
+			if workers = args.shift
+				current = heroku.set_workers(app, workers)
+				display "#{app} now running #{current} worker#{'s' if current != 1}"
+			else
+				info = heroku.info(app)
+				display "#{app} is running #{info[:workers]} worker#{'s' if info[:workers].to_i != 1}"
+			end
+		end
+
+		def destroy
+			if name = extract_option('--app')
+				info = heroku.info(name)
+				url  = info[:domain_name] || "http://#{info[:name]}.#{heroku.host}/"
+				conf = nil
+
+				display("Permanently destroy #{url} (y/n)? ", false)
+				if ask.downcase == 'y'
+					heroku.destroy(name)
+					if remotes = git_remotes(Dir.pwd)
+						remotes.each do |remote_name, remote_app|
+							next if name != remote_app
+							shell "git remote rm #{remote_name}"
+						end
+					end
+					display "Destroyed #{name}"
+				end
+			else
+				display "Set the app you want to destroy adding --app <app name> to this command"
+			end
+		end
+
+		protected
+			@@kb = 1024
+			@@mb = 1024 * @@kb
+			@@gb = 1024 * @@mb
+			def format_bytes(amount)
+				amount = amount.to_i
+				return '(empty)' if amount == 0
+				return amount if amount < @@kb
+				return "#{(amount / @@kb).round}k" if amount < @@mb
+				return "#{(amount / @@mb).round}M" if amount < @@gb
+				return "#{(amount / @@gb).round}G"
+			end
+
+			def console_history_dir
+				FileUtils.mkdir_p(path = "#{home_directory}/.heroku/console_history")
+				path
+			end
+
+			def console_history_file(app)
+				"#{console_history_dir}/#{app}"
+			end
+
+			def console_history_read(app)
+				history = File.read(console_history_file(app)).split("\n")
+				if history.size > 50
+					history = history[(history.size - 51),(history.size - 1)]
+					File.open(console_history_file(app), "w") { |f| f.puts history.join("\n") }
+				end
+				history.each { |cmd| Readline::HISTORY.push(cmd) }
+			rescue Errno::ENOENT
+			end
+
+			def console_history_add(app, cmd)
+				Readline::HISTORY.push(cmd)
+				File.open(console_history_file(app), "a") { |f| f.puts cmd + "\n" }
+			end
+
+	end
+end