class Asynk::CLI

Attributes

environment[RW]

Public Instance Methods

run(args=ARGV) click to toggle source
# File lib/asynk/cli.rb, line 11
def run(args=ARGV)
  Asynk.booted_inside = true
  setup_options(args)
  initialize_logger
  daemonize
  write_pid
  load_celluloid
  boot_system
  Asynk.server.run
end

Private Instance Methods

boot_system() click to toggle source
# File lib/asynk/cli.rb, line 89
def boot_system
  Asynk.logger.info 'Booting Asynk App'
  ENV['RACK_ENV'] = ENV['RAILS_ENV'] = environment

  raise ArgumentError, "#{options[:require]} does not exist" unless File.exist?(options[:require])

  if File.directory?(options[:require])
    require File.expand_path("#{options[:require]}/config/application.rb")
    require File.expand_path("#{options[:require]}/config/environment.rb")
    ::Rails.application.eager_load!
  else
    require options[:require]
  end
end
daemonize() click to toggle source
# File lib/asynk/cli.rb, line 35
def daemonize
  return unless options[:daemon]

  raise ArgumentError, "You really should set a logfile if you're going to daemonize" unless options[:logfile]
  files_to_reopen = []
  ObjectSpace.each_object(File) do |file|
    files_to_reopen << file unless file.closed?
  end

  ::Process.daemon(true, true)

  files_to_reopen.each do |file|
    begin
      file.reopen file.path, "a+"
      file.sync = true
    rescue ::Exception
    end
  end

  [$stdout, $stderr].each do |io|
    File.open(options[:logfile], 'ab') do |f|
      io.reopen(f)
    end
    io.sync = true
  end
  $stdin.reopen('/dev/null')

  initialize_logger
end
initialize_logger() click to toggle source
# File lib/asynk/cli.rb, line 78
def initialize_logger
  Asynk::Logging.initialize_logger(options[:logfile]) if options[:logfile]
  Asynk.logger.level = ::Logger::DEBUG if options[:verbose]
end
load_celluloid() click to toggle source
# File lib/asynk/cli.rb, line 24
def load_celluloid
  raise "Celluloid cannot be required until here, or it will break Sidekiq's daemonization" if defined?(::Celluloid) && options[:daemon]

  # Celluloid can't be loaded until after we've daemonized
  # because it spins up threads and creates locks which get
  # into a very bad state if forked.
  require 'celluloid'
  require 'celluloid/io'
  Celluloid.logger = (options[:verbose] ? Asynk.logger : nil)
end
options() click to toggle source
# File lib/asynk/cli.rb, line 74
def options
  Asynk.options
end
parse_options(argv) click to toggle source
# File lib/asynk/cli.rb, line 108
def parse_options(argv)
  opts = {}

  @parser = OptionParser.new do |o|
    o.on '-d', '--daemon', "Daemonize process" do |arg|
      opts[:daemon] = arg
    end

    o.on '-e', '--environment ENV', "Application environment" do |arg|
      opts[:environment] = arg
    end

    o.on '-r', '--require [PATH|DIR]', "Location of Rails application with workers or file to require" do |arg|
      opts[:require] = arg
    end

    o.on '-L', '--logfile PATH', "path to writable logfile" do |arg|
      opts[:logfile] = arg
    end

    o.on '-P', '--pidfile PATH', "path to pidfile" do |arg|
      opts[:pidfile] = arg
    end

    o.on '-V', '--version', "Print version and exit" do |arg|
      puts "Asynk #{Asynk::VERSION}"
      exit(0)
    end

    o.on "-v", "--verbose", "Print more verbose output" do |arg|
      opts[:verbose] = arg
    end
  end

  @parser.parse!(argv)
  opts
end
set_environment(cli_env) click to toggle source
# File lib/asynk/cli.rb, line 104
def set_environment(cli_env)
  @environment = cli_env || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
end
setup_options(args) click to toggle source
# File lib/asynk/cli.rb, line 83
def setup_options(args)
  opts = parse_options(args)
  set_environment opts[:environment]
  options.merge!(opts)
end
write_pid() click to toggle source
# File lib/asynk/cli.rb, line 65
def write_pid
  if path = options[:pidfile]
    pidfile = File.expand_path(path)
    File.open(pidfile, 'w') do |f|
      f.puts ::Process.pid
    end
  end
end