nats 0.4.28 → 0.5.0.beta.12

data/lib/nats/server.rb

@@ -13,6 +13,8 @@ require "#{ep}/server/server"
 require "#{ep}/server/sublist"
 require "#{ep}/server/connection"
 require "#{ep}/server/options"
+require "#{ep}/server/cluster"
+require "#{ep}/server/route"
 require "#{ep}/server/const"
 require "#{ep}/server/util"
 require "#{ep}/server/varz"
@@ -22,12 +24,13 @@ require "#{ep}/server/connz"
 NATSD::Server.setup(ARGV.dup)
 
 # Event Loop
-EM.run {
+EM.run do
+
   log "Starting #{NATSD::APP_NAME} version #{NATSD::VERSION} on port #{NATSD::Server.port}"
-  log "TLS/SSL Support Enabled" if NATSD::Server.options[:ssl] 
+  log "TLS/SSL Support Enabled" if NATSD::Server.options[:ssl]
   begin
     EM.set_descriptor_table_size(32768) # Requires Root privileges
-    EventMachine::start_server(NATSD::Server.host, NATSD::Server.port, NATSD::Connection)
+    EM.start_server(NATSD::Server.host, NATSD::Server.port, NATSD::Connection)
   rescue => e
     log "Could not start server on port #{NATSD::Server.port}"
     log_error
@@ -44,4 +47,24 @@ EM.run {
       exit(1)
     end
   end
-}
+
+  ###################
+  # CLUSTER SETUP
+  ###################
+
+  # Check to see if we need to fire up a routing listen port
+  if NATSD::Server.options[:cluster_port]
+    begin
+      log "Starting routing on port #{NATSD::Server.options[:cluster_port]}"
+      EM.start_server(NATSD::Server.host, NATSD::Server.options[:cluster_port], NATSD::Route)
+    rescue => e
+      log "Could not start routing server on port #{NATSD::Server.options[:cluster_port]}"
+      log_error
+      exit(1)
+    end
+  end
+
+  # If we have active connections, solicit them now..
+  NATSD::Server.solicit_routes if NATSD::Server.options[:cluster_routes]
+
+end

data/lib/nats/server/cluster.rb

@@ -0,0 +1,102 @@
+require 'uri'
+
+module NATSD #:nodoc: all
+
+  class Server
+    class << self
+      attr_reader :opt_routes, :route_auth_required, :route_ssl_required, :reconnect_interval
+      attr_accessor :num_routes
+
+      alias route_auth_required? :route_auth_required
+      alias route_ssl_required? :route_ssl_required
+
+      def connected_routes
+        @routes ||= []
+      end
+
+      def add_route(route)
+        connected_routes << route unless route.nil?
+      end
+
+      def remove_route(route)
+        connected_routes.delete(route) unless route.nil?
+      end
+
+      def route_info_string
+        @route_info = {
+          :server_id => Server.id,
+          :host => @options[:cluster_net] || host,
+          :port => @options[:cluster_port],
+          :version => VERSION,
+          :auth_required => route_auth_required?,
+          :ssl_required => false,                 # FIXME!
+          :max_payload => @max_payload
+        }
+        @route_info.to_json
+      end
+
+      def route_key(route_url)
+        r = URI.parse(route_url)
+        "#{r.host}:#{r.port}"
+      end
+
+      def route_auth_ok?(user, pass)
+        user == @options[:cluster_user] && pass == @options[:cluster_pass]
+      end
+
+      def solicit_routes #:nodoc:
+        @opt_routes = []
+        NATSD::Server.options[:cluster_routes].each do |r_url|
+          opt_routes << { :route => r_url, :uri => URI.parse(r_url), :key => route_key(r_url) }
+        end
+        try_to_connect_routes
+      end
+
+      def try_to_connect_routes #:nodoc:
+        opt_routes.each do |route|
+          # FIXME, Strip auth
+          debug "Trying to connect to route: #{route[:route]}"
+          EM.connect(route[:uri].host, route[:uri].port, NATSD::Route, route)
+        end
+      end
+
+      def broadcast_proto_to_routes(proto)
+        connected_routes.each { |r| r.queue_data(proto) }
+      end
+
+      def rsid_qsub(rsid)
+        cid, sid = parse_rsid(rsid)
+        conn = Server.connections[cid]
+        sub = conn.subscriptions[sid]
+        sub if sub.qgroup
+      rescue
+        nil
+      end
+
+      def parse_rsid(rsid)
+        m = RSID.match(rsid)
+        return [m[1].to_i, m[2]] if m
+      end
+
+      def routed_sid(sub)
+        "RSID:#{sub.conn.cid}:#{sub.sid}"
+      end
+
+      def route_sub_proto(sub)
+        return "SUB #{sub.subject} #{routed_sid(sub)}#{CR_LF}" if sub.qgroup.nil?
+        return "SUB #{sub.subject} #{sub.qgroup} #{routed_sid(sub)}#{CR_LF}"
+      end
+
+      def broadcast_sub_to_routes(sub)
+        broadcast_proto_to_routes(route_sub_proto(sub))
+      end
+
+      def broadcast_unsub_to_routes(sub)
+        opt_max_str = " #{sub.max_responses}" unless sub.max_responses.nil?
+        broadcast_proto_to_routes("UNSUB #{routed_sid(sub)}#{opt_max_str}#{CR_LF}")
+      end
+
+    end
+  end
+
+end

data/lib/nats/server/connection.rb

@@ -3,7 +3,7 @@ module NATSD #:nodoc: all
   module Connection #:nodoc: all
 
     attr_accessor :in_msgs, :out_msgs, :in_bytes, :out_bytes
-    attr_reader :cid, :closing, :last_activity, :writev_size
+    attr_reader :cid, :closing, :last_activity, :writev_size, :subscriptions
     alias :closing? :closing
 
     def flush_data
@@ -52,7 +52,7 @@ module NATSD #:nodoc: all
       @writev_size = 0
       @parse_state = AWAITING_CONTROL_LINE
       send_info
-      debug "Client connection created", client_info, cid
+      debug "#{type} connection created", client_info, cid
       if Server.ssl_required?
         debug "Starting TLS/SSL", client_info, cid
         flush_data
@@ -62,7 +62,7 @@ module NATSD #:nodoc: all
       @auth_pending = EM.add_timer(NATSD::Server.auth_timeout) { connect_auth_timeout } if Server.auth_required?
       @ping_timer = EM.add_periodic_timer(NATSD::Server.ping_interval) { send_ping }
       @pings_outstanding = 0
-      Server.num_connections += 1
+      inc_connections
       return if max_connections_exceeded?
     end
 
@@ -79,12 +79,12 @@ module NATSD #:nodoc: all
 
     def connect_auth_timeout
       error_close AUTH_REQUIRED
-      debug "Connection timeout due to lack of auth credentials", cid
+      debug "#{type} connection timeout due to lack of auth credentials", cid
     end
 
     def connect_ssl_timeout
       error_close SSL_REQUIRED
-      debug "Connection timeout due to lack of TLS/SSL negotiations", cid
+      debug "#{type} connection timeout due to lack of TLS/SSL negotiations", cid
     end
 
     def receive_data(data)
@@ -131,12 +131,12 @@ module NATSD #:nodoc: all
               queue_data(INVALID_SID_NOEXIST) if @pedantic
             end
           when PING
-            ctrace('PING OP', strip_op($&)) if NATSD::Server.trace_flag?
+            ctrace('PING OP') if NATSD::Server.trace_flag?
             @buf = $'
             queue_data(PONG_RESPONSE)
             flush_data
           when PONG
-            ctrace('PONG OP', strip_op($&)) if NATSD::Server.trace_flag?
+            ctrace('PONG OP') if NATSD::Server.trace_flag?
             @buf = $'
             @pings_outstanding -= 1
           when CONNECT
@@ -149,8 +149,8 @@ module NATSD #:nodoc: all
               queue_data(INVALID_CONFIG)
               log_error
             end
-          when INFO
-            ctrace('INFO OP', strip_op($&)) if NATSD::Server.trace_flag?
+          when INFO_REQ
+            ctrace('INFO_REQUEST OP') if NATSD::Server.trace_flag?
             return connect_auth_timeout if @auth_pending
             @buf = $'
             send_info
@@ -196,6 +196,14 @@ module NATSD #:nodoc: all
       queue_data("INFO #{Server.info_string}#{CR_LF}")
     end
 
+    # Placeholder
+    def process_info(info)
+    end
+
+    def auth_ok?(user, pass)
+      Server.auth_ok?(user, pass)
+    end
+
     def process_connect_config(config)
       @verbose  = config['verbose'] unless config['verbose'].nil?
       @pedantic = config['pedantic'] unless config['pedantic'].nil?
@@ -203,18 +211,18 @@ module NATSD #:nodoc: all
       return queue_data(OK) unless Server.auth_required?
 
       EM.cancel_timer(@auth_pending)
-      if Server.auth_ok?(config['user'], config['pass'])
+      if auth_ok?(config['user'], config['pass'])
         queue_data(OK) if @verbose
         @auth_pending = nil
       else
         error_close AUTH_FAILED
-        debug "Authorization failed for connection", cid
+        debug "Authorization failed for #{type.downcase} 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)
+      Server.unsubscribe(sub, is_route?)
       @subscriptions.delete(sub.sid)
     end
 
@@ -235,25 +243,38 @@ module NATSD #:nodoc: all
       debug "Message payload size exceeded (#{sizes}), closing connection"
     end
 
-    def unbind
-      debug "Client connection closed", client_info, cid
+    def inc_connections
+      Server.num_connections += 1
+      Server.connections[cid] = self
+    end
+
+    def dec_connections
       Server.num_connections -= 1
-      @subscriptions.each_value { |sub| Server.unsubscribe(sub) }
+      Server.connections.delete(cid)
+    end
+
+    def process_unbind
+      dec_connections
       EM.cancel_timer(@ssl_pending) if @ssl_pending
       @ssl_pending = nil
       EM.cancel_timer(@auth_pending) if @auth_pending
       @auth_pending = nil
       EM.cancel_timer(@ping_timer) if @ping_timer
       @ping_timer = nil
-
+      @subscriptions.each_value { |sub| Server.unsubscribe(sub) }
       @closing = true
     end
 
+    def unbind
+      debug "Client connection closed", client_info, cid
+      process_unbind
+    end
+
     def ssl_handshake_completed
       EM.cancel_timer(@ssl_pending)
       @ssl_pending = nil
       cert = get_peer_cert
-      debug "Client Certificate:", cert ? cert : 'N/A', cid
+      debug "#{type} Certificate:", cert ? cert : 'N/A', cid
     end
 
     # FIXME! Cert accepted by default
@@ -268,6 +289,15 @@ module NATSD #:nodoc: all
     def strip_op(op='')
       op.dup.sub(CR_LF, EMPTY)
     end
+
+    def is_route?
+      false
+    end
+
+    def type
+      'Client'
+    end
+
   end
 
 end

data/lib/nats/server/connz.rb

@@ -33,7 +33,6 @@ module NATSD #:nodoc: all
 
   class Server
     class << self
-
       def dump_connections
         conns, total = [], 0
         ObjectSpace.each_object(NATSD::Connection) do |c|
@@ -47,7 +46,6 @@ module NATSD #:nodoc: all
           :connections => conns
         }
       end
