rightscale-nanite 0.4.1 → 0.4.1.1

data/lib/nanite/amqp.rb

@@ -0,0 +1,47 @@
+class MQ
+  class Queue
+    # Asks the broker to redeliver all unacknowledged messages on a
+    # specifieid channel. Zero or more messages may be redelivered.
+    #
+    # * requeue (default false)
+    # If this parameter is false, the message will be redelivered to the original recipient.
+    # If this flag is true, the server will attempt to requeue the message, potentially then
+    # delivering it to an alternative subscriber.
+    #
+    def recover requeue = false
+      @mq.callback{
+        @mq.send Protocol::Basic::Recover.new({ :requeue => requeue })
+      }
+      self
+    end
+  end
+end
+
+# monkey patch to the amqp gem that adds :no_declare => true option for new 
+# Exchange objects. This allows us to send messeages to exchanges that are
+# declared by the mappers and that we have no configuration priviledges on.
+# temporary until we get this into amqp proper
+MQ::Exchange.class_eval do
+  def initialize mq, type, name, opts = {}
+    @mq = mq
+    @type, @name, @opts = type, name, opts
+    @mq.exchanges[@name = name] ||= self
+    @key = opts[:key]
+
+    @mq.callback{
+      @mq.send AMQP::Protocol::Exchange::Declare.new({ :exchange => name,
+                                                 :type => type,
+                                                 :nowait => true }.merge(opts))
+    } unless name == "amq.#{type}" or name == ''  or opts[:no_declare]
+  end
+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)
+      MQ.new(connection)
+    end
+  end
+end

data/lib/nanite/cluster.rb

