class Heroku::API

Constants

HEADERS
OPTIONS
VERSION

Public Class Methods

new(options={}) click to toggle source
# File lib/heroku/api.rb, line 55
def initialize(options={})
  options = OPTIONS.merge(options)

  @api_key = options.delete(:api_key) || ENV['HEROKU_API_KEY']
  if !@api_key && options.has_key?(:username) && options.has_key?(:password)
    username = options.delete(:username)
    password = options.delete(:password)
    @connection = Excon.new("#{options[:scheme]}://#{options[:host]}", options.merge(:headers => HEADERS))
    @api_key = self.post_login(username, password).body["api_key"]
  end

  user_pass = ":#{@api_key}"
  options[:headers] = HEADERS.merge({
    'Authorization' => "Basic #{Base64.encode64(user_pass).gsub("\n", '')}",
  }).merge(options[:headers])

  @connection = Excon.new("#{options[:scheme]}://#{options[:host]}", options)
end

Public Instance Methods

delete_addon(app, addon) click to toggle source

DELETE /apps/:app/addons/:addon

# File lib/heroku/api/addons.rb, line 5
def delete_addon(app, addon)
  request(
    :expects  => 200,
    :method   => :delete,
    :path     => "/apps/#{app}/addons/#{addon}"
  )
end
delete_app(app) click to toggle source

DELETE /apps/:app

# File lib/heroku/api/apps.rb, line 5
def delete_app(app)
  request(
    :expects  => 200,
    :method   => :delete,
    :path     => "/apps/#{app}"
  )
end
delete_collaborator(app, email) click to toggle source

DELETE /apps/:app/collaborators/:email

# File lib/heroku/api/collaborators.rb, line 5
def delete_collaborator(app, email)
  request(
    :expects  => 200,
    :method   => :delete,
    :path     => "/apps/#{app}/collaborators/#{CGI.escape(email)}"
  )
end
delete_config_var(app, key) click to toggle source

DELETE /apps/:app/config_vars/:key

# File lib/heroku/api/config_vars.rb, line 5
def delete_config_var(app, key)
  request(
    :expects  => 200,
    :method   => :delete,
    :path     => "/apps/#{app}/config_vars/#{escape(key)}"
  )
end
delete_domain(app, domain) click to toggle source

DELETE /apps/:app/domains/:domain

# File lib/heroku/api/domains.rb, line 5
def delete_domain(app, domain)
  request(
    :expects  => 200,
    :method   => :delete,
    :path     => "/apps/#{app}/domains/#{escape(domain)}"
  )
end
delete_domains(app) click to toggle source

DELETE /apps/:app/domains

# File lib/heroku/api/domains.rb, line 14
def delete_domains(app)
  request(
    :expects  => 200,
    :method   => :delete,
    :path     => "/apps/#{app}/domains"
  )
end
delete_feature(feature, app = nil) click to toggle source

DELETE /features/:feature

# File lib/heroku/api/features.rb, line 5
def delete_feature(feature, app = nil)
  request(
    :expects  => 200,
    :method   => :delete,
    :path     => "/features/#{feature}",
    :query    => { 'app' => app }
  )
end
delete_key(key) click to toggle source

DELETE /user/keys/:key

# File lib/heroku/api/keys.rb, line 5
def delete_key(key)
  request(
    :expects  => 200,
    :method   => :delete,
    :path     => "/user/keys/#{escape(key)}"
  )
end
delete_keys() click to toggle source

DELETE /user/keys

# File lib/heroku/api/keys.rb, line 14
def delete_keys
  request(
    :expects  => 200,
    :method   => :delete,
    :path     => "/user/keys"
  )
end
delete_ssl_endpoint(app, cname) click to toggle source

DELETE /apps/:app/ssl-endpoint/:cname

# File lib/heroku/api/ssl_endpoints.rb, line 5
def delete_ssl_endpoint(app, cname)
  request(
    :expects  => 200,
    :method   => :delete,
    :path     => "/apps/#{app}/ssl-endpoints/#{escape(cname)}"
  )
end
get_addons(app=nil) click to toggle source

GET /addons GET /apps/:app/addons

# File lib/heroku/api/addons.rb, line 15
def get_addons(app=nil)
  path = if app
    "/apps/#{app}/addons"
  else
    "/addons"
  end
  request(
    :expects  => 200,
    :method   => :get,
    :path     => path
  )
end
get_app(app) click to toggle source

GET /apps/:app

# File lib/heroku/api/apps.rb, line 23
def get_app(app)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}"
  )
end
get_app_maintenance(app) click to toggle source

GET /apps/:app/server/maintenance

