droid 0.9.0

data/speaker/droid_speaker.rb

@@ -0,0 +1,79 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../vendor/json_pure-1.1.3/lib'
+require 'json'
+require 'drb'
+require 'timeout'
+
+class DroidSpeaker
+
+	def self.drb_connect(port)
+		DRb.start_service()
+		@drb = DRbObject.new(nil,"druby://localhost:#{port}")
+	end
+
+	def self.drb_cast(topic, payload, &p) 
+		@drb.publish(topic, payload, &p)
+	end
+
+	def self.drb_call(topic, payload)
+		## this is the best stupid trick I could think of the force blocking
+		lock = Thread.new { sleep 9999 }
+		@r = nil
+		@drb.publish(topic, payload) do |result|
+			@r = result
+			lock.kill
+		end
+		lock.join
+		@r
+	end
+
+	def self.send(topic, payload, &p)
+		i = new
+		i.send(topic, payload, &p)
+		i.flush
+	end
+
+	def self.start
+		i = new
+		yield(i)
+		i.flush
+	end
+
+	def initialize
+		@message = nil
+		@callback = nil
+	end
+
+	def send(topic, payload, &blk)
+		if defined?(Log) and event_id = Log.default_options[:event_id]
+			payload.merge!(:event_hash => event_id)
+		end
+
+		attrs = { :topic => topic, :payload => payload }
+		if blk # this message should be replied
+			attrs.merge!(:has_reply => true)
+			@callback = blk
+		end
+		@message = attrs
+	end
+
+	class MessageError < RuntimeError; end
+
+	def flush
+		out = ''
+		IO.popen("#{File.dirname(__FILE__)}/../speaker/speak 2>/dev/null", 'w+') do |io|
+			io.puts @message.to_json
+			out = io.read
+		end
+		begin
+			response = JSON.parse(out)
+			response.delete('event_hash')
+			@callback.call(response) if @callback
+		rescue JSON::ParserError
+			if out.include?('Timeout::Error')
+				raise Timeout::Error, "Timed out while waiting for a response for #{@message[:topic]}"
+			else
+				raise MessageError, out
+			end
+		end
+	end
+end

data/speaker/speak

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+begin
+	$:.unshift '/usr/local/droid/lib'
+	require 'heroku_droid'
+
+	msg = JSON.load(gets)
+
+	Timeout.timeout(10) do
+		HerokuDroid.new('Droid Speaker', :standard_topics => false) do |droid|
+			if msg['has_reply']
+				@event_hash = msg['payload']['event_hash'] ||= Droid::Basic.new(droid).event_hash
+				droid.listen4('event.error') do |d|
+					if d.headers[:event_hash] == @event_hash
+						puts "Message #{msg['topic']} failed: see event #{@event_hash}"
+						Droid.stop_safe
+					end
+				end
+
+				droid.publish(msg['topic'], msg['payload']) do |d|
+					puts d.params.to_json
+					Droid.stop_safe
+				end
+			else
+				droid.publish(msg['topic'], msg['payload'])
+				puts({}.to_json)
+				Droid.stop_safe
+			end
+		end
+	end
+rescue Object => e
+	puts "#{e.class}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+end

data/speaker/test.rb

@@ -0,0 +1,58 @@
+Thread.new do
+	require File.dirname(__FILE__) + '/../lib/heroku_droid'
+	HerokuDroid.new('Droid speaker test') do |droid|
+		droid.listen4('speaker.test') do |msg|
+			if msg['marco'] == 1
+				puts "Got 'marco', returning 'polo'..."
+				msg.reply('polo' => 1)
+			else
+				puts "Bad payload"
+				msg.reply('error' => 1)
+			end
+		end
+		droid.listen4('speaker.raise') do |msg|
+			raise "droid raised exception"
+		end
+	end
+end
+
+sleep 2
+
+require File.dirname(__FILE__) + '/droid_speaker'
+
+puts "\nTest 1: Sending simple message"
+DroidSpeaker.send('fire.and.forget', 'val' => 1)
+puts "\tSuccess!"
+
+puts "\nTest 2: Sending and receiving response"
+DroidSpeaker.send('speaker.test', 'marco' => 1) do |r|
+	if r['polo'] == 1
+		puts "\tSuccess!"
+	else
+		puts "\tFailed, result: #{r.inspect}"
+	end
+end
+
+puts "\nTest 3: Exceptions"
+begin
+	DroidSpeaker.send('speaker.raise', {}) do |r|
+		puts "\tFailed, expected exception"
+	end
+rescue DroidSpeaker::MessageError => e
+	if e.message =~ /event \w+/
+		puts "\tSuccess!"
+	else
+		puts "\tFailed, droid speaker raised #{e.message}"
+	end
+end
+
+puts "\nTest 4: Timeout"
+begin
+	DroidSpeaker.send('dont.reply', {}) do |r|
+		puts "\tFailed, didnt expect a response"
+	end
+rescue Timeout::Error
+	puts "\tSuccess!"
+rescue Exception => e
+	puts "\tFailed, expected Timeout::Error, got #{e.class.name}"
+end

