pogo 2.31.2 → 2.32.14

data/lib/heroku/command/pg.rb

@@ -26,6 +26,8 @@ class Heroku::Command::Pg < Heroku::Command::Base
 
   # pg:info [DATABASE]
   #
+  #   -x, --extended  # Show extended information
+  #
   # Display database information
   #
   # If DATABASE is not specified, displays all databases
@@ -35,8 +37,8 @@ class Heroku::Command::Pg < Heroku::Command::Base
     validate_arguments!
 
     if db
-      name, url = hpg_resolve(db)
-      display_db name, hpg_info(url)
+      attachment = hpg_resolve(db)
+      display_db attachment.display_name, hpg_info(attachment, options[:extended])
     else
       index
     end
@@ -52,11 +54,10 @@ class Heroku::Command::Pg < Heroku::Command::Base
     end
     validate_arguments!
 
-    name, url = hpg_resolve(db)
-    name ||= 'Custom URL'
+    attachment = hpg_resolve(db)
 
-    action "Promoting #{name} to DATABASE_URL" do
-      hpg_promote(url)
+    action "Promoting #{attachment.display_name} to DATABASE_URL" do
+      hpg_promote(attachment.url)
     end
   end
 
@@ -67,10 +68,10 @@ class Heroku::Command::Pg < Heroku::Command::Base
   # defaults to DATABASE_URL databases if no DATABASE is specified
   #
   def psql
-    name, url = hpg_resolve(shift_argument, "DATABASE_URL")
+    attachment = hpg_resolve(shift_argument, "DATABASE_URL")
     validate_arguments!
 
-    uri = URI.parse(url)
+    uri = URI.parse( attachment.url )
     begin
       ENV["PGPASSWORD"] = uri.password
       ENV["PGSSLMODE"]  = 'require'
@@ -92,14 +93,14 @@ class Heroku::Command::Pg < Heroku::Command::Base
     end
     validate_arguments!
 
-    name, url = hpg_resolve(db)
+    attachment = hpg_resolve(db) unless db == "SHARED_DATABASE"
     return unless confirm_command
 
-    action("Resetting #{name}") do
-      if name =~ /^SHARED_DATABASE/i
-        heroku.database_reset(app)
-      else
-        hpg_client(url).reset
+    if db == "SHARED_DATABASE"
+      action("Resetting SHARED_DATABASE") { heroku.database_reset(app) }
+    else
+      action("Resetting #{attachment.display_name}") do
+        hpg_client(attachment).reset
       end
     end
   end
@@ -114,21 +115,21 @@ class Heroku::Command::Pg < Heroku::Command::Base
     end
     validate_arguments!
 
-    replica_name, replica_url = hpg_resolve(db)
-    replica = hpg_info(replica_url)
+    replica = hpg_resolve(db)
+    replica_info = hpg_info(replica)
 
-    unless replica[:following]
-      error("#{replica_name} is not following another database.")
+    unless replica_info[:following]
+      error("#{replica.display_name} is not following another database.")
     end
-    origin_url = replica[:following]
+    origin_url = replica_info[:following]
     origin_name = database_name_from_url(origin_url)
 
-    output_with_bang "#{replica_name} will become writable and no longer"
+    output_with_bang "#{replica.display_name} will become writable and no longer"
     output_with_bang "follow #{origin_name}. This cannot be undone."
     return unless confirm_command
 
-    action "Unfollowing #{db}" do
-      hpg_client(replica_url).unfollow
+    action "Unfollowing #{replica.display_name}" do
+      hpg_client(replica).unfollow
     end
   end
 
@@ -143,12 +144,10 @@ class Heroku::Command::Pg < Heroku::Command::Base
     validate_arguments!
 
     if db
-      wait_for hpg_info(hpg_resolve(db).last)
+      wait_for hpg_resolve(db)
     else
