artofmission-heroku 1.6.3

data/lib/heroku/commands/auth.rb

@@ -0,0 +1,137 @@
+module Heroku::Command
+	class Auth < Base
+		attr_accessor :credentials
+
+		def client
+			@client ||= init_heroku
+		end
+
+		def init_heroku
+			client = Heroku::Client.new(user, password, host)
+			client.on_warning { |msg| self.display("\n#{msg}\n\n") }
+			client
+		end
+
+		def host
+			ENV['HEROKU_HOST'] || 'heroku.com'
+		end
+
+		def reauthorize
+			@credentials = ask_for_credentials
+			write_credentials
+		end
+
+		def user    # :nodoc:
+			get_credentials
+			@credentials[0]
+		end
+
+		def password    # :nodoc:
+			get_credentials
+			@credentials[1]
+		end
+
+		def credentials_file
+			"#{home_directory}/.heroku/credentials"
+		end
+
+		def get_credentials    # :nodoc:
+			return if @credentials
+			unless @credentials = read_credentials
+				@credentials = ask_for_credentials
+				save_credentials
+			end
+			@credentials
+		end
+
+		def read_credentials
+			File.exists?(credentials_file) and File.read(credentials_file).split("\n")
+		end
+
+		def echo_off
+			system "stty -echo"
+		end
+
+		def echo_on
+			system "stty echo"
+		end
+
+		def ask_for_credentials
+			puts "Enter your Heroku credentials."
+
+			print "Email: "
+			user = ask
+
+			print "Password: "
+			password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+
+			[ user, password ]
+		end
+
+		def ask_for_password_on_windows
+			require "Win32API"
+			char = nil
+			password = ''
+
+			while char = Win32API.new("crtdll", "_getch", [ ], "L").Call do
+				break if char == 10 || char == 13 # received carriage return or newline
+				if char == 127 || char == 8 # backspace and delete
+					password.slice!(-1, 1)
+				else
+					password << char.chr
+				end
+			end
+			puts
+			return password
+		end
+
+		def ask_for_password
+			echo_off
+			password = ask
+			puts
+			echo_on
+			return password
+		end
+
+		def save_credentials
+			begin
+				write_credentials
+				Heroku::Command.run_internal('keys:add', args)
+			rescue RestClient::Unauthorized => e
+				delete_credentials
+				raise e unless retry_login?
+
+				display "\nAuthentication failed"
+				@credentials = ask_for_credentials
+				@client = init_heroku
+				retry
+			rescue Exception => e
+				delete_credentials
+				raise e
+			end
+		end
+
+		def retry_login?
+			@login_attempts ||= 0
+			@login_attempts += 1
+			@login_attempts < 3
+		end
+
+		def write_credentials
+			FileUtils.mkdir_p(File.dirname(credentials_file))
+			File.open(credentials_file, 'w') do |f|
+				f.puts self.credentials
+			end
+			set_credentials_permissions
+		end
+
+		def set_credentials_permissions
+			FileUtils.chmod 0700, File.dirname(credentials_file)
+			FileUtils.chmod 0600, credentials_file
+		end
+
+		def delete_credentials
+			FileUtils.rm_f(credentials_file)
+		end
+	end
+end

data/lib/heroku/commands/base.rb

