droid 1.0.2pre → 1.0.2

data/lib/droid/em.rb

@@ -1,55 +1,55 @@
 class Droid
-	module EMTimerUtils
-		def self.included(base)
-			base.extend(ClassMethods)
-		end
-
-		module ClassMethods
-			# Trap exceptions leaving the block and log them. Do not re-raise
-			def trap_exceptions
-				yield
-			rescue => e
-				em_exception(e)
-			end
-
-			def em_exception(e)
-				msg = format_em_exception(e)
-				log.error "[EM.timer] #{msg}", :exception => e
-			end
-
-			def format_em_exception(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!(/.*\//, '')
-					"#{e.class} in #{file} #{method}: #{e.message}"
-				rescue
-					"#{e.class} in #{e.backtrace.first}: #{e.message}"
-				end
-			end
-
-			# One-shot timer
-			def timer(duration, &blk)
-				EM.add_timer(duration) { trap_exceptions(&blk) }
-			end
-
-			# Add a periodic timer. If the now argument is true, run the block
-			# immediately in addition to scheduling the periodic timer.
-			def periodic_timer(duration, now=false, &blk)
-				timer(1, &blk) if now
-				EM.add_periodic_timer(duration) { trap_exceptions(&blk) }
-			end
-		end
-
-		def timer(*args, &blk); self.class.timer(*args, &blk); end
-		def periodic_timer(*args, &blk); self.class.periodic_timer(*args, &blk); end
-	end
+  module EMTimerUtils
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Trap exceptions leaving the block and log them. Do not re-raise
+      def trap_exceptions
+        yield
+      rescue => e
+        em_exception(e)
+      end
+
+      def em_exception(e)
+        msg = format_em_exception(e)
+        log.error "[EM.timer] #{msg}", :exception => e
+      end
+
+      def format_em_exception(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!(/.*\//, '')
+          "#{e.class} in #{file} #{method}: #{e.message}"
+        rescue
+          "#{e.class} in #{e.backtrace.first}: #{e.message}"
+        end
+      end
+
+      # One-shot timer
+      def timer(duration, &blk)
+        EM.add_timer(duration) { trap_exceptions(&blk) }
+      end
+
+      # Add a periodic timer. If the now argument is true, run the block
+      # immediately in addition to scheduling the periodic timer.
+      def periodic_timer(duration, now=false, &blk)
+        timer(1, &blk) if now
+        EM.add_periodic_timer(duration) { trap_exceptions(&blk) }
+      end
+    end
+
+    def timer(*args, &blk); self.class.timer(*args, &blk); end
+    def periodic_timer(*args, &blk); self.class.periodic_timer(*args, &blk); end
+  end
 end

data/lib/droid/heroku.rb

@@ -3,100 +3,100 @@ require 'droid/heroku/local_stats'
 require 'droid/heroku/logger_client'
 
 Log.configure do |c|
-	c.component = LocalStats.slot
-	c.instance_name = LocalStats.instance_name
+  c.component = LocalStats.slot
+  c.instance_name = LocalStats.instance_name
 end
 
 Droid.log = Log
 
 class Droid
-	module Utils
-		def self.generate_name_for_instance(name)
-			"#{name}.#{LocalStats.slot}.#{LocalStats.ion_instance_id}"
-		end
-	end
+  module Utils
+    def self.generate_name_for_instance(name)
+      "#{name}.#{LocalStats.slot}.#{LocalStats.ion_instance_id}"
+    end
+  end
 end
 
 begin
-	require 'droid/json_server'
+  require 'droid/json_server'
 rescue LoadError => e
-	Droid.log.error "Could not load JSONServer", :exception => e
+  Droid.log.error "Could not load JSONServer", :exception => e
 end
 
 class HerokuDroid < Droid
-	attr_reader :extended_stats
-
-	def initialize(name, opts={}, &blk)
-		@extended_stats = !(opts[:extended_stats] == false)
-
-		super(name, opts) do |droid|
-			setup_standard_topics(self) unless opts[:standard_topics] == false
-			LocalStats.attach
-			blk.call(self)
-		end
-	end
-
-	def stats(&blk)
-		@stats = blk
-		out = call_stats
-		out = out.inspect unless out.kind_of?(String)
-		Log.notice out
-	end
-
-	def call_stats
-		@stats ? @stats.call : nil
-	end
-
-	def name
-		Droid.name
-	end
-
-	def ruby_path
-		if File.exists?("/usr/ruby1.8.6/bin/ruby")
-			"/usr/ruby1.8.6/bin"
-		else
-			"/usr/local/bin"
-		end
-	end
-
-	def setup_standard_topics(droid)
-		setup_ping_topic(droid)
-	end
-
-	def setup_ping_topic(droid)
-		require 'time'
-
-		droid.listener('ping').subscribe do |req|
-			Droid::Utilization.latency = (Time.now.to_f - req['departed_at']).abs
-		end
-
-		blk = Proc.new do |d|
-			begin
-				t1 = Time.now
-				response = {}.merge(LocalStats.stats)
-
-				estats = nil
-				if self.extended_stats
-					estats = droid.call_stats
-					estats = { :notes => estats } unless estats.kind_of?(Hash)
-					estats[:notes] ||= estats.map { |k, v| "#{v} #{k}" }.join(", ")
-					estats.merge!(LocalStats.extended_stats)
-				end
-
-				response.merge!({
-					:extended_stats => estats,
-					:droid_name => Droid.name,
-					:latency => Droid::Utilization.latency,
-				})
-
-				d.publish('pong', response.merge(:stat_collection => (Time.now - t1)))
-			rescue Object => e
-				log.error "Ping Block Error: #{e.class} -> #{e.message}", :exception => e
-			end
-		end
-
-		EM.add_timer(2) { blk.call(droid) }
-		EM.add_periodic_timer(50 + (rand*15).to_i) { blk.call(droid) }
-	end
+  attr_reader :extended_stats
+
+  def initialize(name, opts={}, &blk)
+    @extended_stats = !(opts[:extended_stats] == false)
+
+    super(name, opts) do |droid|
+      setup_standard_topics(self) unless opts[:standard_topics] == false
+      LocalStats.attach
+      blk.call(self)
+    end
+  end
+
+  def stats(&blk)
+    @stats = blk
+    out = call_stats
+    out = out.inspect unless out.kind_of?(String)
+    Log.notice out
+  end
+
+  def call_stats
+    @stats ? @stats.call : nil
+  end
+
+  def name
+    Droid.name
+  end
+
+  def ruby_path
+    if File.exists?("/usr/ruby1.8.6/bin/ruby")
+      "/usr/ruby1.8.6/bin"
+    else
+      "/usr/local/bin"
+    end
+  end
+
+  def setup_standard_topics(droid)
+    setup_ping_topic(droid)
+  end
+
+  def setup_ping_topic(droid)
+    require 'time'
+
+    droid.listener('ping').subscribe do |req|
+      Droid::Utilization.latency = (Time.now.to_f - req['departed_at']).abs
+    end
+
+    blk = Proc.new do |d|
+      begin
+        t1 = Time.now
+        response = {}.merge(LocalStats.stats)
+
+        estats = nil
+        if self.extended_stats
+          estats = droid.call_stats
+          estats = { :notes => estats } unless estats.kind_of?(Hash)
+          estats[:notes] ||= estats.map { |k, v| "#{v} #{k}" }.join(", ")
+          estats.merge!(LocalStats.extended_stats)
+        end
+
+        response.merge!({
+          :extended_stats => estats,
+          :droid_name => Droid.name,
+          :latency => Droid::Utilization.latency,
+        })
+
+        d.publish('pong', response.merge(:stat_collection => (Time.now - t1)))
+      rescue Object => e
+        log.error "Ping Block Error: #{e.class} -> #{e.message}", :exception => e
+      end
+    end
+
+    EM.add_timer(2) { blk.call(droid) }
+    EM.add_periodic_timer(50 + (rand*15).to_i) { blk.call(droid) }
+  end
 end
 

data/lib/droid/json_server.rb

@@ -2,108 +2,108 @@ require 'eventmachine'
 require 'evma_httpserver'
 
 class Droid
-	class JSONServer < ::EM::Connection
-		include ::EM::HttpServer
-
-		def post_init
-			super
-			no_environment_strings
-		end
-
-		def process_http_request
-			return not_found_response if @http_request_method != "GET"
-
-			if @http_request_uri == "/"
-				default_response
-			else
-				method_name = "get_#{@http_request_uri.split("/")[1]}".gsub(/[^\d\w_]/,'').downcase
-				if public_methods.include?(method_name)
-					generate_response(method_name)
-				else
-					not_found_response
-				end
-			end
-		end
-
-		def generate_response(method_name)
-			status, data, content_type = self.send(method_name)
-
-			response = ::EM::DelegatedHttpResponse.new(self)
-			response.status = status
-			response.content_type content_type
-			response.content = data
-			response.send_response
-		end
-
-		def default_response
-			response = ::EM::DelegatedHttpResponse.new(self)
-			response.status = 200
-			response.content_type 'application/json'
-			response.content = {"status" => "OK"}.to_json
-			response.send_response
-		end
-
-		def not_found_response
-			response = ::EM::DelegatedHttpResponse.new(self)
-			response.status = 404
-			response.content_type 'text/plain'
-			response.content = "Not Found"
-			response.send_response
-		end
-
-		def get_droid
-			report_data = Droid::Utilization.report_data
-
-			metrics = {}
-			report_data.each do |topic, data|
-				metrics[topic] = data['msgs']
-			end
-			metrics['latency'] = Droid::Utilization.latency
-
-			summary = Droid::Utilization.report_summary(report_data)
-
-			metrics['total_msgs'] = summary['msgs']
-
-			status = "AMQP: #{summary['msgs']} msgs processed since #{Droid::Utilization.start.utc}"
-
-			# reset metrics data
-			Droid::Utilization.reinit
-
-			data = {
-				'status' => status,
-				'state' => 'ok',
-				'metrics' => hash_to_metrics(metrics)
-			}
-			[200, data.to_json, "application/json"]
-		end
-
-		def hash_to_metrics(hash); self.class.hash_to_metrics(hash); end
-
-		# utility method to convert a ruby hash to a metrics format
-		# that can be consumed by cloudkick
-		def self.hash_to_metrics(hash)
-			hash.collect do |k,v|
-				name = k.to_s
-				value = v
-				type = if v.kind_of?(Integer)
-					'int'
-				elsif v.kind_of?(Float)
-					'float'
-				else
-					'string'
-				end
-
-				# bool -> int conversion
-				if [TrueClass, FalseClass].include?(v.class)
-					value = v ? 1 : 0
-					type = 'int'
-				end
-
-				# if type is really string then it should respond to .to_s
-				value = value.to_s if type == 'string'
-
-				{ 'name' => name, 'type' => type, 'value' => value }
-			end
-		end
-	end
+  class JSONServer < ::EM::Connection
+    include ::EM::HttpServer
+
+    def post_init
+      super
+      no_environment_strings
+    end
+
+    def process_http_request
+      return not_found_response if @http_request_method != "GET"
+
+      if @http_request_uri == "/"
+        default_response
+      else
+        method_name = "get_#{@http_request_uri.split("/")[1]}".gsub(/[^\d\w_]/,'').downcase
+        if public_methods.include?(method_name)
+          generate_response(method_name)
+        else
+          not_found_response
+        end
+      end
+    end
+
+    def generate_response(method_name)
+      status, data, content_type = self.send(method_name)
+
+      response = ::EM::DelegatedHttpResponse.new(self)
+      response.status = status
+      response.content_type content_type
+      response.content = data
+      response.send_response
+    end
+
+    def default_response
+      response = ::EM::DelegatedHttpResponse.new(self)
+      response.status = 200
+      response.content_type 'application/json'
+      response.content = {"status" => "OK"}.to_json
+      response.send_response
+    end
+
+    def not_found_response
+      response = ::EM::DelegatedHttpResponse.new(self)
+      response.status = 404
+      response.content_type 'text/plain'
+      response.content = "Not Found"
+      response.send_response
+    end
+
+    def get_droid
+      report_data = Droid::Utilization.report_data
+
+      metrics = {}
+      report_data.each do |topic, data|
+        metrics[topic] = data['msgs']
+      end
+      metrics['latency'] = Droid::Utilization.latency
+
+      summary = Droid::Utilization.report_summary(report_data)
+
+      metrics['total_msgs'] = summary['msgs']
+
+      status = "AMQP: #{summary['msgs']} msgs processed since #{Droid::Utilization.start.utc}"
+
+      # reset metrics data
+      Droid::Utilization.reinit
+
+      data = {
+        'status' => status,
+        'state' => 'ok',
+        'metrics' => hash_to_metrics(metrics)
+      }
+      [200, data.to_json, "application/json"]
+    end
+
+    def hash_to_metrics(hash); self.class.hash_to_metrics(hash); end
+
+    # utility method to convert a ruby hash to a metrics format
+    # that can be consumed by cloudkick
+    def self.hash_to_metrics(hash)
+      hash.collect do |k,v|
+        name = k.to_s
+        value = v
+        type = if v.kind_of?(Integer)
+          'int'
+        elsif v.kind_of?(Float)
+          'float'
+        else
+          'string'
+        end
+
+        # bool -> int conversion
+        if [TrueClass, FalseClass].include?(v.class)
+          value = v ? 1 : 0
+          type = 'int'
+        end
+
+        # if type is really string then it should respond to .to_s
+        value = value.to_s if type == 'string'
+
+        { 'name' => name, 'type' => type, 'value' => value }
+      end
+    end
+  end
 end