-
     end
   end
 

data/lib/nats/server/const.rb

@@ -1,7 +1,7 @@
 
 module NATSD #:nodoc:
 
-  VERSION  = '0.4.28'
+  VERSION  = '0.5.0.beta.12'
   APP_NAME = 'nats-server'
 
   DEFAULT_PORT = 4222
@@ -12,17 +12,23 @@ module NATSD #:nodoc:
   AWAITING_MSG_PAYLOAD  = 2
 
   # Ops - See protocol.txt for more info
-  INFO     = /\AINFO\s*\r\n/i
+  INFO     = /\AINFO\s*([^\r\n]*)\r\n/i
   PUB_OP   = /\APUB\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?(\d+)\r\n/i
+  MSG      = /\AMSG\s+([^\s]+)\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?(\d+)\r\n/i
   SUB_OP   = /\ASUB\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?([^\s]+)\r\n/i
   UNSUB_OP = /\AUNSUB\s+([^\s]+)\s*(\s+(\d+))?\r\n/i
   PING     = /\APING\s*\r\n/i
   PONG     = /\APONG\s*\r\n/i
+  INFO_REQ = /\AINFO_REQ\s*\r\n/i
+
   CONNECT  = /\ACONNECT\s+([^\r\n]+)\r\n/i
   UNKNOWN  = /\A(.*)\r\n/
   CTRL_C   = /\006/
   CTRL_D   = /\004/
 
