nanite 0.4.1.14 → 0.4.1.15

data/lib/nanite.rb

@@ -40,7 +40,7 @@ require 'nanite/security/static_certificate_store'
 require 'nanite/serializer'
 
 module Nanite
-  VERSION = '0.4.1.14' unless defined?(Nanite::VERSION)
+  VERSION = '0.4.1.15' unless defined?(Nanite::VERSION)
 
   class MapperNotRunning < StandardError; end
 

data/lib/nanite/cluster.rb

@@ -67,7 +67,7 @@ module Nanite
         old_target = request.target
         request.target = target unless target == 'mapper-offline'
         Nanite::Log.debug("SEND #{request.to_s([:from, :tags, :target])}")
-        amq.queue(target).publish(serializer.dump(request), :persistent => request.persistent)
+        amq.queue(target).publish(serializer.dump(request, enforce_format?(target)), :persistent => request.persistent)
       ensure
         request.target = old_target
       end
@@ -75,6 +75,10 @@ module Nanite
 
     protected
 
+    def enforce_format?(target)
+      target == 'mapper-offline' ? :insecure : nil
+    end
+    
     # updates nanite information (last ping timestamps, status)
     # when heartbeat message is received
     def handle_ping(ping)

data/lib/nanite/mapper.rb

@@ -121,20 +121,13 @@ module Nanite
         @options[:log_path] = (@options[:log_dir] || @options[:root] || Dir.pwd)
       end
       @options.freeze
+      @offline_queue = 'mapper-offline'
     end
 
     def run
       setup_logging
       @serializer = Serializer.new(@options[:format])
-      pid_file = PidFile.new(@identity, @options)
-      pid_file.check
-      if @options[:daemonize]
-        daemonize(@identity, @options)
-        pid_file.write
-        at_exit { pid_file.remove }
-      else
-        trap("INT") {exit}
-      end
+      setup_process
       @amq = start_amqp(@options)
       @job_warden = JobWarden.new(@serializer)
       setup_cluster
@@ -195,9 +188,9 @@ module Nanite
         job = job_warden.new_job(request, targets, intm_handler, blk)
         cluster.route(request, job.targets)
         job
-      elsif opts.key?(:offline_failsafe) ? opts[:offline_failsafe] : options[:offline_failsafe]
+      elsif offline_failsafe?(opts)
         job_warden.new_job(request, [], intm_handler, blk)
-        cluster.publish(request, 'mapper-offline')
+        cluster.publish(request, @offline_queue)
         :offline
       else
         false
@@ -234,14 +227,18 @@ module Nanite
       if !targets.empty?
         cluster.route(push, targets)
         true
-      elsif opts.key?(:offline_failsafe) ? opts[:offline_failsafe] : options[:offline_failsafe]
-        cluster.publish(push, 'mapper-offline')
+      elsif offline_failsafe?(opts)
+        cluster.publish(push, @offline_queue)
         :offline
       else
         false
       end
     end
     
+    def offline_failsafe?(opts)
+      opts.key?(:offline_failsafe) ? opts[:offline_failsafe] : options[:offline_failsafe]
+    end
+    
     private
 
     def build_deliverable(deliverable_type, type, payload, opts)
@@ -262,11 +259,12 @@ module Nanite
     end
 
     def setup_offline_queue
-      offline_queue = amq.queue('mapper-offline', :durable => true)
+      offline_queue = amq.queue(@offline_queue, :durable => true)
       offline_queue.subscribe(:ack => true) do |info, deliverable|
-        deliverable = serializer.load(deliverable)
+        deliverable = serializer.load(deliverable, :insecure)
         targets = cluster.targets_for(deliverable)
         unless targets.empty?
+          Nanite::Log.debug("Recovering message from offline queue: #{deliverable.to_s([:from, :tags, :target])}")
           info.ack
           if deliverable.kind_of?(Request)
             if job = job_warden.jobs[deliverable.token]
@@ -303,6 +301,18 @@ module Nanite
     def setup_cluster
       @cluster = Cluster.new(@amq, @options[:agent_timeout], @options[:identity], @serializer, self, @options[:redis], @options[:callbacks])
     end
+    
+    def setup_process
+      pid_file = PidFile.new(@identity, @options)
+      pid_file.check
+      if @options[:daemonize]
+        daemonize(@identity, @options)
+        pid_file.write
+        at_exit { pid_file.remove }
+      else
+        trap("INT") {exit}
+      end
+    end
   end
 end
 

data/lib/nanite/security/signature.rb

@@ -1,4 +1,4 @@
-if defined?(OpenSSL::PKCS7::PKCS7)
+if RUBY_VERSION < '1.8.7'
   Nanite::PKCS7 = OpenSSL::PKCS7::PKCS7
 else
   Nanite::PKCS7 = OpenSSL::PKCS7

data/lib/nanite/serializer.rb

@@ -1,6 +1,9 @@
 module Nanite
   class Serializer
+    SERIALIZERS = {:json => JSON, :marshal => Marshal, :yaml => YAML}.freeze
 
+    attr_reader :preferred_format
+    
     class SerializationError < StandardError
       attr_accessor :action, :packet
       def initialize(action, packet, serializers, msg = nil)
@@ -11,42 +14,52 @@ module Nanite
     end # SerializationError
 
     # The secure serializer should not be part of the cascading
-    def initialize(preferred_format = :marshal)
-      preferred_format ||= :marshal
-      if preferred_format.to_s == 'secure'
+    def initialize(preferred_format = nil)
+      @preferred_format = preferred_format || :marshal
+      if @preferred_format.to_s == 'secure'
         @serializers = [ SecureSerializer ]
       else
-        preferred_serializer = SERIALIZERS[preferred_format.to_sym]
+        preferred_serializer = SERIALIZERS[@preferred_format.to_sym]
         @serializers = SERIALIZERS.values.clone
         @serializers.unshift(@serializers.delete(preferred_serializer)) if preferred_serializer
       end
     end
 
-    def dump(packet)
-      cascade_serializers(:dump, packet)
+    def dump(packet, format = nil)
+      cascade_serializers(:dump, packet, format)
     end
 
-    def load(packet)
-      cascade_serializers(:load, packet)
+    def load(packet, format = nil)
+      cascade_serializers(:load, packet, format)
     end
 
     private
 
-    SERIALIZERS = {:json => JSON, :marshal => Marshal, :yaml => YAML}.freeze
-
-    def cascade_serializers(action, packet)
+    def cascade_serializers(action, packet, format)
       errors = []
-      @serializers.map do |serializer|
+      determine_serializers(format).map do |serializer|
         begin
-          o = serializer.send(action, packet)
+          serialized = serializer.send(action, packet)
         rescue Exception => e
-          o = nil
+          serialized = nil
           errors << "#{e.message}\n\t#{e.backtrace[0]}"
         end
-        return o if o
+        return serialized if serialized
       end
       raise SerializationError.new(action, packet, @serializers, errors.join("\n"))
     end
-
-  end # Serializer
-end # Nanite
+    
+    def determine_serializers(format)
+      if secure_serialization? and format == :insecure
+        SERIALIZERS.values
+      else
+        @serializers
+      end
+    end
+    
+    def secure_serialization?
+      @preferred_format.to_s == 'secure'
+    end
+    
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nanite
 version: !ruby/object:Gem::Version 
-  version: 0.4.1.14
+  version: 0.4.1.15
 platform: ruby
 authors: 
 - Ezra Zygmuntowicz
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-08 00:00:00 +01:00
+date: 2010-02-10 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency