nats 0.3.12 → 0.4.2

data/lib/nats/ext/em.rb

@@ -4,3 +4,10 @@ rescue LoadError
   require 'rubygems'
   require 'eventmachine'
 end
+
+# Check for get_outbound_data_size support, fake it out if it doesn't exist, e.g. jruby
+if !EM::Connection.method_defined? :get_outbound_data_size
+  class EM::Connection
+    def get_outbound_data_size; return 0; end
+  end
+end

data/lib/nats/server.rb

@@ -1,306 +1,25 @@
 
-require File.dirname(__FILE__) + '/ext/em'
-require File.dirname(__FILE__) + '/ext/bytesize'
-require File.dirname(__FILE__) + '/ext/json'
-require File.dirname(__FILE__) + '/server/sublist'
-require File.dirname(__FILE__) + '/server/options'
-require File.dirname(__FILE__) + '/server/const'
-
 require 'socket'
 require 'fileutils'
 require 'pp'
 
+ep = File.expand_path(File.dirname(__FILE__))
 
-module NATSD #:nodoc: all
-
-  # Subscriber
-  Subscriber = Struct.new(:conn, :subject, :sid)
-
-  class Server
-
-    class << self
-      attr_reader :id, :info, :log_time, :auth_required, :debug_flag, :trace_flag
-
-      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 setup(argv)
-        @options = {}
-
-        parser.parse!(argv)
-        read_config_file
-        finalize_options
-
-        @id, @cid = fast_uuid, 1
-        @sublist = Sublist.new
-        @info = {
-          :nats_server_id => Server.id,
-          :version => VERSION,
-          :auth_required => auth_required?,
-          :max_payload => MAX_PAYLOAD_SIZE
-        }
-
-        # Check for daemon flag
-        if @options[:daemonize]
-          require 'rubygems'
-          require 'daemons'
-          # 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"
-          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(subscriber)
-        @sublist.insert(subscriber.subject, subscriber)
-      end
-
-      def unsubscribe(subscriber)
-        @sublist.remove(subscriber.subject, subscriber)
-      end
-
-      def route_to_subscribers(subject, reply, msg)
-        @sublist.match(subject).each do |subscriber|
-          # Skip anyone in the closing state
-          next if subscriber.conn.closing
-
-          trace "Matched subscriber", subscriber[:subject], subscriber[:sid], subscriber.conn.client_info
-          subscriber.conn.send_data("MSG #{subject} #{subscriber.sid} #{reply} #{msg.bytesize}#{CR_LF}")
-          subscriber.conn.send_data(msg)
-          subscriber.conn.send_data(CR_LF)
-
-          # Check the outbound queue here and react if need be..
-          if subscriber.conn.get_outbound_data_size > MAX_OUTBOUND_SIZE
-            subscriber.conn.error_close SLOW_CONSUMER
-            log "Slow consumer dropped", subscriber.conn.client_info
-          end
-        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
-      send_info
-      @auth_pending = EM.add_timer(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 ||= '') << data
-      close_connection and return if @buf =~ /(\006|\004)/ # ctrl+c or ctrl+d for telnet friendly
-      while (@buf && !@buf.empty? && !@closing)
-        # Waiting on msg payload
-        if @msg_size
-          if (@buf.bytesize >= (@msg_size + CR_LF_SIZE))
-              msg = @buf.slice(0, @msg_size)
-              process_msg(msg)
-              @buf = @buf.slice((msg.bytesize + CR_LF_SIZE), @buf.bytesize)
-          else # Waiting for additional msg data
-            return
-          end
-        # Waiting on control line
-        elsif @buf =~ /^(.*)\r\n/
-          @buf = $'
-          process_op($1)
-        else # Waiting for additional data for control line
-          # This is not normal. Close immediately
-          if @buf.bytesize > MAX_CONTROL_LINE_SIZE
-            debug "MAX_CONTROL_LINE exceeded, closing connection.."
-            @closing = true
-            close_connection
-          end
-          return
-        end
-      end
-      # Nothing should be here.
-    end
-
-    def process_op(op)
-      case op
-        when PUB_OP
-          ctrace 'PUB OP', op
-          return if @auth_pending
-          @pub_sub, @reply, @msg_size, = $1, $3, $4.to_i
-          send_data PAYLOAD_TOO_BIG and return if (@msg_size > MAX_PAYLOAD_SIZE)
-          send_data INVALID_SUBJECT and return if @pedantic && !(@pub_sub =~ SUB_NO_WC)
-        when SUB_OP
-          ctrace 'SUB OP', op
-          return if @auth_pending
-          sub, sid = $1, $2
-          send_data INVALID_SUBJECT and return if !($1 =~ SUB)
-          send_data INVALID_SID_TAKEN and return if @subscriptions[sid]
-          subscriber = Subscriber.new(self, sub, sid)
-          @subscriptions[sid] = subscriber
-          Server.subscribe(subscriber)
-          send_data OK if @verbose
-        when UNSUB_OP
-          ctrace 'UNSUB OP', op
-          return if @xsauth_pending
-          sid, subscriber = $1, @subscriptions[$1]
-          send_data INVALID_SID_NOEXIST and return unless subscriber
-          Server.unsubscribe(subscriber)
-          @subscriptions.delete(sid)
-          send_data OK if @verbose
-        when PING
-          ctrace 'PING OP', op
-          send_data PONG_RESPONSE
-        when CONNECT
-          ctrace 'CONNECT OP', op
-          begin
-            config = JSON.parse($1, :symbolize_keys => true)
-            process_connect_config(config)
-          rescue => e
-            send_data INVALID_CONFIG
-            log_error
-          end
-        when INFO
-          ctrace 'INFO OP', op
-          send_info
-        else
-          ctrace 'Unknown Op', op
-          send_data UNKNOWN_OP
-      end
-    end
-
-    def send_info
-      send_data "INFO #{Server.info_string}#{CR_LF}"
-    end
-
-    def process_msg(body)
-      ctrace 'Processing msg', @pub_sub, @reply, body
-      send_data OK if @verbose
-      Server.route_to_subscribers(@pub_sub, @reply, body)
-      @pub_sub = @msg_size = @reply = nil
-      true
-    end
-
-    def process_connect_config(config)
-      @verbose  = config[:verbose] if config[:verbose] != nil
-      @pedantic = config[:pedantic] if config[:pedantic] != nil
-
-      send_data OK and return unless Server.auth_required?
-
-      EM.cancel_timer(@auth_pending)
-      if Server.auth_ok?(config[:user], config[:pass])
-        send_data OK
-        @auth_pending = nil
-      else
-        error_close AUTH_FAILED
-        debug "Authorization failed for connection", cid
-      end
-    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 { |subscriber| Server.unsubscribe(subscriber) }
-      EM.cancel_timer(@auth_pending) if @auth_pending
-      @auth_pending = nil
-    end
-
-    def ctrace(*args)
-      trace(args, "c: #{cid}")
-    end
-  end
-
-end
-
-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 } }
+require "#{ep}/ext/em"
+require "#{ep}/ext/bytesize"
+require "#{ep}/ext/json"
+require "#{ep}/server/server"
+require "#{ep}/server/sublist"
+require "#{ep}/server/options"
+require "#{ep}/server/const"
+require "#{ep}/server/util"
 
 # Do setup
 NATSD::Server.setup(ARGV.dup)
 
 # Event Loop
