brown 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 484e391eba640c3d0556ff4e9ad183427615015b
+  data.tar.gz: 8942004eb6a02b16be0918798311d2796b284539
+SHA512:
+  metadata.gz: d46574e93ee7268e3bfb0d5cfe5be84b8820012682c58e4fd592ea4a85953069da27c4fac289ec7fe362608fb9ee040c4cfd9dd6b8a5536e03046beef69c60ef
+  data.tar.gz: 290cda8b17a65fc9b76fce0439d1e76e02b5f112f82fcc766bc66efb8c9440e39f6c4940fa37b37d8fef5811a7865588cf990cbc487f5495cb5c4c169f8bebd1

data/.gitignore

@@ -0,0 +1,2 @@
+/Gemfile.lock
+/pkg

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Rakefile

@@ -0,0 +1,19 @@
+exec(*(["bundle", "exec", $PROGRAM_NAME] + ARGV)) if ENV['BUNDLE_GEMFILE'].nil?
+
+Bundler.setup(:default, :development)
+
+task :default => :test
+
+begin
+	Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+	$stderr.puts e.message
+	$stderr.puts "Run `bundle install` to install missing gems"
+	exit e.status_code
+end
+
+Bundler::GemHelper.install_tasks
+
+task :release do
+	sh "git release"
+end

data/bin/brown

@@ -0,0 +1,30 @@
+# Run an agent.  Any agent.
+
+require 'envied'
+
+envied_config = (ENVied.config || ENVied::Configuration.new).tap do |cfg|
+	cfg.enable_defaults!
+	cfg.variable :BROWN_ACL_PATH
+	cfg.variable :RABBITMQ_SERVER
+	cfg.variable :BROWN_LOG_LEVEL, :string, :default => "info"
+end
+
+ENVied.require(:default, :config => envied_config)
+
+# Trick smith-using agents into loving us -- since we have a `smith.rb` and
+# we should be the only thing in $LOAD_PATH at the moment, our version will
+# be loaded and the real smith will never darken our door.
+require 'smith'
+
+load *ARGV
+
+agent_classes = ObjectSpace.each_object(Class).select do |k|
+	k != Brown::Agent and k.ancestors.include?(Brown::Agent)
+end
+
+Brown::ACLLoader.load_all(ENVied.BROWN_ACL_PATH.split(":"))
+
+Brown.start(:server_url => ENVied.RABBITMQ_SERVER,
+            :log_level  => ENVied.BROWN_LOG_LEVEL) do
+	agent_classes.each { |k| k.new.run }
+end

data/brown.gemspec

@@ -0,0 +1,29 @@
+require "git-version-bump"
+
+Gem::Specification.new do |s|
+	s.name    = "brown"
+	s.version = GVB.version
+	s.date    = GVB.date
+
+	s.summary = "Run individual smith agents directly from the command line"
+
+	s.licenses = ["GPL-3"]
+
+	s.authors = ["Richard Heycock", "Matt Palmer"]
+
+	s.files = `git ls-files -z`.split("\0")
+	s.executables = %w{brown}
+
+	s.has_rdoc = false
+
+	s.add_runtime_dependency "amqp",            "~> 1.4"
+	s.add_runtime_dependency "envied",          "~> 0.8"
+	s.add_runtime_dependency "eventmachine-le", "~> 1.0"
+	s.add_runtime_dependency "extlib",          "~> 0.9"
+	s.add_runtime_dependency "murmurhash3",     "~> 0.1"
+	s.add_runtime_dependency "protobuf",        "~> 3.0"
+
+	s.add_development_dependency "bundler"
+	s.add_development_dependency "git-version-bump", "~> 0.10"
+	s.add_development_dependency "rake",             "~> 10.4", ">= 10.4.2"
+end

data/lib/brown.rb

@@ -0,0 +1,5 @@
+module Brown; end
+
+Dir["#{__dir__}/brown/*.rb"].each { |f| require f }
+
+Brown.extend Brown::ModuleMethods

data/lib/brown/acl_loader.rb

