azuki 0.0.1

data/lib/azuki.rb

@@ -0,0 +1,17 @@
+require "azuki/client"
+require "azuki/updater"
+require "azuki/version"
+
+module Azuki
+
+  USER_AGENT = "azuki-gem/#{Azuki::VERSION} (#{RUBY_PLATFORM}) ruby/#{RUBY_VERSION}"
+
+  def self.user_agent
+    @@user_agent ||= USER_AGENT
+  end
+
+  def self.user_agent=(agent)
+    @@user_agent = agent
+  end
+
+end

data/lib/azuki/auth.rb

@@ -0,0 +1,339 @@
+require "cgi"
+require "azuki"
+require "azuki/client"
+require "azuki/helpers"
+
+require "netrc"
+
+class Azuki::Auth
+  class << self
+    include Azuki::Helpers
+
+    attr_accessor :credentials
+
+    def api
+      @api ||= begin
+        require("azuki-api")
+        api = Azuki::API.new(default_params.merge(:api_key => password))
+
+        def api.request(params, &block)
+          response = super
+          if response.headers.has_key?('X-Azuki-Warning')
+            Azuki::Command.warnings.concat(response.headers['X-Azuki-Warning'].split("\n"))
+          end
+          response
+        end
+
+        api
+      end
+    end
+
+    def client
+      @client ||= begin
+        client = Azuki::Client.new(user, password, host)
+        client.on_warning { |msg| self.display("\n#{msg}\n\n") }
+        client
+      end
+    end
+
+    def login
+      delete_credentials
+      get_credentials
+    end
+
+    def logout
+      delete_credentials
+    end
+
+    # just a stub; will raise if not authenticated
+    def check
+      api.get_user
+    end
+
+    def default_host
+      "azukiapp.com"
+    end
+
+    def git_host
+      ENV['AZUKI_GIT_HOST'] || host
+    end
+
+    def host
+      ENV['AZUKI_HOST'] || default_host
+    end
+
+    def reauthorize
+      @credentials = ask_for_and_save_credentials
+    end
+
+    def user    # :nodoc:
+      get_credentials[0]
+    end
+
+    def password    # :nodoc:
+      get_credentials[1]
+    end
+
+    def api_key(user = get_credentials[0], password = get_credentials[1])
+      require("azuki-api")
+      api = Azuki::API.new(default_params)
+      api.post_login(user, password).body["api_key"]
+    end
+
+    def get_credentials    # :nodoc:
+      @credentials ||= (read_credentials || ask_for_and_save_credentials)
+    end
+
+    def delete_credentials
+      if File.exists?(legacy_credentials_path)
+        FileUtils.rm_f(legacy_credentials_path)
+      end
+      if netrc
+        netrc.delete("api.#{host}")
+        netrc.delete("code.#{host}")
+        netrc.save
+      end
+      @api, @client, @credentials = nil, nil
+    end
+
+    def legacy_credentials_path
+      if host == default_host
+        "#{home_directory}/.azuki/credentials"
+      else
+        "#{home_directory}/.azuki/credentials.#{CGI.escape(host)}"
+      end
+    end
+
+    def netrc_path
+      default = Netrc.default_path
+      encrypted = default + ".gpg"
+      if File.exists?(encrypted)
+        encrypted
+      else
+        default
+      end
+    end
+
+    def netrc   # :nodoc:
+      @netrc ||= begin
+        File.exists?(netrc_path) && Netrc.read(netrc_path)
+      rescue => error
+        if error.message =~ /^Permission bits for/
+          perm = File.stat(netrc_path).mode & 0777
+          abort("Permissions #{perm} for '#{netrc_path}' are too open. You should run `chmod 0600 #{netrc_path}` so that your credentials are NOT accessible by others.")
+        else
+          raise error
+        end
+      end
+    end
+
+    def read_credentials
+      if ENV['AZUKI_API_KEY']
+        ['', ENV['AZUKI_API_KEY']]
+      else
+        # convert legacy credentials to netrc
+        if File.exists?(legacy_credentials_path)
+          @api, @client = nil
+          @credentials = File.read(legacy_credentials_path).split("\n")
+          write_credentials
+          FileUtils.rm_f(legacy_credentials_path)
+        end
+
+        # read netrc credentials if they exist
+        if netrc
+          # force migration of long api tokens (80 chars) to short ones (40)
+          # #write_credentials rewrites both api.* and code.*
+          credentials = netrc["api.#{host}"]
+          if credentials && credentials[1].length > 40
+            @credentials = [ credentials[0], credentials[1][0,40] ]
+            write_credentials
+          end
+
+          netrc["api.#{host}"]
+        end
+      end
+    end
+
+    def write_credentials
+      FileUtils.mkdir_p(File.dirname(netrc_path))
+      FileUtils.touch(netrc_path)
+      unless running_on_windows?
+        FileUtils.chmod(0600, netrc_path)
+      end
+      netrc["api.#{host}"] = self.credentials
+      netrc["code.#{host}"] = self.credentials
+      netrc.save
+    end
+
+    def echo_off
+      with_tty do
+        system "stty -echo"
+      end
+    end
+
+    def echo_on
+      with_tty do
+        system "stty echo"
+      end
+    end
+
+    def ask_for_credentials
+      puts "Enter your Azuki credentials."
+
+      print "Email: "
+      user = ask
+
+      print "Password (typing will be hidden): "
+      password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+
+      [user, api_key(user, password)]
+    end
+
+    def ask_for_password_on_windows
+      require "Win32API"
+      char = nil
+      password = ''
+
+      while char = Win32API.new("crtdll", "_getch", [ ], "L").Call do
+        break if char == 10 || char == 13 # received carriage return or newline
+        if char == 127 || char == 8 # backspace and delete
+          password.slice!(-1, 1)
+        else
+          # windows might throw a -1 at us so make sure to handle RangeError
+          (password << char.chr) rescue RangeError
+        end
+      end
+      puts
+      return password
+    end
+
+    def ask_for_password
+      echo_off
+      password = ask
+      puts
+      echo_on
+      return password
+    end
+
+    def ask_for_and_save_credentials
+      require("azuki-api") # for the errors
+      begin
+        @credentials = ask_for_credentials
+        write_credentials
+        check
+      rescue Azuki::API::Errors::NotFound, Azuki::API::Errors::Unauthorized => e
+        delete_credentials
+        display "Authentication failed."
+        retry if retry_login?
+        exit 1
+      rescue Exception => e
+        delete_credentials
+        raise e
+      end
+      check_for_associated_ssh_key unless Azuki::Command.current_command == "keys:add"
+      @credentials
+    end
+
+    def check_for_associated_ssh_key
+      if api.get_keys.body.empty?
+        associate_or_generate_ssh_key
+      end
+    end
+
+    def associate_or_generate_ssh_key
+      public_keys = Dir.glob("#{home_directory}/.ssh/*.pub").sort
+
+      case public_keys.length
+      when 0 then
+        display "Could not find an existing public key."
+        display "Would you like to generate one? [Yn] ", false
+        unless ask.strip.downcase == "n"
+          display "Generating new SSH public key."
+          generate_ssh_key("id_rsa")
+          associate_key("#{home_directory}/.ssh/id_rsa.pub")
+        end
+      when 1 then
+        display "Found existing public key: #{public_keys.first}"
+        associate_key(public_keys.first)
+      else
+        display "Found the following SSH public keys:"
+        public_keys.each_with_index do |key, index|
+          display "#{index+1}) #{File.basename(key)}"
+        end
+        display "Which would you like to use with your Azuki account? ", false
+        choice = ask.to_i - 1
+        chosen = public_keys[choice]
+        if choice == -1 || chosen.nil?
+          error("Invalid choice")
+        end
+        associate_key(chosen)
+      end
+    end
+
+    def generate_ssh_key(keyfile)
+      ssh_dir = File.join(home_directory, ".ssh")
+      unless File.exists?(ssh_dir)
+        FileUtils.mkdir_p ssh_dir
+        unless running_on_windows?
+          File.chmod(0700, ssh_dir)
+        end
+      end
+      output = `ssh-keygen -t rsa -N "" -f \"#{home_directory}/.ssh/#{keyfile}\" 2>&1`
+      if ! $?.success?
+        error("Could not generate key: #{output}")
+      end
+    end
+
+    def associate_key(key)
+      action("Uploading SSH public key #{key}") do
+        if File.exists?(key)
+          api.post_key(File.read(key))
+        else
+          error("Could not upload SSH public key: key file '" + key + "' does not exist")
+        end
+      end
+    end
+
+    def retry_login?
+      @login_attempts ||= 0
+      @login_attempts += 1
+      @login_attempts < 3
+    end
+
+    def verified_hosts
+      %w( azukiapp.com azuki-shadow.com )
+    end
+
+    def base_host(host)
+      parts = URI.parse(full_host(host)).host.split(".")
+      return parts.first if parts.size == 1
+      parts[-2..-1].join(".")
+    end
+
+    def full_host(host)
+      (host =~ /^http/) ? host : "https://api.#{host}"
+    end
+
+    def verify_host?(host)
+      hostname = base_host(host)
+      verified = verified_hosts.include?(hostname)
+      verified = false if ENV["AZUKI_SSL_VERIFY"] == "disable"
+      verified
+    end
+
+    protected
+
+    def default_params
+      uri = URI.parse(full_host(host))
+      {
+        :headers          => {
+          'User-Agent'    => Azuki.user_agent
+        },
+        :host             => uri.host,
+        :port             => uri.port.to_s,
+        :scheme           => uri.scheme,
+        :ssl_verify_peer  => verify_host?(host)
+      }
+    end
+  end
+end