-
 EM.run {
-
   log "Starting #{NATSD::APP_NAME} version #{NATSD::VERSION} on port #{NATSD::Server.port}"
-
   begin
     EM.set_descriptor_table_size(32768) # Requires Root privileges
     EventMachine::start_server(NATSD::Server.host, NATSD::Server.port, NATSD::Connection)
@@ -309,5 +28,4 @@ EM.run {
     log_error
     exit
   end
-
 }

data/lib/nats/server/const.rb

@@ -1,51 +1,61 @@
+
 module NATSD #:nodoc:
 
-  VERSION  = '0.3.12'
+  VERSION  = '0.4.2'
   APP_NAME = 'nats-server'
 
   DEFAULT_PORT = 4222
+  DEFAULT_HOST = '0.0.0.0'
 
-  # Ops
-  INFO = /^INFO$/i
-  PUB_OP = /^PUB\s+(\S+)\s+((\S+)\s+)?(\d+)$/i
-  SUB_OP = /^SUB\s+(\S+)\s+(\S+)$/i
-  UNSUB_OP = /^UNSUB\s+(\S+)$/i
-  PING = /^PING$/i
-  CONNECT = /^CONNECT\s+(.+)$/i
-
-  # 1k should be plenty since payloads sans connect are payload
-  MAX_CONTROL_LINE_SIZE = 1024
-
-  # Should be using something different if > 1MB payload
-  MAX_PAYLOAD_SIZE = (1024*1024)
+  # Parser
+  AWAITING_CONTROL_LINE = 1
+  AWAITING_MSG_PAYLOAD  = 2
 
-  # Maximum outbound size per client
-  MAX_OUTBOUND_SIZE = (10*1024*1024)
+  # Ops - See protocol.txt for more info
+  INFO     = /\AINFO\r\n/i
+  PUB_OP   = /\APUB\s+([^\s\r\n]+)\s+(([^\s\r\n]+)[^\S\r\n]+)?(\d+)\r\n/i
+  SUB_OP   = /\ASUB\s+([^\s\r\n]+)\s+(([^\s\r\n]+)[^\S\r\n]+)?([^\s\r\n]+)\r\n/i
+  UNSUB_OP = /\AUNSUB\s+([^\s\r\n]+)\s*(\s+(\d+))?\r\n/i
+  PING     = /\APING\r\n/i
+  CONNECT  = /\ACONNECT\s+([^\r\n]+)\r\n/i
+  UNKNOWN  = /\A(.*)\r\n/
 
   # RESPONSES
   CR_LF = "\r\n".freeze
   CR_LF_SIZE = CR_LF.bytesize
-  OK = "+OK #{CR_LF}".freeze
+  EMPTY = ''.freeze
+  OK = "+OK#{CR_LF}".freeze
   PONG_RESPONSE = "PONG#{CR_LF}".freeze
-
   INFO_RESPONSE = "#{CR_LF}".freeze
 
   # ERR responses
-  PAYLOAD_TOO_BIG     = "-ERR 'Payload size exceeded, max is #{MAX_PAYLOAD_SIZE} bytes'#{CR_LF}".freeze
+  PAYLOAD_TOO_BIG     = "-ERR 'Payload size exceeded'#{CR_LF}".freeze
+  PROTOCOL_OP_TOO_BIG = "-ERR 'Protocol Operation size exceeded'#{CR_LF}".freeze
   INVALID_SUBJECT     = "-ERR 'Invalid Subject'#{CR_LF}".freeze
   INVALID_SID_TAKEN   = "-ERR 'Invalid Subject Identifier (sid), already taken'#{CR_LF}".freeze
   INVALID_SID_NOEXIST = "-ERR 'Invalid Subject-Identifier (sid), no subscriber registered'#{CR_LF}".freeze
   INVALID_CONFIG      = "-ERR 'Invalid config, valid JSON required for connection configuration'#{CR_LF}".freeze
   AUTH_REQUIRED       = "-ERR 'Authorization is required'#{CR_LF}".freeze
   AUTH_FAILED         = "-ERR 'Authorization failed'#{CR_LF}".freeze
-  UNKNOWN_OP          = "-ERR 'Unkown Protocol Operation'#{CR_LF}".freeze
+  UNKNOWN_OP          = "-ERR 'Unknown Protocol Operation'#{CR_LF}".freeze
   SLOW_CONSUMER       = "-ERR 'Slow consumer detected, connection dropped'#{CR_LF}".freeze
 
   # Pedantic Mode
   SUB = /^([^\.\*>\s]+|>$|\*)(\.([^\.\*>\s]+|>$|\*))*$/
   SUB_NO_WC = /^([^\.\*>\s]+)(\.([^\.\*>\s]+))*$/
 
-  # Autorization wait time
-  AUTH_TIMEOUT = 5
+  # Some sane default thresholds
+
+  # 1k should be plenty since payloads sans connect string are separate
+  MAX_CONTROL_LINE_SIZE = 1024
+
+  # Should be using something different if > 1MB payload
+  MAX_PAYLOAD_SIZE = (1024*1024)
+
+  # Maximum outbound size per client
+  MAX_PENDING_SIZE = (10*1024*1024)
+
+  # Authorization wait time
+  AUTH_TIMEOUT = 1
 
 end

data/lib/nats/server/options.rb

@@ -8,44 +8,45 @@ module NATSD
     class << self
       def parser
         @parser ||= OptionParser.new do |opts|
-          opts.banner = "Usage: nats [options]"
+          opts.banner = "Usage: nats-server [options]"
 
           opts.separator ""
           opts.separator "Server options:"
 
           opts.on("-a", "--addr HOST", "Bind to HOST address " +
-                                       "(default: #{@options[:addr]})")                 { |host| @options[:address] = host }
-          opts.on("-p", "--port PORT", "Use PORT (default: #{@options[:port]})")        { |port| @options[:port] = port.to_i }
+                                       "(default: #{DEFAULT_HOST})")           { |host| @options[:addr] = host }
+          opts.on("-p", "--port PORT", "Use PORT (default: #{DEFAULT_PORT})")  { |port| @options[:port] = port.to_i }
+          opts.on("-d", "--daemonize", "Run daemonized in the background")     { @options[:daemonize] = true }
+          opts.on("-P", "--pid FILE", "File to store PID")                     { |file| @options[:pid_file] = file }
 
