pogo 2.31.2 → 2.32.14

data/bin/pogo

@@ -2,10 +2,10 @@
 # encoding: UTF-8
 
 # pogo defaults
-ENV['HEROKU_HOST']        ||= 'http://api.pogoapp.com'
-ENV['HEROKU_STATUS_HOST'] ||= 'http://status.pogoapp.com'
-ENV['HEROKU_SSL_VERIFY']  ||= 'disable'
-ENV['HEROKU_GIT_HOST']    ||= 'git-i.pogoapp.com'
+ENV['HEROKU_HOST']        ||= 'pogoapp.com'
+ENV['HEROKU_STATUS_HOST'] ||= 'status.pogoapp.com'
+ENV['HEROKU_GIT_HOST']    ||= 'git.pogoapp.com'
+ENV['HEROKU_SSL_VERIFY']  ||= 'disable' # StartCom cert + RestClient = :(
 
 # resolve bin path, ignoring symlinks
 require "pathname"
@@ -19,4 +19,5 @@ Heroku::Updater.disable("`heroku update` is only available from Heroku Toolbelt.
 
 # start up the CLI
 require "heroku/cli"
+Heroku.user_agent = "heroku-gem/#{Heroku::VERSION} (#{RUBY_PLATFORM}) ruby/#{RUBY_VERSION}"
 Heroku::CLI.start(*ARGV)

data/lib/heroku.rb

@@ -4,19 +4,14 @@ require "heroku/version"
 
 module Heroku
 
-  USER_AGENT = 'legacy' # left for backwards compatibility with old toolbelt bin files
+  USER_AGENT = "heroku-gem/#{Heroku::VERSION} (#{RUBY_PLATFORM}) ruby/#{RUBY_VERSION}"
 
   def self.user_agent
-    type = if ENV['GEM_HOME'] && __FILE__.include?(ENV['GEM_HOME'])
-      'gem'
-    else
-      'toolbelt'
-    end
-    user_agent = "heroku-#{type}/#{Heroku::Updater.latest_local_version} (#{RUBY_PLATFORM}) ruby/#{RUBY_VERSION}"
-    if Heroku::Updater.autoupdate?
-      user_agent << ' autoupdate'
-    end
-    user_agent
+    @@user_agent ||= USER_AGENT
+  end
+
+  def self.user_agent=(agent)
+    @@user_agent = agent
   end
 
 end

data/lib/heroku/auth.rb

@@ -178,7 +178,7 @@ class Heroku::Auth
     end
 
     def ask_for_credentials
-      puts "Enter your Heroku credentials."
+      puts "Enter your #{host_name} credentials."
 
       print "Email: "
       user = ask
@@ -300,12 +300,29 @@ class Heroku::Auth
       @login_attempts < 3
     end
 
+    def verified_hosts
+      %w( heroku.com heroku-shadow.com )
+    end
+
+    def base_host(host)
+      URI.parse(full_host(host)).host.split(".")[-2..-1].join(".")
+    end
+
+    def full_host(host)
+      (host =~ /^http/) ? host : "https://api.#{host}"
+    end
+
+    def verify_host?(host)
+      hostname = base_host(host)
+      verified = verified_hosts.include?(hostname)
+      verified = false if ENV["HEROKU_SSL_VERIFY"] == "disable"
+      verified
+    end
+
     protected
 
     def default_params
-      full_host  = (host =~ /^http/) ? host : "https://api.#{host}"
-      verify_ssl = ENV['HEROKU_SSL_VERIFY'] != 'disable' && full_host =~ %r|^https://api.heroku.com|
-      uri = URI(full_host)
+      uri = URI.parse(full_host(host))
       {
         :headers          => {
           'User-Agent'    => Heroku.user_agent
@@ -313,7 +330,7 @@ class Heroku::Auth
         :host             => uri.host,
         :port             => uri.port.to_s,
         :scheme           => uri.scheme,
-        :ssl_verify_peer  => verify_ssl
+        :ssl_verify_peer  => verify_host?(host)
       }
     end
   end

data/lib/heroku/client/heroku_postgresql.rb

@@ -1,51 +1,81 @@
 require "heroku/client"
-require "digest/sha2"
 
 class Heroku::Client::HerokuPostgresql
-  Version = 10
+  Version = 11
 
   include Heroku::Helpers
 
-  def initialize(url)
+  @headers = { :x_heroku_gem_version  => Heroku::Client.version }
+
+  def self.add_headers(headers)
+    @headers.merge! headers
+  end
+
+  def self.headers
+    @headers
+  end
+
+  attr_reader :attachment
+  def initialize(attachment)
+    @attachment = attachment
+    if attachment.resource_name == 'SHARED_DATABASE'
+      error('This command is not available for shared database')
+    end
     require 'rest_client'
-    @heroku_postgresql_host = ENV["HEROKU_POSTGRESQL_HOST"] || "https://shogun.heroku.com"
-    @database_sha = sha(url)
-    @heroku_postgresql_resource = RestClient::Resource.new(
-      "#{@heroku_postgresql_host}/client/v10/databases",
-      :headers =>  { :x_heroku_gem_version  => Heroku::Client.version }
+  end
+
+  def heroku_postgresql_host
+    if attachment.starter_plan?
+      ENV["HEROKU_POSTGRESQL_HOST"] || "postgres-starter-api"
+    else
+      if ENV['SHOGUN']
+        "shogun-#{ENV['SHOGUN']}"
+      else
+        ENV["HEROKU_POSTGRESQL_HOST"] || "postgres-api"
+      end
+    end
+  end
+
+  def resource_name
+    attachment.resource_name
+  end
+
+  def heroku_postgresql_resource
+    RestClient::Resource.new(
+      "https://#{heroku_postgresql_host}.heroku.com/client/v11/databases",
+      :user => Heroku::Auth.user,
+      :password => Heroku::Auth.password,
+      :headers => self.class.headers
       )
   end
 
   def ingress
-    http_put "#{@database_sha}/ingress"
+    http_put "#{resource_name}/ingress"
   end
 
   def reset
-    http_put "#{@database_sha}/reset"
+    http_put "#{resource_name}/reset"
   end
 
   def rotate_credentials
-    http_post "#{@database_sha}/credentials_rotation"
+    http_post "#{resource_name}/credentials_rotation"
   end
 
-  def get_database
-    http_get @database_sha
+  def get_database(extended=false)
+    query = extended ? '?extended=true' : ''
+    http_get resource_name + query
   end
 
   def get_wait_status
-    http_get "#{@database_sha}/wait_status"
+    http_get "#{resource_name}/wait_status"
   end
 
   def unfollow
-    http_put "#{@database_sha}/unfollow"
+    http_put "#{resource_name}/unfollow"
   end
 
   protected
 
-  def sha(url)
-    Digest::SHA2.hexdigest url
-  end
-
   def sym_keys(c)
     if c.is_a?(Array)
       c.map { |e| sym_keys(e) }
@@ -77,7 +107,7 @@ class Heroku::Client::HerokuPostgresql
   def http_get(path)
     checking_client_version do
       retry_on_exception(RestClient::Exception) do
-        response = @heroku_postgresql_resource[path].get
+        response = heroku_postgresql_resource[path].get
         display_heroku_warning response
         sym_keys(json_decode(response.to_s))
       end
@@ -86,7 +116,7 @@ class Heroku::Client::HerokuPostgresql
 
   def http_post(path, payload = {})
     checking_client_version do
-      response = @heroku_postgresql_resource[path].post(json_encode(payload))
+      response = heroku_postgresql_resource[path].post(json_encode(payload))
       display_heroku_warning response
       sym_keys(json_decode(response.to_s))
     end
@@ -94,7 +124,7 @@ class Heroku::Client::HerokuPostgresql
 
   def http_put(path, payload = {})
     checking_client_version do
-      response = @heroku_postgresql_resource[path].put(json_encode(payload))
+      response = heroku_postgresql_resource[path].put(json_encode(payload))
       display_heroku_warning response
       sym_keys(json_decode(response.to_s))
     end

data/lib/heroku/client/rendezvous.rb

@@ -1,6 +1,7 @@
 require "timeout"
 require "socket"
 require "uri"
+require "heroku/auth"
 require "heroku/client"
 require "heroku/helpers"
 
@@ -29,10 +30,12 @@ class Heroku::Client::Rendezvous
 
     ssl_socket = Timeout.timeout(connect_timeout) do
       ssl_context = OpenSSL::SSL::SSLContext.new
-      if ((host =~ /heroku\.com$/) && !(ENV["HEROKU_SSL_VERIFY"] == "disable"))
-        ssl_context.ca_file = File.expand_path("../../../../data/cacert.pem", __FILE__)
+
+      if Heroku::Auth.verify_host?(host)
+        ssl_context.ca_file     = File.expand_path("../../../../data/cacert.pem", __FILE__)
         ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
       end
+
       tcp_socket = TCPSocket.open(host, port)
       ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
       ssl_socket.connect

data/lib/heroku/command.rb

@@ -115,20 +115,12 @@ module Heroku
       if args.include?('-h') || args.include?('--help')
         args.unshift(cmd) unless cmd =~ /^-.*/
         cmd = 'help'
-        command = parse('help')
+        command = parse(cmd)
       end
 
-      unless command
-        if cmd == '--version'
-          cmd = 'version'
-          command = parse(cmd)
-        else
-          error([
-            "`#{cmd}` is not a heroku command.",
-            suggestion(cmd, commands.keys + command_aliases.keys),
-            "See `heroku help` for a list of available commands."
-          ].compact.join("\n"))
-        end
+      if cmd == '--version'
+        cmd = 'version'
+        command = parse(cmd)
       end
 
       @current_command = cmd
@@ -141,7 +133,7 @@ module Heroku
         # remove OptionParsers Officious['version'] to avoid conflicts
         # see: https://github.com/ruby/ruby/blob/trunk/lib/optparse.rb#L814
         parser.base.long.delete('version')
-        (global_options + command[:options]).each do |option|
+        (global_options + (command && command[:options] || [])).each do |option|
           parser.on(*option[:args]) do |value|
             if option[:proc]
               option[:proc].call(value)
@@ -173,16 +165,39 @@ module Heroku
       @current_options = opts
       @invalid_arguments = invalid_options
 
-      command_instance = command[:klass].new(args.dup, opts.dup)
-
       @anonymous_command = [ARGV.first, *@anonymized_args].join(' ')
-
-      if !@normalized_args.include?('--app _') && (implied_app = command_instance.app rescue nil)
-        @normalized_args << '--app _'
+      begin
+        usage_directory = "#{home_directory}/.heroku/usage"
+        FileUtils.mkdir_p(usage_directory)
+        usage_file = usage_directory << "/#{Heroku::VERSION}"
+        usage = if File.exists?(usage_file)
+          json_decode(File.read(usage_file))
+        else
+          {}
+        end
+        usage[@anonymous_command] ||= 0
+        usage[@anonymous_command] += 1
+        File.write(usage_file, json_encode(usage) + "\n")
+      rescue
+        # usage writing is not important, allow failures
       end
-      @normalized_command = [ARGV.first, @normalized_args.sort_by {|arg| arg.gsub('-', '')}].join(' ')
 
-      [ command_instance, command[:method] ]
+      if command
+        command_instance = command[:klass].new(args.dup, opts.dup)
+
+        if !@normalized_args.include?('--app _') && (implied_app = command_instance.app rescue nil)
+          @normalized_args << '--app _'
+        end
+        @normalized_command = [ARGV.first, @normalized_args.sort_by {|arg| arg.gsub('-', '')}].join(' ')
+
+        [ command_instance, command[:method] ]
+      else
+        error([
+          "`#{cmd}` is not a heroku command.",
+          suggestion(cmd, commands.keys + command_aliases.keys),
+          "See `heroku help` for a list of available commands."
+        ].compact.join("\n"))
+      end
     end
 
     def self.run(cmd, arguments=[])
@@ -233,6 +248,12 @@ module Heroku
       error e.message
     rescue OptionParser::ParseError
       commands[cmd] ? run("help", [cmd]) : run("help")
+    rescue Excon::Errors::SocketError => e
+      if e.message == 'getaddrinfo: nodename nor servname provided, or not known (SocketError)'
+        error("Unable to connect to Heroku API, please check internet connectivity and try again.")
+      else
+        raise(e)
+      end
     ensure
       display_warnings
     end
@@ -242,7 +263,7 @@ module Heroku
     end
 
     def self.extract_error(body, options={})
-      default_error = block_given? ? yield : "Internal server error.\nRun 'heroku status' to check for known platform issues."
+      default_error = block_given? ? yield : "Internal server error.\nRun `heroku status` to check for known platform issues."
       parse_error_xml(body) || parse_error_json(body) || parse_error_plain(body) || default_error
     end
 

data/lib/heroku/command/apps.rb

@@ -175,7 +175,7 @@ class Heroku::Command::Apps < Heroku::Command::Base
   # $ heroku apps:create myapp-staging --remote staging
   #
   def create
-    name    = shift_argument || options[:app]
+    name    = shift_argument || options[:app] || ENV['HEROKU_APP']
     validate_arguments!
 
     info    = api.post_app({ "name" => name, "stack" => options[:stack] }).body
@@ -206,7 +206,7 @@ class Heroku::Command::Apps < Heroku::Command::Base
 
       hputs([ info["web_url"], info["git_url"] ].join(" | "))
     rescue Timeout::Error
-      hputs("Timed Out! Check heroku status for known issues.")
+      hputs("Timed Out! Run `heroku status` to check for known platform issues.")
     end
 
     unless options[:no_remote].is_a? FalseClass

data/lib/heroku/command/labs.rb

@@ -4,29 +4,39 @@ require "heroku/command/base"
 #
 class Heroku::Command::Labs < Heroku::Command::Base
 
-  # labs [APP]
+  # labs
   #
-  # lists enabled features for an app
+  # list experimental features
   #
   #Example:
   #
-  # $ heroku labs -a myapp
-  # === myapp Enabled Features
-  # sigterm-all: When stopping a dyno, send SIGTERM to all processes rather than only to the root process.
+  # === User Features (david@heroku.com)
+  # [+] dashboard  Use Heroku Dashboard by default
   #
-  # === email@example.com Enabled Features
-  # sumo-rankings: Heroku Sumo ranks and visualizes the scale of your app, and suggests the optimum combination of dynos and add-ons to take it to the next level.
+  # === App Features (glacial-retreat-5913)
+  # [ ] preboot            Provide seamless web dyno deploys
+  # [ ] user-env-compile   Add user config vars to the environment during slug compilation  # $ heroku labs -a myapp
   #
   def index
     validate_arguments!
 
-    if app
-      display_features(app, 'enabled', { 'enabled' => true, 'kind' => 'app' })
+    user_features, app_features = api.get_features(app).body.sort_by do |feature|
+      feature["name"]
+    end.partition do |feature|
+      feature["kind"] == "user"
     end
 
-    display_features(Heroku::Auth.user, 'enabled', { 'enabled' => true, 'kind' => 'user' })
+    display_app = app || "no app specified"
+
+    styled_header "User Features (#{Heroku::Auth.user})"
+    display_features user_features
+    display
+    styled_header "App Features (#{display_app})"
+    display_features app_features
   end
 
+  alias_command "labs:list", "labs"
+
   # labs:info FEATURE
   #
   # displays additional information about FEATURE
@@ -54,107 +64,83 @@ class Heroku::Command::Labs < Heroku::Command::Base
 
   # labs:disable FEATURE
   #
-  # disables FEATURE on an app
+  # disables an experimental feature
   #
   #Example:
   #
-  # $ heroku labs:disable user_env_compile
-  # Disabling user_env_compile for myapp... done
+  # $ heroku labs:disable ninja-power
+  # Disabling ninja-power feature for me@example.org... done
   #
   def disable
-    unless feature_name = shift_argument
-      error("Usage: heroku labs:disable FEATURE\nMust specify FEATURE to disable.")
-    end
+    feature_name = shift_argument
+    error "Usage: heroku labs:disable FEATURE\nMust specify FEATURE to disable." unless feature_name
     validate_arguments!
 
-    message = "Disabling #{feature_name}"
-    message += " for #{app}" if app
-    action(message) do
-      api.delete_feature(feature_name, app)
+    feature = api.get_features(app).body.detect { |f| f["name"] == feature_name }
+    message = "Disabling #{feature_name} "
+
+    error "No such feature: #{feature_name}" unless feature
+
+    if feature["kind"] == "user"
+      message += "for #{Heroku::Auth.user}"
+    else
+      error "Must specify an app" unless app
+      message += "for #{app}"
+    end
+
+    action message do
+      api.delete_feature feature_name, app
     end
   end
 
   # labs:enable FEATURE
   #
-  # enables FEATURE on an app
+  # enables an experimental feature
   #
   #Example:
   #
-  # $ heroku labs:enable user_env_compile
-  # Enabling user_env_compile for myapp... done
-  # For more information see: http://devcenter.heroku.com/articles/labs-user-env-compile
+  # $ heroku labs:enable ninja-power
+  # Enabling ninja-power feature for me@example.org... done
   #
   def enable
-    unless feature_name = shift_argument
-      error("Usage: heroku labs:enable FEATURE\nMust specify FEATURE to enable.")
-    end
+    feature_name = shift_argument
+    error "Usage: heroku labs:enable FEATURE\nMust specify FEATURE to enable." unless feature_name
     validate_arguments!
 
-    message = "Enabling #{feature_name}"
-    message += " for #{app}" if app
-    feature_data = nil
-    action(message) do
-      feature_data = api.post_feature(feature_name, app).body
+    feature = api.get_features.body.detect { |f| f["name"] == feature_name }
+    message = "Enabling #{feature_name} "
+
+    error "No such feature: #{feature_name}" unless feature
+
+    if feature["kind"] == "user"
+      message += "for #{Heroku::Auth.user}"
+    else
+      error "Must specify an app" unless app
+      message += "for #{app}"
     end
-    display("WARNING: This feature is experimental and may change or be removed without notice.")
-    display("For more information see: #{feature_data['docs']}")
-  end
 
-  # labs:list
-  #
-  # lists available features
-  #
-  #Example:
-  #
-  # $ heroku labs:list
-  # === App Available Features
-  # dot-profile:      Source .profile during dyno startup
-  # preboot:          Provide seamless deploys by booting web dynos with new code before killing existing web dynos.
-  # user_env_compile: Add user config vars to the environment during slug compilation
-  #
-  # === User Available Features
-  # default-heroku-postgresql-dev: Use the new heroku-postgresql:dev add-on as the default database for Cedar apps.
-  #
-  def list
-    validate_arguments!
+    feature_data = action(message) do
+      api.post_feature(feature_name, app).body
+    end
 
-    display_features('App', 'available', { 'kind' => 'app' })
-    display_features('User', 'available', { 'kind' => 'user' })
+    display "WARNING: This feature is experimental and may change or be removed without notice."
+    display "For more information see: #{feature_data["docs"]}" if feature_data["docs"]
   end
 
 private
 
+  # app is not required for these commands, so rescue if there is none
   def app
-    # app is not required for these commands, so rescue if there is none
     super
   rescue Heroku::Command::CommandFailed
     nil
   end
 
-  def display_features(type, status, attributes)
-    @features ||= api.get_features(app).body
-
-    selected_features = @features.dup
-    attributes.each do |key, value|
-      selected_features = selected_features.select {|feature| feature[key] == value}
-    end
-
-    feature_hash = {}
-    selected_features.each do |feature|
-      feature_hash[feature['name']] = feature['summary']
-    end
-
-    if feature_hash.empty?
-      case status
-      when 'available'
-        display("There are no #{type} features available.")
-      when 'enabled'
-        display("#{type} has no enabled features.")
-      end
-    else
-      styled_header("#{type} #{status.capitalize} Features")
-      styled_hash(feature_hash)
-      display
+  def display_features(features)
+    longest_name = features.map { |f| f["name"].to_s.length }.sort.last
+    features.each do |feature|
+      toggle = feature["enabled"] ? "[+]" : "[ ]"
+      display "%s %-#{longest_name}s  %s" % [ toggle, feature["name"], feature["summary"] ]
     end
   end