azuki 0.0.1

data/lib/azuki/command/pgbackups.rb

@@ -0,0 +1,329 @@
+require "azuki/client/pgbackups"
+require "azuki/command/base"
+require "azuki/helpers/azuki_postgresql"
+
+module Azuki::Command
+
+  # manage backups of azuki postgresql databases
+  class Pgbackups < Base
+
+    include Azuki::Helpers::AzukiPostgresql
+
+    # 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'],
+          'status'      => transfer_status(t),
+          'size'        => t['size'],
+          'database'    => t['from_name']
+        }
+      }
+
+      if backups.empty?
+        no_backups_error!
+      else
+        display_table(
+          backups,
+          %w{ id created_at status size database },
+          ["ID", "Backup Time", "Status", "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, destroy the oldest manual backup to make room
+    #
+    def capture
+      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"
+
+      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 += "\nPlease run `azuki logs --ps pgbackups` for details."
+        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
+        attachment = hpg_resolve(nil, "DATABASE_URL")
+        to_name = attachment.display_name
+        to_url  = attachment.url
+        backup_id = :latest
+      elsif 1 == args.size
+        attachment = hpg_resolve(shift_argument)
+        to_name = attachment.display_name
+        to_url  = attachment.url
+        backup_id = :latest
+      else
+        attachment = hpg_resolve(shift_argument)
+        to_name = attachment.display_name
+        to_url  = attachment.url
+        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."
+          if restore['log'] =~ /Invalid dump format: .*: XML  document text/
+            message += "\nThe backup url is invalid. Use `pgbackups:url` to generate a new temporary URL."
+          else
+            message += "\nPlease run `azuki logs --ps pgbackups` for details."
+          end
+          error(message)
+        end
+      end
+    end
+
+    # pgbackups:destroy BACKUP_ID
+    #
+    # destroys a backup
+    #
+    def destroy
+      unless name = shift_argument
+        error("Usage: azuki 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 transfer_status(t)
+      if t['finished_at']
+        "Finished @ #{t["finished_at"]}"
+      elsif t['started_at']
+        step = t['progress'] && t['progress'].split[0]
+        step.nil? ? 'Unknown' : step_map[step]
+      else
+        "Unknown"
+      end
+    end
+
+    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:\nazuki addons:add pgbackups") unless pgbackups_url
+      @pgbackup_client ||= Azuki::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_error(app)
+      error <<-EOM
+Failed to query the PGBackups status API. Your backup may still be running.
+Verify the status of your backup with `azuki pgbackups -a #{app}`
+You can also watch progress with `azuki logs --tail --ps pgbackups -a #{app}`
+      EOM
+    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"]
+
+        sleep_time = 1
+        begin
+          sleep(sleep_time)
+          transfer = pgbackup_client.get_transfer(transfer["id"])
+        rescue
+          if sleep_time > 300
+            poll_error(app)
+          else
+            sleep_time *= 2
+            retry
+          end
+        end
+      end
+
+      display "\n"
+
+      return transfer
+    end
+
+    def step_map
+      @step_map ||= {
+        "dump"      => "Capturing",
+        "upload"    => "Storing",
+        "download"  => "Retrieving",
+        "restore"   => "Restoring",
+        "gunzip"    => "Uncompressing",
+        "load"      => "Restoring",
+      }
+    end
+
+    def update_display(transfer)
+      @ticks            ||= 0
+      @last_updated_at  ||= 0
+      @last_logs        ||= []
+      @last_progress    ||= ["", 0]
+
+      @ticks += 1
+
+      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 `azuki 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

data/lib/azuki/command/plugins.rb

@@ -0,0 +1,110 @@
+require "azuki/command/base"
+
+module Azuki::Command
+
+  # manage plugins to the azuki gem
+  class Plugins < Base
+
+    # plugins
+    #
+    # list installed plugins
+    #
+    #Example:
+    #
+    # $ azuki plugins
+    # === Installed Plugins
+    # azuki-accounts
+    #
+    def index
+      validate_arguments!
+
+      plugins = ::Azuki::Plugin.list
+
+      if plugins.length > 0
+        styled_header("Installed Plugins")
+        styled_array(plugins)
+      else
+        display("You have no installed plugins.")
+      end
+    end
+
+    # plugins:install URL
+    #
+    # install a plugin
+    #
+    #Example:
+    #
+    # $ azuki plugins:install https://github.com/ddollar/azuki-accounts.git
+    # Installing azuki-accounts... done
+    #
+    def install
+      plugin = Azuki::Plugin.new(shift_argument)
+      validate_arguments!
+
+      action("Installing #{plugin.name}") do
+        if plugin.install
+          unless Azuki::Plugin.load_plugin(plugin.name)
+            plugin.uninstall
+            exit(1)
+          end
+        else
+          error("Could not install #{plugin.name}. Please check the URL and try again.")
+        end
+      end
+    end
+
+    # plugins:uninstall PLUGIN
+    #
+    # uninstall a plugin
+    #
+    #Example:
+    #
+    # $ azuki plugins:uninstall azuki-accounts
+    # Uninstalling azuki-accounts... done
+    #
+    def uninstall
+      plugin = Azuki::Plugin.new(shift_argument)
+      validate_arguments!
+
+      action("Uninstalling #{plugin.name}") do
+        plugin.uninstall
+      end
+    end
+
+    # plugins:update [PLUGIN]
+    #
+    # updates all plugins or a single plugin by name
+    #
+    #Example:
+    #
+    # $ azuki plugins:update
+    # Updating azuki-accounts... done
+    #
+    # $ azuki plugins:update azuki-accounts
+    # Updating azuki-accounts... done
+    #
+    def update
+      plugins = if plugin = shift_argument
+        [plugin]
+      else
+        ::Azuki::Plugin.list
+      end
+      validate_arguments!
+
+      plugins.each do |plugin|
+        begin
+          action("Updating #{plugin}") do
+            begin
+              Azuki::Plugin.new(plugin).update
+            rescue Azuki::Plugin::ErrorUpdatingSymlinkPlugin
+              status "skipped symlink"
+            end
+          end
+        rescue SystemExit
+          # ignore so that other plugins still update
+        end
+      end
+    end
+
+  end
+end

data/lib/azuki/command/ps.rb

@@ -0,0 +1,232 @@
+require "azuki/command/base"
+
+# manage processes (dynos, workers)
+#
+class Azuki::Command::Ps < Azuki::Command::Base
+
+  # ps:dynos [QTY]
+  #
+  # DEPRECATED: use `azuki ps:scale dynos=N`
+  #
+  # scale to QTY web processes
+  #
+  # if QTY is not specified, display the number of web processes currently running
+  #
+  #Example:
+  #
+  # $ azuki ps:dynos 3
+  # Scaling dynos... done, now running 3
+  #
+  def dynos
+    # deprecation notice added to v2.21.3 on 03/16/12
+    display("~ `azuki ps:dynos QTY` has been deprecated and replaced with `azuki ps:scale dynos=QTY`")
+
+    dynos = shift_argument
+    validate_arguments!
+
+    if dynos
+      action("Scaling dynos") do
+        new_dynos = api.put_dynos(app, dynos).body["dynos"]
+        status("now running #{new_dynos}")
+      end
+    else
+      app_data = api.get_app(app).body
+      if app_data["stack"] == "cedar"
+        raise(Azuki::Command::CommandFailed, "For Cedar apps, use `azuki ps`")
+      else
+        display("#{app} is running #{quantify("dyno", app_data["dynos"])}")
+      end
+    end
+  end
+
+  alias_command "dynos", "ps:dynos"
+
+  # ps:workers [QTY]
+  #
+  # DEPRECATED: use `azuki ps:scale workers=N`
+  #
+  # scale to QTY background processes
+  #
+  # if QTY is not specified, display the number of background processes currently running
+  #
+  #Example:
+  #
+  # $ azuki ps:dynos 3
+  # Scaling workers... done, now running 3
+  #
+  def workers
+    # deprecation notice added to v2.21.3 on 03/16/12
+    display("~ `azuki ps:workers QTY` has been deprecated and replaced with `azuki ps:scale workers=QTY`")
+
+    workers = shift_argument
+    validate_arguments!
+
+    if workers
+      action("Scaling workers") do
+        new_workers = api.put_workers(app, workers).body["workers"]
+        status("now running #{new_workers}")
+      end
+    else
+      app_data = api.get_app(app).body
+      if app_data["stack"] == "cedar"
+        raise(Azuki::Command::CommandFailed, "For Cedar apps, use `azuki ps`")
+      else
+        display("#{app} is running #{quantify("worker", app_data["workers"])}")
+      end
+    end
+  end
+
+  alias_command "workers", "ps:workers"
+
+  # ps
+  #
+  # list processes for an app
+  #
+  #Example:
+  #
+  # $ azuki ps
+  # === run: one-off processes
+  # run.1: up for 5m: `bash`
+  #
+  # === web: `bundle exec thin start -p $PORT`
+  # web.1: created for 30s
+  #
+  def index
+    validate_arguments!
+    processes = api.get_ps(app).body
+
+    processes_by_command = Hash.new {|hash,key| hash[key] = []}
+    processes.each do |process|
+      name    = process["process"].split(".").first
+      elapsed = time_ago(Time.now - process['elapsed'])
+
+      if name == "run"
+        key  = "run: one-off processes"
+        item = "%s: %s %s: `%s`" % [ process["process"], process["state"], elapsed, process["command"] ]
+      else
+        key  = "#{name}: `#{process["command"]}`"
+        item = "%s: %s %s" % [ process["process"], process["state"], elapsed ]
+      end
+
+      processes_by_command[key] << item
+    end
+
+    processes_by_command.keys.each do |key|
+      processes_by_command[key] = processes_by_command[key].sort do |x,y|
+        x.match(/\.(\d+):/).captures.first.to_i <=> y.match(/\.(\d+):/).captures.first.to_i
+      end
+    end
+
+    processes_by_command.keys.sort.each do |key|
+      styled_header(key)
+      styled_array(processes_by_command[key], :sort => false)
+    end
+  end
+
+  # ps:restart [PROCESS]
+  #
+  # restart an app process
+  #
+  # if PROCESS is not specified, restarts all processes on the app
+  #
+  #Examples:
+  #
+  # $ azuki ps:restart web.1
+  # Restarting web.1 process... done
+  #
+  # $ azuki ps:restart web
+  # Restarting web processes... done
+  #
+  # $ azuki ps:restart
+  # Restarting processes... done
+  #
+  def restart
+    process = shift_argument
+    validate_arguments!
+
+    message, options = case process
+    when NilClass
+      ["Restarting processes", {}]
+    when /.+\..+/
+      ps = args.first
+      ["Restarting #{ps} process", { :ps => ps }]
+    else
+      type = args.first
+      ["Restarting #{type} processes", { :type => type }]
+    end
+
+    action(message) do
+      api.post_ps_restart(app, options)
+    end
+  end
+
+  alias_command "restart", "ps:restart"
+
+  # ps:scale PROCESS1=AMOUNT1 [PROCESS2=AMOUNT2 ...]
+  #
+  # scale processes by the given amount
+  #
+  #Examples:
+  #
+  # $ azuki ps:scale web=3 worker+1
+  # Scaling web processes... done, now running 3
+  # Scaling worker processes... done, now running 1
+  #
+  def scale
+    changes = {}
+    args.each do |arg|
+      if arg =~ /^([a-zA-Z0-9_]+)([=+-]\d+)$/
+        changes[$1] = $2
+      end
+    end
+
+    if changes.empty?
+      error("Usage: azuki ps:scale PROCESS1=AMOUNT1 [PROCESS2=AMOUNT2 ...]\nMust specify PROCESS and AMOUNT to scale.")
+    end
+
+    changes.keys.sort.each do |process|
+      amount = changes[process]
+      action("Scaling #{process} processes") do
+        amount.gsub!("=", "")
+        new_qty = api.post_ps_scale(app, process, amount).body
+        status("now running #{new_qty}")
+      end
+    end
+  end
+
+  alias_command "scale", "ps:scale"
+
+  # ps:stop PROCESS
+  #
+  # stop an app process
+  #
+  # Examples:
+  #
+  # $ azuki stop run.3
+  # Stopping run.3 process... done
+  #
+  # $ azuki stop run
+  # Stopping run processes... done
+  #
+  def stop
+    process = shift_argument
+    validate_arguments!
+
+    message, options = case process
+    when NilClass
+      error("Usage: azuki ps:stop PROCESS\nMust specify PROCESS to stop.")
+    when /.+\..+/
+      ps = args.first
+      ["Stopping #{ps} process", { :ps => ps }]
+    else
+      type = args.first
+      ["Stopping #{type} processes", { :type => type }]
+    end
+
+    action(message) do
+      api.post_ps_stop(app, options)
+    end
+  end
+
+  alias_command "stop", "ps:stop"
+end