pogo 2.31.2

data/lib/heroku/command/logs.rb

@@ -0,0 +1,98 @@
+require "heroku/command/base"
+
+# display logs for an app
+#
+class Heroku::Command::Logs < Heroku::Command::Base
+
+  # logs
+  #
+  # display recent log output
+  #
+  # -n, --num NUM        # the number of lines to display
+  # -p, --ps PS          # only display logs from the given process
+  # -s, --source SOURCE  # only display logs from the given source
+  # -t, --tail           # continually stream logs
+  #
+  #Example:
+  #
+  # $ heroku logs
+  # 2012-01-01T12:00:00+00:00 heroku[api]: Config add EXAMPLE by email@example.com
+  # 2012-01-01T12:00:01+00:00 heroku[api]: Release v1 created by email@example.com
+  #
+  def index
+    validate_arguments!
+
+    opts = []
+    opts << "tail=1"                                 if options[:tail]
+    opts << "num=#{options[:num]}"                   if options[:num]
+    opts << "ps=#{URI.encode(options[:ps])}"         if options[:ps]
+    opts << "source=#{URI.encode(options[:source])}" if options[:source]
+
+    @assigned_colors = {}
+    @line_start = true
+    @token = nil
+
+    heroku.read_logs(app, opts) do |chunk|
+      unless chunk.empty?
+        if STDOUT.isatty && ENV.has_key?("TERM")
+          display(colorize(chunk))
+        else
+          display(chunk)
+        end
+      end
+    end
+  rescue Errno::EPIPE
+  rescue Interrupt => interrupt
+    if STDOUT.isatty && ENV.has_key?("TERM")
+      display("\e[0m")
+    end
+    raise(interrupt)
+  end
+
+  # logs:drains
+  #
+  # DEPRECATED: use `heroku drains`
+  #
+  def drains
+    # deprecation notice added 09/30/2011
+    display("~ `heroku logs:drains` has been deprecated and replaced with `heroku drains`")
+    Heroku::Command::Drains.new.index
+  end
+
+  protected
+
+  COLORS = %w( cyan yellow green magenta red )
+  COLOR_CODES = {
+    "red"     => 31,
+    "green"   => 32,
+    "yellow"  => 33,
+    "magenta" => 35,
+    "cyan"    => 36,
+  }
+
+  def colorize(chunk)
+    lines = []
+    chunk.split("\n").map do |line|
+      if parsed_line = parse_log(line)
+        header, identifier, body = parsed_line
+        @assigned_colors[identifier] ||= COLORS[@assigned_colors.size % COLORS.size]
+        lines << [
+          "\e[#{COLOR_CODES[@assigned_colors[identifier]]}m",
+          header,
+          "\e[0m",
+          body,
+        ].join("")
+      elsif not line.empty?
+        lines << line
+      end
+    end
+    lines.join("\n")
+  end
+
+  def parse_log(log)
+    return unless parsed = log.match(/^(.*\[(\w+)([\d\.]+)?\]:)(.*)?$/)
+    [1, 2, 4].map { |i| parsed[i] }
+  end
+
+end
+

data/lib/heroku/command/maintenance.rb

@@ -0,0 +1,61 @@
+require "heroku/command/base"
+
+# manage maintenance mode for an app
+#
+class Heroku::Command::Maintenance < Heroku::Command::Base
+
+  # maintenance
+  #
+  # display the current maintenance status of app
+  #
+  #Example:
+  #
+  # $ heroku maintenance
+  # off
+  #
+  def index
+    validate_arguments!
+
+    case api.get_app_maintenance(app).body['maintenance']
+    when true
+      display('on')
+    when false
+      display('off')
+    end
+  end
+
+  # maintenance:on
+  #
+  # put the app into maintenance mode
+  #
+  #Example:
+  #
+  # $ heroku maintenance:on
+  # Enabling maintenance mode for myapp
+  #
+  def on
+    validate_arguments!
+
+    action("Enabling maintenance mode for #{app}") do
+      api.post_app_maintenance(app, '1')
+    end
+  end
+
+  # maintenance:off
+  #
+  # take the app out of maintenance mode
+  #
+  #Example:
+  #
+  # $ heroku maintenance:off
+  # Disabling maintenance mode for myapp
+  #
+  def off
+    validate_arguments!
+
+    action("Disabling maintenance mode for #{app}") do
+      api.post_app_maintenance(app, '0')
+    end
+  end
+
+end

