nats 0.4.10 → 0.4.22

data/lib/nats/server/server.rb

@@ -6,17 +6,19 @@ module NATSD #:nodoc: all
   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
+      attr_reader :id, :info, :log_time, :auth_required, :ssl_required, :debug_flag, :trace_flag, :options
+      attr_reader :max_payload, :max_pending, :max_control_line, :auth_timeout, :ssl_timeout, :ping_interval, :ping_max
+      attr_accessor :varz, :healthz, :max_connections, :num_connections, :in_msgs, :out_msgs, :in_bytes, :out_bytes
 
       alias auth_required? :auth_required
+      alias ssl_required?  :ssl_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 host; @options[:addr] end
+      def port; @options[:port] end
       def pid_file; @options[:pid_file] end
 
       def process_options(argv=[])
@@ -36,10 +38,18 @@ module NATSD #:nodoc: all
 
         @id, @cid = fast_uuid, 1
         @sublist = Sublist.new
+
+        @num_connections = 0
+        @in_msgs = @out_msgs = 0
+        @in_bytes = @out_bytes = 0
+
         @info = {
           :server_id => Server.id,
+          :host => host,
+          :port => port,
           :version => VERSION,
           :auth_required => auth_required?,
+          :ssl_required => ssl_required?,
           :max_payload => @max_payload
         }
 
@@ -47,12 +57,21 @@ module NATSD #:nodoc: all
         if @options[:daemonize]
           require 'rubygems'
           require 'daemons'
+          require 'tmpdir'
           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 "Starting http monitor on port #{@options[:http_port]}" if @options[:http_port]
             log "Switching to daemon mode"
           end
-          Daemons.daemonize(:app_name => APP_NAME, :mode => :exec)
+          opts = {
+            :app_name => APP_NAME,
+            :mode => :exec,
+            :dir_mode => :normal,
+            :dir => Dir.tmpdir
+          }
+          Daemons.daemonize(opts)
+          FileUtils.rm_f("#{Dir.tmpdir}/#{APP_NAME}.pid")
         end
 
         setup_logs
@@ -74,30 +93,41 @@ module NATSD #:nodoc: all
       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)
+        # Accounting
+        @out_msgs += 1
+        conn.out_msgs += 1
+        unless msg.nil?
+          mbs = msg.bytesize
+          @out_bytes += mbs
+          conn.out_bytes += mbs
+        end
+
+        conn.queue_data("MSG #{subject} #{sub.sid} #{reply}#{msg.bytesize}#{CR_LF}#{msg}#{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
+        if (conn.get_outbound_data_size + conn.writev_size) > NATSD::Server.max_pending
           conn.error_close SLOW_CONSUMER
-          log "Slow consumer dropped, exceeded #{NATSD::Server.max_pending} bytes pending", conn.client_info
+          maxp = pretty_size(NATSD::Server.max_pending)
+          log "Slow consumer dropped, exceeded #{maxp} pending", conn.client_info
         end
       end
 
       def route_to_subscribers(subject, reply, msg)
         qsubs = nil
 
+        # Allows nil reply to not have extra space
+        reply = reply + ' ' if reply
+
+        # Accounting
+        @in_msgs += 1
+        @in_bytes += msg.bytesize unless msg.nil?
+
         @sublist.match(subject).each do |sub|
           # Skip anyone in the closing state
           next if sub.conn.closing
@@ -128,7 +158,8 @@ module NATSD #:nodoc: all
       end
 
       def auth_ok?(user, pass)
-        user == @options[:user] && pass == @options[:pass]
+        @options[:users].each { |u| return true if (user == u[:user] && pass == u[:pass]) }
+        false
       end
 
       def cid
@@ -139,173 +170,43 @@ module NATSD #:nodoc: all
         @info.to_json
       end
 
-    end
-  end
-
-  module Connection #:nodoc:
+      # Monitoring
+      def start_http_server
+        return unless port = @options[:http_port]
 
-    attr_reader :cid, :closing
+        require 'thin'
 
-    def client_info
-      @client_info ||= Socket.unpack_sockaddr_in(get_peername)
-    end
+        log "Starting http monitor on port #{port}"
 
-    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
+        @healthz = "ok\n"
 
-    def connect_auth_timeout
-      error_close AUTH_REQUIRED
-      debug "Connection timeout due to lack of auth credentials", cid
-    end
+        @varz = {
+          :start => Time.now,
+          :options => @options,
+          :cores => num_cpu_cores
+        }
 
-    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]
-            if 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
-            else
-              send_data(INVALID_SID_NOEXIST) if @pedantic
+        http_server = Thin::Server.new(@options[:http_net], port, :signals => false) do
+          Thin::Logging.silent = true
+          if NATSD::Server.options[:http_user]
+            auth = [NATSD::Server.options[:http_user], NATSD::Server.options[:http_password]]
+            use Rack::Auth::Basic do |username, password|
+              [username, password] == auth
             end