-      hpg_databases_with_info.keys.sort.each do |name|
-        unless name =~ /^SHARED_DATABASE/i
-          wait_for(hpg_databases_with_info[name])
-        end
+      hpg_databases.values.each do |attach|
+        wait_for(attach)
       end
     end
   end
@@ -165,23 +164,21 @@ class Heroku::Command::Pg < Heroku::Command::Base
     end
     validate_arguments!
 
-    name, url = hpg_resolve(db)
-
-    url_is_database_url = (url == app_config_vars["DATABASE_URL"])
+    attachment = hpg_resolve(db)
 
     if options[:reset]
-      action "Resetting credentials for #{name}" do
-        hpg_client(url).rotate_credentials
+      action "Resetting credentials for #{attachment.display_name}" do
+        hpg_client(attachment).rotate_credentials
       end
-      if url_is_database_url
+      if attachment.primary_attachment?
         forget_config!
-        name, new_url = hpg_resolve(db)
-        action "Promoting #{name}" do
-          hpg_promote(new_url)
+        attachment = hpg_resolve(db)
+        action "Promoting #{attachment.display_name}" do
+          hpg_promote(attachment.url)
         end
       end
     else
-      uri = URI.parse(url)
+      uri = URI.parse( attachment.url )
       display "Connection info string:"
       display "   \"dbname=#{uri.path[1..-1]} host=#{uri.host} port=#{uri.port || 5432} user=#{uri.user} password=#{uri.password} sslmode=require\""
     end
@@ -200,12 +197,7 @@ private
   end
 
   def display_db(name, db)
-    pretty_name = name
-    if !pretty_name.include?(' (DATABASE_URL)') && app_config_vars["#{name}_URL"] == app_config_vars["DATABASE_URL"]
-      pretty_name += " (DATABASE_URL)"
-    end
-
-    styled_header(pretty_name)
+    styled_header(name)
     styled_hash(db[:info].inject({}) do |hash, item|
       hash.update(item["name"] => hpg_info_display(item))
     end, db[:info].map {|item| item['name']})
@@ -213,31 +205,28 @@ private
     display
   end
 
-  def hpg_client(url)
-    Heroku::Client::HerokuPostgresql.new(url)
+  def hpg_client(attachment)
+    Heroku::Client::HerokuPostgresql.new(attachment)
   end
 
   def hpg_databases_with_info
-    @hpg_databases_with_info ||= hpg_databases.inject({}) do |hash, (name, url)|
-      if name =~ /^SHARED_DATABASE/i
-        data = api.get_app(app).body
-        hash.update(name => {
-          :info => [{
-            'name'    => 'Data Size',
-            'values'  => [format_bytes(data['database_size'])]
-          }],
-          :url        => url
-        })
-      else
-        hash.update(name => hpg_info(url))
-      end
-    end
+    return @hpg_databases_with_info if @hpg_databases_with_info
+
+    @hpg_databases_with_info = Hash[ hpg_databases.map { |config, att| [att.display_name, hpg_info(att, options[:extended])] } ]
+
+    return @hpg_databases_with_info
   end
 
-  def hpg_info(url)
-    info = hpg_client(url).get_database
-    info[:url] = url
-    info
+  def hpg_info(attachment, extended=false)
+    if attachment.resource_name == "SHARED_DATABASE"
+      data = api.get_app(app).body
+      {:info => [{
+        'name'    => 'Data Size',
+        'values'  => [format_bytes(data['database_size'])]
+      }]}
+    else
+      hpg_client(attachment).get_database(extended)
+    end
   end
 
   def hpg_info_display(item)
@@ -260,13 +249,13 @@ private
     end
   end
 
-  def wait_for(db)
+  def wait_for(attach)
     ticking do |ticks|