+  ERR_RESP = /\A-ERR\s+('.+')?\r\n/i
+  OK_RESP  = /\A\+OK\s*\r\n/i #:nodoc:
+
   # RESPONSES
   CR_LF = "\r\n".freeze
   CR_LF_SIZE = CR_LF.bytesize
@@ -52,6 +58,9 @@ module NATSD #:nodoc:
   SUB = /^([^\.\*>\s]+|>$|\*)(\.([^\.\*>\s]+|>$|\*))*$/
   SUB_NO_WC = /^([^\.\*>\s]+)(\.([^\.\*>\s]+))*$/
 
+  # Router Subscription Identifiers
+  RSID = /RSID:(\d+):(\S+)/
+
   # Some sane default thresholds
 
   # 1k should be plenty since payloads sans connect string are separate
@@ -79,6 +88,9 @@ module NATSD #:nodoc:
   DEFAULT_PING_INTERVAL = 120
   DEFAULT_PING_MAX = 2
 
+  # Route Reconnect
+  DEFAULT_ROUTE_RECONNECT_INTERVAL = 1.0
+
   # HTTP
   RACK_JSON_HDR = { 'Content-Type' => 'application/json' }
   RACK_TEXT_HDR = { 'Content-Type' => 'text/plain' }

data/lib/nats/server/options.rb