-          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)
-              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?)
+          map '/healthz' do
+            run lambda { |env| [200, RACK_TEXT_HDR, NATSD::Server.healthz] }
+          end
+          map '/varz' do
+            run Varz.new
+          end
+          map '/connz' do
+            run Connz.new
+          end
         end
+        http_server.start!
       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
 

data/lib/nats/server/sublist.rb

@@ -20,6 +20,8 @@ class Sublist #:nodoc:
   SublistNode  = Struct.new(:leaf_nodes, :next_level)
   SublistLevel = Struct.new(:nodes, :pwc, :fwc)
 
+  EMPTY_LEVEL = SublistLevel.new({})
+
   def initialize(options = {})
     @count = 0
     @results = []
@@ -41,6 +43,13 @@ class Sublist #:nodoc:
   def enable_cache;  @cache ||= {};  end
   def clear_cache; @cache = {} if @cache; end
 
+  # Random removal
+  def prune_cache
+    return unless @cache
+    keys = @cache.keys
+    @cache.delete(keys[rand(keys.size)])
+  end
+
   # Insert a subscriber into the sublist for the given subject.
   def insert(subject, subscriber)
     # TODO - validate subject as correct.
@@ -57,25 +66,13 @@ class Sublist #:nodoc:
     node.leaf_nodes.push(subscriber)
     @count += 1
     clear_cache # Clear the cache
+    node.next_level = nil if node.next_level == EMPTY_LEVEL
   end
 
   # Remove a given subscriber from the sublist for the given subject.
   def remove(subject, subscriber)
-    # TODO: implement (remember cache and count cleanup if applicable)
-    # Reference counts and GC for long empty tree.
-    level, tokens = @root, subject.split('.')
-    for token in tokens
-      next unless level
-      case token
-        when FWC then node = level.fwc
-        when PWC then node = level.pwc
-        else node  = level.nodes[token]
-      end
-      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)
-    clear_cache # Clear the cache
+    return unless subject && subscriber
+    remove_level(@root, subject.split('.'), subscriber)
   end
 
   # Match a subject to all subscribers, return the array of matches.
@@ -86,7 +83,7 @@ class Sublist #:nodoc:
     matchAll(@root, tokens)
     # FIXME: This is too low tech, will revisit when needed.
     if @cache
-      clear_cache if @cache.size > CACHE_SIZE
+      prune_cache if @cache.size > CACHE_SIZE
       @cache[subject] = Array.new(@results).freeze # Avoid tampering of copy
     end
     @results
@@ -113,4 +110,58 @@ class Sublist #:nodoc:
     @results.concat(node.leaf_nodes) if node
   end
 
