azuki 0.0.1

data/lib/azuki/command/fork.rb

@@ -0,0 +1,164 @@
+require "azuki/client/cisaurus"
+require "azuki/command/base"
+
+module Azuki::Command
+
+  # clone an existing app
+  #
+  class Fork < Base
+
+    # fork [NEWNAME]
+    #
+    # Fork an existing app -- copy config vars and Azuki Postgres data, and re-provision add-ons to a new app.
+    # New app name should not be an existing app. The new app will be created as part of the forking process.
+    #
+    # -s, --stack  STACK   # specify a stack
+    # --region REGION      # HIDDEN: specify a region
+    #
+    def index
+      
+      from = app
+      to = shift_argument || "#{from}-#{(rand*1000).to_i}"
+
+      from_info = api.get_app(from).body
+
+      to_info = action("Creating fork #{to}") do
+        api.post_app({
+          :name   => to,
+          :region => options[:region] || from_info["region"],
+          :stack  => options[:stack] || from_info["stack"],
+          :tier   => from_info["tier"] == "legacy" ? "production" : from_info["tier"]
+        }).body
+      end
+
+      action("Copying slug") do
+        job_location = cisaurus_client.copy_slug(from, to)
+        loop do
+          break if cisaurus_client.job_done?(job_location)
+          print "."
+          sleep 1
+        end
+      end
+
+      from_config = api.get_config_vars(from).body
+      from_addons = api.get_addons(from).body
+
+      from_addons.each do |addon|
+        print "Adding #{addon["name"]}... "
+        begin
+          to_addon = api.post_addon(to, addon["name"]).body
+          puts "done"
+        rescue Azuki::API::Errors::RequestFailed => ex
+          puts "skipped (%s)" % json_decode(ex.response.body)["error"]
+        rescue Azuki::API::Errors::NotFound
+          puts "skipped (not found)"
+        end
+        if addon["name"] =~ /^azuki-postgresql:/
+          from_var_name = "#{addon["attachment_name"]}_URL"
+          from_attachment = to_addon["message"].match(/Attached as (\w+)_URL\n/)[1]
+          if from_config[from_var_name] == from_config["DATABASE_URL"]
+            from_config["DATABASE_URL"] = api.get_config_vars(to).body["#{from_attachment}_URL"]
+          end
+          from_config.delete(from_var_name)
+
+          plan = addon["name"].split(":").last
+          unless %w(dev basic).include? plan
+            wait_for_db to, to_addon
+          end
+
+          check_for_pgbackups! from
+          check_for_pgbackups! to
+          migrate_db addon, from, to_addon, to
+        end
+      end
+
+      to_config = api.get_config_vars(to).body
+
+      action("Copying config vars") do
+        diff = from_config.inject({}) do |ax, (key, val)|
+          ax[key] = val unless to_config[key]
+          ax
+        end
+        api.put_config_vars to, diff
+      end
+
+      puts "Fork complete, view it at #{to_info['web_url']}"
+    end
+
+  private
+
+    def cisaurus_client
+      cisaurus_url = ENV["CISAURUS_HOST"] || "https://cisaurus.azukiapp.com"
+      @cisaurus_client ||= Azuki::Client::Cisaurus.new(cisaurus_url)
+    end
+
+    def check_for_pgbackups!(app)
+      unless api.get_addons(app).body.detect { |addon| addon["name"] =~ /^pgbackups:/ }
+        action("Adding pgbackups:plus to #{app}") do
+          api.post_addon app, "pgbackups:plus"
+        end
+      end
+    end
+
+    def migrate_db(from_addon, from, to_addon, to)
+      transfer = nil
+
+      action("Creating database backup from #{from}") do
+        from_config = api.get_config_vars(from).body
+        from_attachment = from_addon["attachment_name"]
+        pgb = Azuki::Client::Pgbackups.new(from_config["PGBACKUPS_URL"])
+        transfer = pgb.create_transfer(from_config["#{from_attachment}_URL"], from_attachment, nil, "BACKUP", :expire => "true")
+        error transfer["errors"].values.flatten.join("\n") if transfer["errors"]
+        loop do
+          transfer = pgb.get_transfer(transfer["id"])
+          error transfer["errors"].values.flatten.join("\n") if transfer["errors"]
+          break if transfer["finished_at"]
+          sleep 1
+          print "."
+        end
+        print " "
+      end
+
+      action("Restoring database backup to #{to}") do
+        to_config = api.get_config_vars(to).body
+        to_attachment = to_addon["message"].match(/Attached as (\w+)_URL\n/)[1]
+        pgb = Azuki::Client::Pgbackups.new(to_config["PGBACKUPS_URL"])
+        transfer = pgb.create_transfer(transfer["public_url"], "EXTERNAL_BACKUP", to_config["#{to_attachment}_URL"], to_attachment)
+        error transfer["errors"].values.flatten.join("\n") if transfer["errors"]
+        loop do
+          transfer = pgb.get_transfer(transfer["id"])
+          error transfer["errors"].values.flatten.join("\n") if transfer["errors"]
+          break if transfer["finished_at"]
+          sleep 1
+          print "."
+        end
+        print " "
+      end
+    end
+
+    def pg_api(starter=false)
+      host = starter ? "postgres-starter-api.azukiapp.com" : "postgres-api.azukiapp.com"
+      RestClient::Resource.new "https://#{host}/client/v11/databases", Azuki::Auth.user, Azuki::Auth.password
+    end
+
+    def wait_for_db(app, attachment)
+      attachments = api.get_attachments(app).body.inject({}) { |ax,att| ax.update(att["name"] => att["resource"]["name"]) }
+      attachment_name = attachment["message"].match(/Attached as (\w+)_URL\n/)[1]
+      action("Waiting for database to be ready") do
+        loop do
+          begin
+            waiting = json_decode(pg_api["#{attachments[attachment_name]}/wait_status"].get.to_s)["waiting?"]
+            break unless waiting
+            print "."
+            sleep 5
+          rescue RestClient::ResourceNotFound
+          rescue Interrupt
+            exit 0
+          end
+        end
+        print " "
+      end
+    end
+
+  end
+end