-          opts.on("-d", "--daemonize", "Run daemonized in the background")              { @options[:daemonize] = true }
-          opts.on("-l", "--log FILE", "File to redirect output " +
-                                      "(default: #{@options[:log_file]})")              { |file| @options[:log_file] = file }
-          opts.on("-T", "--logtime", "Timestamp log entries")                           { @options[:log_time] = true }
+          opts.on("-C", "--config FILE", "Configuration File " +
+                                      "(default: #{@options[:config_file]})")  { |file| @options[:config_file] = file }
 
-          opts.on("-P", "--pid FILE", "File to store PID " +
-                                      "(default: #{@options[:pid_file]})")              { |file| @options[:pid_file] = file }
+          opts.separator ""
+          opts.separator "Logging options:"
 
-          opts.on("-C", "--config FILE", "Configuration File " +
-                                      "(default: #{@options[:config_file]})")           { |file| @options[:config_file] = file }
+          opts.on("-l", "--log FILE", "File to redirect log output")           { |file| @options[:log_file] = file }
+          opts.on("-T", "--logtime", "Timestamp log entries (default: false)") { @options[:log_time] = true }
+          opts.on("-D", "--debug", "Enable debugging output")                  { @options[:debug] = true }
+          opts.on("-V", "--trace", "Trace the raw protocol")                   { @options[:trace] = true }
 
           opts.separator ""
