nats 0.3.12 → 0.4.2

data/lib/nats/server/server.rb

@@ -0,0 +1,307 @@
+module NATSD #:nodoc: all
+
+  # Subscriber
+  Subscriber = Struct.new(:conn, :subject, :sid, :qgroup, :num_responses, :max_responses)
+
+  class Server
+
+    class << self
+      attr_reader :id, :info, :log_time, :auth_required, :debug_flag, :trace_flag, :options
+      attr_reader :max_payload, :max_pending, :max_control_line, :auth_timeout
+
+      alias auth_required? :auth_required
+      alias debug_flag?    :debug_flag
+      alias trace_flag?    :trace_flag
+
+      def version; "nats server version #{NATSD::VERSION}" end
+
+      def host; @options[:addr]  end
+      def port; @options[:port]  end
+      def pid_file; @options[:pid_file] end
+
+      def process_options(argv=[])
+        @options = {}
+
+        # Allow command line to override config file, so do them first.
+        parser.parse!(argv)
+        read_config_file
+        finalize_options
+      end
+
+      def setup(argv)
+        process_options(argv)
+
+        @id, @cid = fast_uuid, 1
+        @sublist = Sublist.new
+        @info = {
+          :server_id => Server.id,
+          :version => VERSION,
+          :auth_required => auth_required?,
+          :max_payload => @max_payload
+        }
+
+        # Check for daemon flag
+        if @options[:daemonize]
+          require 'rubygems'
+          require 'daemons'
+          unless @options[:log_file]
+            # These log messages visible to controlling TTY
+            log "Starting #{NATSD::APP_NAME} version #{NATSD::VERSION} on port #{NATSD::Server.port}"
+            log "Switching to daemon mode"
+          end
+          Daemons.daemonize(:app_name => APP_NAME, :mode => :exec)
+        end
+
+        setup_logs
+
+        # Setup optimized select versions
+        EM.epoll unless @options[:noepoll]
+        EM.kqueue unless @options[:nokqueue]
+
+        # Write pid file if need be.
+        File.open(@options[:pid_file], 'w') { |f| f.puts "#{Process.pid}" } if @options[:pid_file]
+      end
+
+      def subscribe(sub)
+        @sublist.insert(sub.subject, sub)
+      end
+
+      def unsubscribe(sub)
+        @sublist.remove(sub.subject, sub)
+      end
+
+      def deliver_to_subscriber(sub, subject, reply, msg)
+
+        # Allows nil reply to not have extra space
+        reply = reply + ' ' if reply
+
+        conn = sub.conn
+
+        conn.send_data("MSG #{subject} #{sub.sid} #{reply}#{msg.bytesize}#{CR_LF}")
+        conn.send_data(msg)
+        conn.send_data(CR_LF)
+
+        # Account for these response and check for auto-unsubscribe (pruning interest graph)
+        sub.num_responses += 1
+        conn.delete_subscriber(sub) if (sub.max_responses && sub.num_responses >= sub.max_responses)
+
+        # Check the outbound queue here and react if need be..
+        if conn.get_outbound_data_size > NATSD::Server.max_pending
+          conn.error_close SLOW_CONSUMER
+          log "Slow consumer dropped, exceeded #{NATSD::Server.max_pending} bytes pending", conn.client_info
+        end
+      end
+
+      def route_to_subscribers(subject, reply, msg)
+        qsubs = nil
+
+        @sublist.match(subject).each do |sub|
+          # Skip anyone in the closing state
+          next if sub.conn.closing
+
+          unless sub[:qgroup]
+            deliver_to_subscriber(sub, subject, reply, msg)
+          else
+            if NATSD::Server.trace_flag?
+              trace("Matched queue subscriber", sub[:subject], sub[:qgroup], sub[:sid], sub.conn.client_info)
+            end
+            # Queue this for post processing
+            qsubs ||= Hash.new([])
+            qsubs[sub[:qgroup]] = qsubs[sub[:qgroup]] << sub
+          end
+        end
+
+        return unless qsubs
+
+        qsubs.each_value do |subs|
+          # Randomly pick a subscriber from the group
+          sub = subs[rand*subs.size]
+          if NATSD::Server.trace_flag?
+            trace("Selected queue subscriber", sub[:subject], sub[:qgroup], sub[:sid], sub.conn.client_info)
+          end
+          deliver_to_subscriber(sub, subject, reply, msg)
+        end
+      end
+
+      def auth_ok?(user, pass)
+        user == @options[:user] && pass == @options[:pass]
+      end
+
+      def cid
+        @cid += 1
+      end
+
+      def info_string
+        @info.to_json
+      end
+
+    end
+  end
+
+  module Connection #:nodoc:
+
+    attr_reader :cid, :closing
+
+    def client_info
+      @client_info ||= Socket.unpack_sockaddr_in(get_peername)
+    end
+
+    def post_init
+      @cid = Server.cid
+      @subscriptions = {}
+      @verbose = @pedantic = true # suppressed by most clients, but allows friendly telnet
+      @receive_data_calls = 0
+      @parse_state = AWAITING_CONTROL_LINE
+      send_info
+      @auth_pending = EM.add_timer(NATSD::Server.auth_timeout) { connect_auth_timeout } if Server.auth_required?
+      debug "Client connection created", client_info, cid
+    end
+
+    def connect_auth_timeout
+      error_close AUTH_REQUIRED
+      debug "Connection timeout due to lack of auth credentials", cid
+    end
+
+    def receive_data(data)
+      @receive_data_calls += 1
+      @buf = @buf ? @buf << data : data
+      return close_connection if @buf =~ /(\006|\004)/ # ctrl+c or ctrl+d for telnet friendly
+
+      # while (@buf && !@buf.empty? && !@closing)
+      while (@buf && !@closing)
+        case @parse_state
+
+          when AWAITING_CONTROL_LINE
+            case @buf
+              when PUB_OP
+                ctrace('PUB OP', strip_op($&)) if NATSD::Server.trace_flag?
+                return connect_auth_timeout if @auth_pending
+                @buf = $'
+                @parse_state = AWAITING_MSG_PAYLOAD
+                @msg_sub, @msg_reply, @msg_size = $1, $3, $4.to_i
+                if (@msg_size > NATSD::Server.max_payload)
+                  debug "Message payload size exceeded (#{@msg_size}/#{NATSD::Server.max_payload}), closing connection"
+                  error_close PAYLOAD_TOO_BIG
+                end
+                send_data(INVALID_SUBJECT) if (@pedantic && !(@msg_sub =~ SUB_NO_WC))
+              when SUB_OP
+                ctrace('SUB OP', strip_op($&)) if NATSD::Server.trace_flag?
+                return connect_auth_timeout if @auth_pending
+                @buf = $'
+                sub, qgroup, sid = $1, $3, $4
+                return send_data(INVALID_SUBJECT) if !($1 =~ SUB)
+                return send_data(INVALID_SID_TAKEN) if @subscriptions[sid]
+                sub = Subscriber.new(self, sub, sid, qgroup, 0)
+                @subscriptions[sid] = sub
+                Server.subscribe(sub)
+                send_data(OK) if @verbose
+              when UNSUB_OP
+                ctrace('UNSUB OP', strip_op($&)) if NATSD::Server.trace_flag?
+                return connect_auth_timeout if @auth_pending
+                @buf = $'
+                sid, sub = $1, @subscriptions[$1]
+                return send_data(INVALID_SID_NOEXIST) unless sub
+                # If we have set max_responses, we will unsubscribe once we have received the appropriate
+                # amount of responses
+                sub.max_responses = ($2 && $3) ? $3.to_i : nil
+                delete_subscriber(sub) unless (sub.max_responses && (sub.num_responses < sub.max_responses))
+                send_data(OK) if @verbose
+              when PING
+                ctrace('PING OP', strip_op($&)) if NATSD::Server.trace_flag?
+                @buf = $'
+                send_data(PONG_RESPONSE)
+              when CONNECT
+                ctrace('CONNECT OP', strip_op($&)) if NATSD::Server.trace_flag?
+                @buf = $'
+                begin
+                  config = JSON.parse($1, :symbolize_keys => true, :symbolize_names => true)
+                  process_connect_config(config)
+                rescue => e
+                  send_data(INVALID_CONFIG)
+                  log_error
+                end
+              when INFO
+                ctrace('INFO OP', strip_op($&)) if NATSD::Server.trace_flag?
+                return connect_auth_timeout if @auth_pending
+                @buf = $'
+                send_info
+              when UNKNOWN
+                ctrace('Unknown Op', strip_op($&)) if NATSD::Server.trace_flag?
+                return connect_auth_timeout if @auth_pending
+                @buf = $'
+                send_data(UNKNOWN_OP)
+              else
+                # If we are here we do not have a complete line yet that we understand.
+                # If too big, cut the connection off.
+                if @buf.bytesize > NATSD::Server.max_control_line
+                  debug "Control line size exceeded (#{@buf.bytesize}/#{NATSD::Server.max_control_line}), closing connection.."
+                  error_close PROTOCOL_OP_TOO_BIG
+                end
+                return
+            end
+            @buf = nil if (@buf && @buf.empty?)
+
+          when AWAITING_MSG_PAYLOAD
+            return unless (@buf.bytesize >= (@msg_size + CR_LF_SIZE))
+            msg = @buf.slice(0, @msg_size)
+            ctrace('Processing msg', @msg_sub, @msg_reply, msg) if NATSD::Server.trace_flag?
+            send_data(OK) if @verbose
+            Server.route_to_subscribers(@msg_sub, @msg_reply, msg)
+            @buf = @buf.slice((@msg_size + CR_LF_SIZE), @buf.bytesize)
+            @msg_sub = @msg_size = @reply = nil
+            @parse_state = AWAITING_CONTROL_LINE
+            @buf = nil if (@buf && @buf.empty?)
+          end
+      end
+
+    end
+
+    def send_info
+      send_data("INFO #{Server.info_string}#{CR_LF}")
+    end
+
+    def process_connect_config(config)
+      @verbose  = config[:verbose] unless config[:verbose].nil?
+      @pedantic = config[:pedantic] unless config[:pedantic].nil?
+      return send_data(OK) unless Server.auth_required?
+
+      EM.cancel_timer(@auth_pending)
+      if Server.auth_ok?(config[:user], config[:pass])
+        send_data(OK) if @verbose
+        @auth_pending = nil
+      else
+        error_close AUTH_FAILED
+        debug "Authorization failed for connection", cid
+      end
+    end
+
+    def delete_subscriber(sub)
+      ctrace('DELSUB OP', sub.subject, sub.qgroup, sub.sid) if NATSD::Server.trace_flag?
+      Server.unsubscribe(sub)
+      @subscriptions.delete(sub.sid)
+    end
+
+    def error_close(msg)
+      send_data(msg)
+      close_connection_after_writing
+      @closing = true
+    end
+
+    def unbind
+      debug "Client connection closed", client_info, cid
+      # ctrace "Receive_Data called #{@receive_data_calls} times." if @receive_data_calls > 0
+      @subscriptions.each_value { |sub| Server.unsubscribe(sub) }
+      EM.cancel_timer(@auth_pending) if @auth_pending
+      @auth_pending = nil
+    end
+
+    def ctrace(*args)
+      trace(args, "c: #{cid}")
+    end
+
+    def strip_op(op='')
+      op.dup.sub(CR_LF, EMPTY)
+    end
+  end
+
+end