-      status = hpg_client(db[:url]).get_wait_status
+      status = hpg_client(attach).get_wait_status
       error status[:message] if status[:error?]
       break if !status[:waiting?] && ticks.zero?
       redisplay("Waiting for database %s... %s%s" % [
-                  db[:pretty_name],
+                  attach.display_name,
                   status[:waiting?] ? "#{spinner(ticks)} " : "",
                   status[:message]],
                   !status[:waiting?]) # only display a newline on the last tick

data/lib/heroku/command/pgbackups.rb

@@ -67,12 +67,14 @@ module Heroku::Command
     #
     # if no DATABASE is specified, defaults to DATABASE_URL
     #
-    # -e, --expire  # if no slots are available to capture, destroy the oldest backup to make room
+    # -e, --expire  # if no slots are available, destroy the oldest manual backup to make room
     #
     def capture
-      from_name, from_url = hpg_resolve(shift_argument, "DATABASE_URL")
+      attachment = hpg_resolve(shift_argument, "DATABASE_URL")
       validate_arguments!
 
+      from_name = attachment.display_name
+      from_url  = attachment.url
       to_url    = nil # server will assign
       to_name   = "BACKUP"
 
@@ -103,13 +105,19 @@ module Heroku::Command
     #
     def restore
       if 0 == args.size
-        to_name, to_url = hpg_resolve(nil, "DATABASE_URL")
+        attachment = hpg_resolve(nil, "DATABASE_URL")
+        to_name = attachment.display_name
+        to_url  = attachment.url
         backup_id = :latest
       elsif 1 == args.size
-        to_name, to_url = hpg_resolve(shift_argument)
+        attachment = hpg_resolve(shift_argument)
+        to_name = attachment.display_name
+        to_url  = attachment.url
         backup_id = :latest
       else
-        to_name, to_url = hpg_resolve(shift_argument)
+        attachment = hpg_resolve(shift_argument)
+        to_name = attachment.display_name
+        to_url  = attachment.url
         backup_id = shift_argument
       end
 
@@ -195,6 +203,13 @@ module Heroku::Command
       pgbackup_client.create_transfer(from_url, from_name, to_url, to_name, opts)
     end
 
+    def poll_error(app)
+      error <<-EOM
+Failed to query the PGBackups status API. Your backup may still be running.
+Verify the status of your backup with `heroku pgbackups -a #{app}`
+      EOM
+    end
+
     def poll_transfer!(transfer)
       display "\n"
 
@@ -209,12 +224,17 @@ module Heroku::Command
         update_display(transfer)
         break if transfer["finished_at"]
 
-        attempts = 0
+        sleep_time = 1
         begin
-          sleep 1
+          sleep(sleep_time)
           transfer = pgbackup_client.get_transfer(transfer["id"])
-        rescue RestClient::ServiceUnavailable
-          (attempts += 1) <= 5 ? retry : raise
+        rescue RestClient::ServiceUnavailable, RestClient::ServerBrokeConnection
+          if sleep_time > 300
+            poll_error(app)
+          else
+            sleep_time *= 2
+            retry
+          end
         end
       end
 

data/lib/heroku/command/plugins.rb

@@ -48,7 +48,7 @@ module Heroku::Command
             exit(1)
           end
         else
-          error("Could not install #{plugin.name}. Please check the URL and try again")
+          error("Could not install #{plugin.name}. Please check the URL and try again.")
         end
       end
     end

data/lib/heroku/command/run.rb

@@ -125,7 +125,9 @@ protected
       rendezvous.start
     rescue Timeout::Error
       error "\nTimeout awaiting process"
-    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, OpenSSL::SSL::SSLError
+    rescue OpenSSL::SSL::SSLError
+      error "Authentication error"
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET
       error "\nError connecting to process"
     rescue Interrupt
     ensure

data/lib/heroku/command/status.rb

@@ -38,7 +38,7 @@ class Heroku::Command::Status < Heroku::Command::Base
         styled_header("#{issue['title']}  #{duration}")
         changes = issue['updates'].map do |issue|
           [
-            time_ago(Time.now - Time.parse(issue['created_at'])),
+            time_ago(issue['created_at']),
             issue['update_type'],
             issue['contents']
           ]

