brown 2.2.2.25.g85ddf08 → 2.2.2.27.gbc378e8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a28012ee7ec217616a14b03b2fc61827d7f813b34d50e4a847ac6ab7a0e0303
-  data.tar.gz: a8671a1393a9e9c89a00eb8f949ebb901b6607fae694fe697dac0a771c4cff98
+  metadata.gz: 37896a92c6f9b1be0a84ed693b67fb57108bd2f1b97b27676f5f0912babe435b
+  data.tar.gz: 9613d3ee171cacd4eb004c82acfe837d2e3ce757d8bb2d63fba3c45cd9237664
 SHA512:
-  metadata.gz: 3d375959226721589ad39fbca4087bbe360a1394739a1689746b5715c34403b5594d6a3270f47a557dc46d58ba407be0f9917a71d9f015a3140db5cf9f3acd6e
-  data.tar.gz: ac06d3e484d71111faa20d4ca761ba97f0525e68d5ba25769725e8a6d9db2efd108a59a38e52242da3e9e62b959a894ecf2f61865c6bffcbc018c544b575603d
+  metadata.gz: af6720e99c528fc3d57d03f3c208853ec6edb177f29940235811f6713ff8f50585c4f745e6d6a206d7e75750c74c5ad7a8e79ee21b1bce887cc020d462b3f335
+  data.tar.gz: f7f2eee6381f9046e7f5e8ff2d0f5d71725eb62ceca37580830d590ac2b4790f4b3aa5fa173b5d9dbe28a18ad4f488411f73bb57a2dd1a2048218e41cf0a9b58

data/lib/brown/agent/amqp/class_methods.rb

@@ -109,6 +109,12 @@ module Brown::Agent::AMQP::ClassMethods
 	#   bindings are already in place, and thus no declarations should be
 	#   made to the AMQP broker.
 	#
+	# @param reject_on_error [Boolean] by default, if an uncaught exception
+	#   is raised during message handling, an error will be logged and the
+	#   listener will not process any new messages.  However, if
+	#   `reject_on_error: true`, then instead the message will be rejected, and
+	#   processing will continue
+	#
 	# @param blk [Proc] is called every time a message is received from
 	#   the queue, and an instance of {Brown::Agent::AMQPMessage} will
 	#   be passed as the sole argument.
@@ -123,6 +129,7 @@ module Brown::Agent::AMQP::ClassMethods
 	                  allowed_classes: nil,
 	                  routing_key:     nil,
 	                  predeclared:     false,
+	                  reject_on_error: false,
 	                  &blk
 	                 )
 		exchange_list = (Array === exchange_name ? exchange_name : [exchange_name]).map(&:to_s)
@@ -142,6 +149,7 @@ module Brown::Agent::AMQP::ClassMethods
 			routing_key:     routing_key,
 			callback:        blk,
 			predeclared:     predeclared,
+			reject_on_error: reject_on_error,
 		}
 	end
 end

data/lib/brown/agent/amqp/initializer.rb

@@ -58,13 +58,26 @@ module Brown::Agent::AMQP::Initializer
 	def initialize_listeners
 		(self.class.amqp_listeners || []).each do |listener|
 			logger.debug(logloc) { "Initializing AMQP listener #{listener}" }
-			worker_method = "amqp_listener_worker_#{SecureRandom.uuid}".to_sym
+			worker_method  = "amqp_listener_worker_#{SecureRandom.uuid}".to_sym
+			wrapper_method = "amqp_listener_wrapper_#{SecureRandom.uuid}".to_sym
+
 			define_singleton_method(worker_method, listener[:callback])
