hutch-java 1.3.0-java

data/lib/hutch/worker.rb

@@ -0,0 +1,145 @@
+require 'hutch/message'
+require 'hutch/logging'
+require 'hutch/broker'
+require 'hutch/acknowledgements/nack_on_all_failures'
+require 'hutch/waiter'
+require 'carrot-top'
+require 'securerandom'
+
+module Hutch
+  class Worker
+    include Logging
+
+    def initialize(broker, consumers, setup_procs)
+      @broker        = broker
+      self.consumers = consumers
+      self.setup_procs = setup_procs
+    end
+
+    # Run the main event loop. The consumers will be set up with queues, and
+    # process the messages in their respective queues indefinitely. This method
+    # never returns.
+    def run
+      setup_queues
+      setup_procs.each(&:call)
+
+      Waiter.wait_until_signaled
+
+      stop
+    end
+
+    # Stop a running worker by killing all subscriber threads.
+    def stop
+      @broker.stop
+    end
+
+    # Set up the queues for each of the worker's consumers.
+    def setup_queues
+      logger.info 'setting up queues'
+      vetted = @consumers.reject { |c| group_configured? && group_restricted?(c) }
+      vetted.each do |c|
+        setup_queue(c)
+      end
+    end
+
+    # Bind a consumer's routing keys to its queue, and set up a subscription to
+    # receive messages sent to the queue.
+    def setup_queue(consumer)
+      logger.info "setting up queue: #{consumer.get_queue_name}"
+
+      queue = @broker.queue(consumer.get_queue_name, consumer.get_options)
+      @broker.bind_queue(queue, consumer.routing_keys)
+
+      queue.subscribe(consumer_tag: unique_consumer_tag, manual_ack: true) do |*args|
+        delivery_info, properties, payload = Hutch::Adapter.decode_message(*args)
+        handle_message(consumer, delivery_info, properties, payload)
+      end
+    end
+
+    # Called internally when a new messages comes in from RabbitMQ. Responsible
+    # for wrapping up the message and passing it to the consumer.
+    def handle_message(consumer, delivery_info, properties, payload)
+      serializer = consumer.get_serializer || Hutch::Config[:serializer]
+      logger.debug {
+        spec   = serializer.binary? ? "#{payload.bytesize} bytes" : "#{payload}"
+        "message(#{properties.message_id || '-'}): " +
+        "routing key: #{delivery_info.routing_key}, " +
+        "consumer: #{consumer}, " +
+        "payload: #{spec}"
+      }
+
+      message = Message.new(delivery_info, properties, payload, serializer)
+      consumer_instance = consumer.new.tap { |c| c.broker, c.delivery_info = @broker, delivery_info }
+      with_tracing(consumer_instance).handle(message)
+      @broker.ack(delivery_info.delivery_tag) unless consumer_instance.message_rejected?
+    rescue => ex
+      acknowledge_error(delivery_info, properties, @broker, ex)
+      handle_error(properties, payload, consumer, ex)
+    end
+
+    def with_tracing(klass)
+      Hutch::Config[:tracer].new(klass)
+    end
+
+    def handle_error(*args)
+      Hutch::Config[:error_handlers].each do |backend|
+        backend.handle(*args)
+      end
+    end
+
+    def acknowledge_error(delivery_info, properties, broker, ex)
+      acks = error_acknowledgements +
+        [Hutch::Acknowledgements::NackOnAllFailures.new]
+      acks.find do |backend|
+        backend.handle(delivery_info, properties, broker, ex)
+      end
+    end
+
+    def consumers=(val)
+      if val.empty?
+        logger.warn "no consumer loaded, ensure there's no configuration issue"
+      end
+      @consumers = val
+    end
+
+    def error_acknowledgements
+      Hutch::Config[:error_acknowledgements]
+    end
+
+    private
+
+    def group_configured?
+      if group.present? && consumer_groups.blank?
+        logger.info 'Consumer groups are blank'
+      end
+      group.present?
+    end
+
+    def group_restricted?(consumer)
+      consumers_to_load = consumer_groups[group]
+      if consumers_to_load
+        !consumers_to_load.include?(consumer.name)
+      else
+        true
+      end
+    end
+
+    def group
+      Hutch::Config[:group]
+    end
+
+    def consumer_groups
+      Hutch::Config[:consumer_groups]
+    end
+
+    attr_accessor :setup_procs
+
+    def unique_consumer_tag
+      prefix = Hutch::Config[:consumer_tag_prefix]
+      unique_part = SecureRandom.uuid
+      "#{prefix}-#{unique_part}".tap do |tag|
+        raise "Tag must be 255 bytes long at most, current one is #{tag.bytesize} ('#{tag}')" if tag.bytesize > 255
+      end
+    end
+  end
+end