@@ -20,6 +20,8 @@ module NATSD
 
           opts.on("-m", "--http_port PORT", "Use HTTP PORT ")                  { |port| @options[:http_port] = port.to_i }
 
+          opts.on("-r", "--cluster_port PORT", "Use Cluster PORT ")            { |port| @options[:cluster_port] = port.to_i }
+
           opts.on("-c", "--config FILE", "Configuration File")                 { |file| @options[:config_file] = file }
 
           opts.separator ""
@@ -106,6 +108,21 @@ module NATSD
           @options[:ping_max] = ping['max_outstanding'] if @options[:ping_max].nil?
         end
 
+        if cluster = config['cluster']
+          @options[:cluster_port] = cluster['port'] if @options[:cluster_port].nil?
+          if auth = cluster['authorization']
+            @options[:cluster_user] = auth['user'] if @options[:cluster_user].nil?
+            @options[:cluster_pass] = auth['password'] if @options[:cluster_pass].nil?
+            @options[:cluster_pass] = auth['pass'] if @options[:cluster_pass].nil?
+            @options[:cluster_token] = auth['token'] if @options[:cluster_token].nil?
+            @options[:cluster_auth_timeout] = auth['timeout'] if @options[:cluster_auth_timeout].nil?
+            @route_auth_required = true
+          end
+          if routes = cluster['routes']
+            @options[:cluster_routes] = routes if @options[:cluster_routes].nil?
+          end
+        end
+
       rescue => e
         log "Could not read configuration file:  #{e}"
         exit 1
@@ -120,7 +137,7 @@ module NATSD
 
       def open_syslog
         return unless @options[:syslog]
-        Syslog.open("#{@options[:syslog]}", Syslog::LOG_PID,  Syslog::LOG_USER ) unless Syslog.opened? 
+        Syslog.open("#{@options[:syslog]}", Syslog::LOG_PID, Syslog::LOG_USER) unless Syslog.opened?
       end
 
       def close_syslog
@@ -173,7 +190,7 @@ module NATSD
 
         @auth_required = (not @options[:user].nil?)
 
-        @ssl_required = (not @options[:ssl].nil?)
+        @ssl_required = @options[:ssl]
 
         # Pings
         @options[:ping_interval] ||= DEFAULT_PING_INTERVAL

data/lib/nats/server/route.rb