data/lib/heroku/excon.rb

@@ -0,0 +1,9 @@
+module Excon
+
+  def self.get_with_redirect(url, options={})
+    res = Excon.get(url, options)
+    return self.get_with_redirect(res.headers["Location"], options) if res.status == 302
+    res
+  end
+
+end

data/lib/heroku/helpers.rb

@@ -25,6 +25,10 @@ module Heroku
         $stdout.flush
       end
     end
+    
+    def host_name
+      'Pogoapp'
+    end
 
     def redisplay(line, line_break = false)
       display("\r\e[0K#{line}", line_break)

data/lib/heroku/helpers/heroku_postgresql.rb

@@ -5,27 +5,78 @@ module Heroku::Helpers::HerokuPostgresql
   extend self
   extend Heroku::Helpers
 
-  def app_config_vars
-    @app_config_vars ||= api.get_config_vars(app).body
+  class Attachment
+    attr_reader :config_var, :resource_name, :url, :addon, :plan
+    def initialize(raw)
+      @raw = raw
+      @config_var    = raw['config_var']
+      @resource_name = raw['resource']['name']
+      @url           = raw['resource']['value']
+      @addon, @plan  = raw['resource']['type'].split(':')
+    end
+
+    def starter_plan?
+      plan =~ /dev|basic/
+    end
+
+    def display_name
+      config_var + (primary_attachment? ? " (DATABASE_URL)"  : '')
+    end
+
+    def primary_attachment!
+      @primary_attachment = true
+    end
+
+    def primary_attachment?
+      @primary_attachment
+    end
   end
 
   def hpg_addon_name
-    ENV['HEROKU_POSTGRESQL_ADDON_NAME'] || 'heroku-postgresql'
+    if ENV['SHOGUN']
+      "shogun-#{ENV['SHOGUN']}"
+    else
+      ENV['HEROKU_POSTGRESQL_ADDON_NAME'] || 'heroku-postgresql'
+    end
   end
 
-  def hpg_addon_prefix
-    ENV["HEROKU_POSTGRESQL_ADDON_PREFIX"] || "HEROKU_POSTGRESQL"
+  def app_config_vars
+    @app_config_vars ||= api.get_config_vars(app).body
+  end
+
+  def app_attachments
+    @app_attachments ||= api.get_attachments(app).body.map { |raw| Attachment.new(raw) }
   end
 
   def hpg_databases
