br-nanite 0.3.0

data/lib/nanite/agent.rb

@@ -0,0 +1,163 @@
+module Nanite
+  class Agent
+    include AMQPHelper
+    include FileStreaming
+    include ConsoleHelper
+    include DaemonizeHelper
+
+    attr_reader :identity, :log, :options, :serializer, :dispatcher, :registry, :amq
+    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
+    #
+    # services    : list of services provided by this agent, by default
+    #               all methods exposed by actors are listed
+    #
+    # 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 = {})
+      new(options)
+    end
+
+    def initialize(opts)
+      set_configuration(opts)
+      @log = Log.new(@options, @identity)
+      @serializer = Serializer.new(@options[:format])
+      @status_proc = lambda { parse_uptime(`uptime`) rescue 'no status' }
+      daemonize if @options[:daemonize]
+      @amq = start_amqp(@options)
+      @registry = ActorRegistry.new(@log)
+      @dispatcher = Dispatcher.new(@amq, @registry, @serializer, @identity, @log, @options)
+      load_actors
+      setup_queue
+      advertise_services
+      setup_heartbeat
+      start_console if @options[:console] && !@options[:daemonize]
+    end
+
+    def register(actor, prefix = nil)
+      registry.register(actor, prefix)
+    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]
+      Dir["#{options[:root]}/actors/*.rb"].each do |actor|
+        log.info("loading actor: #{actor}")
+        require actor
+      end
+      init_path = File.join(options[:root], 'init.rb')
+      instance_eval(File.read(init_path), init_path) if File.exist?(init_path)
+    end
+
+    def receive(packet)
+      packet = serializer.load(packet)
+      case packet
+      when Advertise
+        log.debug("handling Advertise: #{packet}")
+        advertise_services
+      when Request, Push
+        log.debug("handling Request: #{packet}")
+        dispatcher.dispatch(packet)
+      end
+    end
+
+    def setup_queue
+      amq.queue(identity, :durable => true).subscribe(:ack => true) do |info, msg|
+        info.ack
+        receive(msg)
+      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 advertise_services
+      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)))
+    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,110 @@
+module Nanite
+  class Cluster
+    attr_reader :agent_timeout, :nanites, :reaper, :log, :serializer, :identity, :amq
+
+    def initialize(amq, agent_timeout, identity, log, serializer)
+      @amq = amq
+      @agent_timeout = agent_timeout
+      @identity = identity
+      @serializer = serializer
+      @nanites = {}
+      @reaper = Reaper.new(agent_timeout)
+      @log = log
+      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).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)
+      nanites[reg.identity] = { :services => reg.services, :status => reg.status }
+      reaper.timeout(reg.identity, agent_timeout + 1) { nanites.delete(reg.identity) }
+      log.info("registered: #{reg.identity}, #{nanites[reg.identity]}")
+    end
+
+    def route(request, targets)
+      EM.next_tick { targets.map { |target| publish(request, target) } }
+    end
+
+    def publish(request, target)
+      amq.queue(target).publish(serializer.dump(request), :persistent => request.persistent)
+    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(ping.identity)
+      else
+        amq.queue(ping.identity).publish(serializer.dump(Advertise.new))
+      end
+    end
+
+    # returns least loaded nanite that provides given service
+    def least_loaded(service)
+      candidates = nanites_providing(service)
+      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)
+      nanites_providing(service)
+    end
+
+    # returns a random nanite
+    def random(service)
+      candidates = nanites_providing(service)
+      return [] if candidates.empty?
+
+      [candidates[rand(candidates.size)]]
+    end
+
+    # selects next nanite that provides given service
+    # using round robin rotation
+    def rr(service)
+      @last ||= {}
+      @last[service] ||= 0
+      candidates = nanites_providing(service)
+      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)
+      nanites.find_all { |name, state| state[:services].include?(service) }
+    end
+
+    def setup_queues
+      setup_heartbeat_queue
+      setup_registration_queue
+    end
+
+    def setup_heartbeat_queue
+      amq.queue("heartbeat-#{identity}", :exclusive => true).bind(amq.fanout('heartbeat', :durable => true)).subscribe do |ping|
+        log.debug('got heartbeat')
+        handle_ping(serializer.load(ping))
+      end
+    end
+
+    def setup_registration_queue
+      amq.queue("registration-#{identity}", :exclusive => true).bind(amq.fanout('registration', :durable => true)).subscribe do |msg|
+        log.debug('got registration')
+        register(serializer.load(msg))
+      end
+    end
+  end
+end

data/lib/nanite/config.rb

@@ -0,0 +1,80 @@
+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", "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
+    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 |json|
+        options[:format] = :json
+      end
+
+      opts.on("-d", "--daemonize", "Run #{type} as a daemon") do |d|
+        options[:daemonize] = true
+      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("--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,12 @@
+module Nanite
+  module DaemonizeHelper
+    def daemonize
+      exit if fork
+      Process.setsid
+      exit if fork
+      $stdin.reopen("/dev/null")
+      $stdout.reopen(log.file, "a")
+      $stderr.reopen($stdout)
+    end
+  end
+end