-          opts.separator "Authorization options: (Should be done in config file for production)"
+          opts.separator "Authorization options:"
 
-          opts.on("--user user", "User required for connections")                       { |user| @options[:user] = user }
+          opts.on("--user user", "User required for connections")              { |user| @options[:user] = user }
+          opts.on("--pass password", "Password required for connections")      { |pass| @options[:pass] = pass }
 
-          opts.on("--pass password", "Password required for connections")               { |pass| @options[:pass] = pass }
-          opts.on("--password password", "Password required for connections")           { |pass| @options[:pass] = pass }
+          opts.separator ""
+          opts.separator "Advanced IO options:"
 
-          opts.on("--no_epoll", "Enable epoll (Linux)")                                 { @options[:noepoll] = true }
-          opts.on("--kqueue", "Enable kqueue (MacOSX and BSD)")                         { @options[:nokqueue] = true }
+          opts.on("--no_epoll", "Disable epoll (Linux)")                       { @options[:noepoll] = true }
+          opts.on("--no_kqueue", "Disable kqueue (MacOSX and BSD)")            { @options[:nokqueue] = true }
 
           opts.separator ""
           opts.separator "Common options:"
 
-          opts.on_tail("-h", "--help", "Show this message")                             { puts opts; exit }
-          opts.on_tail('-v', '--version', "Show version")                               { puts NATSD::Server.version; exit }
-          opts.on_tail("-D", "--debug", "Set debugging on")                             { @options[:debug] = true }
-          opts.on_tail("-V", "--trace", "Set tracing on of raw protocol")               { @options[:trace] = true }
+          opts.on_tail("-h", "--help", "Show this message")                    { puts opts; exit }
+          opts.on_tail('-v', '--version', "Show version")                      { puts NATSD::Server.version; exit }
         end
       end
 