@@ -0,0 +1,133 @@
+require 'fileutils'
+
+module Heroku::Command
+	class Base
+		include Heroku::Helpers
+
+		attr_accessor :args
+		attr_reader :autodetected_app
+		def initialize(args, heroku=nil)
+			@args = args
+			@heroku = heroku
+			@autodetected_app = false
+		end
+
+		def display(msg, newline=true)
+			if newline
+				puts(msg)
+			else
+				print(msg)
+				STDOUT.flush
+			end
+		end
+
+		def format_date(date)
+			date = Time.parse(date) if date.is_a?(String)
+			date.strftime("%Y-%m-%d %H:%M %Z")
+		end
+
+		def error(msg)
+			Heroku::Command.error(msg)
+		end
+
+		def ask
+			gets.strip
+		end
+
+		def shell(cmd)
+			FileUtils.cd(Dir.pwd) {|d| return `#{cmd}`}
+		end
+
+		def heroku
+			@heroku ||= Heroku::Command.run_internal('auth:client', args)
+		end
+
+		def extract_app(force=true)
+			app = extract_option('--app')
+			unless app
+				app = extract_app_in_dir(Dir.pwd) ||
+				raise(CommandFailed, "No app specified.\nRun this command from app folder or set it adding --app <app name>") if force
+				@autodetected_app = true
+			end
+			app
+		end
+
+		def extract_app_in_dir(dir)
+			return unless remotes = git_remotes(dir)
+
+			if remote = extract_option('--remote')
+				remotes[remote]
+			else
+				apps = remotes.values.uniq
+				case apps.size
+					when 0; return nil
+					when 1; return apps.first
+					else
+						current_dir_name = dir.split('/').last.downcase
+						apps.select { |a| a.downcase == current_dir_name }.first
+				end
+			end
+		end
+
+		def git_remotes(base_dir)
+			git_config = "#{base_dir}/.git/config"
+			unless File.exists?(git_config)
+				parent = base_dir.split('/')[0..-2].join('/')
+				return git_remotes(parent) unless parent.empty?
+			else
+				remotes = {}
+				current_remote = nil
+				File.read(git_config).split(/\n/).each do |l|
+					current_remote = $1 if l.match(/\[remote \"([\w\d-]+)\"\]/)
+					app = (l.match(/url = git@#{heroku.host}:([\w\d-]+)\.git/) || [])[1]
+					if current_remote && app
+						remotes[current_remote.downcase] = app
+						current_remote = nil
+					end
+				end
+				return remotes
+			end
+		end
+
+		def extract_option(options, default=true)
+			values = options.is_a?(Array) ? options : [options]
+			return unless opt_index = args.select { |a| values.include? a }.first
+			opt_position = args.index(opt_index) + 1
+			if args.size > opt_position && opt_value = args[opt_position]
+				if opt_value.include?('--')
+					opt_value = nil
+				else
+					args.delete_at(opt_position)
+				end
+			end
+			opt_value ||= default
+			args.delete(opt_index)
+			block_given? ? yield(opt_value) : opt_value
+		end
+
+		def web_url(name)
+			"http://#{name}.#{heroku.host}/"
+		end
+
+		def git_url(name)
+			"git@#{heroku.host}:#{name}.git"
+		end
+
+		def app_urls(name)
+			"#{web_url(name)} | #{git_url(name)}"
+		end
+
+		def escape(value)
+			heroku.escape(value)
+		end
+	end
+
+	class BaseWithApp < Base
+		attr_accessor :app
+
+		def initialize(args, heroku=nil)
+			super(args, heroku)
+			@app ||= extract_app
+		end
+	end
+end

data/lib/heroku/commands/bundles.rb

@@ -0,0 +1,51 @@
+module Heroku::Command
+	class Bundles < BaseWithApp
+		def list
+			list = heroku.bundles(app)
+			if list.size > 0
+				list.each do |bundle|
+					space  = ' ' * [(18 - bundle[:name].size),1].max
+					display "#{bundle[:name]}" + space + "#{bundle[:state]} #{bundle[:created_at].strftime("%m/%d/%Y %H:%M")}"
+				end
+			else
+				display "#{app} has no bundles."
+			end
+		end
+		alias :index :list
+
+		def capture
+			bundle = args.shift.strip.downcase rescue nil
+
+			bundle = heroku.bundle_capture(app, bundle)
+			display "Began capturing bundle #{bundle} from #{app}"
+		end
+
+		def destroy
+			bundle = args.first.strip.downcase rescue nil
+			unless bundle
+				display "Usage: heroku bundle:destroy <bundle>"
+			else
+				heroku.bundle_destroy(app, bundle)
+				display "Destroyed bundle #{bundle} from #{app}"
+			end
+		end
+
+		def download
+			fname = "#{app}.tar.gz"
+			bundle = args.shift.strip.downcase rescue nil
+			url = heroku.bundle_url(app, bundle)
+			File.open(fname, "wb") { |f| f.write RestClient.get(url) }
+			display "Downloaded #{File.stat(fname).size} byte bundle #{fname}"
+		end
+
+		def animate
+			bundle = args.shift.strip.downcase rescue ""
+			if bundle.length == 0
+				display "Usage: heroku bundle:animate <bundle>"
+			else
+				name = heroku.create(nil, :origin_bundle_app => app, :origin_bundle => bundle)
+				display "Animated #{app} #{bundle} into #{app_urls(name)}"
+			end
+		end
+	 end
+end

data/lib/heroku/commands/config.rb

@@ -0,0 +1,55 @@
+module Heroku::Command
+	class Config < BaseWithApp
+		def index
+			long = args.delete('--long')
+			vars = heroku.config_vars(app)
+			display_vars(vars, :long => long)
+		end
+
+		def add
+			unless args.size > 0 and args.all? { |a| a.include?('=') }
+				raise CommandFailed, "Usage: heroku config:add <key>=<value> [<key2>=<value2> ...]"
+			end
+
+			vars = args.inject({}) do |vars, arg|
+				key, value = arg.split('=', 2)
+				vars[key] = value
+				vars
+			end
+
+			display "Adding config vars:"
+			display_vars(vars, :indent => 2)
+
+			display "Restarting app...", false
+			heroku.add_config_vars(app, vars)
+			display "done."
+		end
+
+		def remove
+			display "Removing #{args.first} and restarting app...", false
+			heroku.remove_config_var(app, args.first)
+			display "done."
+		end
+		alias :rm :remove
+
+		def clear
+			display "Clearing all config vars and restarting app...", false
+			heroku.clear_config_vars(app)
+			display "done."
+		end
+
+		protected
+			def display_vars(vars, options={})
+				max_length = vars.map { |v| v[0].size }.max
+				vars.keys.sort.each do |key|
+					spaces = ' ' * (max_length - key.size)
+					display "#{' ' * (options[:indent] || 0)}#{key}#{spaces} => #{format(vars[key], options)}"
+				end
+			end
+
+			def format(value, options)
+				return value if options[:long] || value.size < 36
+				value[0, 16] + '...' + value[-16, 16]
+			end
+	end
+end

data/lib/heroku/commands/db.rb

@@ -0,0 +1,129 @@
+module Heroku::Command
+	class Db < BaseWithApp
+		def pull
+			database_url = args.shift.strip rescue ''
+			if database_url == ''
+				database_url = parse_database_yml
+				display "Auto-detected local database: #{database_url}" if database_url != ''
+			end
+			raise(CommandFailed, "Invalid database url") if database_url == ''
+
+			taps_client(database_url) do |client|
+				client.cmd_receive
+			end
+		end
+
+		def push
+			display("Warning: All data in the the remote database will be overwritten and will not be recoverable.")
+			display("Are you sure you wish to push to the remote database? (y/n)? ", false)
+			if ask.downcase == 'y'
+  			database_url = args.shift.strip rescue ''
+  			if database_url == ''
+  				database_url = parse_database_yml
+  				display "Auto-detected local database: #{database_url}" if database_url != ''
+  			end
+  			raise(CommandFailed, "Invalid database url") if database_url == ''
+
+  			taps_client(database_url) do |client|
+  				client.cmd_send
+  			end
+			end
+		end
+
+		def reset
+			if !autodetected_app
+				info = heroku.info(app)
+				url  = info[:domain_name] || "http://#{info[:name]}.#{heroku.host}/"
+
+				display("Warning: All data in the '#{app}' database will be erased and will not be recoverable.")
+				display("Are you sure you wish to continue? (y/n)? ", false)
+				if ask.downcase == 'y'
+					heroku.database_reset(app)
+					display "Database reset for '#{app}' (#{url})"
+				end
+			else
+				display "Set the app you want to reset the database for by adding --app <app name> to this command"
+			end
+		end
+
+		protected
+
+		def parse_database_yml
+			return "" unless File.exists?(Dir.pwd + '/config/database.yml')
+
+			environment = ENV['RAILS_ENV'] || ENV['MERB_ENV'] || ENV['RACK_ENV']
+			environment = 'development' if environment.nil? or environment.empty?
+
+			conf = YAML.load(File.read(Dir.pwd + '/config/database.yml'))[environment]
+			case conf['adapter']
+				when 'sqlite3'
+					return "sqlite://#{conf['database']}"
+				when 'postgresql'
+					uri_hash = conf_to_uri_hash(conf)
+					uri_hash['scheme'] = 'postgres'
+					return uri_hash_to_url(uri_hash)
+				else
+					return uri_hash_to_url(conf_to_uri_hash(conf))
+			end
+		rescue Object => e
+			""
+		end
+
+		def conf_to_uri_hash(conf)
+			uri = {}
+			uri['scheme'] = conf['adapter']
+			uri['username'] = conf['user'] || conf['username']
+			uri['password'] = conf['password']
+			uri['host'] = conf['host'] || conf['hostname']
+			uri['port'] = conf['port']
+			uri['path'] = conf['database']
+
+			conf['encoding'] = 'utf8' if conf['encoding'] == 'unicode' or conf['encoding'].nil?
+			uri['query'] = "encoding=#{conf['encoding']}"
+
+			uri
+		end
+
+		def uri_hash_to_url(uri)
+			url = "#{uri['scheme']}://"
+			if uri['username'].size
+				url += escape(uri['username'])
+				url += ':' + escape(uri['password']) if uri['password']
+				url += "@"
+				url += uri['host'] || '127.0.0.1'
+			else
+				url += uri['host'] if uri['host']
+			end
+			url += uri['port'] if uri['port']
+			url += "/"
+			url += uri['path']
+			url += "?#{uri['query']}" if uri['query']
+			url
+		end
+
+		def taps_client(database_url, &block)
+			chunk_size = 1000
+			Taps::Config.database_url = database_url
+			Taps::Config.verify_database_url
+
+			Taps::ClientSession.start(database_url, "http://heroku:osui59a24am79x@taps.#{heroku.host}", chunk_size) do |client|
+				uri = heroku.database_session(app)
+				client.set_session(uri)
+				client.verify_server
+				yield client
+			end
+		end
+
+		def initialize(*args)
+			super(*args)
+
+			gem 'taps', '>= 0.2.23', '< 0.3.0'
+			require 'taps/client_session'
+		rescue LoadError
+			message  = "Taps Load Error: #{$!.message}\n"
+			message << "You may need to install or update the taps gem to use db commands.\n"
+			message << "On most systems this will be:\n\nsudo gem install taps"
+			error message
+		end
+	end
+end