data/lib/heroku/command/pg.rb

@@ -0,0 +1,277 @@
+require "heroku/client/heroku_postgresql"
+require "heroku/command/base"
+require "heroku/helpers/heroku_postgresql"
+
+# manage heroku-postgresql databases
+#
+class Heroku::Command::Pg < Heroku::Command::Base
+
+  include Heroku::Helpers::HerokuPostgresql
+
+  # pg
+  #
+  # List databases for an app
+  #
+  def index
+    validate_arguments!
+
+    if hpg_databases_with_info.empty?
+      display("#{app} has no heroku-postgresql databases.")
+    else
+      hpg_databases_with_info.keys.sort.each do |name|
+        display_db name, hpg_databases_with_info[name]
+      end
+    end
+  end
+
+  # pg:info [DATABASE]
+  #
+  # Display database information
+  #
+  # If DATABASE is not specified, displays all databases
+  #
+  def info
+    db = shift_argument
+    validate_arguments!
+
+    if db
+      name, url = hpg_resolve(db)
+      display_db name, hpg_info(url)
+    else
+      index
+    end
+  end
+
+  # pg:promote DATABASE
+  #
+  # Sets DATABASE as your DATABASE_URL
+  #
+  def promote
+    unless db = shift_argument
+      error("Usage: heroku pg:promote DATABASE\nMust specify DATABASE to promote.")
+    end
+    validate_arguments!
+
+    name, url = hpg_resolve(db)
+    name ||= 'Custom URL'
+
+    action "Promoting #{name} to DATABASE_URL" do
+      hpg_promote(url)
+    end
+  end
+
+  # pg:psql [DATABASE]
+  #
+  # Open a psql shell to the database
+  #
+  # defaults to DATABASE_URL databases if no DATABASE is specified
+  #
+  def psql
+    name, url = hpg_resolve(shift_argument, "DATABASE_URL")
+    validate_arguments!
+
+    uri = URI.parse(url)
+    begin
+      ENV["PGPASSWORD"] = uri.password
+      ENV["PGSSLMODE"]  = 'require'
+      exec "psql -U #{uri.user} -h #{uri.host} -p #{uri.port || 5432} #{uri.path[1..-1]}"
+    rescue Errno::ENOENT
+      output_with_bang "The local psql command could not be located"
+      output_with_bang "For help installing psql, see http://devcenter.heroku.com/articles/local-postgresql"
+      abort
+    end
+  end
+
+  # pg:reset DATABASE
+  #
+  # Delete all data in DATABASE
+  #
+  def reset
+    unless db = shift_argument
+      error("Usage: heroku pg:reset DATABASE\nMust specify DATABASE to reset.")
+    end
+    validate_arguments!
+
+    name, url = hpg_resolve(db)
+    return unless confirm_command
+
+    action("Resetting #{name}") do
+      if name =~ /^SHARED_DATABASE/i
+        heroku.database_reset(app)
+      else
+        hpg_client(url).reset
+      end
+    end
+  end
+
+  # pg:unfollow REPLICA
+  #
+  # stop a replica from following and make it a read/write database
+  #
+  def unfollow
+    unless db = shift_argument
+      error("Usage: heroku pg:unfollow REPLICA\nMust specify REPLICA to unfollow.")
+    end
+    validate_arguments!
+
+    replica_name, replica_url = hpg_resolve(db)
+    replica = hpg_info(replica_url)
+
+    unless replica[:following]
+      error("#{replica_name} is not following another database.")
+    end
+    origin_url = replica[:following]
+    origin_name = database_name_from_url(origin_url)
+
+    output_with_bang "#{replica_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
+    end
+  end
+
+  # pg:wait [DATABASE]
+  #
+  # monitor database creation, exit when complete
+  #
+  # defaults to all databases if no DATABASE is specified
+  #
+  def wait
+    db = shift_argument
+    validate_arguments!
+
+    if db
+      wait_for hpg_info(hpg_resolve(db).last)
+    else
+      hpg_databases_with_info.keys.sort.each do |name|
+        unless name =~ /^SHARED_DATABASE/i
+          wait_for(hpg_databases_with_info[name])
+        end
+      end
+    end
+  end
+
+  # pg:credentials DATABASE
+  #
+  # Display the DATABASE credentials.
+  #
+  #   --reset  # Reset credentials on the specified database.
+  #
+  def credentials
+    unless db = shift_argument
+      error("Usage: heroku pg:credentials DATABASE\nMust specify DATABASE to display credentials.")
+    end
+    validate_arguments!
+
+    name, url = hpg_resolve(db)
+
+    url_is_database_url = (url == app_config_vars["DATABASE_URL"])
+
+    if options[:reset]
+      action "Resetting credentials for #{name}" do
+        hpg_client(url).rotate_credentials
+      end
+      if url_is_database_url
+        forget_config!
+        name, new_url = hpg_resolve(db)
+        action "Promoting #{name}" do
+          hpg_promote(new_url)
+        end
+      end
+    else
+      uri = URI.parse(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
+  end
+
+private
+
+  def database_name_from_url(url)
+    vars = app_config_vars.reject {|key,value| key == 'DATABASE_URL'}
+    if var = vars.invert[url]
+      var.gsub(/_URL$/, '')
+    else
+      uri = URI.parse(url)
+      "Database on #{uri.host}:#{uri.port || 5432}#{uri.path}"
+    end
+  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_hash(db[:info].inject({}) do |hash, item|
+      hash.update(item["name"] => hpg_info_display(item))
+    end, db[:info].map {|item| item['name']})
+
+    display
+  end
+
+  def hpg_client(url)
+    Heroku::Client::HerokuPostgresql.new(url)
+  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
+  end
+
+  def hpg_info(url)
+    info = hpg_client(url).get_database
+    info[:url] = url
+    info
+  end
+
+  def hpg_info_display(item)
+    item["values"] = [item["value"]] if item["value"]
+    item["values"].map do |value|
+      if item["resolve_db_name"]
+        database_name_from_url(value)
+      else
+        value
+      end
+    end
+  end
+
+  def ticking
+    ticks = 0
+    loop do
+      yield(ticks)
+      ticks +=1
+      sleep 1
+    end
+  end
+
+  def wait_for(db)
+    ticking do |ticks|
+      status = hpg_client(db[:url]).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],
+                  status[:waiting?] ? "#{spinner(ticks)} " : "",
+                  status[:message]],
+                  !status[:waiting?]) # only display a newline on the last tick
+      break unless status[:waiting?]
+    end
+  end
+
+end