# File lib/heroku/api/apps.rb, line 32
def get_app_maintenance(app)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/server/maintenance"
  )
end
get_apps() click to toggle source

GET /apps

# File lib/heroku/api/apps.rb, line 14
def get_apps
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps"
  )
end
get_attachments(app) click to toggle source

GET /apps/:app/attachments

# File lib/heroku/api/attachments.rb, line 5
def get_attachments(app)
  request(
    :expects => 200,
    :method => :get,
    :path => "/apps/#{app}/attachments"
  )
end
get_collaborators(app) click to toggle source

GET /apps/:app/collaborators

# File lib/heroku/api/collaborators.rb, line 14
def get_collaborators(app)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/collaborators"
  )
end
get_config_vars(app) click to toggle source

GET /apps/:app/config_vars

# File lib/heroku/api/config_vars.rb, line 14
def get_config_vars(app)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/config_vars"
  )
end
get_domains(app) click to toggle source

GET /apps/:app/domains

# File lib/heroku/api/domains.rb, line 23
def get_domains(app)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/domains"
  )
end
get_dyno_types(app) click to toggle source

GET /apps/:app/dyno-types

# File lib/heroku/api/processes.rb, line 89
def get_dyno_types(app)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/dyno-types"
  )
end
get_feature(feature, app = nil) click to toggle source

GET /features/:feature

# File lib/heroku/api/features.rb, line 25
def get_feature(feature, app = nil)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/features/#{feature}",
    :query    => { 'app' => app }
  )
end
get_features(app = nil) click to toggle source

GET /features

# File lib/heroku/api/features.rb, line 15
def get_features(app = nil)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/features",
    :query    => { 'app' => app }
  )
end
get_keys() click to toggle source

GET /user/keys

# File lib/heroku/api/keys.rb, line 23
def get_keys
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/user/keys"
  )
end
get_logs(app, options = {}) click to toggle source

GET /apps/:app/logs

# File lib/heroku/api/logs.rb, line 5
def get_logs(app, options = {})
  options = {
    'logplex' => 'true'
  }.merge(options)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/logs",
    :query    => options
  )
end
get_ps(app) click to toggle source

GET /apps/:app/ps

# File lib/heroku/api/processes.rb, line 5
def get_ps(app)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/ps"
  )
end
get_release(app, release) click to toggle source

GET /apps/:app/releases/:release

# File lib/heroku/api/releases.rb, line 14
def get_release(app, release)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/releases/#{release}"
  )
end
get_releases(app) click to toggle source

GET /apps/:app/releases

# File lib/heroku/api/releases.rb, line 5
def get_releases(app)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/releases"
  )
end
get_ssl_endpoint(app, cname) click to toggle source

GET /apps/:app/ssl-endpoint/:cname

# File lib/heroku/api/ssl_endpoints.rb, line 14
def get_ssl_endpoint(app, cname)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/ssl-endpoints/#{escape(cname)}"
  )
end
get_ssl_endpoints(app) click to toggle source

GET /apps/:app/ssl-endpoints

# File lib/heroku/api/ssl_endpoints.rb, line 23
def get_ssl_endpoints(app)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/ssl-endpoints"
  )
end
get_stack(app) click to toggle source
# File lib/heroku/api/stacks.rb, line 4
def get_stack(app)
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/apps/#{app}/stack"
  )
end
get_user() click to toggle source

GET /user

# File lib/heroku/api/user.rb, line 5
def get_user
  request(
    :expects  => 200,
    :method   => :get,
    :path     => "/user"
  )
end
post_addon(app, addon, config = {}) click to toggle source

POST /apps/:app/addons/:addon

# File lib/heroku/api/addons.rb, line 29
def post_addon(app, addon, config = {})
  request(
    :expects  => 200,
    :method   => :post,
    :path     => "/apps/#{app}/addons/#{addon}",
    :query    => addon_params(config)
  )
end
post_app(params={}) click to toggle source

POST /apps

# File lib/heroku/api/apps.rb, line 41
def post_app(params={})
  request(
    :expects  => 202,
    :method   => :post,
    :path     => '/apps',
    :query    => app_params(params)
  )
end
post_app_maintenance(app, maintenance_mode) click to toggle source

POST /apps/:app/server/maintenance

# File lib/heroku/api/apps.rb, line 51
def post_app_maintenance(app, maintenance_mode)
  request(
    :expects  => 200,
    :method   => :post,
    :path     => "/apps/#{app}/server/maintenance",
    :query    => {'maintenance_mode' => maintenance_mode}
  )
end
post_collaborator(app, email) click to toggle source

POST /apps/:app/collaborators

