rightscale-nanite 0.4.1.2 → 0.4.1.3

data/Rakefile

@@ -8,9 +8,9 @@ rescue LoadError
   require 'rake/rdoctask'
 end
 require 'rake/clean'
+require 'lib/nanite'
 
 GEM = "nanite"
-VER = "0.4.1"
 AUTHOR = "Ezra Zygmuntowicz"
 EMAIL = "ezra@engineyard.com"
 HOMEPAGE = "http://github.com/ezmobius/nanite"
@@ -19,8 +19,9 @@ SUMMARY = "self assembling fabric of ruby daemons"
 Dir.glob('tasks/*.rake').each { |r| Rake.application.add_import r }
 
 spec = Gem::Specification.new do |s|
+
   s.name = GEM
-  s.version = ::VER
+  s.version = Nanite::VERSION
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
   s.extra_rdoc_files = ["README.rdoc", "LICENSE", 'TODO']
@@ -46,7 +47,7 @@ end
 task :default => :spec
 
 task :install => [:package] do
-  sh %{sudo gem install pkg/#{GEM}-#{VER}}
+  sh %{sudo gem install pkg/#{GEM}-#{Nanite::VERSION}}
 end
 
 desc "Run unit specs"

data/bin/nanite-agent

@@ -37,6 +37,11 @@ opts = OptionParser.new do |opts|
   opts.on("--single-threaded", "Run all operations in one thread") do
     options[:single_threaded] = true
   end
+  
+  opts.on("--threadpool COUNT", Integer, "Number of threads to run all operations in") do |tps|
+    options[:threadpool_size] = tps
+  end
+  
 end
 
 opts.parse!

data/lib/nanite/actor.rb

@@ -35,7 +35,14 @@ module Nanite
 
       def provides_for(prefix)
         return [] unless @exposed
-        @exposed.map {|meth| "/#{prefix}/#{meth}".squeeze('/')}
+        @exposed.select do |meth|
+          if instance_methods.include?(meth.to_s) or instance_methods.include?(meth.to_sym)
+            true
+          else
+            Nanite::Log.warn("Exposing non-existing method #{meth} in actor #{name}")
+            false
+          end
+        end.map {|meth| "/#{prefix}/#{meth}".squeeze('/')}
       end
 
       def on_exception(proc = nil, &blk)
@@ -54,6 +61,10 @@ module Nanite
       def request(*args, &blk)
         MapperProxy.instance.request(*args, &blk)
       end
+      
+      def push(*args)
+        MapperProxy.instance.push(*args)
+      end
     end # InstanceMethods
     
   end # Actor

data/lib/nanite/agent.rb

@@ -8,8 +8,11 @@ module Nanite
     attr_reader :identity, :options, :serializer, :dispatcher, :registry, :amq, :tags
     attr_accessor :status_proc
 
-    DEFAULT_OPTIONS = COMMON_DEFAULT_OPTIONS.merge({:user => 'nanite', :ping_time => 15,
-      :default_services => []}) unless defined?(DEFAULT_OPTIONS)
+    DEFAULT_OPTIONS = COMMON_DEFAULT_OPTIONS.merge({
+      :user => 'nanite',
+      :ping_time => 15,
+      :default_services => []
+    }) unless defined?(DEFAULT_OPTIONS)
 
     # Initializes a new agent and establishes AMQP connection.
     # This must be used inside EM.run block or if EventMachine reactor
@@ -54,6 +57,8 @@ module Nanite
     #
     # single_threaded: Run all operations in one thread
     #
+    # threadpool_size: Number of threads to run operations in
+    #
     # Connection options:
     #
     # vhost    : AMQP broker vhost that should be used
@@ -94,7 +99,7 @@ module Nanite
       Log.init(@identity, log_path)
       Log.level = @options[:log_level] if @options[:log_level]
       @serializer = Serializer.new(@options[:format])
-      @status_proc = lambda { parse_uptime(`uptime`) rescue 'no status' }
+      @status_proc = lambda { parse_uptime(`uptime 2> /dev/null`) rescue 'no status' }
       pid_file = PidFile.new(@identity, @options)
       pid_file.check
       if @options[:daemonize]
@@ -169,7 +174,7 @@ module Nanite
       Nanite::Log.debug("RECV #{packet.to_s}")
       case packet
       when Advertise
-        Nanite::Log.info("RECV #{packet.to_s}") unless Nanite::Log.level == Logger::DEBUG
+        Nanite::Log.info("RECV #{packet.to_s}") unless Nanite::Log.level == :debug
         advertise_services
       when Request, Push
         if @security && !@security.authorize(packet)
@@ -179,14 +184,14 @@ module Nanite
             amq.queue(packet.reply_to, :no_declare => options[:secure]).publish(serializer.dump(r))
           end
         else
-          Nanite::Log.info("RECV #{packet.to_s([:from, :tags])}") unless Nanite::Log.level == Logger::DEBUG
+          Nanite::Log.info("RECV #{packet.to_s([:from, :tags])}") unless Nanite::Log.level == :debug
           dispatcher.dispatch(packet)
         end
       when Result
-        Nanite::Log.info("RECV #{packet.to_s([])}") unless Nanite::Log.level == Logger::DEBUG
+        Nanite::Log.info("RECV #{packet.to_s([])}") unless Nanite::Log.level == :debug
         @mapper_proxy.handle_result(packet)
       when IntermediateMessage
-        Nanite::Log.info("RECV #{packet.to_s([])}") unless Nanite::Log.level == Logger::DEBUG
+        Nanite::Log.info("RECV #{packet.to_s([])}") unless Nanite::Log.level == :debug
         @mapper_proxy.handle_intermediate_result(packet)
       end
     end

data/lib/nanite/amqp.rb

@@ -39,9 +39,16 @@ end
 module Nanite
   module AMQPHelper
     def start_amqp(options)
-      connection = AMQP.connect(:user => options[:user], :pass => options[:pass], :vhost => options[:vhost],
-        :host => options[:host], :port => (options[:port] || ::AMQP::PORT).to_i, :insist => options[:insist] || false)
+      connection = AMQP.connect({
+        :user => options[:user],
+        :pass => options[:pass],
+        :vhost => options[:vhost],
+        :host => options[:host],
+        :port => (options[:port] || ::AMQP::PORT).to_i,
+        :insist => options[:insist] || false,
+        :retry => options[:retry] || 5
+      })
       MQ.new(connection)
     end
   end
-end
+end

data/lib/nanite/cluster.rb

@@ -87,22 +87,26 @@ module Nanite
     # forward request coming from agent
     def handle_request(request)
       if @security.authorize_request(request)
-        Nanite::Log.info("RECV #{request.to_s([:from, :target, :tags])}") unless Nanite::Log.level == Logger::DEBUG
+        Nanite::Log.info("RECV #{request.to_s([:from, :target, :tags])}") unless Nanite::Log.level == :debug
         Nanite::Log.debug("RECV #{request.to_s}")
-
-        intm_handler = lambda do |result, job|
-          result = IntermediateMessage.new(request.token, job.request.from, mapper.identity, nil, result)
-          forward_response(result, request.persistent)
-        end
+        case request
+        when Push
+          mapper.send_push(request)
+        else
+          intm_handler = lambda do |result, job|
+            result = IntermediateMessage.new(request.token, job.request.from, mapper.identity, nil, result)
+            forward_response(result, request.persistent)
+          end
         
-        result = Result.new(request.token, request.from, nil, mapper.identity)
-        ok = mapper.send_request(request, :intermediate_handler => intm_handler) do |res|
-          result.results = res
-          forward_response(result, request.persistent)
-        end
-
-        if ok == false
-          forward_response(result, request.persistent)
+          result = Result.new(request.token, request.from, nil, mapper.identity)
+          ok = mapper.send_request(request, :intermediate_handler => intm_handler) do |res|
+            result.results = res
+            forward_response(result, request.persistent)
+          end
+          
+          if ok == false
+            forward_response(result, request.persistent)
+          end
         end
       else
         Nanite::Log.warn("RECV NOT AUTHORIZED #{request.to_s}")

data/lib/nanite/config.rb

@@ -1,7 +1,16 @@
 module Nanite
 
-  COMMON_DEFAULT_OPTIONS = {:pass => 'testing', :vhost => '/nanite', :secure => false, :host => '0.0.0.0',
-    :log_level => :info, :format => :marshal, :daemonize => false, :console => false, :root => Dir.pwd}
+  COMMON_DEFAULT_OPTIONS = {
+    :pass => 'testing',
+    :vhost => '/nanite',
+    :secure => false,
+    :host => '0.0.0.0',
+    :log_level => :info,
+    :format => :marshal,
+    :daemonize => false,
+    :console => false,
+    :root => Dir.pwd
+  }
 
   module CommonConfig
     def setup_mapper_options(opts, options)

data/lib/nanite/dispatcher.rb

@@ -10,6 +10,7 @@ module Nanite
       @identity = identity
       @options = options
       @evmclass = EM
+      @evmclass.threadpool_size = (@options[:threadpool_size] || 20).to_i
     end
 
     def dispatch(deliverable)
@@ -37,7 +38,7 @@ module Nanite
         r # For unit tests
       end
 
-      if @options[:single_threaded]
+      if @options[:single_threaded] || @options[:thread_poolsize] == 1
         @evmclass.next_tick { callback.call(operation.call) }
       else
         @evmclass.defer(operation, callback)
@@ -88,4 +89,4 @@ module Nanite
       error
     end
   end
-end
+end

data/lib/nanite/local_state.rb

@@ -18,10 +18,10 @@ module Nanite
       tags = tags.dup.flatten
       nanites = select { |name, state| state[:services].include?(service) }
       unless tags.empty?
-        nanites.select { |a| !(a[1][:tags] & tags).empty? }
+        nanites.select { |a, b| !(b[:tags] & tags).empty? }
       else
         nanites
-      end
+      end.to_a
     end
 
     private

data/lib/nanite/log.rb

@@ -6,6 +6,13 @@ module Nanite
   class Log
   
     @logger = nil
+
+    # Map log levels symbols to values
+    LEVELS = { :debug => Logger::DEBUG,
+               :info  => Logger::INFO,
+               :warn  => Logger::WARN,
+               :error => Logger::ERROR,
+               :fatal => Logger::FATAL }
     
     class << self
       attr_accessor :logger, :level, :file #:nodoc
@@ -21,31 +28,25 @@ module Nanite
         end
         @logger = Logger.new(file)
         @logger.formatter = Nanite::Log::Formatter.new
-        level = @log_level = :info
+        Log.level = :info
       end
       
       # Sets the level for the Logger by symbol or by command line argument.
       # Throws an ArgumentError if you feed it a bogus log level (that is not
-      # one of :debug, :info, :warn, :error, :fatal or the corresponding strings)
+      # one of :debug, :info, :warn, :error, :fatal or the corresponding strings or a valid Logger level)
       def level=(loglevel)
         init() unless @logger
-        loglevel = loglevel.intern if loglevel.is_a?(String)
-        @logger.info("[setup] setting log level to #{loglevel.to_s.upcase}")
-        @level = loglevel
-        case loglevel
-        when :debug
-          @logger.level = Logger::DEBUG
-        when :info
-          @logger.level = Logger::INFO
-        when :warn
-          @logger.level = Logger::WARN
-        when :error
-          @logger.level = Logger::ERROR
-        when :fatal
-          @logger.level = Logger::FATAL
-        else
-          raise ArgumentError, "Log level must be one of :debug, :info, :warn, :error, or :fatal"
+        lvl = case loglevel
+          when String  then loglevel.intern
+          when Integer then LEVELS.invert[loglevel]
+          else loglevel
+        end
+        unless LEVELS.include?(lvl)
+          raise(ArgumentError, 'Log level must be one of :debug, :info, :warn, :error, or :fatal')
         end
+        @logger.info("[setup] setting log level to #{lvl.to_s.upcase}")
+        @level = lvl
+        @logger.level = LEVELS[lvl]
       end
 
       # Passes any other method calls on directly to the underlying Logger object created with init. If

data/lib/nanite/mapper.rb

@@ -23,9 +23,15 @@ module Nanite
 
     attr_reader :cluster, :identity, :job_warden, :options, :serializer, :amq
 
-    DEFAULT_OPTIONS = COMMON_DEFAULT_OPTIONS.merge({:user => 'mapper', :identity => Identity.generate, :agent_timeout => 15,
-      :offline_redelivery_frequency => 10, :persistent => false, :offline_failsafe => false,
-      :callbacks => {} }) unless defined?(DEFAULT_OPTIONS)
+    DEFAULT_OPTIONS = COMMON_DEFAULT_OPTIONS.merge({
+      :user => 'mapper',
+      :identity => Identity.generate,
+      :agent_timeout => 15,
+      :offline_redelivery_frequency => 10,
+      :persistent => false,
+      :offline_failsafe => false,
+      :callbacks => {}
+    }) unless defined?(DEFAULT_OPTIONS)
 
     # Initializes a new mapper and establishes
     # AMQP connection. This must be used inside EM.run block or if EventMachine reactor
@@ -66,9 +72,15 @@ module Nanite
     #
     # persistent  : true instructs the AMQP broker to save messages to persistent storage so that they aren't lost when the
     #               broker is restarted. Default is false. Can be overriden on a per-message basis using the request and push methods.
-    # 
+    #
     # secure      : use Security features of rabbitmq to restrict nanites to themselves
     #
+    # prefetch    : Sets prefetch (only supported in RabbitMQ >= 1.6)
+    # callbacks   : A set of callbacks to have code executed on specific events, supported events are :register,
+    #               :unregister and :timeout. Parameter must be a hash with the corresponding events as keys and
+    #               a block as value. The block will get the corresponding nanite's identity and a copy of the   
+    #               mapper
+    #
     # Connection options:
     #
     # vhost    : AMQP broker vhost that should be used
@@ -106,7 +118,7 @@ module Nanite
       @options[:file_root] ||= File.join(@options[:root], 'files')
       @options.freeze
     end
-    
+
     def run
       setup_logging
       @serializer = Serializer.new(@options[:format])
@@ -187,7 +199,7 @@ module Nanite
         false
       end
     end
-      
+
     # Make a nanite request which does not expect a response.
     #
     # ==== Parameters
@@ -210,6 +222,10 @@ module Nanite
     # @api :public:
     def push(type, payload = '', opts = {})
       push = build_deliverable(Push, type, payload, opts)
+      send_push(push, opts)
+    end
+
+    def send_push(push, opts = {})
       targets = cluster.targets_for(push)
       if !targets.empty?
         cluster.route(push, targets)
@@ -221,7 +237,7 @@ module Nanite
         false
       end
     end
-
+    
     private
 
     def build_deliverable(deliverable_type, type, payload, opts)
@@ -233,6 +249,10 @@ module Nanite
     end
 
     def setup_queues
+      if amq.respond_to?(:prefetch) && @options.has_key?(:prefetch)
+        amq.prefetch(@options[:prefetch])
+      end
+
       setup_offline_queue
       setup_message_queue
     end
@@ -264,14 +284,14 @@ module Nanite
         begin
           msg = serializer.load(msg)     
           Nanite::Log.debug("RECV #{msg.to_s}")
-          Nanite::Log.info("RECV #{msg.to_s([:from])}") unless Nanite::Log.level == Logger::DEBUG
+          Nanite::Log.info("RECV #{msg.to_s([:from])}") unless Nanite::Log.level == :debug
           job_warden.process(msg)
         rescue Exception => e
           Nanite::Log.error("RECV [result] #{e.message}")
         end
       end
     end
-    
+
     def setup_logging
       log_path = false
       if @options[:daemonize]
@@ -280,7 +300,7 @@ module Nanite
       Nanite::Log.init(@identity, log_path)
       Nanite::Log.level = @options[:log_level] if @options[:log_level]
     end
-    
+
     def setup_cluster
       @cluster = Cluster.new(@amq, @options[:agent_timeout], @options[:identity], @serializer, self, @options[:redis], @options[:callbacks])
     end

data/lib/nanite/mapper_proxy.rb

@@ -16,7 +16,7 @@ module Nanite
 
     # Accessor for actor
     def self.instance
-      @@instance
+      @@instance if defined?(@@instance)
     end
 
     def initialize(id, opts)
@@ -40,6 +40,16 @@ module Nanite
       Nanite::Log.info("SEND #{request.to_s([:tags, :target])}")
       amqp.fanout('request', :no_declare => options[:secure]).publish(serializer.dump(request))
     end    
+
+    def push(type, payload = '', opts = {})
+      raise "Mapper proxy not initialized" unless identity && options
+      push = Push.new(type, payload, opts)
+      push.from = identity
+      push.token = Identity.generate
+      push.persistent = opts.key?(:persistent) ? opts[:persistent] : options[:persistent]
+      Nanite::Log.info("SEND #{push.to_s([:tags, :target])}")
+      amqp.fanout('request', :no_declare => options[:secure]).publish(serializer.dump(push))
+    end    
     
     # Handle intermediary result
     def handle_intermediate_result(res)

data/lib/nanite/packets.rb

@@ -12,7 +12,7 @@ module Nanite
     def to_json(*a)
       js = {
         'json_class'   => self.class.name,
-        'data'         => instance_variables.inject({}) {|m,ivar| m[ivar.sub(/@/,'')] = instance_variable_get(ivar); m }
+        'data'         => instance_variables.inject({}) {|m,ivar| m[ivar.to_s.sub(/@/,'')] = instance_variable_get(ivar); m }
       }.to_json(*a)
       js = js.chop + ",\"size\":#{js.size}}"
       js
@@ -37,11 +37,6 @@ module Nanite
       end
     end
 
-    # Wrap given string to given maximum number of characters per line
-    def wrap(txt, col=120)
-      txt.gsub(/(.{1,#{col}})( +|$\n?)|(.{1,#{col}})/, "\\1\\3\n").chomp
-    end
-
   end
 
   # packet that means start of a file transfer
@@ -63,7 +58,7 @@ module Nanite
     end
 
     def to_s
-      wrap("#{super} <#{token}> #{filename} to #{dest}")
+      "#{super} <#{token}> #{filename} to #{dest}"
     end
   end
 
@@ -85,7 +80,7 @@ module Nanite
     end
 
     def to_s
-      wrap("#{super} <#{token}> meta #{meta}")
+      "#{super} <#{token}> meta #{meta}"
     end
   end
 
@@ -158,7 +153,7 @@ module Nanite
       log_msg += ", reply_to #{id_to_s(reply_to)}" if reply_to && (filter.nil? || filter.include?(:reply_to))
       log_msg += ", tags #{tags.inspect}" if tags && !tags.empty? && (filter.nil? || filter.include?(:tags))
       log_msg += ", payload #{payload.inspect}" if filter.nil? || filter.include?(:payload)
-      wrap(log_msg)
+      log_msg
     end
 
   end
@@ -207,7 +202,7 @@ module Nanite
       log_msg += ", target #{id_to_s(target)}" if target && (filter.nil? || filter.include?(:target))
       log_msg += ", tags #{tags.inspect}" if tags && !tags.empty? && (filter.nil? || filter.include?(:tags))
       log_msg += ", payload #{payload.inspect}" if filter.nil? || filter.include?(:payload)
-      wrap(log_msg)
+      log_msg
     end
   end
 
@@ -239,7 +234,7 @@ module Nanite
       log_msg += " from #{id_to_s(from)}" if filter.nil? || filter.include?(:from)
       log_msg += " to #{id_to_s(to)}" if filter.nil? || filter.include?(:to)
       log_msg += " results: #{results.inspect}" if filter.nil? || filter.include?(:results)
-      wrap(log_msg)
+      log_msg
     end
   end
 
@@ -269,7 +264,7 @@ module Nanite
     end
 
     def to_s
-      wrap("#{super} <#{token}> from #{id_to_s(from)}, key #{messagekey}")
+      "#{super} <#{token}> from #{id_to_s(from)}, key #{messagekey}"
     end
   end
 
@@ -300,7 +295,7 @@ module Nanite
       log_msg = "#{super} #{id_to_s(identity)}"
       log_msg += ", services: #{services.join(', ')}" if services && !services.empty?
       log_msg += ", tags: #{tags.join(', ')}" if tags && !tags.empty?
-      wrap(log_msg)
+      log_msg
     end
   end
 

data/lib/nanite/security/encrypted_document.rb

@@ -25,7 +25,7 @@ module Nanite
     # Initialize from encrypted data.
     def self.from_data(encrypted_data)
       doc = EncryptedDocument.allocate
-      doc.instance_variable_set(:@pkcs7, OpenSSL::PKCS7::PKCS7.new(encrypted_data))
+      doc.instance_variable_set(:@pkcs7, Nanite::PKCS7.new(encrypted_data))
       doc
     end
     

data/lib/nanite/security/secure_serializer.rb

@@ -51,6 +51,7 @@ module Nanite
         data = JSON.load(json)
         sig = Signature.from_data(data['signature'])
         certs = @store.get_signer(data['id'])
+        raise "Could not find a cert for signer #{data['id']}" unless certs
         certs = [ certs ] unless certs.respond_to?(:each)
         jsn = data['data'] if certs.any? { |c| sig.match?(c) }
         if jsn && @encrypt && data['encrypted']

data/lib/nanite/security/signature.rb

@@ -1,3 +1,9 @@
+if defined?(OpenSSL::PKCS7::PKCS7)
+  Nanite::PKCS7 = OpenSSL::PKCS7::PKCS7
+else
+  Nanite::PKCS7 = OpenSSL::PKCS7
+end
+
 module Nanite
 
   # Signature that can be validated against certificates
@@ -20,7 +26,7 @@ module Nanite
     # Load signature previously serialized via 'data'
     def self.from_data(data)
       sig = Signature.allocate
-      sig.instance_variable_set(:@p7, OpenSSL::PKCS7::PKCS7.new(data))
+      sig.instance_variable_set(:@p7, Nanite::PKCS7.new(data))
       sig.instance_variable_set(:@store, OpenSSL::X509::Store.new)
       sig
     end

data/lib/nanite/state.rb

@@ -39,7 +39,7 @@ module Nanite
     
     def log_redis_error(meth,&blk)
       blk.call
-    rescue RedisError => e
+    rescue Exception => e
       Nanite::Log.info("redis error in method: #{meth}")
       raise e
     end

data/lib/nanite/util.rb

@@ -30,22 +30,29 @@ class String
 end
 
 class Object
-  module InstanceExecHelper; end
-  include InstanceExecHelper
-  def instance_exec(*args, &block)
-    begin
-      old_critical, Thread.critical = Thread.critical, true
-      n = 0
-      n += 1 while respond_to?(mname="__instance_exec#{n}")
-      InstanceExecHelper.module_eval{ define_method(mname, &block) }
-    ensure
-      Thread.critical = old_critical
-    end
-    begin
-      ret = send(mname, *args)
-    ensure
-      InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+  unless defined? instance_exec # 1.9 and 1.8.7
+    module InstanceExecHelper; end
+    include InstanceExecHelper
+
+    # Evaluate the block with the given arguments within the context of
+    # this object, so self is set to the method receiver.
+    #
+    # From Mauricio's http://eigenclass.org/hiki/bounded+space+instance_exec
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(method_name = "__instance_exec#{n}")
+        InstanceExecMethods.module_eval { define_method(method_name, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+
+      begin
+        send(method_name, *args)
+      ensure
+        InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
+      end
     end
-    ret
   end
 end

data/lib/nanite.rb

@@ -39,7 +39,7 @@ require 'nanite/security/static_certificate_store'
 require 'nanite/serializer'
 
 module Nanite
-  VERSION = '0.4.0' unless defined?(Nanite::VERSION)
+  VERSION = '0.4.1.3' unless defined?(Nanite::VERSION)
 
   class MapperNotRunning < StandardError; end
 
@@ -65,7 +65,10 @@ module Nanite
     end
 
     def ensure_mapper
-      raise MapperNotRunning.new('A mapper needs to be started via Nanite.start_mapper') unless @mapper
+      @mapper ||= MapperProxy.instance
+      unless @mapper
+        raise MapperNotRunning.new('A mapper needs to be started via Nanite.start_mapper')
+      end
     end
   end
 end

data/spec/actor_registry_spec.rb

@@ -2,30 +2,28 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe Nanite::ActorRegistry do
   
-  before(:all) do
-    class WebDocumentImporter
-      include Nanite::Actor
-      expose :import, :cancel
+  class ::WebDocumentImporter
+    include Nanite::Actor
+    expose :import, :cancel
 
-      def import
-        1
-      end
-      def cancel
-        0
-      end
+    def import
+      1
+    end
+    def cancel
+      0
     end
+  end
 
-    module Actors
-      class ComedyActor
-        include Nanite::Actor
-        expose :fun_tricks
-        def fun_tricks
-          :rabbit_in_the_hat
-        end
+  module ::Actors
+    class ComedyActor
+      include Nanite::Actor
+      expose :fun_tricks
+      def fun_tricks
+        :rabbit_in_the_hat
       end
     end
   end
-  
+
   before(:each) do
     Nanite::Log.stub!(:info)
     @registry = Nanite::ActorRegistry.new

data/spec/actor_spec.rb

@@ -1,33 +1,46 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
-class WebDocumentImporter
-  include Nanite::Actor
-  expose :import, :cancel
+describe Nanite::Actor do
+  class ::WebDocumentImporter
+    include Nanite::Actor
+    expose :import, :cancel
 
-  def import
-    1
-  end
-  def cancel
-    0
-  end
-  def continue
-    1
+    def import
+      1
+    end
+    def cancel
+      0
+    end
+    def continue
+      1
+    end
   end
-end
 
-module Actors
-  class ComedyActor
-    include Nanite::Actor
-    expose :fun_tricks
-    def fun_tricks
-      :rabbit_in_the_hat
+  module ::Actors
+    class ComedyActor
+      include Nanite::Actor
+      expose :fun_tricks
+      def fun_tricks
+        :rabbit_in_the_hat
+      end
     end
   end
-end
 
-describe Nanite::Actor do
+  class ::Actors::InvalidActor
+    include Nanite::Actor
+    expose :non_existing
+  end
   
   describe ".expose" do
+    before :each do
+      @exposed = WebDocumentImporter.instance_variable_get(:@exposed).dup
+    end
+    
+    after :each do
+      WebDocumentImporter.instance_variable_set(:@exposed, @exposed)
+    end
+    
+    
     it "should single expose method only once" do
       3.times { WebDocumentImporter.expose(:continue) }
       WebDocumentImporter.provides_for("webfiles").should == ["/webfiles/import", "/webfiles/cancel", "/webfiles/continue"]
@@ -45,6 +58,7 @@ describe Nanite::Actor do
     before :each do
       @provides = Actors::ComedyActor.provides_for("money")
     end
+    
     it "returns an array" do
       @provides.should be_kind_of(Array)
     end
@@ -55,5 +69,9 @@ describe Nanite::Actor do
       wdi_provides.should include("/webfiles/import")
       wdi_provides.should include("/webfiles/cancel")
     end
+    
+    it "should not include methods not existing in the actor class" do
+      Actors::InvalidActor.provides_for("money").should_not include("/money/non_existing")
+    end
   end
 end

data/spec/agent_spec.rb

@@ -186,7 +186,12 @@ describe "Agent:" do
       agent.tags.should include("sample_tag_1")
       agent.tags.should include("sample_tag_2")
     end
-
+    
+    it "for threadpool_size" do
+      agent = Nanite::Agent.start(:threadpool_size => 5)
+      agent.dispatcher.evmclass.threadpool_size.should == 5
+    end
+    
   end
   
   describe "Security" do

data/spec/cluster_spec.rb

@@ -94,17 +94,23 @@ describe Nanite::Cluster do
     end # Reaper
 
     describe "State" do
-      require 'nanite/state'
-      it "should use a local state by default" do
-        cluster = Nanite::Cluster.new(@amq, 443, "the_identity", @serializer, @mapper)
-        cluster.nanites.instance_of?(Nanite::LocalState).should == true
+      begin
+        require 'nanite/state'
+      rescue LoadError
       end
+
+      if defined?(Redis)
+        it "should use a local state by default" do
+          cluster = Nanite::Cluster.new(@amq, 443, "the_identity", @serializer, @mapper)
+          cluster.nanites.instance_of?(Nanite::LocalState).should == true
+        end
       
-      it "should set up a redis state when requested" do
-        state = Nanite::State.new("")
-        Nanite::State.should_receive(:new).with("localhost:1234").and_return(state)
-        cluster = Nanite::Cluster.new(@amq, 443, "the_identity", @serializer, @mapper, "localhost:1234")
-        cluster.nanites.instance_of?(Nanite::State).should == true
+        it "should set up a redis state when requested" do
+          state = Nanite::State.new("")
+          Nanite::State.should_receive(:new).with("localhost:1234").and_return(state)
+          cluster = Nanite::Cluster.new(@amq, 443, "the_identity", @serializer, @mapper, "localhost:1234")
+          cluster.nanites.instance_of?(Nanite::State).should == true
+        end
       end
     end
   end # Intialization
@@ -410,6 +416,14 @@ describe Nanite::Cluster do
       @cluster_with_target.should_receive(:forward_response)
       @cluster_with_target.__send__(:handle_request, @request_with_target)
     end
+    
+    describe "when getting push requests from an agent" do
+      it "should send the push message through the mapper" do
+        push = Nanite::Push.new(nil, nil)
+        @mapper_with_target.should_receive(:send_push).with(push)
+        @cluster_with_target.__send__(:handle_request, push)
+      end
+    end
   end # Agent Request Handling
 
   describe "Heartbeat" do

data/spec/log_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Nanite::Log do
+  describe "Using log without initializing it first" do
+    before(:each) do
+      Nanite::Log.instance_variable_set(:@logger, nil)
+    end
+    
+    it "should use standard out for logging" do
+      Nanite::Log.init
+      STDOUT.should_receive(:write) do |arg|
+        arg.include?("For your consideration").should == true
+      end
+      Nanite::Log.info("For your consideration")
+    end
+  end
+
+  describe "Initializing the log level" do
+    it "should default to :info" do
+      Nanite::Log.init
+      Nanite::Log.level.should == :info
+    end
+
+    it "should raise an error if level is incorrect" do
+      lambda { Nanite::Log.level = "fool" }.should raise_error
+    end
+
+    it "should succeed when using symbols" do
+      [ :debug, :info, :warn, :error, :fatal ].each do |level|
+        Nanite::Log.level = level
+        Nanite::Log.level.should == level
+      end
+    end
+
+
+    it "should succeed when using log levels" do
+      lvls = { Logger::DEBUG => :debug,
+               Logger::INFO  => :info,
+               Logger::WARN  => :warn,
+               Logger::ERROR => :error,
+               Logger::FATAL => :fatal }
+      lvls.keys.each do |level|
+        Nanite::Log.level = level
+        Nanite::Log.level.should == lvls[level]
+      end
+    end
+
+  end
+end

data/spec/mapper_proxy_spec.rb

@@ -0,0 +1,72 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Nanite::MapperProxy do
+  describe "when fetching the instance" do
+    before(:each) do
+      if Nanite::MapperProxy.class_variables.include?('@@instance')
+        Nanite::MapperProxy.__send__(:remove_class_variable, :@@instance)
+      end
+    end
+    
+    it "should return nil when the instance is undefined" do
+      Nanite::MapperProxy.instance.should == nil
+    end
+    
+    it "should return the instance if defined" do
+      instance = mock
+      Nanite::MapperProxy.class_eval do
+        @@instance = "instance"
+      end
+      
+      Nanite::MapperProxy.instance.should_not == nil
+    end
+  end
+
+  describe "when pushing a message" do
+    before do
+      AMQP.stub!(:connect)
+      MQ.stub!(:new)
+      Nanite::MapperProxy.new('mapperproxy', {})
+      @instance = Nanite::MapperProxy.instance
+      @fanout = stub(:fanout, :publish => true)
+      @instance.amqp.stub!(:fanout).and_return(@fanout)
+    end
+    
+    it "should raise an error if mapper proxy is not initialized" do
+      lambda {
+        @instance.stub!(:identity).and_return nil
+        @instance.push('/welcome/aboard', 'iZac')
+      }.should raise_error("Mapper proxy not initialized")
+    end
+    
+    it "should set correct attributes on the push message" do
+      @fanout.should_receive(:publish).with do |push|
+        push = @instance.serializer.load(push)
+        push.token.should_not == nil
+        push.persistent.should_not == true
+        push.from.should == 'mapperproxy'
+      end
+      
+      @instance.push('/welcome/aboard', 'iZac')
+    end
+    
+    it "should mark the message as persistent when the option is specified on the parameter" do
+      @fanout.should_receive(:publish).with do |push|
+        push = @instance.serializer.load(push)
+        push.persistent.should == true
+      end
+      
+      @instance.push('/welcome/aboard', 'iZac', :persistent => true)
+    end
+    
+    it "should mark the message as persistent when the option is set globally" do
+      @instance.options[:persistent] = true
+      @fanout.should_receive(:publish).with do |push|
+        push = @instance.serializer.load(push)
+        push.persistent.should == true
+      end
+      
+      @instance.push('/welcome/aboard', 'iZac')
+    end
+  end
+end

data/spec/mapper_spec.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Nanite::Mapper do
+  include SpecHelpers
+
+  describe "Initializing" do
+    before(:each) do
+      @mapper = Nanite::Mapper.new({})
+    end
+
+    it "should set the identity" do
+      @mapper.identity.should_not == nil
+      @mapper.identity.should =~ /mapper-.*/
+    end
+
+    it "should set the identity to a custom identity" do
+      @mapper = Nanite::Mapper.new({:identity => "bob"})
+      @mapper.identity.should == "mapper-bob"
+    end
+
+    it "should set the file root" do
+      @mapper.options[:file_root].should == File.expand_path("#{File.dirname(__FILE__)}/../files")
+    end
+  end
+
+  describe "Starting" do
+    before(:each) do
+      @mapper = Nanite::Mapper.new({:log_level => :debug})
+      @mapper.stub!(:setup_queues)
+      @mapper.stub!(:start_amqp)
+    end
+
+    it "should initialize the logger" do
+      @mapper.stub!(:setup_cluster)
+      run_in_em do
+        @mapper.run
+        Nanite::Log.logger.level.should == Logger::DEBUG
+      end
+    end
+
+    it "should set up the cluster" do
+      Nanite::Cluster.should_receive(:new).with(nil, 15, instance_of(String), instance_of(Nanite::Serializer), @mapper, nil, {})
+      run_in_em do
+        @mapper.run
+      end
+    end
+
+    it "should set the prefetch value" do
+      amqp = mock("AMQP")
+
+      mapper = Nanite::Mapper.new(:prefetch => 11)
+      mapper.stub!(:setup_offline_queue)
+      mapper.stub!(:setup_message_queue)
+      mapper.stub!(:start_amqp)
+      mapper.stub!(:setup_cluster)
+
+      mapper.stub!(:start_amqp).and_return(amqp)
+      amqp.should_receive(:prefetch).with(11)
+      mapper.run
+    end
+
+    it "should hand over callback options to the cluster" do
+      @mapper = Nanite::Mapper.new({:callbacks => {:register => lambda {|*args|}}})
+      @mapper.stub!(:setup_queues)
+      @mapper.stub!(:start_amqp)
+      Nanite::Cluster.should_receive(:new)
+      run_in_em {@mapper.run}
+    end
+  end
+end

data/spec/nanite_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Nanite do
+  describe "when ensuring a mapper exists" do
+    describe "with a configured mapper proxy" do
+      before(:each) do
+        Nanite.instance_variable_set(:@mapper, nil)
+        Nanite::MapperProxy.stub!(:instance).and_return(mock(:mapper_proxy))
+      end
+      
+      it "should not raise an error" do
+        lambda {
+          Nanite.ensure_mapper
+        }.should_not raise_error
+      end
+      
+      it "should set the mapper instance variable to the mapper proxy instance" do
+        Nanite.ensure_mapper
+        Nanite.mapper.should == Nanite::MapperProxy.instance
+      end
+    end
+    
+    describe "when the mapper wasn't started yet" do
+      before do
+        Nanite.instance_variable_set(:@mapper, nil)
+        Nanite::MapperProxy.stub!(:instance).and_return(nil)
+      end
+      
+      it "should raise an error" do
+        lambda {
+          Nanite.ensure_mapper
+        }.should raise_error(Nanite::MapperNotRunning)
+      end
+    end
+  end
+end

data/spec/packet_spec.rb

@@ -1,13 +1,15 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
+class TestPacket < Nanite::Packet
+  @@cls_attr = "ignore"
+  def initialize(attr1)
+    @attr1 = attr1
+  end
+end
+
 describe "Packet: Base class" do
+
   before(:all) do
-    class TestPacket < Nanite::Packet
-      @@cls_attr = "ignore"
-      def initialize(attr1)
-        @attr1 = attr1
-      end
-    end
   end
 
   it "should be an abstract class" do

data/spec/spec_helper.rb

@@ -7,9 +7,6 @@ require 'nanite'
 
 module SpecHelpers
 
-  # Initialize logger so it writes to file instead of STDOUT
-  Nanite::Log.init('test', File.join(File.dirname(__FILE__)))
-
   # Create test certificate
   def issue_cert
     test_dn = { 'C'  => 'US',
@@ -30,4 +27,4 @@ module SpecHelpers
     end
   end
   
-end  
+end  

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rightscale-nanite
 version: !ruby/object:Gem::Version 
-  version: 0.4.1.2
+  version: 0.4.1.3
 platform: ruby
 authors: 
 - Ezra Zygmuntowicz
@@ -86,9 +86,11 @@ files:
 - spec/certificate_cache_spec.rb
 - spec/cached_certificate_store_proxy_spec.rb
 - spec/dispatcher_spec.rb
+- spec/log_spec.rb
 - spec/rsa_key_pair_spec.rb
 - spec/cluster_spec.rb
 - spec/spec_helper.rb
+- spec/mapper_spec.rb
 - spec/actor_registry_spec.rb
 - spec/actor_spec.rb
 - spec/packet_spec.rb
@@ -96,9 +98,11 @@ files:
 - spec/static_certificate_store_spec.rb
 - spec/job_spec.rb
 - spec/signature_spec.rb
+- spec/mapper_proxy_spec.rb
 - spec/secure_serializer_spec.rb
 - spec/serializer_spec.rb
 - spec/certificate_spec.rb
+- spec/nanite_spec.rb
 - spec/distinguished_name_spec.rb
 has_rdoc: true
 homepage: http://github.com/ezmobius/nanite