data/lib/azuki/cli.rb

@@ -0,0 +1,38 @@
+load('azuki/helpers.rb') # reload helpers after possible inject_loadpath
+load('azuki/updater.rb') # reload updater after possible inject_loadpath
+
+require "azuki"
+require "azuki/command"
+require "azuki/helpers"
+
+# workaround for rescue/reraise to define errors in command.rb failing in 1.8.6
+if RUBY_VERSION =~ /^1.8.6/
+  require('azuki-api')
+  require('rest_client')
+end
+
+class Azuki::CLI
+
+  extend Azuki::Helpers
+
+  def self.start(*args)
+    begin
+      if $stdin.isatty
+        $stdin.sync = true
+      end
+      if $stdout.isatty
+        $stdout.sync = true
+      end
+      command = args.shift.strip rescue "help"
+      Azuki::Command.load
+      Azuki::Command.run(command, args)
+    rescue Interrupt
+      `stty icanon echo`
+      error("Command cancelled.")
+    rescue => error
+      styled_error(error)
+      exit(1)
+    end
+  end
+
+end

data/lib/azuki/client.rb

@@ -0,0 +1,764 @@
+require 'rexml/document'
+require 'uri'
+require 'time'
+require 'azuki/auth'
+require 'azuki/command'
+require 'azuki/helpers'
+require 'azuki/version'
+require 'azuki/client/ssl_endpoint'
+
+# A Ruby class to call the Azuki REST API.  You might use this if you want to
+# manage your Azuki apps from within a Ruby program, such as Capistrano.
+#
+# Example:
+#
+#   require 'azuki'
+#   azuki = Azuki::Client.new('me@example.com', 'mypass')
+#   azuki.create()
+#
+class Azuki::Client
+
+  include Azuki::Helpers
+  extend Azuki::Helpers
+
+  def self.version
+    Azuki::VERSION
+  end
+
+  def self.gem_version_string
+    "azuki-gem/#{version}"
+  end
+
+  attr_accessor :host, :user, :password
+
+  def initialize(user, password, host=Azuki::Auth.host)
+    require 'rest_client'
+    @user = user
+    @password = password
+    @host = host
+  end
+
+  def self.deprecate
+    method = caller.first.split('`').last[0...-1]
+    source = caller[1].split(' ').first[0...-3]
+    $stderr.puts(" !    DEPRECATED: Azuki::Client##{method} is deprecated, please use the azuki-api gem.")
+    $stderr.puts(" !    DEPRECATED: More information available at https://github.com/azuki/azuki.rb")
+    $stderr.puts(" !    DEPRECATED: Deprecated method called from #{source}.")
+  end
+
+  def deprecate
+    self.class.deprecate
+  end
+
+  def self.auth(user, password, host=Azuki::Auth.host)
+    deprecate # 08/01/2012
+    client = new(user, password, host)
+    json_decode client.post('/login', { :username => user, :password => password }, :accept => 'json').to_s
+  end
+
+  # Show a list of apps which you are a collaborator on.
+  def list
+    deprecate # 07/26/2012
+    doc = xml(get('/apps').to_s)
+    doc.elements.to_a("//apps/app").map do |a|
+      name = a.elements.to_a("name").first
+      owner = a.elements.to_a("owner").first
+      [name.text, owner.text]
+    end
+  end
+
+  # Show info such as mode, custom domain, and collaborators on an app.
+  def info(name_or_domain)
+    deprecate # 07/26/2012
+    raise ArgumentError.new("name_or_domain is required for info") unless name_or_domain
+    name_or_domain = name_or_domain.gsub(/^(http:\/\/)?(www\.)?/, '')
+    doc = xml(get("/apps/#{name_or_domain}").to_s)
+    attrs = hash_from_xml_doc(doc)[:app]
+    attrs.merge!(:collaborators => list_collaborators(attrs[:name]))
+    attrs.merge!(:addons        => installed_addons(attrs[:name]))
+  end
+
+  # Create a new app, with an optional name.
+  def create(name=nil, options={})
+    deprecate # 07/26/2012
+    name = create_request(name, options)
+    loop do
+      break if create_complete?(name)
+      sleep 1
+    end
+    name
+  end
+
+  def create_app(name=nil, options={})
+    deprecate # 07/26/2012
+    options[:name] = name if name
+    json_decode(post("/apps", { :app => options }, :accept => "application/json").to_s)
+  end
+
+  def create_request(name=nil, options={})
+    deprecate # 07/26/2012
+    options[:name] = name if name
+    xml(post('/apps', :app => options).to_s).elements["//app/name"].text
+  end
+
+  def create_complete?(name)
+    deprecate # 07/26/2012
+    put("/apps/#{name}/status", {}).code == 201
+  end
+
+  # Update an app.  Available attributes:
+  #   :name => rename the app (changes http and git urls)
+  def update(name, attributes)
+    deprecate # 07/26/2012
+    put("/apps/#{name}", :app => attributes).to_s
+  end
+
+  # Destroy the app permanently.
+  def destroy(name)
+    deprecate # 07/26/2012
+    delete("/apps/#{name}").to_s
+  end
+
+  def maintenance(app_name, mode)
+    deprecate # 07/31/2012
+    mode = mode == :on ? '1' : '0'
+    post("/apps/#{app_name}/server/maintenance", :maintenance_mode => mode).to_s
+  end
+
+  def config_vars(app_name)
+    deprecate # 07/27/2012
+    json_decode get("/apps/#{app_name}/config_vars", :accept => :json).to_s
+  end
+
+  def add_config_vars(app_name, new_vars)
+    deprecate # 07/27/2012
+    put("/apps/#{app_name}/config_vars", json_encode(new_vars), :accept => :json).to_s
+  end
+
+  def remove_config_var(app_name, key)
+    deprecate # 07/27/2012
+    delete("/apps/#{app_name}/config_vars/#{escape(key)}", :accept => :json).to_s
+  end
+
+  def clear_config_vars(app_name)
+    deprecate # 07/27/2012
+    delete("/apps/#{app_name}/config_vars").to_s
+  end
+
+  # Get a list of collaborators on the app, returns an array of hashes each with :email
+  def list_collaborators(app_name)
+    deprecate # 07/31/2012
+    doc = xml(get("/apps/#{app_name}/collaborators").to_s)
+    doc.elements.to_a("//collaborators/collaborator").map do |a|
+      { :email => a.elements['email'].text }
+    end
+  end
+
+  # Invite a person by email address to collaborate on the app.
+  def add_collaborator(app_name, email)
+    deprecate # 07/31/2012
+    xml(post("/apps/#{app_name}/collaborators", { 'collaborator[email]' => email }).to_s)
+  end
+
+  # Remove a collaborator.
+  def remove_collaborator(app_name, email)
+    deprecate # 07/31/2012
+    delete("/apps/#{app_name}/collaborators/#{escape(email)}").to_s
+  end
+
+  def list_domains(app_name)
+    deprecate # 08/02/2012
+    doc = xml(get("/apps/#{app_name}/domains").to_s)
+    doc.elements.to_a("//domain-names/*").map do |d|
+      attrs = { :domain => d.elements['domain'].text }
+      if cert = d.elements['cert']
+        attrs[:cert] = {
+          :expires_at => Time.parse(cert.elements['expires-at'].text),
+          :subject    => cert.elements['subject'].text,
+          :issuer     => cert.elements['issuer'].text,
+        }
+      end
+      attrs
+    end
+  end
+
+  def add_domain(app_name, domain)
+    deprecate # 07/31/2012
+    post("/apps/#{app_name}/domains", domain).to_s
+  end
+
+  def remove_domain(app_name, domain)
+    deprecate # 07/31/2012
+    raise ArgumentError.new("invalid domain: #{domain.inspect}") if domain.to_s.strip == ""
+    delete("/apps/#{app_name}/domains/#{domain}").to_s
+  end
+
+  def remove_domains(app_name)
+    deprecate # 07/31/2012
+    delete("/apps/#{app_name}/domains").to_s
+  end
+
+  # Get the list of ssh public keys for the current user.
+  def keys
+    deprecate # 07/31/2012
+    doc = xml get('/user/keys').to_s
+    doc.elements.to_a('//keys/key').map do |key|
+      key.elements['contents'].text
+    end
+  end
+
+  # Add an ssh public key to the current user.
+  def add_key(key)
+    deprecate # 07/31/2012
+    post("/user/keys", key, { 'Content-Type' => 'text/ssh-authkey' }).to_s
+  end
+
+  # Remove an existing ssh public key from the current user.
+  def remove_key(key)
+    deprecate # 07/31/2012
+    delete("/user/keys/#{escape(key)}").to_s
+  end
+
+  # Clear all keys on the current user.
+  def remove_all_keys
+    deprecate # 07/31/2012
+    delete("/user/keys").to_s
+  end
+
+  # Retreive ps list for the given app name.
+  def ps(app_name)
+    deprecate # 07/31/2012
+    json_decode get("/apps/#{app_name}/ps", :accept => 'application/json').to_s
+  end
+
+  # Restart the app servers.
+  def restart(app_name)
+    deprecate # 07/31/2012
+    delete("/apps/#{app_name}/server").to_s
+  end
+
+  def dynos(app_name)
+    deprecate # 07/31/2012
+    doc = xml(get("/apps/#{app_name}").to_s)
+    doc.elements["//app/dynos"].text.to_i
+  end
+
+  def workers(app_name)
+    deprecate # 07/31/2012
+    doc = xml(get("/apps/#{app_name}").to_s)
+    doc.elements["//app/workers"].text.to_i
+  end
+
+  # Scales the web processes.
+  def set_dynos(app_name, qty)
+    deprecate # 07/31/2012
+    put("/apps/#{app_name}/dynos", :dynos => qty).to_s
+  end
+
+  # Scales the background processes.
+  def set_workers(app_name, qty)
+    deprecate # 07/31/2012
+    put("/apps/#{app_name}/workers", :workers => qty).to_s
+  end
+
+  def ps_run(app, opts={})
+    deprecate # 07/31/2012
+    json_decode post("/apps/#{app}/ps", opts, :accept => :json).to_s
+  end
+
+  def ps_scale(app, opts={})
+    deprecate # 07/31/2012
+    Integer(post("/apps/#{app}/ps/scale", opts).to_s)
+  end
+
+  def ps_restart(app, opts={})
+    deprecate # 07/31/2012
+    post("/apps/#{app}/ps/restart", opts)
+  end
+
+  def ps_stop(app, opts={})
+    deprecate # 07/31/2012
+    post("/apps/#{app}/ps/stop", opts)
+  end
+
+  def releases(app)
+    deprecate # 07/31/2012
+    json_decode get("/apps/#{app}/releases", :accept => :json).to_s
+  end
+
+  def release(app, release)
+    deprecate # 07/31/2012
+    json_decode get("/apps/#{app}/releases/#{release}", :accept => :json).to_s
+  end
+
+  def rollback(app, release=nil)
+    deprecate # 07/31/2012
+    post("/apps/#{app}/releases", :rollback => release)
+  end
+
+  # Fetch recent logs from the app server.
+  def logs(app_name)
+    deprecate # 07/31/2012
+    get("/apps/#{app_name}/logs").to_s
+  end
+
+  def list_features(app)
+    deprecate # 07/31/2012
+    json_decode(get("features?app=#{app}", :accept => :json).to_s)
+  end
+
+  def get_feature(app, name)
+    deprecate # 07/31/2012
+    json_decode get("features/#{name}?app=#{app}", :accept => :json).to_s
+  end
+
+  def enable_feature(app, name)
+    deprecate # 07/31/2012
+    json_decode post("/features/#{name}?app=#{app}", :accept => :json).to_s
+  end
+
+  def disable_feature(app, name)
+    deprecate # 07/31/2012
+    json_decode delete("/features/#{name}?app=#{app}", :accept => :json).to_s
+  end
+
+  # Get a list of stacks available to the app, with the current one marked.
+  def list_stacks(app_name, options={})
+    deprecate # 07/31/2012
+    include_deprecated = options.delete(:include_deprecated) || false
+
+    json_decode get("/apps/#{app_name}/stack",
+      :params => { :include_deprecated => include_deprecated },
+      :accept => 'application/json'
+    ).to_s
+  end
+
+  # Request a stack migration.
+  def migrate_to_stack(app_name, stack)
+    deprecate # 07/31/2012
+    put("/apps/#{app_name}/stack", stack, :accept => 'text/plain').to_s
+  end
+
+  # Run a rake command on the Azuki app and return output as a string
+  def rake(app_name, cmd)
+    # deprecated by virtue of start deprecation 08/02/2012
+    start(app_name, "rake #{cmd}", :attached).to_s
+  end
+
+  class Service
+    attr_accessor :attached
+
+    def initialize(client, app)
+      require 'rest_client'
+      @client = client
+      @app = app
+    end
+
+    # start the service
+    def start(command, attached=false)
+      @attached = attached
+      @response = @client.post(
+        "/apps/#{@app}/services",
+        command,
+        :content_type => 'text/plain'
+      )
+      @next_chunk = @response.to_s
+      @interval = 0
+      self
+    rescue RestClient::RequestFailed => e
+      raise AppCrashed, e.http_body  if e.http_code == 502
+      raise
+    end
+
+    # Does the service have any remaining output?
+    def end_of_stream?
+      @next_chunk.nil?
+    end
+
+    # Read the next chunk of output.
+    def read
+      chunk = @client.get(@next_chunk)
+      if chunk.headers[:location].nil? && chunk.code != 204
+        # no more chunks
+        @next_chunk = nil
+        chunk.to_s
+      elsif chunk.to_s == ''
+        # assume no content and back off
+        @interval = 2
+        ''
+      elsif location = chunk.headers[:location]
+        # some data read and next chunk available
+        @next_chunk = location
+        @interval = 0
+        chunk.to_s
+      end
+    end
+
+    # Iterate over all output chunks until EOF is reached.
+    def each
+      until end_of_stream?
+        sleep(@interval)
+        output = read
+        yield output unless output.empty?
+      end
+    end
+
+    # All output as a string
+    def to_s
+      buf = []
+      each { |part| buf << part }
+      buf.join
+    end
+  end
+
+  # Run a service. If Responds to #each and yields output as it's received.
+  def start(app_name, command, attached=false)
+    deprecate # 08/02/2012
+    service = Service.new(self, app_name)
+    service.start(command, attached)
+  end
+
+  def add_ssl(app_name, pem, key)
+    json_decode(post("/apps/#{app_name}/ssl", :pem => pem, :key => key).to_s)
+  end
+
+  def remove_ssl(app_name, domain)
+    delete("/apps/#{app_name}/domains/#{domain}/ssl").to_s
+  end
+
+  def clear_ssl(app_name)
+    delete("/apps/#{app_name}/ssl")
+  end
+
+  class AppCrashed < RuntimeError; end
+
+  # support for console sessions
+  class ConsoleSession
+    def initialize(id, app, client)
+      require 'rest_client'
+      @id = id; @app = app; @client = client
+    end
+    def run(cmd)
+      @client.run_console_command("/apps/#{@app}/consoles/#{@id}/command", cmd, "=> ")
+    end
+  end
+
+  # Execute a one-off console command, or start a new console tty session if
+  # cmd is nil.
+  def console(app_name, cmd=nil)
+    if block_given?
+      id = post("/apps/#{app_name}/consoles").to_s
+      yield ConsoleSession.new(id, app_name, self)
+      delete("/apps/#{app_name}/consoles/#{id}").to_s
+    else
+      run_console_command("/apps/#{app_name}/console", cmd)
+    end
+  rescue RestClient::BadGateway => e
+    raise(AppCrashed, <<-ERROR)
+Unable to attach to a dyno to open a console session.
+Your application may have crashed.
+Check the output of "azuki ps" and "azuki logs" for more information.
+    ERROR
+  end
+
+  # internal method to run console commands formatting the output
+  def run_console_command(url, command, prefix=nil)
+    output = post(url, { :command => command }, :accept => "text/plain").to_s
+    return output unless prefix
+    if output.include?("\n")
+      lines  = output.split("\n")
+      (lines[0..-2] << "#{prefix}#{lines.last}").join("\n")
+    else
+      prefix + output
+    end
+  rescue RestClient::RequestFailed => e
+    if e.http_code == 422
+      Azuki::Command.extract_error(e.http_body, :raw => true)
+    else
+      raise e
+    end
+  end
+
+  def read_logs(app_name, options=[])
+    query = "&" + options.join("&") unless options.empty?
+    url = get("/apps/#{app_name}/logs?logplex=true#{query}").to_s
+    if url == 'Use old logs'
+      puts get("/apps/#{app_name}/logs").to_s
+    else
+      uri  = URI.parse(url);
+
+      if uri.scheme == 'https'
+        proxy = https_proxy
+      else
+        proxy = http_proxy
+      end
+
+      if proxy
+        proxy_uri = URI.parse(proxy)
+        http = Net::HTTP.new(uri.host, uri.port, proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+      else
+        http = Net::HTTP.new(uri.host, uri.port)
+      end
+
+      if uri.scheme == 'https'
+        http.use_ssl = true
+        if ENV["AZUKI_SSL_VERIFY"] == "disable"
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        else
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          http.ca_file = local_ca_file
+          http.verify_callback = lambda do |preverify_ok, ssl_context|
+            if (!preverify_ok) || ssl_context.error != 0
+              error "WARNING: Unable to verify SSL certificate for #{host}\nTo disable SSL verification, run with AZUKI_SSL_VERIFY=disable"
+            end
+            true
+          end
+        end
+      end
+
+      http.read_timeout = 60 * 60 * 24
+
+      begin
+        http.start do
+          http.request_get(uri.path + (uri.query ? "?" + uri.query : "")) do |request|
+            request.read_body do |chunk|
+              yield chunk
+            end
+          end
+        end
+      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError
+        error("Could not connect to logging service")
+      rescue Timeout::Error, EOFError
+        error("\nRequest timed out")
+      end
+    end
+  end
+
+  def list_drains(app_name)
+    get("/apps/#{app_name}/logs/drains").to_s
+  end
+
+  def add_drain(app_name, url)
+    post("/apps/#{app_name}/logs/drains", "url=#{url}").to_s
+  end
+
+  def remove_drain(app_name, url)
+    delete("/apps/#{app_name}/logs/drains?url=#{URI.escape(url)}").to_s
+  end
+
+  def addons
+    json_decode get("/addons", :accept => 'application/json').to_s
+  end
+
+  def installed_addons(app_name)
+    json_decode get("/apps/#{app_name}/addons", :accept => 'application/json').to_s
+  end
+
+  def install_addon(app_name, addon, config={})
+    configure_addon :install, app_name, addon, config
+  end
+
+  def upgrade_addon(app_name, addon, config={})
+    configure_addon :upgrade, app_name, addon, config
+  end
+  alias_method :downgrade_addon, :upgrade_addon
+
+  def uninstall_addon(app_name, addon, options={})
+    configure_addon :uninstall, app_name, addon, options
+  end
+
+  def database_session(app_name)
+    json_decode(post("/apps/#{app_name}/database/session2", '', :x_taps_version => ::Taps.version).to_s)
+  end
+
+  def database_reset(app_name)
+    post("/apps/#{app_name}/database/reset", '').to_s
+  end
+
+  def httpcache_purge(app_name)
+    delete("/apps/#{app_name}/httpcache").to_s
+  end
+
+  def confirm_billing
+    post("/user/#{escape(@user)}/confirm_billing").to_s
+  end
+
+  def on_warning(&blk)
+    @warning_callback = blk
+  end
+
+  ##################
+
+  def resource(uri, options={})
+    RestClient.proxy = case URI.parse(realize_full_uri(uri)).scheme
+    when "http"
+      http_proxy
+    when "https"
+      https_proxy
+    end
+    RestClient::Resource.new(realize_full_uri(uri), options.merge(:user => user, :password => password))
+  end
+
+  def get(uri, extra_headers={})    # :nodoc:
+    process(:get, uri, extra_headers)
+  end
+
+  def post(uri, payload="", extra_headers={})    # :nodoc:
+    process(:post, uri, extra_headers, payload)
+  end
+
+  def put(uri, payload, extra_headers={})    # :nodoc:
+    process(:put, uri, extra_headers, payload)
+  end
+
+  def delete(uri, extra_headers={})    # :nodoc:
+    process(:delete, uri, extra_headers)
+  end
+
+  def process(method, uri, extra_headers={}, payload=nil)
+    headers  = azuki_headers.merge(extra_headers)
+    args     = [method, payload, headers].compact
+
+    resource_options = default_resource_options_for_uri(uri)
+
+    begin
+      response = resource(uri, resource_options).send(*args)
+    rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError
+      host = URI.parse(realize_full_uri(uri)).host
+      error "Unable to connect to #{host}"
+    rescue RestClient::SSLCertificateNotVerified => ex
+      host = URI.parse(realize_full_uri(uri)).host
+      error "WARNING: Unable to verify SSL certificate for #{host}\nTo disable SSL verification, run with AZUKI_SSL_VERIFY=disable"
+    end
+
+    extract_warning(response)
+    response
+  end
+
+  def extract_warning(response)
+    return unless response
+    if response.headers[:x_azuki_warning] && @warning_callback
+      warning = response.headers[:x_azuki_warning]
+      @displayed_warnings ||= {}
+      unless @displayed_warnings[warning]
+        @warning_callback.call(warning)
+        @displayed_warnings[warning] = true
+      end
+    end
+  end
+
+  def azuki_headers   # :nodoc:
+    {
+      'X-Azuki-API-Version' => '2',
+      'User-Agent'           => Azuki.user_agent,
+      'X-Ruby-Version'       => RUBY_VERSION,
+      'X-Ruby-Platform'      => RUBY_PLATFORM
+    }
+  end
+
+  def xml(raw)   # :nodoc:
+    REXML::Document.new(raw)
+  end
+
+  def escape(value)  # :nodoc:
+    escaped = URI.escape(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    escaped.gsub('.', '%2E') # not covered by the previous URI.escape
+  end
+
+  module JSON
+    def self.parse(json)
+      json_decode(json)
+    end
+  end
+
+  private
+
+  def configure_addon(action, app_name, addon, config = {})
+    response = update_addon action,
+                            addon_path(app_name, addon),
+                            config
+
+    json_decode(response.to_s) unless response.to_s.empty?
+  end
+
+  def addon_path(app_name, addon)
+    "/apps/#{app_name}/addons/#{escape(addon)}"
+  end
+
+  def update_addon(action, path, config)
+    params  = { :config => config }
+    app     = params[:config].delete(:confirm)
+    headers = { :accept => 'application/json' }
+    params.merge!(:confirm => app) if app
+
+    case action
+    when :install
+      post path, params, headers
+    when :upgrade
+      put path, params, headers
+    when :uninstall
+      confirm = app ? "confirm=#{app}" : ''
+      delete "#{path}?#{confirm}", headers
+    end
+  end
+
+  def realize_full_uri(given)
+    full_host = (host =~ /^http/) ? host : "https://api.#{host}"
+    host = URI.parse(full_host)
+    uri = URI.parse(given)
+    uri.host ||= host.host
+    uri.scheme ||= host.scheme || "https"
+    uri.path = (uri.path[0..0] == "/") ? uri.path : "/#{uri.path}"
+    uri.port = host.port if full_host =~ /\:\d+/
+    uri.to_s
+  end
+
+  def default_resource_options_for_uri(uri)
+    if ENV["AZUKI_SSL_VERIFY"] == "disable"
+      {}
+    elsif realize_full_uri(uri) =~ %r|^https://api.azukiapp.com|
+      { :verify_ssl => OpenSSL::SSL::VERIFY_PEER, :ssl_ca_file => local_ca_file }
+    else
+      {}
+    end
+  end
+
+  def local_ca_file
+    File.expand_path("../../../data/cacert.pem", __FILE__)
+  end
+
+  def hash_from_xml_doc(elements)
+    elements.inject({}) do |hash, e|
+      next(hash) unless e.respond_to?(:children)
+      hash.update(e.name.gsub("-","_").to_sym => case e.children.length
+        when 0 then nil
+        when 1 then e.text
+        else hash_from_xml_doc(e.children)
+      end)
+    end
+  end
+
+  def http_proxy
+    proxy = ENV['HTTP_PROXY'] || ENV['http_proxy']
+    if proxy && !proxy.empty?
+      unless /^[^:]+:\/\// =~ proxy
+        proxy = "http://" + proxy
+      end
+      proxy
+    else
+      nil
+    end
+  end
+
+  def https_proxy
+    proxy = ENV['HTTPS_PROXY'] || ENV['https_proxy']
+    if proxy && !proxy.empty?
+      unless /^[^:]+:\/\// =~ proxy
+        proxy = "https://" + proxy
+      end
+      proxy
+    else
+      nil
+    end
+  end
+end