data/lib/nats/server/sublist.rb

@@ -1,9 +1,9 @@
 #--
 #
 # Sublist implementation for a publish-subscribe system.
-# This container class holds subscriptions and matches 
+# This container class holds subscriptions and matches
 # candidate subjects to those subscriptions.
-# Certain wildcards are supported for subscriptions. 
+# Certain wildcards are supported for subscriptions.
 # '*' will match any given token at any level.
 # '>' will match all subsequent tokens.
 #--
@@ -14,12 +14,12 @@ class Sublist #:nodoc:
   PWC = '*'.freeze
   FWC = '>'.freeze
   CACHE_SIZE = 4096
-  
+
   attr_reader :count
 
   SublistNode  = Struct.new(:leaf_nodes, :next_level)
   SublistLevel = Struct.new(:nodes, :pwc, :fwc)
-  
+
   def initialize(options = {})
     @count = 0
     @results = []
@@ -36,7 +36,7 @@ class Sublist #:nodoc:
   # does not need to completely go away when a remove happens..
   #
   # front end caching is on by default, but we can turn it off here if needed
-  
+
   def disable_cache; @cache = nil; end
   def enable_cache;  @cache ||= {};  end
   def clear_cache; @cache = {} if @cache; end
@@ -71,16 +71,16 @@ class Sublist #:nodoc:
         when PWC then node = level.pwc
         else node  = level.nodes[token]
       end