@@ -53,13 +54,32 @@ module NATSD
         return unless config_file = @options[:config_file]
         config = File.open(config_file) { |f| YAML.load(f) }
         # Command lines args, parsed first, will override these.
-        [:addr, :port, :log_file, :pid_file, :user, :pass, :log_time, :debug].each do |p|
-          c = config[p.to_s]
-          @options[p] = c if c and not @options[p]
+        @options[:port] = config['port'] if @options[:port].nil?
+        @options[:addr] = config['net'] if @options[:addr].nil?
+        if auth = config['authorization']
+          @options[:user] = auth['user'] if @options[:user].nil?
+          @options[:pass] = auth['password'] if @options[:pass].nil?
+          @options[:token] = auth['token'] if @options[:token].nil?
+          @options[:auth_timeout] = auth['timeout'] if @options[:auth_timeout].nil?
         end
-        rescue => e
-          log "Could not read configuration file:  #{e}"
-          exit
+        @options[:pid_file] = config['pid_file'] if @options[:pid_file].nil?
+        @options[:log_file] = config['log_file'] if @options[:log_file].nil?
+        @options[:logtime] = config['logtime'] if @options[:logtime].nil?
+        @options[:debug] = config['debug'] if @options[:debug].nil?
+        @options[:trace] = config['trace'] if @options[:trace].nil?
+
+        # these just override if present
+        @options[:max_control_line] = config['max_control_line'] if config['max_control_line']
+        @options[:max_payload] = config['max_payload'] if config['max_payload']
+        @options[:max_pending] = config['max_pending'] if config['max_pending']
+
+        # just set
+        @options[:noepoll] = config['no_epoll'] if config['no_epoll']
+        @options[:nokqueue] = config['no_kqueue'] if config['no_kqueue']
+
+      rescue => e
+        log "Could not read configuration file:  #{e}"
+        exit
       end
 
       def setup_logs
@@ -72,7 +92,7 @@ module NATSD
       def finalize_options
         # Addr/Port
         @options[:port] ||= DEFAULT_PORT
-        @options[:addr] ||= '0.0.0.0'
+        @options[:addr] ||= DEFAULT_HOST
 
         # Debug and Tracing
         @debug_flag = @options[:debug]
@@ -80,14 +100,26 @@ module NATSD
 
         # Log timestamps
         @log_time = @options[:log_time]
-        # setup_logs
 
         debug @options # Block pass?
         debug "DEBUG is on"
         trace "TRACE is on"
 
-        # Auth
-        @auth_required = (@options[:user] != nil)
+        # Authorization
+        @auth_required = (not @options[:user].nil?)
+
+        # Thresholds
+        @options[:max_control_line] ||= MAX_CONTROL_LINE_SIZE
+        @max_control_line = @options[:max_control_line]
+
+        @options[:max_payload] ||= MAX_PAYLOAD_SIZE
+        @max_payload = @options[:max_payload]
+
+        @options[:max_pending] ||= MAX_PENDING_SIZE
+        @max_pending = @options[:max_pending]
+
+        @options[:auth_timeout] ||= AUTH_TIMEOUT
+        @auth_timeout = @options[:auth_timeout]
       end
 
     end