brown 1.1.2 → 2.1.0

data/lib/brown/acl_loader.rb

@@ -1,57 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'tmpdir'
-require 'protobuf'
-
-require "brown/logger"
-
-class Brown::ACLLoader
-	extend 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

@@ -1,52 +0,0 @@
-# -*- 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/amqp_errors.rb

@@ -1,148 +0,0 @@
-# -*- 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

@@ -1,51 +0,0 @@
-# -*- 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

@@ -1,73 +0,0 @@
-# -*- 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

@@ -1,134 +0,0 @@
-# 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
-	end
-
-	def config
-		Class.new.tap do |cfg|
-			cfg.send(:define_method, :method_missing) do |*_args|
-				Class.new.tap do |group|
-					group.send(:define_method, :method_missing) do |*_args|
-						""
-					end
-				end.new
-			end
-		end.new
-	end
-
-	def running?
-		EM.reactor_running?
-	end
-
-	def start(opts={})
-		@log_level = opts[:log_level] || "info"
-
-		# Why these are not the defaults, I will never know
-		EM.epoll if EM.epoll?
-		EM.kqueue if EM.kqueue?
-
-		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