@@ -0,0 +1,203 @@
+module Nanite
+  class Cluster
+    attr_reader :agent_timeout, :nanites, :reaper, :serializer, :identity, :amq, :redis, :mapper
+
+    def initialize(amq, agent_timeout, identity, serializer, mapper, redis=nil)
+      @amq = amq
+      @agent_timeout = agent_timeout
+      @identity = identity
+      @serializer = serializer
+      @mapper = mapper
+      @redis = redis
+      @security = SecurityProvider.get
+      if redis
+        Nanite::Log.info("using redis for state storage")
+        require 'nanite/state'
+        @nanites = ::Nanite::State.new(redis)
+      else
+        require 'nanite/local_state'
+        @nanites = Nanite::LocalState.new
+      end
+      @reaper = Reaper.new(agent_timeout)
+      setup_queues
+    end
+
+    # determine which nanites should receive the given request
+    def targets_for(request)
+      return [request.target] if request.target
+      __send__(request.selector, request.type, request.tags).collect {|name, state| name }
+    end
+
+    # adds nanite to nanites map: key is nanite's identity
+    # and value is a services/status pair implemented
+    # as a hash
+    def register(reg)
+      case reg
+      when Register
+        if @security.authorize_registration(reg)
+          nanites[reg.identity] = { :services => reg.services, :status => reg.status, :tags => reg.tags }
+          reaper.timeout(reg.identity, agent_timeout + 1) { nanites.delete(reg.identity) }
+          Nanite::Log.info("registered: #{reg.identity}, #{nanites[reg.identity].inspect}")
+        else
+          Nanite::Log.warning("registration of #{reg.inspect} not authorized")
+        end
+      when UnRegister
+        nanites.delete(reg.identity)
+        Nanite::Log.info("un-registering: #{reg.identity}")
+      end
+    end
+
+    def route(request, targets)
+      EM.next_tick { targets.map { |target| publish(request, target) } }
+    end
+
+    def publish(request, target)
+      # We need to initialize the 'target' field of the request object so that the serializer has
+      # access to it.
+      begin
+        old_target = request.target
+        request.target = target unless target == 'mapper-offline'
+        amq.queue(target).publish(serializer.dump(request), :persistent => request.persistent)
+      ensure
+        request.target = old_target
+      end
+    end
+
+    protected
+
+    # updates nanite information (last ping timestamps, status)
+    # when heartbeat message is received
+    def handle_ping(ping)
+      if nanite = nanites[ping.identity]
+        nanite[:status] = ping.status
+        reaper.reset_with_autoregister_hack(ping.identity, agent_timeout + 1) { nanites.delete(ping.identity) }
+      else
+        amq.queue(ping.identity).publish(serializer.dump(Advertise.new))
+      end
+    end
+    
+    # forward request coming from agent
+    def handle_request(request)
+      if @security.authorize_request(request)
+        result = Result.new(request.token, request.from, nil, mapper.identity)
+        intm_handler = lambda do |res|
+          result.results = res
+          forward_response(result, request.persistent)
+        end
+        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
+      else
+        Nanite::Log.warning("request #{request.inspect} not authorized")
+      end
+    end
+    
+    # forward response back to agent that originally made the request
+    def forward_response(res, persistent)
+      amq.queue(res.to).publish(serializer.dump(res), :persistent => persistent)
+    end
+    
+    # returns least loaded nanite that provides given service
+    def least_loaded(service, tags=[])
+      candidates = nanites_providing(service,tags)
+      return [] if candidates.empty?
+
+      [candidates.min { |a,b| a[1][:status] <=> b[1][:status] }]
+    end
+
+    # returns all nanites that provide given service
+    def all(service, tags=[])
+      nanites_providing(service,tags)
+    end
+
+    # returns a random nanite
+    def random(service, tags=[])
+      candidates = nanites_providing(service,tags)
+      return [] if candidates.empty?
+
+      [candidates[rand(candidates.size)]]
+    end
+
+    # selects next nanite that provides given service
+    # using round robin rotation
+    def rr(service, tags=[])
+      @last ||= {}
+      @last[service] ||= 0
+      candidates = nanites_providing(service,tags)
+      return [] if candidates.empty?
+      @last[service] = 0 if @last[service] >= candidates.size
+      candidate = candidates[@last[service]]
+      @last[service] += 1
+      [candidate]
+    end
+
+    # returns all nanites that provide the given service
+    def nanites_providing(service, *tags)
+      nanites.nanites_for(service, *tags)
+    end
+
+    def setup_queues
+      setup_heartbeat_queue
+      setup_registration_queue
+      setup_request_queue
+    end
+
+    def setup_heartbeat_queue
+      handler = lambda do |ping|
+        begin
+          ping = serializer.load(ping)
+          Nanite::Log.debug("got heartbeat from #{ping.identity}") if ping.respond_to?(:identity)
+          handle_ping(ping)
+        rescue Exception => e
+          Nanite::Log.error("Error handling heartbeat: #{e.message}")
+        end
+      end
+      hb_fanout = amq.fanout('heartbeat', :durable => true)
+      if @redis
+        amq.queue("heartbeat").bind(hb_fanout).subscribe &handler
+      else
+        amq.queue("heartbeat-#{identity}", :exclusive => true).bind(hb_fanout).subscribe &handler
+      end
+    end
+
+    def setup_registration_queue
+      handler = lambda do |msg|
+        begin
+          msg = serializer.load(msg)
+          Nanite::Log.debug("got registration from #{msg.identity}")
+          register(msg)
+        rescue Exception => e
+          Nanite::Log.error("Error handling registration: #{e.message}")
+        end
+      end
+      reg_fanout = amq.fanout('registration', :durable => true)
+      if @redis
+        amq.queue("registration").bind(reg_fanout).subscribe &handler
+      else
+        amq.queue("registration-#{identity}", :exclusive => true).bind(reg_fanout).subscribe &handler
+      end
+    end
+    
+    def setup_request_queue
+      handler = lambda do |msg|
+        begin
+          msg = serializer.load(msg)
+          Nanite::Log.debug("got request from #{msg.from} of type #{msg.type}")
+          handle_request(msg)
+        rescue Exception => e
+          Nanite::Log.error("Error handling request: #{e.message}")
+        end
+      end
+      req_fanout = amq.fanout('request', :durable => true)
+      if @redis
+        amq.queue("request").bind(req_fanout).subscribe &handler
+      else
+        amq.queue("request-#{identity}", :exclusive => true).bind(req_fanout).subscribe &handler
+      end
+    end
+  end
+end

data/lib/nanite/config.rb