+			define_singleton_method(wrapper_method) do |msg|
+				begin
+					__send__(worker_method, msg)
+				rescue StandardError => ex
+					log_exception(ex) { "Exception while processing message #{msg.payload.inspect}" }
+					if listener[:reject_on_error]
+						logger.info(logloc) { "Rejecting message which caused exception" }
+						msg.reject
+					end
+				end
+			end
 
 			@stimuli ||= []
 			@stimuli << {
 				name: "amqp_listener_#{listener[:exchange_list].join("_").gsub(/[^A-Za-z0-9_]/, '_').gsub(/__+/, "_")}",
-				method: method(worker_method),
+				method: method(wrapper_method),
 				stimuli_proc: proc do |worker|
 					consumer = queue(listener).subscribe(manual_ack: true) do |di, prop, payload|
 						if listener[:autoparse]

data/lib/brown/agent/inotify/class_methods.rb

@@ -0,0 +1,34 @@
+require 'logger'
+require 'rb-inotify'
+require 'securerandom'
+
+# Class-level inotify support for Brown agents.
+#
+# These methods are intended to be applied to a `Brown::Agent` subclass, so you
+# can use them to define new file watchers in your agent.
+# You should not attempt to extend your classes directly with this module; the
+# {Brown::Agent::FileWatch} module should handle that for you automatically.
+#
+module Brown::Agent::FileWatch::ClassMethods
+	attr_reader :file_watchers
+
+	# Watch one or more files or directories for modification.
+	#
+	# If a change is detected on any of the paths you list, then the associated
+	# block of code will be executed.  If a path is a directory, then the entire
+	# directory hierarchy will be watched recursively for any file or directory
+	# creation, deletion, renaming, ormodification.  If the path is a file, it
+	# will be watched for modification.  In either case, the path being
+	# specified must already exist.
+	#
+	# @yieldparam event [INotify::Event] the raw `INotify::Event` that
+	#   caused the block to be called.
+	#
+	def watch(*paths, &blk)
+		@watchers ||= []
+		@watchers << {
+			paths:    paths,
+			callback: blk,
+		}
+	end
+end

data/lib/brown/agent/inotify/initializer.rb

@@ -0,0 +1,140 @@
+require "securerandom"
+require "json"
+require "yaml"
+
+# Methods that have to be prepended in order to work properly.
+#
+module Brown::Agent::AMQP::Initializer
+	def initialize(*_)
+		begin
+			super
+		rescue ArgumentError => ex
+			if ex.message =~ /wrong number of arguments.*expected 0/
+				super()
+			else
+				raise
+			end
+		end
+
+		initialize_publishers
+	end
+
+	def run
+		initialize_listeners
+
+		super
+	end
+
+	def shutdown
+		amqp_session.close
+
+		super
+	end
+
+	private
+
+	def amqp_session
+		@amqp_session ||= begin
+			logger.debug(logloc) { "Initializing AMQP session" }
+			Bunny.new(config.amqp_url, recover_from_connection_close: true, logger: config.logger).tap do |session|
+				session.on_blocked { |blocked| logger.warn(logloc) { "AMQP connection has become blocked: #{blocked.reason}" } }
+				session.on_unblocked { logger.info(logloc) { "AMQP connection has unblocked" } }
+				session.start
+			end
+		end
+	end
+
+	def initialize_publishers
+		(self.class.amqp_publishers || []).each do |publisher|
+			logger.debug(logloc) { "Initializing AMQP publisher #{publisher}" }
+			opts = { exchange_name: publisher[:name] }.merge(publisher[:opts])
+
+			amqp_publisher = Brown::Agent::AMQPPublisher.new(amqp_session: amqp_session, **opts)
+
+			define_singleton_method(publisher[:name]) { amqp_publisher }
+		end
+	end
+
+	def initialize_listeners
+		(self.class.amqp_listeners || []).each do |listener|
+			logger.debug(logloc) { "Initializing AMQP listener #{listener}" }
+			worker_method = "amqp_listener_worker_#{SecureRandom.uuid}".to_sym
+			define_singleton_method(worker_method, listener[:callback])
+
+			@stimuli ||= []
+			@stimuli << {
+				name: "amqp_listener_#{listener[:exchange_list].join("_").gsub(/[^A-Za-z0-9_]/, '_').gsub(/__+/, "_")}",
+				method: method(worker_method),
+				stimuli_proc: proc do |worker|
+					consumer = queue(listener).subscribe(manual_ack: true) do |di, prop, payload|
+						if listener[:autoparse]
+							logger.debug(logloc) { "Attempting to autoparse against Content-Type: #{prop.content_type.inspect}" }
+							case prop.content_type
+							when "application/json"
+								logger.debug(logloc) { "Parsing as JSON" }
+								payload = JSON.parse(payload)
+							when "application/x.yaml"
+								logger.debug(logloc) { "Parsing as YAML" }
+								payload = YAML.load(payload)
+							when "application/vnd.brown.object.v1"
+								logger.debug(logloc) { "Parsing as Brown object, allowed classes: #{listener[:allowed_classes]}" }
+								begin
+									payload = YAML.safe_load(payload, listener[:allowed_classes])
+								rescue Psych::DisallowedClass => ex
+									logger.error(logloc) { "message rejected: #{ex.message}" }
+									di.channel.nack(di.delivery_tag, false, false)
+									next
+								end
+							end
+						end
+
+						worker.call Brown::Agent::AMQPMessage.new(di, prop, payload)
+					end
+
+					while consumer&.channel&.status == :open do
+						logger.debug(logloc) { "stimuli_proc for #{listener[:queue_name]} having a snooze" }
+						sleep
+					end
+				end
+			}
+		end
+	end
+
+	def queue(listener)
+		@queue_cache ||= {}
+		@queue_cache[listener] ||= begin
+			bind_queue(
+				queue_name:    listener[:queue_name],
+				exchange_list: listener[:exchange_list].map(&:to_s),
+				concurrency:   listener[:concurrency],
+			)
+		rescue StandardError => ex
+			log_exception(ex) { "Unknown error while binding queue #{listener[:queue_name].inspect} to exchange list #{listener[:exchange_list].inspect}" }
+			sleep 5
+			retry
+		end
+	end
+
+	def bind_queue(queue_name:, exchange_list:, concurrency:)
+		ch = amqp_session.create_channel
+		ch.prefetch(concurrency)
+
+		ch.queue(queue_name, durable: true).tap do |q|
+			exchange_list.each do |exchange_name|
+				if exchange_name != ""
+					begin
+						q.bind(exchange_name)
+					rescue Bunny::NotFound => ex
+						logger.error { "bind failed: #{ex.message}" }
+						sleep 5
+						return bind_queue(
+						       queue_name:    queue_name,
+						       exchange_list: exchange_list,
+						       concurrency:   concurrency
+						      )
+					end
+				end
+			end
+		end
+	end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brown
 version: !ruby/object:Gem::Version
-  version: 2.2.2.25.g85ddf08
+  version: 2.2.2.27.gbc378e8
 platform: ruby
 authors:
 - Matt Palmer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-22 00:00:00.000000000 Z
+date: 2020-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -203,6 +203,8 @@ files:
 - lib/brown/agent/amqp_message_mock.rb
 - lib/brown/agent/amqp_publisher.rb
 - lib/brown/agent/class_methods.rb
+- lib/brown/agent/inotify/class_methods.rb
+- lib/brown/agent/inotify/initializer.rb
 - lib/brown/agent/memo.rb
 - lib/brown/agent/stimulus.rb
 - lib/brown/agent/stimulus/metrics.rb