data/lib/heroku/command/pgbackups.rb

@@ -0,0 +1,289 @@
+require "heroku/client/pgbackups"
+require "heroku/command/base"
+require "heroku/helpers/heroku_postgresql"
+
+module Heroku::Command
+
+  # manage backups of heroku postgresql databases
+  class Pgbackups < Base
+
+    include Heroku::Helpers::HerokuPostgresql
+
+    # pgbackups
+    #
+    # list captured backups
+    #
+    def index
+      validate_arguments!
+
+      backups = []
+      pgbackup_client.get_transfers.each { |t|
+        next unless backup_types.member?(t['to_name']) && !t['error_at'] && !t['destroyed_at']
+        backups << {
+          'id' => backup_name(t['to_url']),
+          'created_at' => t['created_at'],
+          'size' => t['size'],
+          'database' => t['from_name']
+        }
+      }
+
+      if backups.empty?
+        no_backups_error!
+      else
+        display_table(
+          backups,
+          %w{ id created_at size database },
+          ["ID", "Backup Time", "Size", "Database"]
+        )
+      end
+    end
+
+    # pgbackups:url [BACKUP_ID]
+    #
+    # get a temporary URL for a backup
+    #
+    def url
+      name = shift_argument
+      validate_arguments!
+
+      if name
+        b = pgbackup_client.get_backup(name)
+      else
+        b = pgbackup_client.get_latest_backup
+      end
+      unless b['public_url']
+        error("No backup found.")
+      end
+      if $stdout.isatty
+        display '"'+b['public_url']+'"'
+      else
+        display b['public_url']
+      end
+    end
+
+    # pgbackups:capture [DATABASE]
+    #
+    # capture a backup from a database id
+    #
+    # 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
+    #
+    def capture
+      from_name, from_url = hpg_resolve(shift_argument, "DATABASE_URL")
+      validate_arguments!
+
+      to_url    = nil # server will assign
+      to_name   = "BACKUP"
+
+      opts      = {:expire => options[:expire]}
+
+      backup = transfer!(from_url, from_name, to_url, to_name, opts)
+
+      to_uri = URI.parse backup["to_url"]
+      backup_id = to_uri.path.empty? ? "error" : File.basename(to_uri.path, '.*')
+      display "\n#{from_name}  ----backup--->  #{backup_id}"
+
+      backup = poll_transfer!(backup)
+
+      if backup["error_at"]
+        message  =   "An error occurred and your backup did not finish."
+        message += "\nThe database is not yet online. Please try again." if backup['log'] =~ /Name or service not known/
+        message += "\nThe database credentials are incorrect."           if backup['log'] =~ /psql: FATAL:/
+        error(message)
+      end
+    end
+
+    # pgbackups:restore [<DATABASE> [BACKUP_ID|BACKUP_URL]]
+    #
+    # restore a backup to a database
+    #
+    # if no DATABASE is specified, defaults to DATABASE_URL and latest backup
+    # if DATABASE is specified, but no BACKUP_ID, defaults to latest backup
+    #
+    def restore
+      if 0 == args.size
+        to_name, to_url = hpg_resolve(nil, "DATABASE_URL")
+        backup_id = :latest
+      elsif 1 == args.size
+        to_name, to_url = hpg_resolve(shift_argument)
+        backup_id = :latest
+      else
+        to_name, to_url = hpg_resolve(shift_argument)
+        backup_id = shift_argument
+      end
+
+      if :latest == backup_id
+        backup = pgbackup_client.get_latest_backup
+        no_backups_error! if {} == backup
+        to_uri = URI.parse backup["to_url"]
+        backup_id = File.basename(to_uri.path, '.*')
+        backup_id = "#{backup_id} (most recent)"
+        from_url  = backup["to_url"]
+        from_name = "BACKUP"
+      elsif backup_id =~ /^http(s?):\/\//
+        from_url  = backup_id
+        from_name = "EXTERNAL_BACKUP"
+        from_uri  = URI.parse backup_id
+        backup_id = from_uri.path.empty? ? from_uri : File.basename(from_uri.path)
+      else
+        backup = pgbackup_client.get_backup(backup_id)
+        abort("Backup #{backup_id} already destroyed.") if backup["destroyed_at"]
+
+        from_url  = backup["to_url"]
+        from_name = "BACKUP"
+      end
+
+      message = "#{to_name}  <---restore---  "
+      padding = " " * message.length
+      display "\n#{message}#{backup_id}"
+      if backup
+        display padding + "#{backup['from_name']}"
+        display padding + "#{backup['created_at']}"
+        display padding + "#{backup['size']}"
+      end
+
+      if confirm_command
+        restore = transfer!(from_url, from_name, to_url, to_name)
+        restore = poll_transfer!(restore)
+
+        if restore["error_at"]
+          message  =   "An error occurred and your restore did not finish."
+          message += "\nThe backup url is invalid. Use `pgbackups:url` to generate a new temporary URL." if restore['log'] =~ /Invalid dump format: .*: XML  document text/
+          error(message)
+        end
+      end
+    end
+
+    # pgbackups:destroy BACKUP_ID
+    #
+    # destroys a backup
+    #
+    def destroy
+      unless name = shift_argument
+        error("Usage: heroku pgbackups:destroy BACKUP_ID\nMust specify BACKUP_ID to destroy.")
+      end
+      backup = pgbackup_client.get_backup(name)
+      if backup["destroyed_at"]
+        error("Backup #{name} already destroyed.")
+      end
+
+      action("Destroying #{name}") do
+        pgbackup_client.delete_backup(name)
+      end
+    end
+
+    protected
+
+    def config_vars
+      @config_vars ||= api.get_config_vars(app).body
+    end
+
+    def pgbackup_client
+      pgbackups_url = ENV["PGBACKUPS_URL"] || config_vars["PGBACKUPS_URL"]
+      error("Please add the pgbackups addon first via:\nheroku addons:add pgbackups") unless pgbackups_url
+      @pgbackup_client ||= Heroku::Client::Pgbackups.new(pgbackups_url)
+    end
+
+    def backup_name(to_url)
+      # translate s3://bucket/email/foo/bar.dump => foo/bar
+      parts = to_url.split('/')
+      parts.slice(4..-1).join('/').gsub(/\.dump$/, '')
+    end
+
+    def transfer!(from_url, from_name, to_url, to_name, opts={})
+      pgbackup_client.create_transfer(from_url, from_name, to_url, to_name, opts)
+    end
+
+    def poll_transfer!(transfer)
+      display "\n"
+
+      if transfer["errors"]
+        transfer["errors"].values.flatten.each { |e|
+          output_with_bang "#{e}"
+        }
+        abort
+      end
+
+      while true
+        update_display(transfer)
+        break if transfer["finished_at"]
+
+        attempts = 0
+        begin
+          sleep 1
+          transfer = pgbackup_client.get_transfer(transfer["id"])
+        rescue RestClient::ServiceUnavailable
+          (attempts += 1) <= 5 ? retry : raise
+        end
+      end
+
+      display "\n"
+
+      return transfer
+    end
+
+    def update_display(transfer)
+      @ticks            ||= 0
+      @last_updated_at  ||= 0
+      @last_logs        ||= []
+      @last_progress    ||= ["", 0]
+
+      @ticks += 1
+
+      step_map = {
+        "dump"      => "Capturing",
+        "upload"    => "Storing",
+        "download"  => "Retrieving",
+        "restore"   => "Restoring",
+        "gunzip"    => "Uncompressing",
+        "load"      => "Restoring",
+      }
+
+      if !transfer["log"]
+        @last_progress = ['pending', nil]
+        redisplay "Pending... #{spinner(@ticks)}"
+      else
+        logs        = transfer["log"].split("\n")
+        new_logs    = logs - @last_logs
+        @last_logs  = logs
+
+        new_logs.each do |line|
+          matches = line.scan /^([a-z_]+)_progress:\s+([^ ]+)/
+          next if matches.empty?
+
+          step, amount = matches[0]
+
+          if ['done', 'error'].include? amount
+            # step is done, explicitly print result and newline
+            redisplay "#{@last_progress[0].capitalize}... #{amount}\n"
+          end
+
+          # store progress, last one in the logs will get displayed
+          step = step_map[step] || step
+          @last_progress = [step, amount]
+        end
+
+        step, amount = @last_progress
+        unless ['done', 'error'].include? amount
+          redisplay "#{step.capitalize}... #{amount} #{spinner(@ticks)}"
+        end
+      end
+    end
+
+    private
+
+    def no_backups_error!
+      error("No backups. Capture one with `heroku pgbackups:capture`.")
+    end
+
+    # lists all types of backups ('to_name' attribute)
+    #
+    # Useful when one doesn't care if a backup is of a particular
+    # kind, but wants to know what backups of any kind exist.
+    #
+    def backup_types
+      %w[BACKUP DAILY_SCHEDULED_BACKUP HOURLY_SCHEDULED_BACKUP AUTO_SCHEDULED_BACKUP]
+    end
+  end
+end