# File lib/heroku/api/collaborators.rb, line 23
def post_collaborator(app, email)
  request(
    :expects  => [200, 201],
    :method   => :post,
    :path     => "/apps/#{app}/collaborators",
    :query    => {'collaborator[email]' => email}
  )
end
post_domain(app, domain) click to toggle source

POST /apps/:app/domains

# File lib/heroku/api/domains.rb, line 32
def post_domain(app, domain)
  request(
    :expects  => 201,
    :method   => :post,
    :path     => "/apps/#{app}/domains",
    :query    => {'domain_name[domain]' => domain}
  )
end
post_feature(feature, app = nil) click to toggle source

POST /features/:feature

# File lib/heroku/api/features.rb, line 35
def post_feature(feature, app = nil)
  request(
    :expects  => [200, 201],
    :method   => :post,
    :path     => "/features/#{feature}",
    :query    => { 'app' => app }
  )
end
post_key(key) click to toggle source

POST /user/keys

# File lib/heroku/api/keys.rb, line 32
def post_key(key)
  request(
    :body     => key,
    :expects  => 200,
    :method   => :post,
    :path     => "/user/keys"
  )
end
post_login(username, password) click to toggle source
# File lib/heroku/api/login.rb, line 4
def post_login(username, password)
  request(
    :expects  => 200,
    :method   => :post,
    :path     => '/login',
    :query    => { 'username' => username, 'password' => password }
  )
end
post_ps(app, command, options={}) click to toggle source

POST /apps/:app/ps

# File lib/heroku/api/processes.rb, line 14
def post_ps(app, command, options={})
  options = { 'command' => command }.merge(options)
  request(
    :expects  => 200,
    :method   => :post,
    :path     => "/apps/#{app}/ps",
    :query    => ps_options(options)
  )
end
post_ps_restart(app, options={}) click to toggle source

POST /apps/:app/ps/restart

# File lib/heroku/api/processes.rb, line 25
def post_ps_restart(app, options={})
  request(
    :expects  => 200,
    :method   => :post,
    :path     => "/apps/#{app}/ps/restart",
    :query    => options
  )
end
post_ps_scale(app, type, quantity) click to toggle source

POST /apps/:app/ps/scale

# File lib/heroku/api/processes.rb, line 35
def post_ps_scale(app, type, quantity)
  request(
    :expects  => 200,
    :method   => :post,
    :path     => "/apps/#{app}/ps/scale",
    :query    => {
      'type'  => type,
      'qty'   => quantity
    }
  )
end
post_ps_stop(app, options) click to toggle source

POST /apps/:app/ps/stop

# File lib/heroku/api/processes.rb, line 48
def post_ps_stop(app, options)
  request(
    :expects  => 200,
    :method   => :post,
    :path     => "/apps/#{app}/ps/stop",
    :query    => options
  )
end
post_release(app, release=nil) click to toggle source

POST /apps/:app/releases/:release

# File lib/heroku/api/releases.rb, line 23
def post_release(app, release=nil)
  request(
    :expects  => 200,
    :method   => :post,
    :path     => "/apps/#{app}/releases",
    :query    => {'rollback' => release}
  )
end
post_ssl_endpoint(app, pem, key) click to toggle source

POST /apps/:app/ssl-endpoints

# File lib/heroku/api/ssl_endpoints.rb, line 32
def post_ssl_endpoint(app, pem, key)
  request(
    :expects  => 200,
    :method   => :post,
    :path     => "/apps/#{app}/ssl-endpoints",
    :query     => { 'key' => key, 'pem' => pem }
  )
end
post_ssl_endpoint_rollback(app, cname) click to toggle source

POST /apps/:app/ssl-endpoints/:cname/rollback

# File lib/heroku/api/ssl_endpoints.rb, line 42
def post_ssl_endpoint_rollback(app, cname)
  request(
    :expects  => 200,
    :method   => :post,
    :path     => "/apps/#{app}/ssl-endpoints/#{escape(cname)}/rollback"
  )
end
put_addon(app, addon, config = {}) click to toggle source

PUT /apps/:app/addons/:addon

# File lib/heroku/api/addons.rb, line 39
def put_addon(app, addon, config = {})
  request(
    :expects  => 200,
    :method   => :put,
    :path     => "/apps/#{app}/addons/#{addon}",
    :query    => addon_params(config)
  )
end
put_app(app, params) click to toggle source

PUT /apps/:app

# File lib/heroku/api/apps.rb, line 61
def put_app(app, params)
  request(
    :expects  => 200,
    :method   => :put,
    :path     => "/apps/#{app}",
    :query    => app_params(params)
  )