data/lib/azuki/command/git.rb

@@ -0,0 +1,64 @@
+require "azuki/command/base"
+
+# manage git for apps
+#
+class Azuki::Command::Git < Azuki::Command::Base
+
+  # git:clone APP [DIRECTORY]
+  #
+  # clones a azuki app to your local machine at DIRECTORY (defaults to app name)
+  #
+  # -r, --remote REMOTE  # the git remote to create, default "azuki"
+  #
+  #Examples:
+  #
+  # $ azuki git:clone example
+  # Cloning from app 'example'...
+  # Cloning into 'example'...
+  # remote: Counting objects: 42, done.
+  # ...
+  #
+  def clone
+    remote = options[:remote] || "azuki"
+
+    name = options[:app] || shift_argument || error("Usage: azuki git:clone APP [DIRECTORY]")
+    directory = shift_argument
+    validate_arguments!
+
+    git_url = api.get_app(name).body["git_url"]
+
+    puts "Cloning from app '#{name}'..."
+    system "git clone -o #{remote} #{git_url} #{directory}".strip
+  end
+
+  alias_command "clone", "git:clone"
+
+  # git:remote [OPTIONS]
+  #
+  # adds a git remote to an app repo
+  #
+  # if OPTIONS are specified they will be passed to git remote add
+  #
+  # -r, --remote REMOTE        # the git remote to create, default "azuki"
+  #
+  #Examples:
+  #
+  # $ azuki git:remote -a example
+  # Git remote azuki added
+  #
+  # $ azuki git:remote -a example
+  # !    Git remote azuki already exists
+  #
+  def remote
+    git_options = args.join(" ")
+    remote = options[:remote] || 'azuki'
+
+    if git('remote').split("\n").include?(remote)
+      error("Git remote #{remote} already exists")
+    else
+      app_data = api.get_app(app).body
+      create_git_remote(remote, app_data['git_url'])
+    end
+  end
+
+end

data/lib/azuki/command/help.rb

