azuki 0.0.1

data/lib/azuki/command/regions.rb

@@ -0,0 +1,22 @@
+require "azuki/command/base"
+
+# HIDDEN: get info on available regions
+#
+class Azuki::Command::Regions < Azuki::Command::Base
+
+  # regions
+  #
+  # HIDDEN: List available regions for deployment
+  #
+  #Example:
+  #
+  # $ azuki regions
+  # === Regions
+  # us
+  def index
+    regions = json_decode(azuki.get("/regions"))
+    styled_header("Regions")
+    styled_array(regions.map { |region| [region["slug"], region["name"]] })
+  end
+end
+

data/lib/azuki/command/releases.rb

@@ -0,0 +1,124 @@
+require "azuki/command/base"
+
+# manage app releases
+#
+class Azuki::Command::Releases < Azuki::Command::Base
+
+  # releases
+  #
+  # list releases
+  #
+  #Example:
+  #
+  # $ azuki releases
+  # === example Releases
+  # v1 Config add FOO_BAR by email@example.com 0s ago
+  # v2 Config add BAR_BAZ by email@example.com 0s ago
+  # v3 Config add BAZ_QUX by email@example.com 0s ago
+  #
+  def index
+    validate_arguments!
+
+    releases_data = api.get_releases(app).body.sort_by do |release|
+      release["name"][1..-1].to_i
+    end.reverse.slice(0, 15)
+
+    unless releases_data.empty?
+      releases = releases_data.map do |release|
+        [
+          release["name"],
+          truncate(release["descr"], 40),
+          release["user"],
+          time_ago(release['created_at'])
+        ]
+      end
+
+      styled_header("#{app} Releases")
+      styled_array(releases, :sort => false)
+    else
+      display("#{app} has no releases.")
+    end
+  end
+
+  # releases:info RELEASE
+  #
+  # view detailed information for a release
+  # find latest release details by passing 'current' as the release
+  #
+  # -s, --shell  # output config vars in shell format
+  #
+  #Example:
+  #
+  # $ azuki releases:info v10
+  # === Release v10
+  # Addons: deployhooks:http
+  # By:     email@example.com
+  # Change: deploy ABCDEFG
+  # When:   2012-01-01 12:00:00
+  #
+  # === v10 Config Vars
+  # EXAMPLE: foo
+  #
+  def info
+    unless release = shift_argument
+      error("Usage: azuki releases:info RELEASE")
+    end
+    validate_arguments!
+
+    release_data = api.get_release(app, release).body
+
+    data = {
+      'By'     => release_data['user'],
+      'Change' => release_data['descr'],
+      'When'   => time_ago(release_data["created_at"])
+    }
+
+    unless release_data['addons'].empty?
+      data['Addons'] = release_data['addons']
+    end
+
+    styled_header("Release #{release}")
+    styled_hash(data)
+
+    display
+
+    styled_header("#{release} Config Vars")
+    unless release_data['env'].empty?
+      if options[:shell]
+        release_data['env'].keys.sort.each do |key|
+          display("#{key}=#{release_data['env'][key]}")
+        end
+      else
+        styled_hash(release_data['env'])
+      end
+    else
+      display("#{release} has no config vars.")
+    end
+  end
+
+  # releases:rollback [RELEASE]
+  #
+  # roll back to an older release
+  #
+  # if RELEASE is not specified, will roll back one step
+  #
+  #Example:
+  #
+  # $ azuki releases:rollback
+  # Rolling back example... done, v122
+  #
+  # $ azuki releases:rollback v42
+  # Rolling back example to v42... done
+  #
+  def rollback
+    release = shift_argument
+    validate_arguments!
+
+    action("Rolling back #{app}") do
+      status(api.post_release(app, release).body)
+    end
+  end
+
+  alias_command "rollback", "releases:rollback"
+
+end

data/lib/azuki/command/run.rb

