azuki 0.0.1

data/lib/azuki/command/labs.rb

@@ -0,0 +1,147 @@
+require "azuki/command/base"
+
+# manage optional features
+#
+class Azuki::Command::Labs < Azuki::Command::Base
+
+  # labs
+  #
+  # list experimental features
+  #
+  #Example:
+  #
+  # === User Features (david@azukiapp.com)
+  # [+] dashboard  Use Azuki Dashboard by default
+  #
+  # === App Features (glacial-retreat-5913)
+  # [ ] preboot            Provide seamless web dyno deploys
+  # [ ] user-env-compile   Add user config vars to the environment during slug compilation  # $ azuki labs -a example
+  #
+  def index
+    validate_arguments!
+
+    user_features, app_features = api.get_features(app).body.sort_by do |feature|
+      feature["name"]
+    end.partition do |feature|
+      feature["kind"] == "user"
+    end
+
+    display_app = app || "no app specified"
+
+    styled_header "User Features (#{Azuki::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
+  #
+  #Example:
+  #
+  # $ azuki labs:info user_env_compile
+  # === user_env_compile
+  # Docs:    http://devcenter.azukiapp.com/articles/labs-user-env-compile
+  # Summary: Add user config vars to the environment during slug compilation
+  #
+  def info
+    unless feature_name = shift_argument
+      error("Usage: azuki labs:info FEATURE\nMust specify FEATURE for info.")
+    end
+    validate_arguments!
+
+    feature_data = api.get_feature(feature_name, app).body
+    styled_header(feature_data['name'])
+    styled_hash({
+      'Summary' => feature_data['summary'],
+      'Docs'    => feature_data['docs']
+    })
+  end
+
+  # labs:disable FEATURE
+  #
+  # disables an experimental feature
+  #
+  #Example:
+  #
+  # $ azuki labs:disable ninja-power
+  # Disabling ninja-power feature for me@example.org... done
+  #
+  def disable
+    feature_name = shift_argument
+    error "Usage: azuki labs:disable FEATURE\nMust specify FEATURE to disable." unless feature_name
+    validate_arguments!
+
+    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 #{Azuki::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 an experimental feature
+  #
+  #Example:
+  #
+  # $ azuki labs:enable ninja-power
+  # Enabling ninja-power feature for me@example.org... done
+  #
+  def enable
+    feature_name = shift_argument
+    error "Usage: azuki labs:enable FEATURE\nMust specify FEATURE to enable." unless feature_name
+    validate_arguments!
+
+    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 #{Azuki::Auth.user}"
+    else
+      error "Must specify an app" unless app
+      message += "for #{app}"
+    end
+
+    feature_data = action(message) do
+      api.post_feature(feature_name, app).body
+    end
+
+    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
+    super
+  rescue Azuki::Command::CommandFailed
+    nil
+  end
+
+  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
+
+end

data/lib/azuki/command/logs.rb

@@ -0,0 +1,45 @@
+require "azuki/command/base"
+require "azuki/helpers/log_displayer"
+
+# display logs for an app
+#
+class Azuki::Command::Logs < Azuki::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:
+  #
+  # $ azuki logs
+  # 2012-01-01T12:00:00+00:00 azuki[api]: Config add EXAMPLE by email@example.com
+  # 2012-01-01T12:00:01+00:00 azuki[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]
+
+    log_displayer = ::Azuki::Helpers::LogDisplayer.new(azuki, app, opts)
+    log_displayer.display_logs
+  end
+
+  # logs:drains
+  #
+  # DEPRECATED: use `azuki drains`
+  #
+  def drains
+    # deprecation notice added 09/30/2011
+    display("~ `azuki logs:drains` has been deprecated and replaced with `azuki drains`")
+    Azuki::Command::Drains.new.index
+  end
+end

data/lib/azuki/command/maintenance.rb

@@ -0,0 +1,61 @@
+require "azuki/command/base"
+
+# manage maintenance mode for an app
+#
+class Azuki::Command::Maintenance < Azuki::Command::Base
+
+  # maintenance
+  #
+  # display the current maintenance status of app
+  #
+  #Example:
+  #
+  # $ azuki 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:
+  #
+  # $ azuki maintenance:on
+  # Enabling maintenance mode for example
+  #
+  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:
+  #
+  # $ azuki maintenance:off
+  # Disabling maintenance mode for example
+  #
+  def off
+    validate_arguments!
+
+    action("Disabling maintenance mode for #{app}") do
+      api.post_app_maintenance(app, '0')
+    end
+  end
+
+end