@@ -0,0 +1,179 @@
+require "azuki/command/base"
+require "azuki/deprecated/help"
+
+# list commands and display help
+#
+class Azuki::Command::Help < Azuki::Command::Base
+
+  PRIMARY_NAMESPACES = %w( auth apps ps run addons config releases domains logs sharing )
+
+  include Azuki::Deprecated::Help
+
+  # help [COMMAND]
+  #
+  # list available commands or display help for a specific command
+  #
+  #Examples:
+  #
+  # $ azuki help
+  # Usage: azuki COMMAND [--app APP] [command-specific-options]
+  #
+  # Primary help topics, type "azuki help TOPIC" for more details:
+  #
+  #   addons    #  manage addon resources
+  #   apps      #  manage apps (create, destroy)
+  #   ...
+  #
+  # Additional topics:
+  #
+  #   account      #  manage azuki account options
+  #   accounts     #  manage multiple azuki accounts
+  #   ...
+  #
+  # $ azuki help apps:create
+  # Usage: azuki 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
+  #  -r, --remote REMOTE        # the git remote to create, default "azuki"
+  #  -s, --stack STACK          # the stack on which to create the app
+  #
+  def index
+    if command = args.shift
+      help_for_command(command)
+    else
+      help_for_root
+    end
+  end
+
+  alias_command "-h", "help"
+  alias_command "--help", "help"
+
+private
+
+  def commands_for_namespace(name)
+    Azuki::Command.commands.values.select do |command|
+      command[:namespace] == name && command[:command] != name
+    end
+  end
+
+  def namespaces
+    namespaces = Azuki::Command.namespaces
+    namespaces.delete("app")
+    namespaces
+  end
+
+  def commands
+    Azuki::Command.commands
+  end
+
+  def legacy_help_for_namespace(namespace)
+    instance = Azuki::Command::Help.groups.map do |group|
+      [ group.title, group.select { |c| c.first =~ /^#{namespace}/ }.length ]
+    end.sort_by { |l| l.last }.last
+    return nil unless instance
+    return nil if instance.last.zero?
+    instance.first
+  end
+
+  def legacy_help_for_command(command)
+    Azuki::Command::Help.groups.each do |group|
+      group.each do |cmd, description|
+        return description if cmd.split(" ").first == command
+      end
+    end
+    nil
+  end
+
+  def skip_namespace?(ns)
+    return true if ns[:description] =~ /DEPRECATED:/
+    return true if ns[:description] =~ /HIDDEN:/
+    false
+  end
+
+  def skip_command?(command)
+    return true if command[:help] =~ /DEPRECATED:/
+    return true if command[:help] =~ /^ HIDDEN:/
+    false
+  end
+
+  def primary_namespaces
+    PRIMARY_NAMESPACES.map { |name| namespaces[name] }.compact
+  end
+
+  def additional_namespaces
+    (namespaces.values - primary_namespaces)
+  end
+
+  def summary_for_namespaces(namespaces)
+    size = longest(namespaces.map { |n| n[:name] })
+    namespaces.sort_by {|namespace| namespace[:name]}.each do |namespace|
+      next if skip_namespace?(namespace)
+      name = namespace[:name]
+      namespace[:description] ||= legacy_help_for_namespace(name)
+      puts "  %-#{size}s  # %s" % [ name, namespace[:description] ]
+    end
+  end
+
+  def help_for_root
+    puts "Usage: azuki COMMAND [--app APP] [command-specific-options]"
+    puts
+    puts "Primary help topics, type \"azuki help TOPIC\" for more details:"
+    puts
+    summary_for_namespaces(primary_namespaces)
+    puts
+    puts "Additional topics:"
+    puts
+    summary_for_namespaces(additional_namespaces)
+    puts
+  end
+
+  def help_for_namespace(name)
+    namespace_commands = commands_for_namespace(name)
+
+    unless namespace_commands.empty?
+      size = longest(namespace_commands.map { |c| c[:banner] })
+      namespace_commands.sort_by { |c| c[:banner].to_s }.each do |command|
+        next if skip_command?(command)
+        command[:summary] ||= legacy_help_for_command(command[:command])
+        puts "  %-#{size}s  # %s" % [ command[:banner], command[:summary] ]
+      end
+    end
+  end
+
+  def help_for_command(name)
+    if command_alias = Azuki::Command.command_aliases[name]
+      display("Alias: #{name} redirects to #{command_alias}")
+      name = command_alias
+    end
+    if command = commands[name]
+      puts "Usage: azuki #{command[:banner]}"
+
+      if command[:help].strip.length > 0
+        help = command[:help].split("\n").reject do |line|
+          line =~ /HIDDEN/
+        end
+        puts help[1..-1].join("\n")
+      else
+        puts
+        puts " " + legacy_help_for_command(name).to_s
+      end
+      puts
+    end
+
+    namespace_commands = commands_for_namespace(name).reject do |command|
+      command[:help] =~ /DEPRECATED/
+    end
+
+    if !namespace_commands.empty?
+      puts "Additional commands, type \"azuki help COMMAND\" for more details:"
+      puts
+      help_for_namespace(name)
+      puts
+    elsif command.nil?
+      error "#{name} is not a azuki command. See `azuki help`."
+    end
+  end
+end

data/lib/azuki/command/keys.rb

@@ -0,0 +1,115 @@
+require "azuki/command/base"
+
+module Azuki::Command
+
+  # manage authentication keys
+  #
+  class Keys < Base
+
+    # keys
+    #
+    # display keys for the current user
+    #
+    # -l, --long  # display extended information for each key
+    #
+    #Examples:
+    #
+    # $ azuki keys
+    # === email@example.com Keys
+    # ssh-rsa ABCDEFGHIJK...OPQRSTUV== email@example.com
+    #
+    # $ azuki keys --long
+    # === email@example.com Keys
+    # ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAp9AJD5QABmOcrkHm6SINuQkDefaR0MUrfgZ1Pxir3a4fM1fwa00dsUwbUaRuR7FEFD8n1E9WwDf8SwQTHtyZsJg09G9myNqUzkYXCmydN7oGr5IdVhRyv5ixcdiE0hj7dRnOJg2poSQ3Qi+Ka8SVJzF7nIw1YhuicHPSbNIFKi5s0D5a+nZb/E6MNGvhxoFCQX2IcNxaJMqhzy1ESwlixz45aT72mXYq0LIxTTpoTqma1HuKdRY8HxoREiivjmMQulYP+CxXFcMyV9kxTKIUZ/FXqlC6G5vSm3J4YScSatPOj9ID5HowpdlIx8F6y4p1/28r2tTl4CY40FFyoke4MQ== email@example.com
+    #
+    def index
+      validate_arguments!
+      keys = api.get_keys.body
+      if keys.length > 0
+        styled_header("#{Azuki::Auth.user} Keys")
+        keys = if options[:long]
+          keys.map {|key| key["contents"].strip}
+        else
+          keys.map {|key| format_key_for_display(key["contents"])}
+        end
+        styled_array(keys)
+      else
+        display("You have no keys.")
+      end
+    end
+
+    # keys:add [KEY]
+    #
+    # add a key for the current user
+    #
+    # if no KEY is specified, will try to find ~/.ssh/id_[rd]sa.pub
+    #
+    #Examples:
+    #
+    # $ azuki keys:add
+    # Could not find an existing public key.
+    # Would you like to generate one? [Yn] y
+    # Generating new SSH public key.
+    # Uploading SSH public key /.ssh/id_rsa.pub... done
+    #
+    # $ azuki keys:add /my/key.pub
+    # Uploading SSH public key /my/key.pub... done
+    #
+    def add
+      keyfile = shift_argument
+      validate_arguments!
+
+      if keyfile
+        Azuki::Auth.associate_key(keyfile)
+      else
+        # make sure we have credentials
+        Azuki::Auth.get_credentials
+        Azuki::Auth.associate_or_generate_ssh_key
+      end
+    end
+
+    # keys:remove KEY
+    #
+    # remove a key from the current user
+    #
+    #Examples:
+    #
+    # $ azuki keys:remove email@example.com
+    # Removing email@example.com SSH key... done
+    #
+    def remove
+      key = shift_argument
+      if key.nil? || key.empty?
+        error("Usage: azuki keys:remove KEY\nMust specify KEY to remove.")
+      end
+      validate_arguments!
+
+      action("Removing #{key} SSH key") do
+        api.delete_key(key)
+      end
+    end
+
+    # keys:clear
+    #
+    # remove all authentication keys from the current user
+    #
+    #Examples:
+    #
+    # $ azuki keys:clear
+    # Removing all SSH keys... done
+    #
+    def clear
+      validate_arguments!
+
+      action("Removing all SSH keys") do
+        api.delete_keys
+      end
+    end
+
+    protected
+      def format_key_for_display(key)
+        type, hex, local = key.strip.split(/\s/)
+        [type, hex[0,10] + '...' + hex[-10,10], local].join(' ')
+      end
+  end
+end