nats 0.3.12

data/lib/nats/ext/bytesize.rb

@@ -0,0 +1,5 @@
+if RUBY_VERSION <= "1.8.6"
+  class String #:nodoc:
+    def bytesize; self.size; end
+  end
+end

data/lib/nats/ext/em.rb

@@ -0,0 +1,6 @@
+begin
+  require 'eventmachine'
+rescue LoadError
+  require 'rubygems'
+  require 'eventmachine'
+end

data/lib/nats/ext/json.rb

@@ -0,0 +1,7 @@
+begin
+  require 'yajl'
+  require 'yajl/json_gem'
+rescue LoadError
+  require 'rubygems'
+  require 'json'
+end

data/lib/nats/server.rb

@@ -0,0 +1,313 @@
+
+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'
+
+
+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 } }
+
+# 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)
+  rescue => e
+    log "Could not start server on port #{NATSD::Server.port}"
+    log_error
+    exit
+  end
+
+}

data/lib/nats/server/const.rb

@@ -0,0 +1,51 @@
+module NATSD #:nodoc:
+
+  VERSION  = '0.3.12'
+  APP_NAME = 'nats-server'
+
+  DEFAULT_PORT = 4222
+
+  # 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)
+
+  # Maximum outbound size per client
+  MAX_OUTBOUND_SIZE = (10*1024*1024)
+
+  # RESPONSES
+  CR_LF = "\r\n".freeze
+  CR_LF_SIZE = CR_LF.bytesize
+  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
+  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
+  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
+
+end

data/lib/nats/server/options.rb

@@ -0,0 +1,96 @@
+
+require 'optparse'
+require 'yaml'
+
+module NATSD
+  class Server
+
+    class << self
+      def parser
+        @parser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: nats [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 }
+
+          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("-P", "--pid FILE", "File to store PID " +
+                                      "(default: #{@options[:pid_file]})")              { |file| @options[:pid_file] = file }
+
+          opts.on("-C", "--config FILE", "Configuration File " +
+                                      "(default: #{@options[:config_file]})")           { |file| @options[:config_file] = file }
+
+          opts.separator ""
+          opts.separator "Authorization options: (Should be done in config file for production)"
+
+          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("--password password", "Password required for connections")           { |pass| @options[:pass] = pass }
+
+          opts.on("--no_epoll", "Enable epoll (Linux)")                                 { @options[:noepoll] = true }
+          opts.on("--kqueue", "Enable 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 }
+        end
+      end
+
+      def read_config_file
+        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]
+        end
+        rescue => e
+          log "Could not read configuration file:  #{e}"
+          exit
+      end
+
+      def setup_logs
+        return unless @options[:log_file]
+        $stdout.reopen(@options[:log_file], "w")
+        $stdout.sync = true
+        $stderr.reopen($stdout)
+      end
+
+      def finalize_options
+        # Addr/Port
+        @options[:port] ||= DEFAULT_PORT
+        @options[:addr] ||= '0.0.0.0'
+
+        # Debug and Tracing
+        @debug_flag = @options[:debug]
+        @trace_flag = @options[:trace]
+
+        # 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)
+      end
+
+    end
+
+  end
+end