@@ -0,0 +1,57 @@
+# -*- encoding: utf-8 -*-
+
+require 'tmpdir'
+require 'protobuf'
+
+require "brown/logger"
+
+class Brown::ACLLoader
+	include Brown::Logger
+
+	def self.load_all(*dirs)
+		dirs.flatten!
+		pfiles = dirs.each_with_object([]) do |dir, list|
+			list << Dir["#{dir}/*.proto"]
+		end.flatten
+
+		load_proto_files(pfiles, dirs)
+	end
+
+	def self.load_proto_files(pfiles, dirs)
+		orig_load_path = $LOAD_PATH
+
+		Dir.mktmpdir do |tmpdir|
+			dirs = pfiles.map { |f| File.dirname(f) }.uniq + [tmpdir]
+			dirs.each { |d| $LOAD_PATH.unshift(d) }
+
+			compiles = []
+
+			pfiles.each do |f|
+				pbrbfile = f.gsub(/\.proto$/, ".pb.rb")
+				unless File.exists?(pbrbfile) and File.stat(pfile).mtime <= File.stat(pbrbfile).mtime
+					compiles << f
+				end
+			end
+
+			includes = dirs.map { |d| "-I '#{d}'" }.join(" ")
+
+			unless compiles.empty?
+				cmd = "protoc --ruby_out='#{tmpdir}' #{includes} #{compiles.map { |f| "'#{f}'" }.join(' ')} 2>&1"
+				output = nil
+
+				IO.popen(cmd) { |fd| output = fd.read }
+
+				if $?.exitstatus != 0
+					logger.fatal { "protoc failed: #{output}" }
+					raise RuntimeError, output
+				end
+			end
+
+			pfiles.each do |f|
+				require "#{File.basename(f, '.proto')}.pb"
+			end
+		end
+	ensure
+		$LOAD_PATH.replace(orig_load_path)
+	end
+end

data/lib/brown/acl_lookup.rb

@@ -0,0 +1,52 @@
+# -*- encoding: utf-8 -*-
+
+require 'extlib'
+require 'murmurhash3'
+
+module Brown::ACLLookup
+	def get_by_hash(type)
+		hashes[type]
+	end
+	module_function :get_by_hash
+
+	def get_by_type(type)
+		to_murmur32(type)
+	end
+	module_function :get_by_type
+
+	# Look the key up in the cache. This defaults to the key being the hash.
+	# If :by_type => true is passed in as the second argument then it will
+	# perform the lookup in the type hash.
+	#
+	def include?(key, opts={})
+		if opts[:by_type]
+			!get_by_type(key).nil?
+		else
+			!get_by_hash(key).nil?
+		end
+	end
+	module_function :include?
+
+	def clear!
+		@hashes = nil
+	end
+	module_function :clear!
+
+	def hashes
+		@hashes ||= begin
+			map = ObjectSpace.each_object(Class).map do |k|
+				[[to_murmur32(k), k], [k.to_s.split(/::/).last.snake_case, k]]
+			end.flatten(1)
+			Hash[map]
+		end
+	end
+	module_function :hashes
+
+	private
+
+	# Convert the name to a base 36 murmur hash
+	def to_murmur32(type)
+		MurmurHash3::V32.murmur3_32_str_hash(type.to_s).to_s(36)
+	end
+	module_function :to_murmur32
+end

data/lib/brown/agent.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+require "brown/logger"
+
+class Brown::Agent
+	include Brown::Logger
+
+	# Override this method to implement your own agent.
+	def run
+		raise ArgumentError, "You must override this method"
+	end
+
+	def receiver(queue_name, opts={}, &blk)
+		queues.receiver(queue_name, opts, &blk)
+	end
+
+	def sender(queue_name, opts={}, &blk)
+		queues.sender(queue_name, opts, &blk)
+	end
+
+	class << self
+		# I care not for your opts... this is just here for Smith compatibility
+		def options(opts)
+		end
+	end
+
+	protected
+
+	def queues
+		@queues ||= Brown::QueueFactory.new
+	end
+end

data/lib/brown/amqp_errors.rb