@@ -0,0 +1,279 @@
+module NATSD #:nodoc: all
+
+  # Need to make this a class with EM > 1.0
+  class Route < EventMachine::Connection #:nodoc:
+
+    include Connection
+
+    attr_reader :rid, :remote_rid, :closing, :r_obj, :reconnecting
+    alias :peer_info :client_info
+    alias :reconnecting? :reconnecting
+
+    def initialize(route=nil)
+      @r_obj = route
+    end
+
+    def solicited?
+      r_obj != nil
+    end
+
+    def connection_completed
+      debug "Route connected", rid
+      return unless reconnecting?
+
+      # Kill reconnect if we got here from there
+      cancel_reconnect
+      @buf, @closing = nil, false
+      post_init
+    end
+
+    def post_init
+      @rid = Server.rid
+      @subscriptions = {}
+      @in_msgs = @out_msgs = @in_bytes = @out_bytes = 0
+      @writev_size = 0
+      @parse_state = AWAITING_CONTROL_LINE
+
+      # Queue up auth if needed and we solicited the connection
+      debug "Route connection created", peer_info, rid
+
+      # queue up auth if needed and we solicited the connection
+      if solicited?
+        debug "Route sent authorization", rid
+        send_auth
+      else
+        # FIXME, separate variables for timeout?
+        @auth_pending = EM.add_timer(NATSD::Server.auth_timeout) { connect_auth_timeout } if Server.route_auth_required?
+      end
+
+      send_info
+      @ping_timer = EM.add_periodic_timer(NATSD::Server.ping_interval) { send_ping }
+      @pings_outstanding = 0
+      inc_connections
+      send_local_subs_to_route
+    end
+
+    # TODO: Make sure max_requested is also propogated on reconnect
+    def send_local_subs_to_route
+      ObjectSpace.each_object(NATSD::Connection) do |c|
+        next if c.closing? || c.type != 'Client'
+        c.subscriptions.each_value do |sub|
+          queue_data(NATSD::Server.route_sub_proto(sub))
+        end
+      end
+    end
+
+    def process_connect_route_config(config)
+      @verbose  = config['verbose'] unless config['verbose'].nil?
+      @pedantic = config['pedantic'] unless config['pedantic'].nil?
+
+      return queue_data(OK) unless Server.route_auth_required?
+
+      EM.cancel_timer(@auth_pending)
+      if auth_ok?(config['user'], config['pass'])
+        debug "Route received proper credentials", rid
+        queue_data(OK) if @verbose
+        @auth_pending = nil
+      else
+        error_close AUTH_FAILED
+        debug "Authorization failed for #{type.downcase} connection", rid
+      end
+    end
+
+    def connect_auth_timeout
+      error_close AUTH_REQUIRED
+      debug "#{type} connection timeout due to lack of auth credentials", rid
+    end
+
+    def receive_data(data)
+      @buf = @buf ? @buf << data : data
+      return close_connection if @buf =~ /(\006|\004)/ # ctrl+c or ctrl+d for telnet friendly
+
+      while (@buf && !@closing)
+        case @parse_state
+        when AWAITING_CONTROL_LINE
+          case @buf
+          when MSG
+            ctrace('MSG OP', strip_op($&)) if NATSD::Server.trace_flag?
+            return connect_auth_timeout if @auth_pending
+            @buf = $'
+            @parse_state = AWAITING_MSG_PAYLOAD
+            @msg_sub, @msg_sid, @msg_reply, @msg_size = $1, $2, $4, $5.to_i
+            if (@msg_size > NATSD::Server.max_payload)
+              debug_print_msg_too_big(@msg_size)
+              error_close PAYLOAD_TOO_BIG
+            end
+            queue_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 queue_data(INVALID_SUBJECT) if !($1 =~ SUB)
+            return queue_data(INVALID_SID_TAKEN) if @subscriptions[sid]
+            sub = Subscriber.new(self, sub, sid, qgroup, 0)
+            @subscriptions[sid] = sub
+            Server.subscribe(sub, is_route?)
+            queue_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))
+              queue_data(OK) if @verbose
+            else
+              queue_data(INVALID_SID_NOEXIST) if @pedantic
+            end
+          when PING
+            ctrace('PING OP') if NATSD::Server.trace_flag?
+            @buf = $'
+            queue_data(PONG_RESPONSE)
+            flush_data
+          when PONG
+            ctrace('PONG OP') if NATSD::Server.trace_flag?
+            @buf = $'
+            @pings_outstanding -= 1
+          when CONNECT
+            ctrace('CONNECT OP', strip_op($&)) if NATSD::Server.trace_flag?
+            @buf = $'
+            begin
+              config = JSON.parse($1)
+              process_connect_route_config(config)
+            rescue => e
+              queue_data(INVALID_CONFIG)
+              log_error
+            end
+          when INFO_REQ
+            ctrace('INFO_REQUEST OP') if NATSD::Server.trace_flag?
+            return connect_auth_timeout if @auth_pending
+            @buf = $'
+            send_info
+          when INFO
+            ctrace('INFO OP', strip_op($&)) if NATSD::Server.trace_flag?
+            return connect_auth_timeout if @auth_pending
+            @buf = $'
+            process_info($1)
+          when ERR_RESP
+            ctrace('-ERR', $1) if NATSD::Server.trace_flag?
+            close_connection
+            exit
+          when OK_RESP
+            ctrace('+OK') if NATSD::Server.trace_flag?
+            @buf = $'
+          when UNKNOWN
+            ctrace('Unknown Op', strip_op($&)) if NATSD::Server.trace_flag?
+            return connect_auth_timeout if @auth_pending
+            @buf = $'
+            queue_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_print_controlline_too_big(@buf.bytesize)
+              close_connection
+            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 routed msg', @msg_sub, @msg_reply, msg) if NATSD::Server.trace_flag?
+          queue_data(OK) if @verbose
+
+          # We deliver normal subscriptions like a client publish, which
+          # eliminates the duplicate traversal over the route. However,
+          # qgroups are sent individually per group for only the route
+          # with the intended subscriber, since route interest is L2
+          # semantics, we deliver those direct.
+          if (sub = Server.rsid_qsub(@msg_sid))
+            # Allows nil reply to not have extra space
+            reply = @msg_reply + ' ' if @msg_reply
+            Server.deliver_to_subscriber(sub, @msg_sub, reply, msg)
+          else
+            Server.route_to_subscribers(@msg_sub, @msg_reply, msg, is_route?)
+          end
+
+          @in_msgs += 1
+          @in_bytes += @msg_size
+          @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_auth
+      return unless r_obj[:uri].user
+      cs = { :user => r_obj[:uri].user, :pass => r_obj[:uri].password }
+      queue_data("CONNECT #{cs.to_json}#{CR_LF}")
+    end
+
+    def send_info
+      queue_data("INFO #{Server.route_info_string}#{CR_LF}")
+    end
+
+    def process_info(info_json)
+      info = JSON.parse(info_json)
+      @remote_rid = info['server_id'] unless info['server_id'].nil?
+      super(info_json)
+    end
+
+    def auth_ok?(user, pass)
+      Server.route_auth_ok?(user, pass)
+    end
+
+    def inc_connections
+      Server.num_routes += 1
+      Server.add_route(self)
+    end
+
+    def dec_connections
+      Server.num_routes -= 1
+      Server.remove_route(self)
+    end
+
+    def try_reconnect
+      debug "Trying to reconnect route", peer_info, rid
+      EM.reconnect(r_obj[:uri].host, r_obj[:uri].port, self)
+    end
+
+    def cancel_reconnect
+      EM.cancel_timer(@reconnect_timer) if @reconnect_timer
+      @reconnect_timer = nil
+      @reconnecting = false
+    end
+
+    def unbind
+      return if reconnecting?
+      debug "Route connection closed", peer_info, rid
+      process_unbind
+      if solicited?
+        @reconnecting = true
+        @reconnect_timer = EM.add_periodic_timer(NATSD::DEFAULT_ROUTE_RECONNECT_INTERVAL) { try_reconnect }
+      end
+    end
+
+    def ctrace(*args)
+      trace(args, "r: #{rid}")
+    end
+
+    def is_route?
+      true
+    end
+
+    def type
+      'Route'
+    end
+
+  end
+
+end