data/lib/azuki/command/pg.rb

@@ -0,0 +1,269 @@
+require "azuki/client/azuki_postgresql"
+require "azuki/command/base"
+require "azuki/helpers/azuki_postgresql"
+
+# manage azuki-postgresql databases
+#
+class Azuki::Command::Pg < Azuki::Command::Base
+
+  include Azuki::Helpers::AzukiPostgresql
+
+  # pg
+  #
+  # List databases for an app
+  #
+  def index
+    validate_arguments!
+
+    if hpg_databases_with_info.empty?
+      display("#{app} has no azuki-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]
+  #
+  #   -x, --extended  # Show extended information
+  #
+  # Display database information
+  #
+  # If DATABASE is not specified, displays all databases
+  #
+  def info
+    db = shift_argument
+    validate_arguments!
+
+    if db
+      attachment = hpg_resolve(db)
+      display_db attachment.display_name, hpg_info(attachment, options[:extended])
+    else
+      index
+    end
+  end
+
+  # pg:promote DATABASE
+  #
+  # Sets DATABASE as your DATABASE_URL
+  #
+  def promote
+    unless db = shift_argument
+      error("Usage: azuki pg:promote DATABASE\nMust specify DATABASE to promote.")
+    end
+    validate_arguments!
+
+    attachment = hpg_resolve(db)
+
+    action "Promoting #{attachment.display_name} to DATABASE_URL" do
+      hpg_promote(attachment.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
+    attachment = hpg_resolve(shift_argument, "DATABASE_URL")
+    validate_arguments!
+
+    uri = URI.parse( attachment.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.azukiapp.com/articles/local-postgresql"
+      abort
+    end
+  end
+
+  # pg:reset DATABASE
+  #
+  # Delete all data in DATABASE
+  #
+  def reset
+    unless db = shift_argument
+      error("Usage: azuki pg:reset DATABASE\nMust specify DATABASE to reset.")
+    end
+    validate_arguments!
+
+    attachment = hpg_resolve(db) unless db == "SHARED_DATABASE"
+    return unless confirm_command
+
+    if db == "SHARED_DATABASE"
+      action("Resetting SHARED_DATABASE") { azuki.database_reset(app) }
+    else
+      action("Resetting #{attachment.display_name}") do
+        hpg_client(attachment).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: azuki pg:unfollow REPLICA\nMust specify REPLICA to unfollow.")
+    end
+    validate_arguments!
+
+    replica = hpg_resolve(db)
+    replica_info = hpg_info(replica)
+
+    unless replica_info[:following]
+      error("#{replica.display_name} is not following another database.")
+    end
+    origin_url = replica_info[:following]
+    origin_name = database_name_from_url(origin_url)
+
+    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 #{replica.display_name}" do
+      hpg_client(replica).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_resolve(db)
+    else
+      hpg_databases.values.each do |attach|
+        wait_for(attach)
+      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: azuki pg:credentials DATABASE\nMust specify DATABASE to display credentials.")
+    end
+    validate_arguments!
+
+    attachment = hpg_resolve(db)
+
+    if options[:reset]
+      action "Resetting credentials for #{attachment.display_name}" do
+        hpg_client(attachment).rotate_credentials
+      end
+      if attachment.primary_attachment?
+        forget_config!
+        attachment = hpg_resolve(db)
+        action "Promoting #{attachment.display_name}" do
+          hpg_promote(attachment.url)
+        end
+      end
+    else
+      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\""
+      display "Connection URL:"
+      display "    " + attachment.url
+
+    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)
+    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']})
+
+    display
+  end
+
+  def hpg_client(attachment)
+    Azuki::Client::AzukiPostgresql.new(attachment)
+  end
+
+  def hpg_databases_with_info
+    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(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)
+    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(attach)
+    ticking do |ticks|
+      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" % [
+                  attach.display_name,
+                  status[:waiting?] ? "#{spinner(ticks)} " : "",
+                  status[:message]],
+                  !status[:waiting?]) # only display a newline on the last tick
+      break unless status[:waiting?]
+    end
+  end
+
+end