@@ -0,0 +1,148 @@
+# -*- encoding: utf-8 -*-
+
+module Brown::AmqpErrors
+	def error_message(code, text, &blk)
+		details = error_lookup(code)
+		message = "#{details[:error_class]} exception: #{code} " +
+		          "(#{details[:name]}). #{details[:description]}"
+
+		case code
+		when 404
+			diagnosis = "looks like the queue has been deleted."
+		when 406
+			case text
+			when /.*(unknown delivery tag [0-9]+).*/
+				diagnosis = "#{$1} - you've probably already acknowledged the message."
+			end
+		else
+		end
+		blk.call(message, diagnosis)
+	end
+
+	def error_lookup(code)
+		errors[code]
+	end
+
+	def errors
+		@errors ||= {
+			311 => {
+				:name        => "content-too-large",
+				:error_class => "Channel",
+				:description => "The client attempted to transfer content larger " +
+				                "than the server could accept at the present time. " +
+				                "The client may retry at a later time."
+			},
+			313 => {
+				:name        => "no-consumers",
+				:error_class => "Channel",
+				:description => "When the exchange cannot deliver to a consumer " +
+				                "when the immediate flag is set. As a result of " +
+				                "pending data on the queue or the absence of any " +
+				                "consumers of the queue."
+			},
+			320 => {
+				:name        => "connection-forced",
+				:error_class => "Connection",
+				:description => "An operator intervened to close the Connection " +
+				                "for some reason. The client may retry at some " +
+				                "later date."
+			},
+			402 => {
+				:name        => "invalid-path",
+				:error_class => "Connection",
+				:description => "The client tried to work with an unknown virtual host."
+			},
+			403 => {
+				:name        => "access-refused",
+				:error_class => "Channel",
+				:description => "The client attempted to work with a server " +
+				                "entity to which it has no access due to security " +
+				                "settings."
+			},
+			404 => {
+				:name        => "not-found",
+				:error_class => "Channel",
+				:description => "The client attempted to work with a server " +
+				                "entity that does not exist."
+			},
+			405 => {
+				:name        => "resource-locked",
+				:error_class => "Channel",
+				:description => "The client attempted to work with a server " +
+				                "entity to which it has no access because " +
+				                "another client is working with it."
+			},
+			406 => {
+				:name        => "precondition-failed",
+				:error_class => "Channel",
+				:description => "The client requested a method that was not " +
+				                "allowed because some precondition failed."
+			},
+			501 => {
+				:name        => "frame-error",
+				:error_class => "Connection",
+				:description => "The sender sent a malformed frame that the " +
+				                "recipient could not decode. This strongly " +
+				                "implies a programming error in the sending peer."
+			},
+			502 => {
+				:name        => "syntax-error",
+				:error_class => "Connection",
+				:description => "The sender sent a frame that contained illegal " +
+				                "values for one or more fields. This strongly " +
+				                "implies a programming error in the sending peer."
+			},
+			503 => {
+				:name        => "command-invalid",
+				:error_class => "Connection",
+				:description => "The client sent an invalid sequence of frames, " +
+				                "attempting to perform an operation that was " +
+				                "considered invalid by the server. This usually " +
+				                "implies a programming error in the client."
+			},
+			504 => {
+				:name        => "channel-error",
+				:error_class => "Connection",
+				:description => "The client attempted to work with a Channel that " +
+				                "had not been correctly opened. This most likely " +
+				                "indicates a fault in the client layer."
+			},
+			505 => {
+				:name        => "unexpected-frame",
+				:error_class => "Connection",
+				:description => "The peer sent a frame that was not expected, " +
+				                "usually in the context of a content header and " +
+				                "body. This strongly indicates a fault in the " +
+				                "peer's content processing."
+			},
+			506 => {
+				:name        => "resource-error",
+				:error_class => "Connection",
+				:description => "The server could not complete the method because " +
+				                "it lacked sufficient resources. This may be due " +
+				                "to the client creating too many of some type of entity."
+			},
+			530 => {
+				:name        => "not-allowed",
+				:error_class => "Connection",
+				:description => "The client tried to work with some entity in a " +
+				                "manner that is prohibited by the server, due to " +
+				                "security settings or by some other criteria."
+			},
+			540 => {
+				:name        => "not-implemented",
+				:error_class => "Connection",
+				:description => "The client tried to use functionality that is " +
+				                "not implemented in the server."
+			},
+			541 => {
+				:name        => "internal-error",
+				:error_class => "Connection",
+				:description => "The server could not complete the method " +
+				                "because of an internal error. The server may " +
+				                "require intervention by an operator in order " +
+				                "to resume normal operations."
+			}
+		}
+	end
+end