data/lib/hutch.rb

@@ -0,0 +1,69 @@
+require 'hutch/adapter'
+require 'hutch/consumer'
+require 'hutch/worker'
+require 'hutch/broker'
+require 'hutch/logging'
+require 'hutch/serializers/identity'
+require 'hutch/serializers/json'
+require 'hutch/config'
+require 'hutch/message'
+require 'hutch/cli'
+require 'hutch/version'
+require 'hutch/error_handlers'
+require 'hutch/exceptions'
+require 'hutch/tracers'
+
+module Hutch
+  @@connection_mutex = Mutex.new
+
+  def self.register_consumer(consumer)
+    self.consumers << consumer
+  end
+
+  def self.consumers
+    @consumers ||= []
+  end
+
+  def self.logger
+    Hutch::Logging.logger
+  end
+
+  def self.global_properties=(properties)
+    @global_properties = properties
+  end
+
+  def self.global_properties
+    @global_properties ||= {}
+  end
+
+  # Connects to broker, if not yet connected.
+  #
+  # @param options [Hash] Connection options
+  # @param config [Hash] Configuration
+  # @option options [Boolean] :enable_http_api_use
+  def self.connect(options = {}, config = Hutch::Config)
+    @@connection_mutex.synchronize do
+      unless connected?
+        @broker = Hutch::Broker.new(config)
+        @broker.connect(options)
+      end
+    end
+  end
+
+  def self.disconnect
+    @broker.disconnect if @broker
+  end
+
+  def self.broker
+    @broker
+  end
+
+  # @return [Boolean]
+  def self.connected?
+    broker && broker.connection && broker.connection.open?
+  end
+
+  def self.publish(*args)
+    broker.publish(*args)
+  end
+end

data/lib/yard-settings/handler.rb

@@ -0,0 +1,38 @@
+# :nodoc:
+class SettingsHandlerBase < YARD::Handlers::Ruby::Base
+  handles method_call :string_setting
+  handles method_call :number_setting
+  handles method_call :boolean_setting
+
+  namespace_only
+
+  def process
+    name = statement.parameters.first.jump(:tstring_content, :ident).source
+    object = YARD::CodeObjects::MethodObject.new(namespace, name)
+    register(object)
+
+    # Modify the code object for the new instance method
+    object.dynamic = true
+    # Add custom metadata to the object
+    object['custom_field'] = '(Found using method_missing)'
+
+    # Module-level configuration notes
+    hutch_config = YARD::CodeObjects::ModuleObject.new(:root, "Hutch::Config")
+    collection_name = statement.first.first
+    default_value = statement.parameters[1].jump(:tstring_content, :ident).source
+
+    (hutch_config['setting_rows'] ||= []) << {
+      name: name,
+      default_value: default_value,
+      type: collection_name.sub('_setting', '').capitalize,
+      description: object.docstring,
+      first_line_of_description: first_line_of_description(object)
+    }
+  end
+
+  def first_line_of_description(object)
+    return '' if object.docstring.blank?
+
+    object.docstring.lines.first
+  end
+end

data/lib/yard-settings/yard-settings.rb

@@ -0,0 +1,2 @@
+YARD::Templates::Engine.register_template_path(File.dirname(__FILE__) + '/../../templates')
+require File.join(File.dirname(__FILE__), 'handler') if RUBY19