@@ -0,0 +1,102 @@
+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}
+
+  module CommonConfig
+    def setup_mapper_options(opts, options)
+      setup_common_options(opts, options, 'mapper')
+
+      opts.on("-a", "--agent-timeout TIMEOUT", "How long to wait before an agent is considered to be offline and thus removed from the list of available agents.") do |timeout|
+        options[:agent_timeout] = timeout
+      end
+
+      opts.on("-r", "--offline-redelivery-frequency", "The frequency in seconds that messages stored in the offline queue will be retrieved for attempted redelivery to the nanites. Default is 10 seconds.") do |frequency|
+        options[:offline_redelivery_frequency] = frequency
+      end
+
+      opts.on("--persistent", "Instructs the AMQP broker to save messages to persistent storage so that they aren't lost when the broker is restarted. Can be overriden on a per-message basis using the request and push methods.") do
+        options[:persistent] = true
+      end
+
+      opts.on("--offline-failsafe", "Store messages in an offline queue when all the nanites are offline. Messages will be redelivered when nanites come online. Can be overriden on a per-message basis using the request methods.") do
+        options[:offline_failsafe] = true
+      end
+      
+      opts.on("--redis HOST_PORT", "Use redis as the agent state storage in the mapper: --redis 127.0.0.1:6379; missing host and/or port will be filled with defaults if colon is present") do |redis|
+        redishost, redisport = redis.split(':')
+        redishost = '127.0.0.1' if (redishost.nil? || redishost.empty?)
+        redisport = '6379' if (redishost.nil? || redishost.empty?)
+        redis = "#{redishost}:#{redisport}"
+        options[:redis] = redis
+      end
+      
+    end
+    
+    def setup_common_options(opts, options, type)
+      opts.version = Nanite::VERSION
+
+      opts.on("-i", "--irb-console", "Start #{type} in irb console mode.") do |console|
+        options[:console] = 'irb'
+      end
+
+      opts.on("-u", "--user USER", "Specify the rabbitmq username.") do |user|
+        options[:user] = user
+      end
+
+      opts.on("-h", "--host HOST", "Specify the rabbitmq hostname.") do |host|
+        options[:host] = host
+      end
+
+      opts.on("-P", "--port PORT", "Specify the rabbitmq PORT, default 5672.") do |port|
+        options[:port] = port
+      end
+
+      opts.on("-p", "--pass PASSWORD", "Specify the rabbitmq password") do |pass|
+        options[:pass] = pass
+      end
+
+      opts.on("-t", "--token IDENITY", "Specify the #{type} identity.") do |ident|
+        options[:identity] = ident
+      end
+
+      opts.on("-v", "--vhost VHOST", "Specify the rabbitmq vhost") do |vhost|
+        options[:vhost] = vhost
+      end
+
+      opts.on("-s", "--secure", "Use Security features of rabbitmq to restrict nanites to themselves") do
+        options[:secure] = true
+      end
+
+      opts.on("-f", "--format FORMAT", "The serialization type to use for transfering data. Can be marshal, json or yaml. Default is marshal") do |fmt|
+        options[:format] = fmt.to_sym
+      end
+
+      opts.on("-d", "--daemonize", "Run #{type} as a daemon") do |d|
+        options[:daemonize] = true
+      end
+      
+      opts.on("--pid-dir PATH", "Specify the pid path, only used with daemonize") do |dir|
+        options[:pid_dir] = dir
+      end
+
+      opts.on("-l", "--log-level LEVEL", "Specify the log level (fatal, error, warn, info, debug). Default is info") do |level|
+        options[:log_level] = level
+      end
+      
+      opts.on("--log-dir PATH", "Specify the log path") do |dir|
+        options[:log_dir] = dir
+      end
+
+      opts.on("--tag TAG", "Specify a tag.  Can issue multiple times.") do |tag|
+        options[:tag] ||= []
+        options[:tag] << tag
+      end
+
+      opts.on("--version", "Show the nanite version number") do |res|
+        puts "Nanite Version #{opts.version}"
+        exit
+      end
+    end
+  end
+end

data/lib/nanite/console.rb