data/lib/brown/logger.rb

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+
+require 'logger'
+
+class Logger
+	VERBOSE = 0.5
+	TRACE   = -1
+
+	# Lack of prior planning, peeps!
+	remove_const(:SEV_LABEL)
+	SEV_LABEL = {
+		TRACE   => "TRACE",
+		DEBUG   => "DEBUG",
+		VERBOSE => "VERB",
+		INFO    => "INFO",
+		WARN    => "WARN",
+		ERROR   => "ERROR",
+		FATAL   => "FATAL"
+	}
+
+	def verbose(progname = nil, &block)
+		add(VERBOSE, nil, progname, &block)
+	end
+
+	def trace(progname = nil, &block)
+		add(TRACE, nil, progname, &block)
+	end
+end
+
+module Brown::Logger
+	def logger
+		@logger ||= begin
+			Logger.new($stderr).tap do |l|
+				l.formatter = proc { |s,dt,n,msg| "#{$$} [#{s[0]}] #{msg}\n" }
+				l.level = Logger.const_get(Brown.log_level.upcase.to_sym)
+			end
+		end
+	end
+
+	def log_level(level=nil)
+		if level
+			logger.level = Logger.const_get(level.upcase.to_sym)
+		end
+	end
+
+	def backtrace(ex)
+		if ex.respond_to?(:backtrace) and ex.backtrace
+			self.debug { ex.backtrace.map { |l| "  #{l}" }.join("\n") }
+		end
+	end
+end

data/lib/brown/message.rb

@@ -0,0 +1,73 @@
+# -*- encoding: utf-8 -*-
+
+require 'brown/logger'
+
+class Brown::Message
+	include Brown::Logger
+
+	attr_reader :payload, :metadata
+
+	def initialize(payload, metadata, requeue_queue, requeue_options, opts = {}, &blk)
+		@metadata = metadata
+
+		@requeue_queue   = requeue_queue
+		@requeue_options = requeue_options
+
+		@requeue_options[:strategy] ||= :linear
+
+		@requeue_options[:on_requeue] ||= ->(count, total_count, cumulative_delay) {
+			logger.info { "Requeuing (#{@requeue_options[:strategy]}) message on queue: #{@requeue_queue.name}, count: #{count} of #{total_count}." }
+		}
+
+		@requeue_options[:on_requeue_limit] ||= ->(message, count, total_count, cumulative_delay) {
+			logger.info { "Not attempting any more requeues, requeue limit reached: #{total_count} for queue: #{@requeue_queue.name}, cummulative delay: #{cumulative_delay}s." }
+		}
+
+		klass = Brown::ACLLookup.get_by_hash(metadata.type)
+		raise RuntimeError, "Unknown ACL: #{metadata.type}" if klass.nil?
+
+		@payload = klass.new.parse_from_string(payload)
+
+		blk.call(@payload, self)
+		ack if opts[:auto_ack]
+	end
+
+	def ack(multiple = false)
+		@metadata.ack(multiple)
+	end
+
+	def nak(opts = {})
+		@metadata.reject(opts)
+	end
+
+	alias_method :reject, :nak
+
+	def requeue
+		if current_requeue_number < @requeue_options[:count]
+			cumulative_delay = case @requeue_options[:strategy].to_sym
+			when :linear
+				@requeue_options[:delay] * (current_requeue_number + 1)
+			when :exponential
+				@requeue_options[:delay] * (2 ** current_requeue_number)
+			when :exponential_no_initial_delay
+				@requeue_options[:delay] * (2 ** current_requeue_number - 1)
+			else
+				raise RuntimeError, "Unknown requeue strategy #{@requeue_options[:strategy].to_sym.inspect}"
+			end
+
+			EM.add_timer(cumulative_delay) do
+				new_headers = (@metadata.headers || {}).merge('requeue' => current_requeue_number + 1)
+				@requeue_queue.publish(@payload, @metadata.to_hash.merge(:headers => new_headers))
+			end
+
+			@requeue_options[:on_requeue].call(current_requeue_number + 1, @requeue_options[:count], cumulative_delay)
+		else
+			@requeue_options[:on_requeue_limit].call(@payload, current_requeue_number + 1, @requeue_options[:count], @requeue_options[:delay] * current_requeue_number)
+		end
+	end
+
+	private
+	def current_requeue_number
+		(@metadata.headers['requeue'] rescue nil) || 0
+	end
+end