data/test/base.rb

@@ -0,0 +1,43 @@
+require 'rush'
+
+def publish(message, payload={})
+	Droid.new('Sender', RabbitmqSetup.credentials) do |d|
+		d.publish(message, payload)
+		Droid.stop_safe
+	end
+	sleep(0.1)
+end
+
+$exchange = nil
+$mutex = Mutex.new
+def exchange
+	$mutex.synchronize { $exchange }
+end
+def save_in_exchange(v)
+	$mutex.synchronize { $exchange = v }
+end
+
+module RabbitmqSetup
+	extend self
+
+	def credentials
+		{
+			:vhost => '/test',
+			:host	=> 'localhost',
+			:user	=> 'test',
+			:pass	=> 'test'
+		}
+	end
+
+	def run_rabbitmqctl(command)
+		Rush::Box.new.bash "rabbitmqctl #{command}"
+	rescue Rush::BashFailed => e
+		raise unless e.message.match(/already_exists/)
+	end
+
+	def run
+		run_rabbitmqctl("add_vhost #{credentials[:vhost]}")
+		run_rabbitmqctl("add_user #{credentials[:user]} #{credentials[:pass]}")
+		run_rabbitmqctl("map_user_vhost #{credentials[:user]} #{credentials[:vhost]}")
+	end
+end

data/test/droid_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../lib/droid'
+require File.dirname(__FILE__) + '/base'
+
+require 'rubygems'
+require 'thread'
+require 'bacon'
+
+RabbitmqSetup.run
+
+Bacon.summary_on_exit
+
+Thread.new do
+	Droid.new('Test Droid', RabbitmqSetup.credentials) do |d|
+		d.on_error do |msg, e|
+			save_in_exchange(e)
+		end
+
+		d.before_filter do |msg|
+			if to_save = msg[:save_in_before_filter]
+				save_in_exchange(to_save)
+			end
+		end
+
+		d.listen4('save.msg') do |msg|
+			save_in_exchange(msg)
+		end
+
+		d.listen4('do.nothing') do |msg|
+		end
+	end
+end
+
+sleep(2) # wait until droid is up
+describe Droid do
+	before do
+		save_in_exchange(nil)
+	end
+
+	it "sends and receives simple messages" do
+		publish('save.msg')
+		exchange.should.not == nil
+	end
+
+	it "sends messages with params" do
+		publish('save.msg', :test => 1)
+		exchange[:test].should == 1
+	end
+
+	it "accepts before filters" do
+		publish('do.nothing', :save_in_before_filter => 42)
+		exchange.should == 42
+	end
+end

data/test/heroku_droid_test.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../lib/heroku_droid'
+require File.dirname(__FILE__) + '/base'
+
+require 'rubygems'
+require 'thread'
+require 'bacon'
+
+Bacon.summary_on_exit
+
+Thread.new do
+	HerokuDroid.new('Test Heroku Droid') do |d|
+		d.stats do
+			"some stats"
+		end
+
+		d.listen4('pong') do |msg|
+			save_in_exchange('worked') if msg['notes'] == 'some stats'
+		end
+
+		d.listen4('save.msg') do |msg|
+			save_in_exchange(msg)
+		end
+	end
+end
+
+sleep(2) # wait until droid is up
+describe HerokuDroid do
+	before do
+		save_in_exchange(nil)
+	end
+
+	it "sends and receives simple messages" do
+		publish('save.msg')
+		exchange.should.not == nil
+	end
+
+	it "responds to ping with a pong message and instances/droid stats filled in" do
+		publish('ping')
+		sleep 3
+		exchange.should == 'worked'
+	end
+end

