roundhouse-x 0.1.0

data/lib/roundhouse/cli.rb

@@ -0,0 +1,396 @@
+# encoding: utf-8
+$stdout.sync = true
+
+require 'yaml'
+require 'singleton'
+require 'optparse'
+require 'erb'
+require 'fileutils'
+
+require 'roundhouse'
+require 'roundhouse/util'
+
+module Roundhouse
+  # We are shutting down Roundhouse but what about workers that
+  # are working on some long job?  This error is
+  # raised in workers that have not finished within the hard
+  # timeout limit.  This is needed to rollback db transactions,
+  # otherwise Ruby's Thread#kill will commit.  See #377.
+  # DO NOT RESCUE THIS ERROR.
+  class Shutdown < Interrupt; end
+
+  class CLI
+    include Util
+    include Singleton unless $TESTING
+
+    # Used for CLI testing
+    attr_accessor :code
+    attr_accessor :launcher
+    attr_accessor :environment
+
+    def initialize
+      @code = nil
+    end
+
+    def parse(args=ARGV)
+      @code = nil
+
+      setup_options(args)
+      initialize_logger
+      validate!
+      daemonize
+      write_pid
+      load_celluloid
+    end
+
+    # Code within this method is not tested because it alters
+    # global process state irreversibly.  PRs which improve the
+    # test coverage of Roundhouse::CLI are welcomed.
+    def run
+      boot_system
+      print_banner
+
+      self_read, self_write = IO.pipe
+
+      %w(INT TERM USR1 USR2 TTIN).each do |sig|
+        begin
+          trap sig do
+            self_write.puts(sig)
+          end
+        rescue ArgumentError
+          puts "Signal #{sig} not supported"
+        end
+      end
+
+      logger.info "Running in #{RUBY_DESCRIPTION}"
+      logger.info Roundhouse::LICENSE
+      logger.info "Upgrade to Roundhouse Pro for more features and support: http://roundhouse.org" unless defined?(::Roundhouse::Pro)
+
+      fire_event(:startup)
+
+      logger.debug {
+        "Middleware: #{Roundhouse.server_middleware.map(&:klass).join(', ')}"
+      }
+
+      Roundhouse.redis do |conn|
+        # touch the connection pool so it is created before we
+        # launch the actors.
+      end
+
+      if !options[:daemon]
+        logger.info 'Starting processing, hit Ctrl-C to stop'
+      end
+
+      require 'roundhouse/launcher'
+      @launcher = Roundhouse::Launcher.new(options)
+
+      begin
+        launcher.run
+
+        while readable_io = IO.select([self_read])
+          signal = readable_io.first[0].gets.strip
+          handle_signal(signal)
+        end
+      rescue Interrupt
+        logger.info 'Shutting down'
+        launcher.stop
+        fire_event(:shutdown, true)
+        # Explicitly exit so busy Processor threads can't block
+        # process shutdown.
+        exit(0)
+      end
+    end
+
+    def self.banner
+%q{         s
+          ss
+     sss  sss         ss
+     s  sss s   ssss sss   ____  _     _      _    _
+     s     sssss ssss     / ___|(_) __| | ___| | _(_) __ _
+    s         sss         \___ \| |/ _` |/ _ \ |/ / |/ _` |
+    s sssss  s             ___) | | (_| |  __/   <| | (_| |
+    ss    s  s            |____/|_|\__,_|\___|_|\_\_|\__, |
+    s     s s                                           |_|
+          s s
+         sss
+         sss }
+    end
+
+    def handle_signal(sig)
+      Roundhouse.logger.debug "Got #{sig} signal"
+      case sig
+      when 'INT'
+        # Handle Ctrl-C in JRuby like MRI
+        # http://jira.codehaus.org/browse/JRUBY-4637
+        raise Interrupt
+      when 'TERM'
+        # Heroku sends TERM and then waits 10 seconds for process to exit.
+        raise Interrupt
+      when 'USR1'
+        Roundhouse.logger.info "Received USR1, no longer accepting new work"
+        launcher.manager.async.stop
+        fire_event(:quiet, true)
+      when 'USR2'
+        if Roundhouse.options[:logfile]
+          Roundhouse.logger.info "Received USR2, reopening log file"
+          Roundhouse::Logging.reopen_logs
+        end
+      when 'TTIN'
+        Thread.list.each do |thread|
+          Roundhouse.logger.warn "Thread TID-#{thread.object_id.to_s(36)} #{thread['label']}"
+          if thread.backtrace
+            Roundhouse.logger.warn thread.backtrace.join("\n")
+          else
+            Roundhouse.logger.warn "<no backtrace available>"
+          end
+        end
+      end
+    end
+
+    private
+
+    def print_banner
+      # Print logo and banner for development
+      if environment == 'development' && $stdout.tty?
+        puts "\e[#{31}m"
+        puts Roundhouse::CLI.banner
+        puts "\e[0m"
+      end
+    end
+
+    def load_celluloid
+      raise "Celluloid cannot be required until here, or it will break Roundhouse'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/current'
+      Celluloid.logger = (options[:verbose] ? Roundhouse.logger : nil)
+
+      require 'roundhouse/manager'
+      require 'roundhouse/scheduled'
+    end
+
+    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
+
+    def set_environment(cli_env)
+      @environment = cli_env || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+    end
+
+    alias_method :die, :exit
+    alias_method :☠, :exit
+
+    def setup_options(args)
+      opts = parse_options(args)
+      set_environment opts[:environment]
+
+      cfile = opts[:config_file]
+      opts = parse_config(cfile).merge(opts) if cfile
+
+      opts[:strict] = true if opts[:strict].nil?
+
+      options.merge!(opts)
+    end
+
+    def options
+      Roundhouse.options
+    end
+
+    def boot_system
+      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 'rails'
+        if ::Rails::VERSION::MAJOR < 4
+          require 'roundhouse/rails'
+          require File.expand_path("#{options[:require]}/config/environment.rb")
+          ::Rails.application.eager_load!
+        else
+          # Painful contortions, see 1791 for discussion
+          require File.expand_path("#{options[:require]}/config/application.rb")
+          ::Rails::Application.initializer "roundhouse.eager_load" do
+            ::Rails.application.config.eager_load = true
+          end
+          require 'roundhouse/rails'
+          require File.expand_path("#{options[:require]}/config/environment.rb")
+        end
+        options[:tag] ||= default_tag
+      else
+        require options[:require]
+      end
+    end
+
+    def default_tag
+      dir = ::Rails.root
+      name = File.basename(dir)
+      if name.to_i != 0 && prevdir = File.dirname(dir) # Capistrano release directory?
+        if File.basename(prevdir) == 'releases'
+          return File.basename(File.dirname(prevdir))
+        end
+      end
+      name
+    end
+
+    def validate!
+      options[:queues] << 'default' if options[:queues].empty?
+
+      if !File.exist?(options[:require]) ||
+         (File.directory?(options[:require]) && !File.exist?("#{options[:require]}/config/application.rb"))
+        logger.info "=================================================================="
+        logger.info "  Please point roundhouse to a Rails 3/4 application or a Ruby file  "
+        logger.info "  to load your worker classes with -r [DIR|FILE]."
+        logger.info "=================================================================="
+        logger.info @parser
+        die(1)
+      end
+
+      [:concurrency, :timeout].each do |opt|
+        raise ArgumentError, "#{opt}: #{options[opt]} is not a valid value" if options.has_key?(opt) && options[opt].to_i <= 0
+      end
+    end
+
+    def parse_options(argv)
+      opts = {}
+
+      @parser = OptionParser.new do |o|
+        o.on '-c', '--concurrency INT', "processor threads to use" do |arg|
+          opts[:concurrency] = Integer(arg)
+        end
+
+        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 '-g', '--tag TAG', "Process tag for procline" do |arg|
+          opts[:tag] = arg
+        end
+
+        o.on '-i', '--index INT', "unique process index on this machine" do |arg|
+          opts[:index] = Integer(arg.match(/\d+/)[0])
+        end
+
+        o.on "-q", "--queue QUEUE[,WEIGHT]", "Queues to process with optional weights" do |arg|
+          queue, weight = arg.split(",")
+          parse_queue opts, queue, weight
+        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 '-t', '--timeout NUM', "Shutdown timeout" do |arg|
+          opts[:timeout] = Integer(arg)
+        end
+
+        o.on "-v", "--verbose", "Print more verbose output" do |arg|
+          opts[:verbose] = arg
+        end
+
+        o.on '-C', '--config PATH', "path to YAML config file" do |arg|
+          opts[:config_file] = 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 "Roundhouse #{Roundhouse::VERSION}"
+          die(0)
+        end
+      end
+
+      @parser.banner = "roundhouse [options]"
+      @parser.on_tail "-h", "--help", "Show help" do
+        logger.info @parser
+        die 1
+      end
+      @parser.parse!(argv)
+      opts[:config_file] ||= 'config/roundhouse.yml' if File.exist?('config/roundhouse.yml')
+      opts
+    end
+
+    def initialize_logger
+      Roundhouse::Logging.initialize_logger(options[:logfile]) if options[:logfile]
+
+      Roundhouse.logger.level = ::Logger::DEBUG if options[:verbose]
+    end
+
+    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
+
+    def parse_config(cfile)
+      opts = {}
+      if File.exist?(cfile)
+        opts = YAML.load(ERB.new(IO.read(cfile)).result) || opts
+        opts = opts.merge(opts.delete(environment) || {})
+        parse_queues(opts, opts.delete(:queues) || [])
+      else
+        # allow a non-existent config file so Roundhouse
+        # can be deployed by cap with just the defaults.
+      end
+      ns = opts.delete(:namespace)
+      if ns
+        # logger hasn't been initialized yet, puts is all we have.
+        puts("namespace should be set in your ruby initializer, is ignored in config file")
+        puts("config.redis = { :url => ..., :namespace => '#{ns}' }")
+      end
+      opts
+    end
+
+    def parse_queues(opts, queues_and_weights)
+      queues_and_weights.each { |queue_and_weight| parse_queue(opts, *queue_and_weight) }
+    end
+
+    def parse_queue(opts, q, weight=nil)
+      [weight.to_i, 1].max.times do
+       (opts[:queues] ||= []) << q
+      end
+      opts[:strict] = false if weight.to_i > 0
+    end
+  end
+end

data/lib/roundhouse/client.rb

@@ -0,0 +1,210 @@
+require 'securerandom'
+require 'roundhouse/monitor'
+require 'roundhouse/middleware/chain'
+
+module Roundhouse
+  class Client
+
+    ##
+    # Define client-side middleware:
+    #
+    #   client = Roundhouse::Client.new
+    #   client.middleware do |chain|
+    #     chain.use MyClientMiddleware
+    #   end
+    #   client.push('class' => 'SomeWorker', 'args' => [1,2,3])
+    #
+    # All client instances default to the globally-defined
+    # Roundhouse.client_middleware but you can change as necessary.
+    #
+    def middleware(&block)
+      @chain ||= Roundhouse.client_middleware
+      if block_given?
+        @chain = @chain.dup
+        yield @chain
+      end
+      @chain
+    end
+
+    attr_accessor :redis_pool
+
+    # Roundhouse::Client normally uses the default Redis pool but you may
+    # pass a custom ConnectionPool if you want to shard your
+    # Roundhouse jobs across several Redis instances (for scalability
+    # reasons, e.g.)
+    #
+    #   Roundhouse::Client.new(ConnectionPool.new { Redis.new })
+    #
+    # Generally this is only needed for very large Roundhouse installs processing
+    # more than thousands jobs per second.  I do not recommend sharding unless
+    # you truly cannot scale any other way (e.g. splitting your app into smaller apps).
+    # Some features, like the API, do not support sharding: they are designed to work
+    # against a single Redis instance only.
+    def initialize(redis_pool=nil)
+      @redis_pool = redis_pool || Thread.current[:roundhouse_via_pool] || Roundhouse.redis_pool
+    end
+
+    ##
+    # The main method used to push a job to Redis.  Accepts a number of options:
+    #
+    #   queue_id - integer queue_id (required, no default)
+    #   class - the worker class to call, required
+    #   args - an array of simple arguments to the perform method, must be JSON-serializable
+    #   retry - whether to retry this job if it fails, true or false, default true
+    #   backtrace - whether to save any error backtrace, default false
+    #
+    # All options must be strings, not symbols.  NB: because we are serializing to JSON, all
+    # symbols in 'args' will be converted to strings.
+    #
+    # Returns a unique Job ID.  If middleware stops the job, nil will be returned instead.
+    #
+    # Example:
+    #   push('queue' => 1, 'class' => MyWorker, 'args' => ['foo', 1, :bat => 'bar'])
+    #
+    def push(item)
+      normed = normalize_item(item)
+      payload = process_single(item['class'], normed)
+
+      if payload
+        raw_push([payload])
+        payload['jid']
+      end
+    end
+
+    ##
+    # Push a large number of jobs to Redis.  In practice this method is only
+    # useful if you are pushing tens of thousands of jobs or more, or if you need
+    # to ensure that a batch doesn't complete prematurely.  This method
+    # basically cuts down on the redis round trip latency.
+    #
+    # Note: Roundhouse implementation does not use MULTI, so this is not going
+    # to be as fast as Sidekiq. As such, this is not officially supported.
+    #
+    # Takes the same arguments as #push except that args is expected to be
+    # an Array of Arrays.  All other keys are duplicated for each job.  Each job
+    # is run through the client middleware pipeline and each job gets its own Job ID
+    # as normal.
+    #
+    # Returns an array of the of pushed jobs' jids.  The number of jobs pushed can be less
+    # than the number given if the middleware stopped processing for one or more jobs.
+    def push_bulk(items)
+      Roundhouse.logger.warn '#push_bulk is not officially supported. Use at your own risk.'
+      normed = normalize_item(items)
+      payloads = items['args'].map do |args|
+        raise ArgumentError, "Bulk arguments must be an Array of Arrays: [[1], [2]]" if !args.is_a?(Array)
+        process_single(items['class'], normed.merge('args' => args, 'jid' => SecureRandom.hex(12), 'enqueued_at' => Time.now.to_f))
+      end.compact
+
+      raw_push(payloads) if !payloads.empty?
+      payloads.collect { |payload| payload['jid'] }
+    end
+
+    # Allows sharding of jobs across any number of Redis instances.  All jobs
+    # defined within the block will use the given Redis connection pool.
+    #
+    #   pool = ConnectionPool.new { Redis.new }
+    #   Roundhouse::Client.via(pool) do
+    #     SomeWorker.perform_async(1,2,3)
+    #     SomeOtherWorker.perform_async(1,2,3)
+    #   end
+    #
+    # Generally this is only needed for very large Roundhouse installs processing
+    # more than thousands jobs per second.  I do not recommend sharding unless
+    # you truly cannot scale any other way (e.g. splitting your app into smaller apps).
+    # Some features, like the API, do not support sharding: they are designed to work
+    # against a single Redis instance.
+    def self.via(pool)
+      raise NotImplementedError, 'Roundhouse does not support sharding at this point.'
+
+      raise ArgumentError, "No pool given" if pool.nil?
+      raise RuntimeError, "Roundhouse::Client.via is not re-entrant" if x = Thread.current[:roundhouse_via_pool] && x != pool
+      Thread.current[:roundhouse_via_pool] = pool
+      yield
+    ensure
+      Thread.current[:roundhouse_via_pool] = nil
+    end
+
+    class << self
+
+      # deprecated
+      def default
+        @default ||= new
+      end
+
+      def push(item)
+        new.push(item)
+      end
+
+      def push_bulk(items)
+        new.push_bulk(items)
+      end
+
+      # Resque compatibility helpers.  Note all helpers
+      # should go through Worker#client_push.
+
+      # Example usage:
+      #   Roundhouse::Client.enqueue_to(queue_id, MyWorker, 'foo', 1, :bat => 'bar')
+      #
+      def enqueue_to(queue_id, klass, *args)
+        klass.client_push('queue_id' => queue_id, 'class' => klass, 'args' => args)
+      end
+
+      # Example usage:
+      #   Roundhouse::Client.enqueue_to_in(queue_id, 3.minutes, MyWorker, 'foo', 1, :bat => 'bar')
+      #
+      def enqueue_to_in(queue_id, interval, klass, *args)
+        int = interval.to_f
+        now = Time.now.to_f
+        ts = (int < 1_000_000_000 ? now + int : int)
+
+        item = { 'class' => klass, 'args' => args, 'at' => ts, 'queue_id' => queue_id }
+        item.delete('at'.freeze) if ts <= now
+
+        klass.client_push(item)
+      end
+
+    end
+
+    private
+
+    def raw_push(payloads)
+      @redis_pool.with do |conn|
+        Roundhouse::Monitor.push_job(conn, payloads)
+      end
+      true
+    end
+
+    def process_single(worker_class, item)
+      queue_id = item['queue_id']
+
+      middleware.invoke(worker_class, item, queue_id, @redis_pool) do
+        item
+      end
+    end
+
+    def normalize_item(item)
+      raise(ArgumentError, "Job must be a Hash with 'class' and 'args' keys: { 'class' => SomeWorker, 'args' => ['bob', 1, :foo => 'bar'] }") unless item.is_a?(Hash) && item.has_key?('class'.freeze) && item.has_key?('args'.freeze)
+      raise(ArgumentError, "Queue ID must be an integer") unless item['queue_id'.freeze].is_a?(Fixnum)
+      raise(ArgumentError, "Job args must be an Array") unless item['args'].is_a?(Array)
+      raise(ArgumentError, "Job class must be either a Class or String representation of the class name") unless item['class'.freeze].is_a?(Class) || item['class'.freeze].is_a?(String)
+
+      normalized_hash(item['class'.freeze])
+        .each{ |key, value| item[key] = value if item[key].nil? }
+
+      item['class'.freeze] = item['class'.freeze].to_s
+      item['queue_id'.freeze] = item['queue_id'.freeze].to_i
+      item['jid'.freeze] ||= SecureRandom.hex(12)
+      item['created_at'.freeze] ||= Time.now.to_f
+      item
+    end
+
+    def normalized_hash(item_class)
+      if item_class.is_a?(Class)
+        raise(ArgumentError, "Message must include a Roundhouse::Worker class, not class name: #{item_class.ancestors.inspect}") if !item_class.respond_to?('get_roundhouse_options'.freeze)
+        item_class.get_roundhouse_options
+      else
+        Roundhouse.default_worker_options
+      end
+    end
+  end
+end

data/lib/roundhouse/core_ext.rb

@@ -0,0 +1,105 @@
+begin
+  require 'active_support/core_ext/class/attribute'
+rescue LoadError
+
+  # A dumbed down version of ActiveSupport's
+  # Class#class_attribute helper.
+  class Class
+    def class_attribute(*attrs)
+      instance_writer = true
+
+      attrs.each do |name|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def self.#{name}() nil end
+          def self.#{name}?() !!#{name} end
+
+          def self.#{name}=(val)
+            singleton_class.class_eval do
+              define_method(:#{name}) { val }
+            end
+
+            if singleton_class?
+              class_eval do
+                def #{name}
+                  defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+                end
+              end
+            end
+            val
+          end
+
+          def #{name}
+            defined?(@#{name}) ? @#{name} : self.class.#{name}
+          end
+
+          def #{name}?
+            !!#{name}
+          end
+        RUBY
+
+        attr_writer name if instance_writer
+      end
+    end
+
+    private
+    def singleton_class?
+      ancestors.first != self
+    end
+  end
+end
+
+begin
+  require 'active_support/core_ext/hash/keys'
+  require 'active_support/core_ext/hash/deep_merge'
+rescue LoadError
+  class Hash
+    def stringify_keys
+      keys.each do |key|
+        self[key.to_s] = delete(key)
+      end
+      self
+    end if !{}.respond_to?(:stringify_keys)
+
+    def symbolize_keys
+      keys.each do |key|
+        self[(key.to_sym rescue key) || key] = delete(key)
+      end
+      self
+    end if !{}.respond_to?(:symbolize_keys)
+
+    def deep_merge(other_hash, &block)
+      dup.deep_merge!(other_hash, &block)
+    end if !{}.respond_to?(:deep_merge)
+
+    def deep_merge!(other_hash, &block)
+      other_hash.each_pair do |k,v|
+        tv = self[k]
+        if tv.is_a?(Hash) && v.is_a?(Hash)
+          self[k] = tv.deep_merge(v, &block)
+        else
+          self[k] = block && tv ? block.call(k, tv, v) : v
+        end
+      end
+      self
+    end if !{}.respond_to?(:deep_merge!)
+  end
+end
+
+begin
+  require 'active_support/core_ext/string/inflections'
+rescue LoadError
+  class String
+    def constantize
+      names = self.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+  end if !"".respond_to?(:constantize)
+end
+
+