data/lib/brown/module_methods.rb

@@ -0,0 +1,120 @@
+# Remove any pre-existing activation of eventmachine, so that `eventmachine-le`
+# takes priority
+$:.delete_if { |d| d =~ /\/eventmachine-\d/ }
+
+require 'eventmachine-le'
+require 'amqp'
+require 'uri'
+
+require 'brown/logger'
+
+module Brown::ModuleMethods
+	include Brown::Logger
+
+	attr_reader :connection, :log_level
+
+	def compile_acls
+		@compiler = ACLCompiler.new
+		@compiler.compile
+	end
+
+	def running?
+		EM.reactor_running?
+	end
+
+	def start(opts={})
+		@log_level = opts[:log_level] || "info"
+
+		connection_settings = {
+		  :on_tcp_connection_failure          => method(:tcp_connection_failure_handler),
+		  :on_possible_authentication_failure => method(:authentication_failure_handler)
+		}
+
+		AMQP.start(opts[:server_url], connection_settings) do |connection|
+			EM.threadpool_size = 1
+			@connection = connection
+
+			connection.on_connection do
+				logger.info { "Connected to: AMQP Broker: #{broker_identifier(connection)}" }
+			end
+
+			connection.on_tcp_connection_loss do |connection, settings|
+				logger.info { "Reconnecting to AMQP Broker: #{broker_identifier(connection)} in 5s" }
+				connection.reconnect(false, 5)
+			end
+
+			connection.after_recovery do |connection|
+				logger.info { "Connection with AMQP Broker restored: #{broker_identifier(connection)}" }
+			end
+
+			connection.on_error do |connection, connection_close|
+				# If the broker is gracefully shutdown we get a 320. Log a nice message.
+				if connection_close.reply_code == 320
+					logger.info { "AMQP Broker shutdown: #{broker_identifier(connection)}" }
+				else
+					logger.warn { connection_close.reply_text }
+				end
+			end
+
+			# This will be the last thing run by the reactor.
+			shutdown_hook { logger.debug { "Reactor Stopped" } }
+
+			yield if block_given?
+		end
+	end
+
+	def shutdown_hook(&block)
+		EM.add_shutdown_hook(&block)
+	end
+
+	def stop(immediately=false, &blk)
+		shutdown_hook(&blk) if blk
+
+		if running?
+			if immediately
+				EM.next_tick do
+					@connection.close { EM.stop_event_loop }
+				end
+			else
+				EM.add_timer(1) do
+					@connection.close { EM.stop_event_loop }
+				end
+			end
+		else
+			logger.fatal { "Eventmachine is not running, exiting with prejudice" }
+			exit!
+		end
+	end
+
+	private
+
+	def tcp_connection_failure_handler(settings)
+		# Only display the following settings.
+		s = settings.select { |k,v| ([:user, :pass, :vhost, :host, :port, :ssl].include?(k)) }
+
+		logger.fatal { "Cannot connect to the AMQP server." }
+		logger.fatal { "Is the server running and are the connection details correct?" }
+		logger.info { "Details:" }
+		s.each do |k,v|
+			logger.info { " Setting: %-7s%s" %  [k, v] }
+		end
+		EM.stop
+	end
+
+	def authentication_failure_handler(settings)
+		# Only display the following settings.
+		s = settings.select { |k,v| [:user, :pass, :vhost, :host].include?(k) }
+
+		logger.fatal { "Authentication failure." }
+		logger.info { "Details:" }
+		s.each do |k,v|
+			logger.info { " Setting: %-7s%s" %  [k, v] }
+		end
+		EM.stop
+	end
+
+	def broker_identifier(connection)
+		broker = connection.broker.properties
+		"#{connection.broker_endpoint}, (#{broker['product']}/v#{broker['version']})"
+	end
+end

