ezmobius-nanite 0.4.0 → 0.4.1.1

data/lib/nanite/agent.rb

@@ -0,0 +1,250 @@
+module Nanite
+  class Agent
+    include AMQPHelper
+    include FileStreaming
+    include ConsoleHelper
+    include DaemonizeHelper
+
+    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)
+
+    # Initializes a new agent and establishes AMQP connection.
+    # This must be used inside EM.run block or if EventMachine reactor
+    # is already started, for instance, by a Thin server that your Merb/Rails
+    # application runs on.
+    #
+    # Agent options:
+    #
+    # identity    : identity of this agent, may be any string
+    #
+    # status_proc : a callable object that returns agent load as a string,
+    #               defaults to load averages string extracted from `uptime`
+    # format      : format to use for packets serialization. One of the three:
+    #               :marshall, :json, or :yaml. Defaults to
+    #               Ruby's Marshall format. For interoperability with
+    #               AMQP clients implemented in other languages, use JSON.
+    #
+    #               Note that Nanite uses JSON gem,
+    #               and ActiveSupport's JSON encoder may cause clashes
+    #               if ActiveSupport is loaded after JSON gem.
+    #
+    # root        : application root for this agent, defaults to Dir.pwd
+    #
+    # log_dir     : path to directory where agent stores it's log file
+    #               if not given, app_root is used.
+    #
+    # file_root   : path to directory to files this agent provides
+    #               defaults to app_root/files
+    #
+    # ping_time   : time interval in seconds between two subsequent heartbeat messages
+    #               this agent broadcasts. Default value is 15.
+    #
+    # console     : true tells Nanite to start interactive console
+    #
+    # daemonize   : true tells Nanite to daemonize
+    #
+    # pid_dir     : path to the directory where the agent stores its pid file (only if daemonized)
+    #               defaults to the root or the current working directory.
+    #
+    # services    : list of services provided by this agent, by default
+    #               all methods exposed by actors are listed
+    #
+    # single_threaded: Run all operations in one thread
+    #
+    # Connection options:
+    #
+    # vhost    : AMQP broker vhost that should be used
+    #
+    # user     : AMQP broker user
+    #
+    # pass     : AMQP broker password
+    #
+    # host     : host AMQP broker (or node of interest) runs on,
+    #            defaults to 0.0.0.0
+    #
+    # port     : port AMQP broker (or node of interest) runs on,
+    #            this defaults to 5672, port used by some widely
+    #            used AMQP brokers (RabbitMQ and ZeroMQ)
+    #
+    # On start Nanite reads config.yml, so it is common to specify
+    # options in the YAML file. However, when both Ruby code options
+    # and YAML file specify option, Ruby code options take precedence.
+    def self.start(options = {})
+      agent = new(options)
+      agent.run
+      agent
+    end
+
+    def initialize(opts)
+      set_configuration(opts)
+      @tags = []
+      @tags << opts[:tag]
+      @tags.flatten!
+      @options.freeze
+    end
+    
+    def run
+      log_path = false
+      if @options[:daemonize]
+        log_path = (@options[:log_dir] || @options[:root] || Dir.pwd)
+      end
+      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' }
+      pid_file = PidFile.new(@identity, @options)
+      pid_file.check
+      if @options[:daemonize]
+        daemonize
+        pid_file.write
+        at_exit { pid_file.remove }
+      end
+      @amq = start_amqp(@options)
+      @registry = ActorRegistry.new
+      @dispatcher = Dispatcher.new(@amq, @registry, @serializer, @identity, @options)
+      setup_mapper_proxy
+      load_actors
+      setup_traps
+      setup_queue
+      advertise_services
+      setup_heartbeat
+      at_exit { un_register } unless $TESTING
+      start_console if @options[:console] && !@options[:daemonize]
+    end
+
+    def register(actor, prefix = nil)
+      registry.register(actor, prefix)
+    end
+
+    # Can be used in agent's initialization file to register a security module
+    # This security module 'authorize' method will be called back whenever the
+    # agent receives a request and will be given the corresponding deliverable.
+    # It should return 'true' for the request to proceed.
+    # Requests will return 'deny_token' or the string "Denied" by default when
+    # 'authorize' does not return 'true'.
+    def register_security(security, deny_token = "Denied")
+      @security = security
+      @deny_token = deny_token
+    end
+
+    protected
+
+    def set_configuration(opts)
+      @options = DEFAULT_OPTIONS.clone
+      root = opts[:root] || @options[:root]
+      custom_config = if root
+        file = File.expand_path(File.join(root, 'config.yml'))
+        File.exists?(file) ? (YAML.load(IO.read(file)) || {}) : {}
+      else
+        {}
+      end
+      opts.delete(:identity) unless opts[:identity]
+      @options.update(custom_config.merge(opts))
+      @options[:file_root] ||= File.join(@options[:root], 'files')
+      return @identity = "nanite-#{@options[:identity]}" if @options[:identity]
+      token = Identity.generate
+      @identity = "nanite-#{token}"
+      File.open(File.expand_path(File.join(@options[:root], 'config.yml')), 'w') do |fd|
+        fd.write(YAML.dump(custom_config.merge(:identity => token)))
+      end
+    end
+
+    def load_actors
+      return unless options[:root]
+      actors_dir = @options[:actors_dir] || "#{@options[:root]}/actors"
+      actors = @options[:actors]
+      Dir["#{actors_dir}/*.rb"].each do |actor|
+        next if actors && !actors.include?(File.basename(actor, ".rb"))
+        Nanite::Log.info("loading actor: #{actor}")
+        require actor
+      end
+      init_path = @options[:initrb] || File.join(options[:root], 'init.rb')
+      instance_eval(File.read(init_path), init_path) if File.exist?(init_path)
+    end
+
+    def receive(packet)
+      case packet
+      when Advertise
+        Nanite::Log.debug("handling Advertise: #{packet.inspect}")
+        advertise_services
+      when Request, Push
+        Nanite::Log.debug("handling Request: #{packet.inspect}")
+        if @security && !@security.authorize(packet)
+          if packet.kind_of?(Request)
+            r = Result.new(packet.token, packet.reply_to, @deny_token, identity)
+            amq.queue(packet.reply_to, :no_declare => options[:secure]).publish(serializer.dump(r))
+          end
+        else
+          dispatcher.dispatch(packet)
+        end
+      when Result
+        Nanite::Log.debug("handling Result: #{packet.inspect}")
+        @mapper_proxy.handle_result(packet)
+      when IntermediateMessage
+        Nanite::Log.debug("handling Intermediate Result: #{packet.inspect}")
+        @mapper_proxy.handle_intermediate_result(packet)
+      end
+    end
+    
+    def tag(*tags)
+      tags.each {|t| @tags << t}
+      @tags.uniq!
+    end
+
+    def setup_queue
+      amq.queue(identity, :durable => true).subscribe(:ack => true) do |info, msg|
+        begin
+          info.ack
+          packet = serializer.load(msg)
+          receive(packet)
+        rescue Exception => e
+          Nanite::Log.error("Error handling packet: #{e.message}")
+        end
+      end
+    end
+
+    def setup_heartbeat
+      EM.add_periodic_timer(options[:ping_time]) do
+        amq.fanout('heartbeat', :no_declare => options[:secure]).publish(serializer.dump(Ping.new(identity, status_proc.call)))
+      end
+    end
+    
+    def setup_mapper_proxy
+      @mapper_proxy = MapperProxy.new(identity, options)
+    end
+    
+    def setup_traps
+      ['INT', 'TERM'].each do |sig|
+        old = trap(sig) do
+          un_register
+          amq.instance_variable_get('@connection').close do
+            EM.stop
+            old.call if old.is_a? Proc
+          end
+        end
+      end
+    end
+    
+    def un_register
+      unless @unregistered
+        @unregistered = true
+        amq.fanout('registration', :no_declare => options[:secure]).publish(serializer.dump(UnRegister.new(identity)))
+      end
+    end
+
+    def advertise_services
+      Nanite::Log.debug("advertise_services: #{registry.services.inspect}")
+      amq.fanout('registration', :no_declare => options[:secure]).publish(serializer.dump(Register.new(identity, registry.services, status_proc.call, self.tags)))
+    end
+
+    def parse_uptime(up)
+      if up =~ /load averages?: (.*)/
+        a,b,c = $1.split(/\s+|,\s+/)
+        (a.to_f + b.to_f + c.to_f) / 3
+      end
+    end
+  end
+end

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