@@ -0,0 +1,180 @@
+require "readline"
+require "azuki/command/base"
+require "azuki/helpers/log_displayer"
+
+# run one-off commands (console, rake)
+#
+class Azuki::Command::Run < Azuki::Command::Base
+
+  # run COMMAND
+  #
+  # run an attached process
+  #
+  #Example:
+  #
+  # $ azuki run bash
+  # Running `bash` attached to terminal... up, run.1
+  # ~ $
+  #
+  def index
+    command = args.join(" ")
+    error("Usage: azuki run COMMAND") if command.empty?
+    run_attached(command)
+  end
+
+  # run:detached COMMAND
+  #
+  # run a detached process, where output is sent to your logs
+  #
+  # -t, --tail           # stream logs for the process
+  #
+  #Example:
+  #
+  # $ azuki run:detached ls
+  # Running `ls` detached... up, run.1
+  # Use `azuki logs -p run.1` to view the output.
+  #
+  def detached
+    command = args.join(" ")
+    error("Usage: azuki run COMMAND") if command.empty?
+    opts = { :attach => false, :command => command }
+    app_name = app
+    process_data = action("Running `#{command}` detached", :success => "up") do
+      process_data = api.post_ps(app_name, command, { :attach => false }).body
+      status(process_data['process'])
+      process_data
+    end
+    if options[:tail]
+      opts = []
+      opts << "tail=1"
+      opts << "ps=#{process_data['process']}"
+      log_displayer = ::Azuki::Helpers::LogDisplayer.new(azuki, app, opts)
+      log_displayer.display_logs
+    else
+      display("Use `azuki logs -p #{process_data['process']}` to view the output.")
+    end
+  end
+
+  # run:rake COMMAND
+  #
+  # WARNING: `azuki run:rake` has been deprecated. Please use `azuki run rake` instead."
+  #
+  # remotely execute a rake command
+  #
+  #Example:
+  #
+  # $ azuki run:rake -T
+  # Running `rake -T` attached to terminal... up, run.1
+  # (in /app)
+  # rake test  # run tests
+  #
+  def rake
+    deprecate("`azuki #{current_command}` has been deprecated. Please use `azuki run rake` instead.")
+    command = "rake #{args.join(' ')}"
+    run_attached(command)
+  end
+
+  alias_command "rake", "run:rake"
+
+  # run:console [COMMAND]
+  #
+  # open a remote console session
+  #
+  # if COMMAND is specified, run the command and exit
+  #
+  # NOTE: For Cedar apps, use `azuki run console`
+  #
+  #Examples:
+  #
+  # $ azuki console
+  # Ruby console for example.azukiapp.com
+  # >>
+  #
+  def console
+    puts "`azuki #{current_command}` has been removed. Please use: `azuki run` instead."
+    puts "For more information, please see:"
+    puts " * https://devcenter.azukiapp.com/articles/one-off-dynos"
+    puts " * https://devcenter.azukiapp.com/articles/rails3#console"
+    puts " * https://devcenter.azukiapp.com/articles/console-bamboo"
+  end
+  alias_command "console", "run:console"
+
+protected
+
+  def run_attached(command)
+    app_name = app
+    process_data = action("Running `#{command}` attached to terminal", :success => "up") do
+      process_data = api.post_ps(app_name, command, { :attach => true, :ps_env => get_terminal_environment }).body
+      status(process_data["process"])
+      process_data
+    end
+    rendezvous_session(process_data["rendezvous_url"])
+  end
+
+  def rendezvous_session(rendezvous_url, &on_connect)
+    begin
+      set_buffer(false)
+      rendezvous = Azuki::Client::Rendezvous.new(
+        :rendezvous_url => rendezvous_url,
+        :connect_timeout => (ENV["AZUKI_CONNECT_TIMEOUT"] || 120).to_i,
+        :activity_timeout => nil,
+        :input => $stdin,
+        :output => $stdout)
+      rendezvous.on_connect(&on_connect)
+      rendezvous.start
+    rescue Timeout::Error
+      error "\nTimeout awaiting process"
+    rescue OpenSSL::SSL::SSLError
+      error "Authentication error"
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET
+      error "\nError connecting to process"
+    rescue Interrupt
+    ensure
+      set_buffer(true)
+    end
+  end
+
+  def console_history_dir
+    FileUtils.mkdir_p(path = "#{home_directory}/.azuki/console_history")
+    path
+  end
+
+  def console_session(app)
+    azuki.console(app) do |console|
+      console_history_read(app)
+
+      display "Ruby console for #{app}.#{azuki.host}"
+      while cmd = Readline.readline('>> ')
+        unless cmd.nil? || cmd.strip.empty?
+          console_history_add(app, cmd)
+          break if cmd.downcase.strip == 'exit'
+          display console.run(cmd)
+        end
+      end
+    end
+  end
+
+  def console_history_file(app)
+    "#{console_history_dir}/#{app}"
+  end
+
+  def console_history_read(app)
+    history = File.read(console_history_file(app)).split("\n")
+    if history.size > 50
+      history = history[(history.size - 51),(history.size - 1)]
+      File.open(console_history_file(app), "w") { |f| f.puts history.join("\n") }
+    end
+    history.each { |cmd| Readline::HISTORY.push(cmd) }
+  rescue Errno::ENOENT
+  rescue Exception => ex
+    display "Error reading your console history: #{ex.message}"
+    if confirm("Would you like to clear it? (y/N):")
+      FileUtils.rm(console_history_file(app)) rescue nil
+    end
+  end
+
+  def console_history_add(app, cmd)
+    Readline::HISTORY.push(cmd)
+    File.open(console_history_file(app), "a") { |f| f.puts cmd + "\n" }
+  end
+end