@@ -0,0 +1,39 @@
+module Nanite
+  module ConsoleHelper
+    def self.included(base)
+      @@base = base
+    end
+    
+    def start_console
+      puts "Starting #{@@base.name.split(":").last.downcase} console (#{self.identity}) (Nanite #{Nanite::VERSION})"
+      Thread.new do
+        Console.start(self)
+      end
+    end
+  end
+  
+  module Console
+    class << self; attr_accessor :instance; end
+
+    def self.start(binding)
+      require 'irb'
+      old_args = ARGV.dup
+      ARGV.replace ["--simple-prompt"]
+
+      IRB.setup(nil)
+      self.instance = IRB::Irb.new(IRB::WorkSpace.new(binding))
+
+      @CONF = IRB.instance_variable_get(:@CONF)
+      @CONF[:IRB_RC].call self.instance.context if @CONF[:IRB_RC]
+      @CONF[:MAIN_CONTEXT] = self.instance.context
+
+      catch(:IRB_EXIT) { self.instance.eval_input }
+    ensure
+      ARGV.replace old_args
+      # Clean up tty settings in some evil, evil cases
+      begin; catch(:IRB_EXIT) { irb_exit }; rescue Exception; end
+      # Make nanite exit when irb does
+      EM.stop if EM.reactor_running?
+    end
+  end
+end

data/lib/nanite/daemonize.rb

@@ -0,0 +1,13 @@
+module Nanite
+  module DaemonizeHelper
+    def daemonize
+      exit if fork
+      Process.setsid
+      exit if fork
+      File.umask 0000
+      STDIN.reopen "/dev/null"
+      STDOUT.reopen "/dev/null", "a"
+      STDERR.reopen STDOUT
+    end
+  end
+end

data/lib/nanite/dispatcher.rb

@@ -0,0 +1,90 @@
+module Nanite
+  class Dispatcher
+    attr_reader :registry, :serializer, :identity, :amq, :options
+    attr_accessor :evmclass
+
+    def initialize(amq, registry, serializer, identity, options)
+      @amq = amq
+      @registry = registry
+      @serializer = serializer
+      @identity = identity
+      @options = options
+      @evmclass = EM
+    end
+
+    def dispatch(deliverable)
+      prefix, meth = deliverable.type.split('/')[1..-1]
+      meth ||= :index
+      actor = registry.actor_for(prefix)
+
+      operation = lambda do
+        begin
+          intermediate_results_proc = lambda { |*args| self.handle_intermediate_results(actor, meth, deliverable, *args) }
+          args = [ deliverable.payload ]
+          args.push(deliverable) if actor.method(meth).arity == 2
+          actor.send(meth, *args, &intermediate_results_proc)
+        rescue Exception => e
+          handle_exception(actor, meth, deliverable, e)
+        end
+      end
+      
+      callback = lambda do |r|
+        if deliverable.kind_of?(Request)
+          r = Result.new(deliverable.token, deliverable.reply_to, r, identity)
+          amq.queue(deliverable.reply_to, :no_declare => options[:secure]).publish(serializer.dump(r))
+        end
+        r # For unit tests
+      end
+
+      if @options[:single_threaded]
+        @evmclass.next_tick { callback.call(operation.call) }
+      else
+        @evmclass.defer(operation, callback)
+      end
+    end
+
+    protected
+
+    def handle_intermediate_results(actor, meth, deliverable, *args)
+      messagekey = case args.size
+      when 1
+        'defaultkey'
+      when 2
+        args.first.to_s
+      else
+        raise ArgumentError, "handle_intermediate_results passed unexpected number of arguments (#{args.size})"
+      end
+      message = args.last
+      @evmclass.defer(lambda {
+        [deliverable.reply_to, IntermediateMessage.new(deliverable.token, deliverable.reply_to, identity, messagekey, message)]
+      }, lambda { |r|
+        amq.queue(r.first, :no_declare => options[:secure]).publish(serializer.dump(r.last))
+      })
+    end
+
+    private
+
+    def describe_error(e)
+      "#{e.class.name}: #{e.message}\n #{e.backtrace.join("\n  ")}"
+    end
+
+    def handle_exception(actor, meth, deliverable, e)
+      error = describe_error(e)
+      Nanite::Log.error(error)
+      begin
+        if actor.class.exception_callback
+          case actor.class.exception_callback
+          when Symbol, String
+            actor.send(actor.class.exception_callback, meth.to_sym, deliverable, e)
+          when Proc
+            actor.instance_exec(meth.to_sym, deliverable, e, &actor.class.exception_callback)
+          end
+        end
+      rescue Exception => e1
+        error = describe_error(e1)
+        Nanite::Log.error(error)
+      end
+      error
+    end
+  end
+end