data/test/wait_for_port_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../lib/droid'
+require File.dirname(__FILE__) + '/base'
+
+require 'rubygems'
+require 'thread'
+require 'bacon'
+
+Bacon.summary_on_exit
+
+Thread.new do
+	sleep 2
+	TCPServer.new('localhost', 20_001).accept.close
+end
+
+describe Droid do
+	it "waits for the rabbitmq server to come up before opening the amqp connection" do
+		start = Time.now
+		Droid.wait_for_tcp_port('localhost', 20_001)
+		finish = Time.now
+		(finish - start).should > 1
+		(finish - start).should < 3
+	end
+end

data/vendor/logger_client/Rakefile

@@ -0,0 +1,53 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_opts = ['--colour --format progress --loadby mtime --reverse']
+	t.spec_files = FileList['spec/*_spec.rb']
+end
+
+task :default => :spec
+
+###
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'fileutils'
+
+version = "0.1"
+name = "logger_client"
+
+spec = Gem::Specification.new do |s|
+	s.name = name
+	s.version = version
+	s.summary = "Client for Heroku logger"
+	s.author = "Pedro Belo"
+	s.email = "pedro@heroku.com"
+
+	s.platform = Gem::Platform::RUBY
+	s.has_rdoc = false
+
+	s.files = %w(Rakefile init.rb) + Dir.glob("{lib,spec}/**/*")
+
+	s.require_path = "lib"
+
+	s.add_dependency('rest-client', '>=0.6.2')
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+end
+
+task :install => [ :package ] do
+	sh %{sudo gem install pkg/#{name}-#{version}.gem}
+end
+
+task :uninstall => [ :clean ] do
+	sh %{sudo gem uninstall #{name}}
+end
+
+CLEAN.include [ 'pkg', '*.gem', '.config' ]

data/vendor/logger_client/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/lib/logger_client'

data/vendor/logger_client/lib/logger_client.rb

@@ -0,0 +1,210 @@
+# Logger Client
+# Use as a gem or Rails plugin. Example configuration:
+# 
+# Log.configure do |config|
+#   config.component = 'core'
+#   config.instance = 'userapps.123'
+#   config.failsafe = :file
+# end
+
+require 'rubygems'
+require 'time'
+require 'syslog'
+
+module Log; end
+
+class Log::InvalidConfiguration < RuntimeError
+	def message
+		"Invalid component. Configure with Log.configure { |c| c.component = 'myComponent' }"
+	end
+end
+
+class Log::Config
+	def initialize
+		@contents = { :console_log => true }
+	end
+
+	def method_missing(method, value)
+		@contents[method.to_s.gsub(/=$/, '').to_sym] = value
+	end
+
+	def to_hash
+		@contents
+	end
+end
+
+module Log
+	extend self
+
+	unless defined? SyslogConvertion
+		SyslogConvertion = {
+			'error'   => 3,
+			'warning' => 4,
+			'notice'  => 5,
+			'debug'   => 7,
+		}
+	end
+
+	def debug(msg, options={})
+		log msg, options.merge(:level => 'debug')
+	end
+
+	def notice(msg, options={})
+		log msg, options.merge(:level => 'notice')
+	end
+
+	def warning(msg, options={})
+		log msg, options.merge(:level => 'warning')
+	end
+
+	def error(msg, options={})
+		# Fake an exception for error messages with no exception object
+		# so that we get a backtrace.
+		if options[:exception].nil?
+			begin
+				raise StandardError, msg
+			rescue => error
+				error.backtrace.shift
+				options[:exception] = error
+			end
+		end
+
+		log msg, options.merge(:level => 'error')
+	end
+
+	##########
+
+	def log(msg, options={})
+		console_log(msg)
+		syslog(msg, options)
+	rescue InvalidConfiguration => e
+		raise e
+	end
+
+	def default_error(e)
+		# avoid backtrace in /usr or vendor if possible
+		system, app = e.backtrace.partition { |b| b =~ /(^\/usr\/|vendor)/ }
+		reordered_backtrace = app + system
+
+		# avoid "/" as the method name (we want the controller action)
+		row = 0
+		row = 1 if reordered_backtrace[row].match(/in `\/'$/)
+
+		# get file and method name
+		begin
+			file, method = reordered_backtrace[row].match(/(.*):in `(.*)'$/)[1..2]
+			file.gsub!(/.*\//, '')
+			self.log "#{e.class} in #{file} #{method}: #{e.message}", :exception => e, :level => 'error'
+		rescue
+			self.log "#{e.class} in #{e.backtrace.first}: #{e.message}", :exception => e, :level => 'error'
+		end
+	end
+
+	def web_error(args)
+		e = args[:exception]
+		summary = "#{e.class} processing #{args[:url]}"
+
+		body = []
+		body << "\tURL: #{args[:url]}"
+		body << "\tParams: #{args[:params].inspect}"
+		body << "\tUser: #{args[:user]}" if args[:user]
+		body << "\tBacktrace:"
+		body << "\t\t#{e.class} (#{e.message}):"
+		body += e.backtrace.map { |l| "\t\t#{l}" }
+		body = body.join("\n")
+
+		log "#{summary}\n#{body}", :level => 'error'
+	end
+
+	def exception(e)
+		msg = "Exception #{e.class} -> #{e.message}\n"
+		msg += filtered_backtrace(e.backtrace)
+		STDERR.puts msg
+		Log.error e.message, :exception => e
+	end
+
+	def filtered_backtrace(backtrace)
+		backtrace.select do |line|
+			!line.match(/^\/usr/)
+		end.map do |line|
+			"   #{line}\n"
+		end.join
+	end
+
+	def event(name, options = {})
+		console_log("EVENT: #{name} begins")
+		result = yield
+		console_log("EVENT: #{name} complete")
+		result
+	end
+
+	def context(options)
+		prev_options = default_options.dup
+		default_options.merge!(options)
+		yield
+		@@default_options = prev_options
+	end
+
+	def configure
+		config = Config.new
+		yield(config)
+		set_default_options(config.to_hash)
+	end
+
+	def set_default_options(options)
+		default_options.merge!(options)
+	end
+
+	def default_options
+		@@default_options ||= {}
+	end
+
+	def failsafe(params)
+		case default_options[:failsafe]
+			when :file
+				dir = defined?(RAILS_ROOT) ? RAILS_ROOT : '.'
+				File.open("#{dir}/failsafe.log", "a") do |f|
+					f.puts "#{Time.now} #{params[:log][:level]} : #{params[:log][:message]}"
+					f.puts params[:log][:addendum] if params[:log][:addendum]
+				end
+			when :console, nil
+				console_log(params[:log][:message])
+		end
+	end
+
+	def console_log(msg)
+		STDERR.puts "#{Time.now.iso8601} #{msg}" if default_options[:console_log]
+	end
+
+	def syslog(msg, opts = {})
+		@retried = false
+		begin
+			level = SyslogConvertion[opts[:level]]
+			if opts[:exception]
+				msg += "\n" + format_syslog_exception(opts[:exception])
+			end
+			syslog_resource.log(level, '%s', msg)
+		rescue Exception => e
+			failsafe(:log => { :level => 'error', :message => "could not log to syslog: #{e.class.name} #{e.message}"})
+			unless @retried
+				@retried = true
+				@@syslog.close rescue nil
+				@@syslog = Syslog.open(default_options[:component]) rescue nil
+				retry
+			end
+		end
+	end
+
+	def format_syslog_exception(e)
+		if e.respond_to?(:backtrace)
+			"\t#{e.class}: #{e.message}\n" + e.backtrace.map { |t| "\t#{t}" }.join("\n")
+		else
+			"\t#{e.class}: #{e.message}"
+		end
+	end
+
+	def syslog_resource
+		@@syslog ||= Syslog.open(default_options[:component].to_s, Syslog::LOG_PID | Syslog::LOG_CONS, default_options[:syslog_facility] || Syslog::LOG_USER)
+	end
+end
+