end
put_config_vars(app, vars) click to toggle source

PUT /apps/:app/config_vars

# File lib/heroku/api/config_vars.rb, line 23
def put_config_vars(app, vars)
  request(
    :body     => MultiJson.dump(vars),
    :expects  => 200,
    :method   => :put,
    :path     => "/apps/#{app}/config_vars"
  )
end
put_dynos(app, dynos) click to toggle source

PUT /apps/:app/dynos

# File lib/heroku/api/processes.rb, line 58
def put_dynos(app, dynos)
  request(
    :expects  => 200,
    :method   => :put,
    :path     => "/apps/#{app}/dynos",
    :query    => {'dynos' => dynos}
  )
end
put_formation(app, options) click to toggle source

PUT /apps/:app/formation

# File lib/heroku/api/processes.rb, line 78
def put_formation(app, options)
  options.each { |process, size| options[process] = {'size' => size} }
  request(
    :body     => MultiJson.dump(options),
    :expects  => 200,
    :method   => :put,
    :path     => "/apps/#{app}/formation"
  )
end
put_ssl_endpoint(app, cname, pem, key) click to toggle source

PUT /apps/:app/ssl-endpoints/:cname

# File lib/heroku/api/ssl_endpoints.rb, line 51
def put_ssl_endpoint(app, cname, pem, key)
  request(
    :expects  => 200,
    :method   => :put,
    :path     => "/apps/#{app}/ssl-endpoints/#{escape(cname)}",
    :query     => { 'key' => key, 'pem' => pem }
  )
end
put_stack(app, stack) click to toggle source
# File lib/heroku/api/stacks.rb, line 12
def put_stack(app, stack)
  request(
    :body     => stack,
    :expects  => 200,
    :method   => :put,
    :path     => "/apps/#{app}/stack"
  )
end
put_workers(app, workers) click to toggle source

PUT /apps/:app/workers

# File lib/heroku/api/processes.rb, line 68
def put_workers(app, workers)
  request(
    :expects  => 200,
    :method   => :put,
    :path     => "/apps/#{app}/workers",
    :query    => {'workers' => workers}
  )
end
request(params, &block) click to toggle source
# File lib/heroku/api.rb, line 74
def request(params, &block)
  begin
    response = @connection.request(params, &block)
  rescue Excon::Errors::HTTPStatusError => error
    klass = case error.response.status
      when 401 then Heroku::API::Errors::Unauthorized
      when 402 then Heroku::API::Errors::VerificationRequired
      when 403 then Heroku::API::Errors::Forbidden
      when 404
        if error.request[:path].match /\/apps\/\/.*/
          Heroku::API::Errors::NilApp
        else
          Heroku::API::Errors::NotFound
        end
      when 408 then Heroku::API::Errors::Timeout
      when 422 then Heroku::API::Errors::RequestFailed
      when 423 then Heroku::API::Errors::Locked
      when 429 then Heroku::API::Errors::RateLimitExceeded
      when /50./ then Heroku::API::Errors::RequestFailed
      else Heroku::API::Errors::ErrorWithResponse
    end

    decompress_response!(error.response)
    reerror = klass.new(error.message, error.response)
    reerror.set_backtrace(error.backtrace)
    raise(reerror)
  end

  if response.body && !response.body.empty?
    decompress_response!(response)
    begin
      response.body = MultiJson.load(response.body)
    rescue
      # leave non-JSON body as is
    end
  end

  # reset (non-persistent) connection
  @connection.reset

  response
end

Private Instance Methods

addon_params(params) click to toggle source
# File lib/heroku/api.rb, line 132
def addon_params(params)
  params.inject({}) do |accum, (key, value)|
    accum["config[#{key}]"] = value
    accum
  end
end
app_params(params) click to toggle source
# File lib/heroku/api.rb, line 124
def app_params(params)
  app_params = {}
  params.each do |key, value|
    app_params["app[#{key}]"] = value
  end
  app_params
end
decompress_response!(response) click to toggle source
# File lib/heroku/api.rb, line 119
def decompress_response!(response)
  return unless response.headers['Content-Encoding'] == 'gzip'
  response.body = Zlib::GzipReader.new(StringIO.new(response.body)).read
end
escape(string) click to toggle source
# File lib/heroku/api.rb, line 139
def escape(string)
  CGI.escape(string).gsub('.', '%2E')
end
ps_options(params) click to toggle source
# File lib/heroku/api.rb, line 143
def ps_options(params)
  if ps_env = params.delete(:ps_env) || params.delete('ps_env')
    ps_env.each do |key, value|
      params["ps_env[#{key}]"] = value
    end
  end
  params
end