data/lib/azuki/command/sharing.rb

@@ -0,0 +1,89 @@
+require "azuki/command/base"
+
+module Azuki::Command
+
+  # manage collaborators on an app
+  #
+  class Sharing < Base
+
+    # sharing
+    #
+    # list collaborators on an app
+    #
+    #Example:
+    #
+    # $ azuki sharing
+    # === example Collaborators
+    # collaborator@example.com
+    # email@example.com
+    #
+    def index
+      validate_arguments!
+
+      # this is never empty, as it always includes the owner
+      collaborators = api.get_collaborators(app).body
+      styled_header("#{app} Collaborators")
+      styled_array(collaborators.map {|collaborator| collaborator["email"]})
+    end
+
+    # sharing:add EMAIL
+    #
+    # add a collaborator to an app
+    #
+    #Example:
+    #
+    # $ azuki sharing:add collaborator@example.com
+    # Adding collaborator@example.com to example collaborators... done
+    #
+    def add
+      unless email = shift_argument
+        error("Usage: azuki sharing:add EMAIL\nMust specify EMAIL to add sharing.")
+      end
+      validate_arguments!
+
+      action("Adding #{email} to #{app} collaborators") do
+        api.post_collaborator(app, email)
+      end
+    end
+
+    # sharing:remove EMAIL
+    #
+    # remove a collaborator from an app
+    #
+    #Example:
+    #
+    # $ azuki sharing:remove collaborator@example.com
+    # Removing collaborator@example.com to example collaborators... done
+    #
+    def remove
+      unless email = shift_argument
+        error("Usage: azuki sharing:remove EMAIL\nMust specify EMAIL to remove sharing.")
+      end
+      validate_arguments!
+
+      action("Removing #{email} from #{app} collaborators") do
+        api.delete_collaborator(app, email)
+      end
+    end
+
+    # sharing:transfer EMAIL
+    #
+    # transfer an app to a new owner
+    #
+    #Example:
+    #
+    # $ azuki sharing:transfer collaborator@example.com
+    # Transferring example to collaborator@example.com... done
+    #
+    def transfer
+      unless email = shift_argument
+        error("Usage: azuki sharing:transfer EMAIL\nMust specify EMAIL to transfer an app.")
+      end
+      validate_arguments!
+
+      action("Transferring #{app} to #{email}") do
+        api.put_app(app, "transfer_owner" => email)
+      end
+    end
+  end
+end

data/lib/azuki/command/ssl.rb

@@ -0,0 +1,43 @@
+require "azuki/command/base"
+
+module Azuki::Command
+
+  # DEPRECATED: see `azuki certs` instead
+  #
+  # manage ssl certificates for an app
+  #
+  class Ssl < Base
+
+    # ssl
+    #
+    # list legacy certificates for an app
+    #
+    def index
+      api.get_domains(app).body.each do |domain|
+        if cert = domain['cert']
+          display "#{domain['domain']} has a SSL certificate registered to #{cert['subject']} which expires on #{format_date(cert['expires_at'])}"
+        else
+          display "#{domain['domain']} has no certificate"
+        end
+      end
+    end
+
+    # ssl:add PEM KEY
+    #
+    # DEPRECATED: see `azuki certs:add` instead
+    #
+    def add
+      $stderr.puts " !    `azuki ssl:add` has been deprecated. Please use the SSL Endpoint add-on and the `azuki certs` commands instead."
+      $stderr.puts " !    SSL Endpoint documentation is available at: https://devcenter.azukiapp.com/articles/ssl-endpoint"
+    end
+
+    # ssl:clear
+    #
+    # remove legacy ssl certificates from an app
+    #
+    def clear
+      azuki.clear_ssl(app)
+      display "Cleared certificates for #{app}"
+    end
+  end
+end