data/lib/brown/queue_definition.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+class Brown::QueueDefinition
+	attr_reader :options
+
+	def initialize(name, options)
+		@normalised_queue = "smith.#{name}"
+		@denormalised_queue = "#{name}"
+		@options = options
+	end
+
+	def denormalise
+		@denormalised_queue
+	end
+
+	def name
+		@normalised_queue
+	end
+
+	def normalise
+		@normalised_queue
+	end
+
+	# to_a is defined to make the splat operator work.
+	def to_a
+		return @normalised_queue, @options
+	end
+
+	def to_s
+		"<#{self.class}: #{@denormalised_queue}, #{@options.inspect}>"
+	end
+end

data/lib/brown/queue_factory.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+class Brown::QueueFactory
+	def initialize
+		@cache = {}
+	end
+
+	# Convenience method that returns a Sender object.
+	def sender(queue_name, opts={}, &blk)
+		k = "sender:#{queue_name}"
+		@cache[k] ||= Brown::Sender.new(queue_name, opts)
+		blk.call(@cache[k])
+	end
+
+	# Convenience method that returns a Receiver object.
+	def receiver(queue_name, opts={}, &blk)
+		k = "receiver:#{queue_name}"
+		@cache[k] ||= Brown::Receiver.new(queue_name, opts)
+		blk.call(@cache[k])
+	end
+
+	# Passes each queue to the supplied block.
+	def each_queue
+		@cache.values.each do |queue|
+			yield queue if block_given?
+		end
+	end
+
+	# Returns all queues as a hash, with the queue name being the key.
+	def queues
+		@cache
+	end
+end

data/lib/brown/receiver.rb

