azuki 0.0.1

data/lib/azuki/command/account.rb

@@ -0,0 +1,23 @@
+require "azuki/command/base"
+
+# manage azuki account options
+#
+class Azuki::Command::Account < Azuki::Command::Base
+
+  # account:confirm_billing
+  #
+  # Confirm that your account can be billed at the end of the month
+  #
+  #Example:
+  #
+  # $ azuki account:confirm_billing
+  # This action will cause your account to be billed at the end of the month
+  # For more information, see http://docs.azukiapp.com/billing
+  # Are you sure you want to do this? (y/n)
+  #
+  def confirm_billing
+    validate_arguments!
+    Azuki::Helpers.confirm_billing
+  end
+
+end

data/lib/azuki/command/accounts.rb

@@ -0,0 +1,34 @@
+if Azuki::Plugin.list.include?('azuki-accounts')
+
+  require "azuki/command/base"
+
+  # manage multiple azuki accounts
+  #
+  class Azuki::Command::Accounts < Azuki::Command::Base
+
+    # accounts:default
+    # set a system-wide default account
+    def default
+      name = shift_argument
+      validate_arguments!
+
+      unless name
+        error("Please specify an account name.")
+      end
+
+      unless account_exists?(name)
+        error("That account does not exist.")
+      end
+
+      result = %x{ git config --global azuki.account #{name} }
+
+      # update netrc
+      Azuki::Auth.instance_variable_set(:@account, nil) # kill memoization
+      Azuki::Auth.credentials = [Azuki::Auth.user, Azuki::Auth.password]
+      Azuki::Auth.write_credentials
+
+      result
+    end
+
+  end
+end

data/lib/azuki/command/addons.rb

@@ -0,0 +1,305 @@
+require "azuki/command/base"
+require "azuki/helpers/azuki_postgresql"
+
+module Azuki::Command
+
+  # manage addon resources
+  #
+  class Addons < Base
+
+    include Azuki::Helpers::AzukiPostgresql
+
+    # addons
+    #
+    # list installed addons
+    #
+    def index
+      validate_arguments!
+
+      installed = api.get_addons(app).body
+      if installed.empty?
+        display("#{app} has no add-ons.")
+      else
+        available, pending = installed.partition { |a| a['configured'] }
+
+        unless available.empty?
+          styled_header("#{app} Configured Add-ons")
+          styled_array(available.map do |a|
+            [a['name'], a['attachment_name'] || '']
+          end)
+        end
+
+        unless pending.empty?
+          styled_header("#{app} Add-ons to Configure")
+          styled_array(pending.map do |a|
+            [a['name'], app_addon_url(a['name'])]
+          end)
+        end
+      end
+    end
+
+    # addons:list
+    #
+    # list all available addons
+    #
+    def list
+      addons = azuki.addons
+      if addons.empty?
+        display "No addons available currently"
+      else
+        partitioned_addons = partition_addons(addons)
+        partitioned_addons.each do |key, addons|
+          partitioned_addons[key] = format_for_display(addons)
+        end
+        display_object(partitioned_addons)
+      end
+    end
+
+    # addons:add ADDON
+    #
+    # install an addon
+    #
+    def add
+      configure_addon('Adding') do |addon, config|
+        azuki.install_addon(app, addon, config)
+      end
+    end
+
+    # addons:upgrade ADDON
+    #
+    # upgrade an existing addon
+    #
+    def upgrade
+      configure_addon('Upgrading to') do |addon, config|
+        azuki.upgrade_addon(app, addon, config)
+      end
+    end
+
+    # addons:downgrade ADDON
+    #
+    # downgrade an existing addon
+    #
+    def downgrade
+      configure_addon('Downgrading to') do |addon, config|
+        azuki.upgrade_addon(app, addon, config)
+      end
+    end
+
+    # addons:remove ADDON1 [ADDON2 ...]
+    #
+    # uninstall one or more addons
+    #
+    def remove
+      return unless confirm_command
+
+      args.each do |name|
+        messages = nil
+        action("Removing #{name} on #{app}") do
+          messages = addon_run { azuki.uninstall_addon(app, name, :confirm => app) }
+        end
+        display(messages[:attachment]) if messages[:attachment]
+        display(messages[:message]) if messages[:message]
+      end
+    end
+
+    # addons:docs ADDON
+    #
+    # open an addon's documentation in your browser
+    #
+    def docs
+      unless addon = shift_argument
+        error("Usage: azuki addons:docs ADDON\nMust specify ADDON to open docs for.")
+      end
+      validate_arguments!
+
+      addon_names = api.get_addons.body.map {|a| a['name']}
+      addon_types = addon_names.map {|name| name.split(':').first}.uniq
+
+      name_matches = addon_names.select {|name| name =~ /^#{addon}/}
+      type_matches = addon_types.select {|name| name =~ /^#{addon}/}
+
+      if name_matches.include?(addon) || type_matches.include?(addon)
+        type_matches = [addon]
+      end
+
+      case type_matches.length
+      when 0 then
+        error([
+          "`#{addon}` is not a azuki add-on.",
+          suggestion(addon, addon_names + addon_types),
+          "See `azuki addons:list` for all available addons."
+        ].compact.join("\n"))
+      when 1
+        addon_type = type_matches.first
+        launchy("Opening #{addon_type} docs", addon_docs_url(addon_type))
+      else
+        error("Ambiguous addon name: #{addon}\nPerhaps you meant #{name_matches[0...-1].map {|match| "`#{match}`"}.join(', ')} or `#{name_matches.last}`.\n")
+      end
+    end
+
+    # addons:open ADDON
+    #
+    # open an addon's dashboard in your browser
+    #
+    def open
+      unless addon = shift_argument
+        error("Usage: azuki addons:open ADDON\nMust specify ADDON to open.")
+      end
+      validate_arguments!
+
+      app_addons = api.get_addons(app).body.map {|a| a['name']}
+      matches = app_addons.select {|a| a =~ /^#{addon}/}.sort
+
+      case matches.length
+      when 0 then
+        addon_names = api.get_addons.body.map {|a| a['name']}
+        if addon_names.any? {|name| name =~ /^#{addon}/}
+          error("Addon not installed: #{addon}")
+        else
+          error([
+            "`#{addon}` is not a azuki add-on.",
+            suggestion(addon, addon_names + addon_names.map {|name| name.split(':').first}.uniq),
+            "See `azuki addons:list` for all available addons."
+          ].compact.join("\n"))
+        end
+      when 1 then
+        addon_to_open = matches.first
+        launchy("Opening #{addon_to_open} for #{app}", app_addon_url(addon_to_open))
+      else
+        error("Ambiguous addon name: #{addon}\nPerhaps you meant #{matches[0...-1].map {|match| "`#{match}`"}.join(', ')} or `#{matches.last}`.\n")
+      end
+    end
+
+    private
+
+    def addon_docs_url(addon)
+      "https://devcenter.#{azuki.host}/articles/#{addon.split(':').first}"
+    end
+
+    def app_addon_url(addon)
+      "https://api.#{azuki.host}/apps/#{app}/addons/#{addon}"
+    end
+
+    def partition_addons(addons)
+      addons.group_by{ |a| (a["state"] == "public" ? "available" : a["state"]) }
+    end
+
+    def format_for_display(addons)
+      grouped = addons.inject({}) do |base, addon|
+        group, short = addon['name'].split(':')
+        base[group] ||= []
+        base[group] << addon.merge('short' => short)
+        base
+      end
+      grouped.keys.sort.map do |name|
+        addons = grouped[name]
+        row = name.dup
+        if addons.any? { |a| a['short'] }
+          row << ':'
+          size = row.size
+          stop = false
+          row << addons.map { |a| a['short'] }.compact.sort.map do |short|
+            size += short.size
+            if size < 31
+              short
+            else
+              stop = true
+              nil
+            end
+          end.compact.join(', ')
+          row << '...' if stop
+        end
+        row
+      end
+    end
+
+    def addon_run
+      response = yield
+
+      if response
+        price = "(#{ response['price'] })" if response['price']
+
+        if response['message'] =~ /(Attached as [A-Z0-9_]+)\n(.*)/m
+          attachment = $1
+          message = $2
+        else
+          attachment = nil
+          message = response['message']
+        end
+
+        begin
+          release = api.get_release(app, 'current').body
+          release = release['name']
+        rescue Azuki::API::Errors::Error
+          release = nil
+        end
+      end
+
+      status [ release, price ].compact.join(' ')
+      { :attachment => attachment, :message => message }
+    rescue RestClient::ResourceNotFound => e
+      error Azuki::Command.extract_error(e.http_body) {
+        e.http_body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
+      }
+    rescue RestClient::Locked => ex
+      raise
+    rescue RestClient::RequestFailed => e
+      retry if e.http_code == 402 && confirm_billing
+      error Azuki::Command.extract_error(e.http_body)
+    end
+
+    def configure_addon(label, &install_or_upgrade)
+      addon = args.shift
+      raise CommandFailed.new("Missing add-on name") if addon.nil? || ["--fork", "--follow"].include?(addon)
+
+      config = parse_options(args)
+      config.merge!(:confirm => app) if app == options[:confirm]
+      raise CommandFailed.new("Unexpected arguments: #{args.join(' ')}") unless args.empty?
+
+      hpg_translate_fork_and_follow(addon, config)
+
+      messages = nil
+      action("#{label} #{addon} on #{app}") do
+        messages = addon_run { install_or_upgrade.call(addon, config) }
+      end
+      display(messages[:attachment]) unless messages[:attachment].to_s.strip == ""
+      display(messages[:message]) unless messages[:message].to_s.strip == ""
+
+      display("Use `azuki addons:docs #{addon}` to view documentation.")
+    end
+
+    #this will clean up when we officially deprecate
+    def parse_options(args)
+      config = {}
+      deprecated_args = []
+      flag = /^--/
+
+      args.size.times do
+        break if args.empty?
+        peek = args.first
+        next unless peek && (peek.match(flag) || peek.match(/=/))
+        arg  = args.shift
+        peek = args.first
+        key  = arg
+        if key.match(/=/)
+          deprecated_args << key unless key.match(flag)
+          key, value = key.split('=', 2)
+        elsif peek.nil? || peek.match(flag)
+          value = true
+        else
+          value = args.shift
+        end
+        value = true if value == 'true'
+        config[key.sub(flag, '')] = value
+
+        if !deprecated_args.empty?
+          out_string = deprecated_args.map{|a| "--#{a}"}.join(' ')
+          display("Warning: non-unix style params have been deprecated, use #{out_string} instead")
+        end
+      end
+
+      config
+    end
+
+  end
+end

data/lib/azuki/command/apps.rb

@@ -0,0 +1,393 @@
+require "azuki/command/base"
+
+# manage apps (create, destroy)
+#
+class Azuki::Command::Apps < Azuki::Command::Base
+
+  # apps
+  #
+  # list your apps
+  #
+  #Example:
+  #
+  # $ azuki apps
+  # === My Apps
+  # example
+  # example2
+  #
+  # === Collaborated Apps
+  # theirapp   other@owner.name
+  #
+  def index
+    validate_arguments!
+    apps = api.get_apps.body
+    unless apps.empty?
+      my_apps, collaborated_apps = apps.partition do |app|
+        app["owner_email"] == Azuki::Auth.user
+      end
+
+      unless my_apps.empty?
+        non_legacy_apps = my_apps.select do |app|
+          app["tier"] != "legacy"
+        end
+
+        unless non_legacy_apps.empty?
+          production_basic_apps, dev_legacy_apps = my_apps.partition do |app|
+            ["production", "basic"].include?(app["tier"])
+          end
+
+          unless production_basic_apps.empty?
+            styled_header("Basic & Production Apps")
+            styled_array(production_basic_apps.map { |app| regionized_app_name(app) })
+          end
+
+          unless dev_legacy_apps.empty?
+            styled_header("Dev & Legacy Apps")
+            styled_array(dev_legacy_apps.map { |app| regionized_app_name(app) })
+          end
+        else
+          styled_header("My Apps")
+          styled_array(my_apps.map { |app| regionized_app_name(app) })
+        end
+      end
+
+      unless collaborated_apps.empty?
+        styled_header("Collaborated Apps")
+        styled_array(collaborated_apps.map { |app| [regionized_app_name(app), app["owner_email"]] })
+      end
+    else
+      display("You have no apps.")
+    end
+  end
+
+  alias_command "list", "apps"
+
+  # apps:info
+  #
+  # show detailed app information
+  #
+  # -s, --shell  # output more shell friendly key/value pairs
+  #
+  #Examples:
+  #
+  # $ azuki apps:info
+  # === example
+  # Git URL:   git@azukiapp.com:example.git
+  # Repo Size: 5M
+  # ...
+  #
+  # $ azuki apps:info --shell
+  # git_url=git@azukiapp.com:example.git
+  # repo_size=5000000
+  # ...
+  #
+  def info
+    validate_arguments!
+    app_data = api.get_app(app).body
+
+    unless options[:shell]
+      styled_header(app_data["name"])
+    end
+
+    addons_data = api.get_addons(app).body.map {|addon| addon['name']}.sort
+    collaborators_data = api.get_collaborators(app).body.map {|collaborator| collaborator["email"]}.sort
+    collaborators_data.reject! {|email| email == app_data["owner_email"]}
+
+    if options[:shell]
+      if app_data['domain_name']
+        app_data['domain_name'] = app_data['domain_name']['domain']
+      end
+      unless addons_data.empty?
+        app_data['addons'] = addons_data.join(',')
+      end
+      unless collaborators_data.empty?
+        app_data['collaborators'] = collaborators_data.join(',')
+      end
+      app_data.keys.sort_by { |a| a.to_s }.each do |key|
+        hputs("#{key}=#{app_data[key]}")
+      end
+    else
+      data = {}
+
+      unless addons_data.empty?
+        data["Addons"] = addons_data
+      end
+
+      data["Collaborators"] = collaborators_data
+
+      if app_data["create_status"] && app_data["create_status"] != "complete"
+        data["Create Status"] = app_data["create_status"]
+      end
+
+      if app_data["cron_finished_at"]
+        data["Cron Finished At"] = format_date(app_data["cron_finished_at"])
+      end
+
+      if app_data["cron_next_run"]
+        data["Cron Next Run"] = format_date(app_data["cron_next_run"])
+      end
+
+      if app_data["database_size"]
+        data["Database Size"] = format_bytes(app_data["database_size"])
+      end
+
+      data["Git URL"] = app_data["git_url"]
+
+      if app_data["database_tables"]
+        data["Database Size"].gsub!('(empty)', '0K') + " in #{quantify("table", app_data["database_tables"])}"
+      end
+
+      if app_data["dyno_hours"].is_a?(Hash)
+        data["Dyno Hours"] = app_data["dyno_hours"].keys.map do |type|
+          "%s - %0.2f dyno-hours" % [ type.to_s.capitalize, app_data["dyno_hours"][type] ]
+        end
+      end
+
+      data["Owner Email"] = app_data["owner_email"]
+
+      if app_data["region"]
+        data["Region"] = app_data["region"]
+      end
+
+      if app_data["repo_size"]
+        data["Repo Size"] = format_bytes(app_data["repo_size"])
+      end
+
+      if app_data["slug_size"]
+        data["Slug Size"] = format_bytes(app_data["slug_size"])
+      end
+
+      data["Stack"] = app_data["stack"]
+      if data["Stack"] != "cedar"
+        data.merge!("Dynos" => app_data["dynos"], "Workers" => app_data["workers"])
+      end
+
+      data["Web URL"] = app_data["web_url"]
+
+      if app_data["tier"]
+        data["Tier"] = app_data["tier"].capitalize
+      end
+
+      styled_hash(data)
+    end
+  end
+
+  alias_command "info", "apps:info"
+
+  # apps:create [NAME]
+  #
+  # create a new app
+  #
+  #     --addons ADDONS        # a comma-delimited list of addons to install
+  # -b, --buildpack BUILDPACK  # a buildpack url to use for this app
+  # -n, --no-remote            # don't create a git remote
+  # -r, --remote REMOTE        # the git remote to create, default "azuki"
+  # -s, --stack STACK          # the stack on which to create the app
+  #     --region REGION        # HIDDEN: specify region for this app to run on
+  # -t, --tier TIER            # HIDDEN: the tier for this app
+  #
+  #Examples:
+  #
+  # $ azuki apps:create
+  # Creating floating-dragon-42... done, stack is cedar
+  # http://floating-dragon-42.azukiapp.com/ | git@azukiapp.com:floating-dragon-42.git
+  #
+  # $ azuki apps:create -s bamboo
+  # Creating floating-dragon-42... done, stack is bamboo-mri-1.9.2
+  # http://floating-dragon-42.azukiapp.com/ | git@azukiapp.com:floating-dragon-42.git
+  #
+  # # specify a name
+  # $ azuki apps:create example
+  # Creating example... done, stack is cedar
+  # http://example.azukiapp.com/ | git@azukiapp.com:example.git
+  #
+  # # create a staging app
+  # $ azuki apps:create example-staging --remote staging
+  #
+  def create
+    name    = shift_argument || options[:app] || ENV['AZUKI_APP']
+    validate_arguments!
+
+    info    = api.post_app({
+      "name" => name,
+      "region" => options[:region],
+      "stack" => options[:stack],
+      "tier" => options[:tier]
+    }).body
+    begin
+      action("Creating #{info['name']}") do
+        if info['create_status'] == 'creating'
+          Timeout::timeout(options[:timeout].to_i) do
+            loop do
+              break if api.get_app(info['name']).body['create_status'] == 'complete'
+              sleep 1
+            end
+          end
+        end
+        if info['region']
+          status("region is #{info['region']}")
+        else
+          status("stack is #{info['stack']}")
+        end
+      end
+
+      (options[:addons] || "").split(",").each do |addon|
+        addon.strip!
+        action("Adding #{addon} to #{info["name"]}") do
+          api.post_addon(info["name"], addon)
+        end
+      end
+
+      if buildpack = options[:buildpack]
+        api.put_config_vars(info["name"], "BUILDPACK_URL" => buildpack)
+        display("BUILDPACK_URL=#{buildpack}")
+      end
+
+      hputs([ info["web_url"], info["git_url"] ].join(" | "))
+    rescue Timeout::Error
+      hputs("Timed Out! Run `azuki status` to check for known platform issues.")
+    end
+
+    unless options[:no_remote].is_a? FalseClass
+      create_git_remote(options[:remote] || "azuki", info["git_url"])
+    end
+  end
+
+  alias_command "create", "apps:create"
+
+  # apps:rename NEWNAME
+  #
+  # rename the app
+  #
+  #Example:
+  #
+  # $ azuki apps:rename example-newname
+  # http://example-newname.azukiapp.com/ | git@azukiapp.com:example-newname.git
+  # Git remote azuki updated
+  #
+  def rename
+    newname = shift_argument
+    if newname.nil? || newname.empty?
+      error("Usage: azuki apps:rename NEWNAME\nMust specify NEWNAME to rename.")
+    end
+    validate_arguments!
+
+    action("Renaming #{app} to #{newname}") do
+      api.put_app(app, "name" => newname)
+    end
+
+    app_data = api.get_app(newname).body
+    hputs([ app_data["web_url"], app_data["git_url"] ].join(" | "))
+
+    if remotes = git_remotes(Dir.pwd)
+      remotes.each do |remote_name, remote_app|
+        next if remote_app != app
+        git "remote rm #{remote_name}"
+        git "remote add #{remote_name} #{app_data["git_url"]}"
+        hputs("Git remote #{remote_name} updated")
+      end
+    else
+      hputs("Don't forget to update your Git remotes on any local checkouts.")
+    end
+  end
+
+  alias_command "rename", "apps:rename"
+
+  # apps:open
+  #
+  # open the app in a web browser
+  #
+  #Example:
+  #
+  # $ azuki apps:open
+  # Opening example... done
+  #
+  def open
+    validate_arguments!
+
+    app_data = api.get_app(app).body
+    launchy("Opening #{app}", app_data['web_url'])
+  end
+
+  alias_command "open", "apps:open"
+
+  # apps:destroy
+  #
+  # permanently destroy an app
+  #
+  #Example:
+  #
+  # $ azuki apps:destroy -a example --confirm example
+  # Destroying example (including all add-ons)... done
+  #
+  def destroy
+    @app = shift_argument || options[:app] || options[:confirm]
+    validate_arguments!
+
+    unless @app
+      error("Usage: azuki apps:destroy --app APP\nMust specify APP to destroy.")
+    end
+
+    api.get_app(@app) # fail fast if no access or doesn't exist
+
+    message = "WARNING: Potentially Destructive Action\nThis command will destroy #{@app} (including all add-ons)."
+    if confirm_command(@app, message)
+      action("Destroying #{@app} (including all add-ons)") do
+        api.delete_app(@app)
+        if remotes = git_remotes(Dir.pwd)
+          remotes.each do |remote_name, remote_app|
+            next if @app != remote_app
+            git "remote rm #{remote_name}"
+          end
+        end
+      end
+    end
+  end
+
+  alias_command "destroy", "apps:destroy"
+  alias_command "apps:delete", "apps:destroy"
+
+  # apps:upgrade TIER
+  #
+  # HIDDEN: upgrade an app's pricing tier
+  #
+  def upgrade
+    tier = shift_argument
+    error("Usage: azuki apps:upgrade TIER\nMust specify TIER to upgrade.") if tier.nil? || tier.empty?
+    validate_arguments!
+
+    action("Upgrading #{app} to #{tier}") do
+      api.put_app(app, "tier" => tier)
+    end
+  end
+
+  alias_command "upgrade", "apps:upgrade"
+
+  # apps:downgrade TIER
+  #
+  # HIDDEN: downgrade an app's pricing tier
+  #
+  def downgrade
+    tier = shift_argument
+    error("Usage: azuki apps:downgrade TIER\nMust specify TIER to downgrade.") if tier.nil? || tier.empty?
+    validate_arguments!
+
+    action("Upgrading #{app} to #{tier}") do
+      api.put_app(app, "tier" => tier)
+    end
+  end
+
+  alias_command "downgrade", "apps:downgrade"
+
+  private
+
+  def regionized_app_name(app)
+    # temporary, show region for non-us apps
+    if app["region"] && app["region"] != 'us'
+      "#{app["name"]} (#{app["region"]})"
+    else
+      app["name"]
+    end
+  end
+
+end