-      level = node.next_level      
+      level = node.next_level
     end
     # This could be expensize if a large number of subscribers exist.
-    node.leaf_nodes.delete(subscriber) if (node && node.leaf_nodes) 
+    node.leaf_nodes.delete(subscriber) if (node && node.leaf_nodes)
     clear_cache # Clear the cache
   end
-  
+
   # Match a subject to all subscribers, return the array of matches.
   def match(subject)
-    return @cache[subject] if (@cache && @cache[subject])    
+    return @cache[subject] if (@cache && @cache[subject])
     tokens = subject.split('.')
     @results.clear
     matchAll(@root, tokens)
@@ -93,24 +93,24 @@ class Sublist #:nodoc:
   end
 
   private
-  
+
   def matchAll(level, tokens)
     node, pwc = nil, nil # Define for scope
     i, ts = 0, tokens.size
     while (i < ts) do
       return if level == nil
       # Handle a full wildcard here by adding all of the subscribers.
-      @results.concat(level.fwc.leaf_nodes) if level.fwc      
+      @results.concat(level.fwc.leaf_nodes) if level.fwc
       # Handle an internal partial wildcard by branching recursively
       lpwc = level.pwc
       matchAll(lpwc.next_level, tokens[i+1, ts]) if lpwc
       node, pwc = level.nodes[tokens[i]], lpwc
       #level = node.next_level if node