+  def prune_level(level, node, token)
+    # Prune here if needed.
+    return unless level && node
+    return unless node.leaf_nodes.empty? && (!node.next_level || node.next_level == EMPTY_LEVEL)
+    if node == level.fwc
+      level.fwc = nil
+    elsif node == level.pwc
+      level.pwc = nil
+    else
+      level.nodes.delete(token)
+    end
+  end
+
+  def remove_level(level, tokens, subscriber)
+    return unless level
+    token = tokens.shift
+    case token
+      when FWC then node = level.fwc
+      when PWC then node = level.pwc
+      else node = level.nodes[token]
+    end
+    return unless node
+
+    # This could be expensive if a large number of subscribers exist.
+    if tokens.empty?
+      if (node.leaf_nodes && node.leaf_nodes.delete(subscriber))
+        @count -= 1
+        prune_level(level, node, token)
+        clear_cache # Clear the cache
+      end
+    else
+      remove_level(node.next_level, tokens, subscriber)
+      prune_level(level, node, token)
+    end
+  end
+
+  ################################################
+  # Used for tests on pruning subscription nodes.
+  ################################################
+
+  def node_count_level(level, nc)
+    return 0 unless level
+    nc += 1 if level.fwc
+    nc += node_count_level(level.pwc.next_level, nc+1) if level.pwc
+    level.nodes.each_value do |node|
+      nc += node_count_level(node.next_level, nc)
+    end
+    nc += level.nodes.length
+  end
+
+  def node_count
+    node_count_level(@root, 0)
+  end
+
 end

data/lib/nats/server/util.rb

@@ -7,7 +7,7 @@ end
 
 def log(*args) #:nodoc:
   args.unshift(Time.now) if NATSD::Server.log_time
-  pp args.compact
+  PP::pp(args.compact, $stdout, 120)
 end
 
 def debug(*args) #:nodoc:
@@ -22,13 +22,56 @@ def log_error(e=$!) #:nodoc:
   debug e, e.backtrace
 end
 
+def uptime_string(delta)
+  num_seconds = delta.to_i
+  days = num_seconds / (60 * 60 * 24);
+  num_seconds -= days * (60 * 60 * 24);
+  hours = num_seconds / (60 * 60);
+  num_seconds -= hours * (60 * 60);
+  minutes = num_seconds / 60;
+  num_seconds -= minutes * 60;
+  "#{days}d:#{hours}h:#{minutes}m:#{num_seconds}s"
+end
+
+def pretty_size(size, prec=1)
+  return 'NA' unless size
+  return "#{size}B" if size < 1024
+  return sprintf("%.#{prec}fK", size/1024.0) if size < (1024*1024)
+  return sprintf("%.#{prec}fM", size/(1024.0*1024.0)) if size < (1024*1024*1024)
+  return sprintf("%.#{prec}fG", size/(1024.0*1024.0*1024.0))
+end
+
+def num_cpu_cores
+  if RUBY_PLATFORM =~ /linux/
+    return `cat /proc/cpuinfo | grep processor | wc -l`.to_i
+  elsif RUBY_PLATFORM =~ /darwin/
+    `sysctl -n hw.ncpu`.strip.to_i
+  elsif RUBY_PLATFORM =~ /freebsd|netbsd/
+    `sysctl hw.ncpu`.strip.to_i
+  else
+    return 1
+  end
+end
+
 def shutdown #:nodoc:
   puts
   log 'Server exiting..'
   EM.stop
-  FileUtils.rm(NATSD::Server.pid_file) if NATSD::Server.pid_file
+  if NATSD::Server.pid_file
+    FileUtils.rm(NATSD::Server.pid_file) if File.exists? NATSD::Server.pid_file
+  end
   exit
 end
 
 ['TERM','INT'].each { |s| trap(s) { shutdown } }
 
+# FIXME - Should probably be smarter when lots of connections
+def dump_connection_state
+  log "Dumping connection state on SIG_USR2"
+  ObjectSpace.each_object(NATSD::Connection) do |c|
+    log c.info unless c.closing?
+  end
+  log 'Connection Dump Complete'
+end
+
+trap('USR2') { dump_connection_state }