class Heroku::Command::Run

run one-off commands (console, rake)

Public Instance Methods

console() click to toggle source
run:console [COMMAND]

open a remote console session

if COMMAND is specified, run the command and exit

NOTE: For Cedar apps, use `pogo run console`

Examples:

$ pogo console
Ruby console for example.heroku.com
>>
# File lib/heroku/command/run.rb, line 98
def console
  puts "`pogo #{current_command}` has been removed. Please use: `pogo run` instead."
  puts "For more information, please see:"
  puts " * https://devcenter.heroku.com/articles/one-off-dynos"
  puts " * https://devcenter.heroku.com/articles/rails3#console"
  puts " * https://devcenter.heroku.com/articles/console-bamboo"
end
detached() click to toggle source
run:detached COMMAND

run a detached dyno, where output is sent to your logs

-s, --size SIZE      # specify dyno size
-t, --tail           # stream logs for the dyno

Example:

$ pogo run:detached ls
Running `ls` detached... up, run.1
Use `pogo logs -p run.1` to view the output.
# File lib/heroku/command/run.rb, line 40
def detached
  command = args.join(" ")
  error("Usage: pogo run COMMAND") if command.empty?
  opts = { :attach => false, :command => command }
  opts[:size] = get_size if options[:size]

  app_name = app
  process_data = action("Running `#{command}` detached", :success => "up") do
    process_data = api.post_ps(app_name, command, opts).body
    status(process_data['process'])
    process_data
  end
  if options[:tail]
    opts = []
    opts << "tail=1"
    opts << "ps=#{process_data['process']}"
    log_displayer = ::Heroku::Helpers::LogDisplayer.new(heroku, app, opts)
    log_displayer.display_logs
  else
    display("Use `pogo logs -p #{process_data['process']}` to view the output.")
  end
end
index() click to toggle source
run COMMAND

run an attached dyno

-s, --size SIZE      # specify dyno size

Example:

$ pogo run bash
Running `bash` attached to terminal... up, run.1
~ $
# File lib/heroku/command/run.rb, line 21
def index
  command = args.join(" ")
  error("Usage: pogo run COMMAND") if command.empty?
  run_attached(command)
end
rake() click to toggle source
run:rake COMMAND

WARNING: `pogo run:rake` has been deprecated. Please use `pogo run rake` instead."

remotely execute a rake command

Example:

$ pogo run:rake -T
Running `rake -T` attached to terminal... up, run.1
(in /app)
rake test  # run tests
# File lib/heroku/command/run.rb, line 76
def rake
  deprecate("`pogo #{current_command}` has been deprecated. Please use `pogo run rake` instead.")
  command = "rake #{args.join(' ')}"
  run_attached(command)
end

Protected Instance Methods

console_history_add(app, cmd) click to toggle source
# File lib/heroku/command/run.rb, line 184
def console_history_add(app, cmd)
  Readline::HISTORY.push(cmd)
  File.open(console_history_file(app), "a") { |f| f.puts cmd + "\n" }
end
console_history_dir() click to toggle source
# File lib/heroku/command/run.rb, line 145
def console_history_dir
  FileUtils.mkdir_p(path = "#{home_directory}/.heroku/console_history")
  path
end
console_history_file(app) click to toggle source
# File lib/heroku/command/run.rb, line 165
def console_history_file(app)
  "#{console_history_dir}/#{app}"
end
console_history_read(app) click to toggle source
# File lib/heroku/command/run.rb, line 169
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
console_session(app) click to toggle source
# File lib/heroku/command/run.rb, line 150
def console_session(app)
  heroku.console(app) do |console|
    console_history_read(app)

    display "Ruby console for #{app}.#{heroku.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
get_size() click to toggle source
# File lib/heroku/command/run.rb, line 189
def get_size
  size = options[:size].to_i
  error("Must specify SIZE in format '1X' or '2X'.") if size <= 0
  size
end
rendezvous_session(rendezvous_url, &on_connect) click to toggle source
# File lib/heroku/command/run.rb, line 122
def rendezvous_session(rendezvous_url, &on_connect)
  begin
    set_buffer(false)
    rendezvous = Heroku::Client::Rendezvous.new(
      :rendezvous_url => rendezvous_url,
      :connect_timeout => (ENV["HEROKU_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
run_attached(command) click to toggle source
# File lib/heroku/command/run.rb, line 109
def run_attached(command)
  app_name = app
  opts = { :attach => true, :ps_env => get_terminal_environment }
  opts[:size] = get_size if options[:size]

  process_data = action("Running `#{command}` attached to terminal", :success => "up") do
    process_data = api.post_ps(app_name, command, opts).body
    status(process_data["process"])
    process_data
  end
  rendezvous_session(process_data["rendezvous_url"])
end