-      level = node ? node.next_level : nil    
+      level = node ? node.next_level : nil
       i += 1
     end
-    @results.concat(pwc.leaf_nodes) if pwc    
+    @results.concat(pwc.leaf_nodes) if pwc
     @results.concat(node.leaf_nodes) if node
-  end  
+  end
 
 end

data/lib/nats/server/util.rb

@@ -0,0 +1,34 @@
+
+def fast_uuid #:nodoc:
+  v = [rand(0x0010000),rand(0x0010000),rand(0x0010000),
+       rand(0x0010000),rand(0x0010000),rand(0x1000000)]
+  "%04x%04x%04x%04x%04x%06x" % v
+end
+
+def log(*args) #:nodoc:
+  args.unshift(Time.now) if NATSD::Server.log_time
+  pp args.compact
+end
+
+def debug(*args) #:nodoc:
+  log *args if NATSD::Server.debug_flag?
+end
+
+def trace(*args) #:nodoc:
+  log *args if NATSD::Server.trace_flag?
+end
+
+def log_error(e=$!) #:nodoc:
+  debug e, e.backtrace
+end
+
+def shutdown #:nodoc:
+  puts
+  log 'Server exiting..'
+  EM.stop
+  FileUtils.rm(NATSD::Server.pid_file) if NATSD::Server.pid_file
+  exit
+end
+
+['TERM','INT'].each { |s| trap(s) { shutdown } }
+

data/nats.gemspec

@@ -8,39 +8,43 @@ require 'nats/server/const.rb'
 spec = Gem::Specification.new do |s|
   s.name = 'nats'
   s.version = NATSD::VERSION
-  s.date = '2010-11-20'
-  s.summary = 'Simple Publish-Subscribe Messaging System'
-  s.homepage = "http://github.com/derekcollison/nats"
-  s.description = "A lightweight, fast, publish-subscribe messaging system."
+  s.date = '2011-02-09'
+  s.summary = 'A lightweight publish-subscribe messaging system.'
+  s.homepage = 'http://github.com/derekcollison/nats'
+  s.description = 'A lightweight publish-subscribe messaging system.'
   s.has_rdoc = true
 
-  s.authors = ["Derek Collison"]
-  s.email = ["derek.collison@gmail.com"]
+  s.authors = ['Derek Collison']
+  s.email = ['derek.collison@gmail.com']
 
   s.add_dependency('eventmachine', '>= 0.12.10')
-  s.add_dependency('yajl-ruby', '>= 0.7.8')
+  s.add_dependency('json_pure', '>= 1.5.1')
   s.add_dependency('daemons', '>= 1.1.0')
 
   s.require_paths = ['lib']
   s.bindir = 'bin'
-  s.executables = [NATSD::APP_NAME, 'nats-pub', 'nats-sub']
+  s.executables = [NATSD::APP_NAME, 'nats-pub', 'nats-sub', 'nats-queue']
 
   s.files = %w[
     COPYING
     README.md
+    ChangeLog
     nats.gemspec
     Rakefile
     bin/nats-server
     bin/nats-sub
     bin/nats-pub
+    bin/nats-queue
     lib/nats/client.rb
     lib/nats/ext/bytesize.rb
     lib/nats/ext/em.rb
     lib/nats/ext/json.rb
     lib/nats/server.rb
+    lib/nats/server/server.rb
     lib/nats/server/options.rb
     lib/nats/server/sublist.rb
     lib/nats/server/const.rb
+    lib/nats/server/util.rb
   ]
 
 end