@@ -0,0 +1,143 @@
+# -*- encoding: utf-8 -*-
+
+require 'brown/logger'
+require 'brown/util'
+
+class Brown::Receiver
+	include Brown::Logger
+	include Brown::Util
+
+	def initialize(queue_def, opts={}, &blk)
+		@queue_def = queue_def.is_a?(Brown::QueueDefinition) ? queue_def : Brown::QueueDefinition.new(queue_def, opts)
+
+		@acl_type_cache = Brown::ACLLookup
+
+		@options = opts
+
+		@requeue_options = {}
+		@requeue_queue   = Brown::Sender.new(@queue_def, opts)
+
+		@payload_type = Array(option_or_default(@queue_def.options, :type, []))
+
+		prefetch = option_or_default(@queue_def.options, :prefetch, 1)
+
+		@channel_completion = EM::Completion.new
+		@queue_completion = EM::Completion.new
+
+		open_channel(:prefetch => prefetch) do |channel|
+			logger.debug { "channel open for receiver on #{@queue_def.denormalise}" }
+			channel.on_error do |ch, close|
+				logger.fatal { "Channel error: #{close.inspect}" }
+			end
+
+			channel.queue(@queue_def.normalise) do |queue|
+				logger.debug { "Registered queue #{@queue_def.denormalise} on channel" }
+				@queue_completion.succeed(queue)
+			end
+
+			@channel_completion.succeed(channel)
+		end
+
+		blk.call(self) if blk
+	end
+
+	def ack(multiple=false)
+		@channel_completion.completion {|channel| channel.ack(multiple) }
+	end
+
+	# Subscribes to a queue and passes the headers and payload into the
+	# block. +subscribe+ will automatically acknowledge the message unless
+	# the options sets :ack to false.
+	def subscribe(opts = {}, &blk)
+		@queue_completion.completion do |queue|
+			logger.debug { "Subscribing to: [queue]:#{@queue_def.denormalise} [options]:#{@queue_def.options}" }
+			queue.subscribe(opts.merge(:ack => true)) do |metadata,payload|
+				logger.debug { "Received a message on #{@queue_def.denormalise}: #{metadata.to_hash.inspect}" }
+				if payload
+					on_message(metadata, payload, &blk)
+				else
+					logger.debug { "Received null message on: #{@queue_def.denormalise} [options]:#{@queue_def.options}" }
+				end
+			end
+		end
+	end
+
+	def unsubscribe(&blk)
+		@queue_completion.completion do |queue|
+			queue.unsubscribe(&blk)
+		end
+	end
+
+	def requeue_parameters(opts)
+		@requeue_options.merge!(opts)
+	end
+
+	def on_requeue(&blk)
+		@requeue_options[:on_requeue] = blk
+	end
+
+	def on_requeue_limit(&blk)
+		@requeue_options[:on_requeue_limit] = blk
+	end
+
+	# pops a message off the queue and passes the headers and payload
+	# into the block. +pop+ will automatically acknowledge the message
+	# unless the options sets :ack to false.
+	def pop(&blk)
+		@queue_completion.completion do |queue|
+			queue.pop({}) do |metadata, payload|
+				if payload
+					on_message(metadata, payload, &blk)
+				else
+					blk.call(nil,nil)
+				end
+			end
+		end
+	end
+
+	# Define a channel error handler.
+	def on_error(chain=false, &blk)
+		# TODO Check that this chains callbacks
+		@channel_completion.completion do |channel|
+			channel.on_error(&blk)
+		end
+	end
+
+	def queue_name
+		@queue_def.denormalise
+	end
+
+	def delete(&blk)
+		@queue_completion.completion do |queue|
+			@channel_completion.completion do |channel|
+				queue.unbind(exchange) do
+					queue.delete do
+						exchange.delete do
+							channel.close(&blk)
+						end
+					end
+				end
+			end
+		end
+	end
+
+	def status(&blk)
+		@queue_completion.completion do |queue|
+			queue.status do |num_messages, num_consumers|
+				blk.call(num_messages, num_consumers)
+			end
+		end
+	end
+
+	private
+
+	def on_message(metadata, payload, &blk)
+		if @payload_type.empty? || @payload_type.include?(@acl_type_cache.get_by_hash(metadata.type))
+			Brown::Message.new(payload, metadata, @requeue_queue, @requeue_options, @options, &blk)
+		else
+			allowable_acls = @payload_type.join(", ")
+			received_acl = @acl_type_cache.get_by_hash(metadata.type)
+			raise ACL::IncorrectTypeError, "Received ACL: #{received_acl} on queue: #{@queue_def.denormalise}. This queue can only accept the following ACLs: #{allowable_acls}"
+		end
+	end
+end

data/lib/brown/sender.rb