-    @hpg_databases ||= app_config_vars.inject({}) do |hash, (name, url)|
-      if name =~ /^(#{hpg_addon_prefix}\w+)_URL$/
-        hash.update($1 => url)
-      elsif name == 'SHARED_DATABASE_URL'
-        hash.update('SHARED_DATABASE' => url)
-      end
-      hash
+    return @hpg_databases if @hpg_databases
+    pairs = app_attachments.select {|att|
+        att.addon == hpg_addon_name
+      }.map { |att|
+        [att.config_var, att]
+      }
+    @hpg_databases = Hash[ pairs ]
+
+    if find_database_url_real_attachment
+      @hpg_databases['DATABASE_URL'] = find_database_url_real_attachment
     end
+
+    if app_config_vars['SHARED_DATABASE_URL']
+      @hpg_databases['SHARED_DATABASE'] = Attachment.new({
+        'config_var' => 'SHARED_DATABASE',
+        'resource' => {
+            'name'  => 'SHARED_DATABASE',
+            'value' => app_config_vars['SHARED_DATABASE_URL'],
+            'type'  => 'shared:database'
+          }
+        })
+    end
+
+    return @hpg_databases
+  end
+
+  def resource_url(resource)
+    api.get_resource(resource).body['value']
   end
 
   def forget_config!
@@ -33,32 +84,47 @@ module Heroku::Helpers::HerokuPostgresql
     @app_config_vars = nil
   end
 
-  def hpg_resolve(name, default=nil)
-    uri = URI.parse(name) rescue nil
-    if uri && uri.scheme
-      [nil, name]
+  def find_database_url_real_attachment
+    primary_db_url = app_config_vars['DATABASE_URL']
+    return unless primary_db_url
+
+    real_config = app_config_vars.detect {|k,v| k != 'DATABASE_URL' && v == primary_db_url }
+    if real_config
+      real = hpg_databases[real_config.first]
+      real.primary_attachment! if real
+      return real
     else
-      if app_config_vars["DATABASE_URL"]
-        hpg_databases["DATABASE"] = app_config_vars["DATABASE_URL"]
-      end
-      if hpg_databases.empty?
-        error("Your app has no databases.")
-      end
+      return nil
+    end
+  end
 
-      name = name.to_s.upcase.gsub(/_URL$/, "")
-
-      if hpg_databases[name]
-        [hpg_pretty_name(name), hpg_databases[name]]
-      elsif (config_var = "HEROKU_POSTGRESQL_#{name}") && hpg_databases[config_var]
-        [hpg_pretty_name(config_var), hpg_databases[config_var]]
-      elsif default && name.empty? && app_config_vars[default]
-        [hpg_pretty_name(default), app_config_vars[default]]
-      elsif name.empty?
-        error("Unknown database. Valid options are: #{hpg_databases.keys.sort.join(", ")}")
-      else
-        error("Unknown database: #{name}. Valid options are: #{hpg_databases.keys.sort.join(", ")}")
-      end
+  def match_attachments_by_name(name)
+     return [] if name.empty?
+     return [name] if hpg_databases[name]
+     hpg_databases.keys.grep(%r{#{ name }}i)
+  end
+
+  def hpg_resolve(name, default=nil)
+    name = '' if name.nil?
+    name = 'DATABASE_URL' if name == 'DATABASE'
+
+    if hpg_databases.empty?
+      error("Your app has no databases.")
     end
+
+    found_attachment = nil
+    canidates = match_attachments_by_name(name)
+    if default && name.empty? && app_config_vars[default]
+      found_attachment = hpg_databases[default]
+    elsif canidates.size == 1
+      found_attachment = hpg_databases[canidates.first]
+    end
+
+    if found_attachment.nil?
+      error("Unknown database#{': ' + name unless name.empty?}. Valid options are: #{hpg_databases.keys.sort.join(", ")}")
+    end
+
+    return found_attachment
   end
 
   def hpg_translate_fork_and_follow(addon, config)
@@ -68,35 +134,23 @@ module Heroku::Helpers::HerokuPostgresql
           unless val.is_a?(String)
             error("--#{opt} requires a database argument")
           end
-          name, url = hpg_resolve(val)
-          config[opt] = url
-        end
-      end
-    end
-  end
 
-  private
-
-  def hpg_pretty_name(name)
-    if ['DATABASE', 'DATABASE_URL'].include?(name)
-      if key = app_config_vars.keys.detect do |key|
-          if key == 'DATABASE_URL'
-            next
+          uri = URI.parse(val) rescue nil
+          if uri && uri.scheme
+            argument_url = uri.to_s
           else
-            app_config_vars[key] == app_config_vars['DATABASE_URL']
+            attachment = hpg_resolve(val)
+            argument_url = attachment.url
           end
+
+          config[opt] = argument_url
         end
-        "#{key.gsub(/_URL$/, '')} (DATABASE_URL)"
-      else
-        name.gsub(/_URL$/, '')
       end
-    elsif hpg_databases[name] == hpg_databases['DATABASE']
-      "#{name} (DATABASE_URL)"
-    else
-      name
     end
   end
 
+  private
+
   def hpg_promote(url)
     api.put_config_vars(app, "DATABASE_URL" => url)
   end