@@ -0,0 +1,92 @@
+# -*- encoding: utf-8 -*-
+
+require 'brown/logger'
+require 'brown/util'
+
+class Brown::Sender
+	include Brown::Logger
+	include Brown::Util
+
+	attr_reader :name
+
+	def initialize(queue_def, opts={})
+		@queue_def = queue_def.is_a?(Brown::QueueDefinition) ? queue_def : Brown::QueueDefinition.new(queue_def, opts)
+		@name      = @queue_def.denormalise
+
+		@reply_container = {}
+
+		@message_count = 0
+
+		@channel_completion = EM::Completion.new
+
+		open_channel do |channel|
+			logger.debug { "Opening a channel for sending" }
+			@channel_completion.succeed(channel)
+		end
+	end
+
+	def publish(payload, opts={}, &blk)
+		logger.debug { "Publishing to: [queue]: #{@queue_def.denormalise}. [options]: #{opts}" }
+		logger.debug { "ACL content: [queue]: #{@queue_def.denormalise}, [metadata type]: #{payload.class}, [message]: #{payload.inspect}" }
+
+		increment_counter
+
+		type = Brown::ACLLookup.get_by_type(payload.class)
+
+		@channel_completion.completion do |channel|
+			logger.debug { "Publishing #{payload.inspect} to queue #{@queue_def.denormalise}" }
+			AMQP::Exchange.default(channel).publish(payload.to_s, opts.merge(:type => type, :routing_key => @queue_def.normalise), &blk)
+		end
+	end
+
+	def delete(&blk)
+		queue.delete do
+			@channel_completion.completion do |channel|
+				channel.close(&blk)
+			end
+		end
+	end
+
+=begin
+	def status(&blk)
+		@queue_completion.completion do |queue|
+			queue.status do |num_messages, num_consumers|
+				blk.call(num_messages, num_consumers) if blk
+			end
+		end
+	end
+
+	def message_count(&blk)
+		status do |messages|
+			blk.call(messages) if blk
+		end
+	end
+
+	def consumer_count(&blk)
+		status do |_, consumers|
+			blk.call(consumers) if blk
+		end
+	end
+=end
+
+	def counter
+		@message_count
+	end
+
+	# Define a channel error handler.
+	def on_error(chain=false, &blk)
+		@channel_completion.completion do |channel|
+			channel.on_error(&blk)
+		end
+	end
+
+	def queue_name
+		@queue_def.denormalise
+	end
+
+	private
+
+	def increment_counter(value=1)
+		@message_count += value
+	end
+end

data/lib/brown/util.rb

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+
+require "brown/amqp_errors"
+require "brown/logger"
+
+module Brown::Util
+	include Brown::AmqpErrors
+	include Brown::Logger
+
+	def number_of_messages
+		status do |num_messages, _|
+			yield num_messages
+		end
+	end
+
+	def number_of_consumers
+		status do |_, num_consumers|
+			yield num_consumers
+		end
+	end
+
+	private
+
+	def open_channel(opts={}, &blk)
+		AMQP::Channel.new(Brown.connection) do |channel,_|
+			logger.debug { "Opened channel: #{"%#x" % channel.object_id}" }
+
+			channel.auto_recovery = true
+			logger.debug { "Channel auto recovery enabled" }
+
+			# Set up QoS. If you do not do this then any subscribes will get
+			# overwhelmed if there are too many messages.
+			prefetch = opts[:prefetch] || 1
+
+			channel.prefetch(prefetch)
+			logger.debug { "AMQP prefetch set to: #{prefetch}" }
+
+			blk.call(channel)
+		end
+	end
+
+	def random(prefix = '', suffix = '')
+		"#{prefix}#{SecureRandom.hex(8)}#{suffix}"
+	end
+
+	def option_or_default(options, key, default, &blk)
+		if options.is_a?(Hash)
+			if options.key?(key)
+				v = options.delete(key)
+				(blk) ? blk.call(v) : v
+			else
+				default
+			end
+		else
+			raise ArguementError, "Options must be a Hash."
+		end
+	end
+end

data/lib/smith.rb

@@ -0,0 +1,4 @@
+# -*- encoding: utf-8 -*-
+require 'brown'
+
+Smith = Brown

metadata

@@ -0,0 +1,196 @@
+--- !ruby/object:Gem::Specification
+name: brown
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Richard Heycock
+- Matt Palmer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: amqp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: envied
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: eventmachine-le
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: extlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: murmurhash3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: git-version-bump
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+description: 
+email: 
+executables:
+- brown
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Rakefile
+- bin/brown
+- brown.gemspec
+- lib/brown.rb
+- lib/brown/acl_loader.rb
+- lib/brown/acl_lookup.rb
+- lib/brown/agent.rb
+- lib/brown/amqp_errors.rb
+- lib/brown/logger.rb
+- lib/brown/message.rb
+- lib/brown/module_methods.rb
+- lib/brown/queue_definition.rb
+- lib/brown/queue_factory.rb
+- lib/brown/receiver.rb
+- lib/brown/sender.rb
+- lib/brown/util.rb
+- lib/smith.rb
+homepage: 
+licenses:
+- GPL-3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Run individual smith agents directly from the command line
+test_files: []