SYMBOL INDEX (301 symbols across 31 files)

FILE: benchmark/latency_perf.rb
  function done (line 45) | def done
  function send_request (line 51) | def send_request

FILE: benchmark/pub_perf.rb
  function send_batch (line 64) | def send_batch
  function display_final_results (line 85) | def display_final_results

FILE: benchmark/pub_sub_perf.rb
  function send_batch (line 67) | def send_batch
  function display_final_results (line 88) | def display_final_results

FILE: benchmark/sublist_perf.rb
  class PerfSublist (line 18) | class PerfSublist
    method subsInit (line 24) | def PerfSublist.subsInit(pre=nil)
    method disableSublistCache (line 33) | def PerfSublist.disableSublistCache
    method addWildcards (line 37) | def PerfSublist.addWildcards
    method matchTest (line 43) | def PerfSublist.matchTest(subject, loop)
    method reset (line 50) | def PerfSublist.reset
    method removeAll (line 54) | def PerfSublist.removeAll
    method subscriptionCount (line 60) | def PerfSublist.subscriptionCount
    method totalCount (line 64) | def PerfSublist.totalCount
  function ms_time (line 70) | def ms_time(t)

FILE: examples/auth_pub.rb
  function usage (line 4) | def usage

FILE: examples/auth_sub.rb
  function usage (line 6) | def usage

FILE: examples/auto_unsub.rb
  function usage (line 6) | def usage

FILE: examples/busy_body.rb
  function create_subscribers (line 11) | def create_subscribers(sub='foo.bar', num_subs=10, num_connections=20)
  function create_publishers (line 19) | def create_publishers(sub='foo.bar', body='Hello World!', num_connection...
  function timed_publish (line 27) | def timed_publish(sub='foo.bar', body='Hello World!', delay=1, burst=500)

FILE: examples/expected.rb
  function usage (line 6) | def usage

FILE: examples/pub.rb
  function usage (line 4) | def usage

FILE: examples/queue_sub.rb
  function usage (line 6) | def usage

FILE: examples/sub.rb
  function usage (line 6) | def usage

FILE: examples/sub_timeout.rb
  function usage (line 6) | def usage

FILE: lib/nats/client.rb
  type NATS (line 28) | module NATS
    class Error (line 77) | class Error < StandardError; end
    class ServerError (line 80) | class ServerError < Error; end
    class ClientError (line 83) | class ClientError < Error; end
    class ConnectError (line 86) | class ConnectError < Error; end
    class AuthError (line 89) | class AuthError < ConnectError; end
    function connect (line 151) | def connect(uri=nil, opts={}, &blk)
    function start (line 236) | def start(*args, &blk)
    function stop (line 256) | def stop(&blk)
    function drain (line 269) | def drain(&blk)
    function connected_server (line 276) | def connected_server
    function connected? (line 282) | def connected?
    function reconnecting? (line 288) | def reconnecting?
    function draining? (line 294) | def draining?
    function options (line 300) | def options
    function server_info (line 306) | def server_info
    function on_error (line 313) | def on_error(&callback)
    function on_reconnect (line 319) | def on_reconnect(&callback)
    function on_disconnect (line 326) | def on_disconnect(&callback)
    function on_close (line 333) | def on_close(&callback)
    function publish (line 340) | def publish(*args, &blk)
    function subscribe (line 346) | def subscribe(*args, &blk)
    function unsubscribe (line 352) | def unsubscribe(*args)
    function timeout (line 358) | def timeout(*args, &blk)
    function request (line 364) | def request(*args, &blk)
    function create_inbox (line 370) | def create_inbox
    function flush (line 376) | def flush(*args, &blk)
    function pending_data_size (line 382) | def pending_data_size(*args)
    function wait_for_server (line 386) | def wait_for_server(uri, max_wait = 5) # :nodoc:
    function server_running? (line 394) | def server_running?(uri) # :nodoc:
    function clear_client (line 403) | def clear_client # :nodoc:
    function uri_is_remote? (line 409) | def uri_is_remote?(uri)
    function process_uri (line 413) | def process_uri(uris)
    function initialize (line 456) | def initialize(options)
    function publish (line 505) | def publish(subject, msg=EMPTY_MSG, opt_reply=nil, &blk)
    function subscribe (line 525) | def subscribe(subject, opts={}, &callback)
    function unsubscribe (line 540) | def unsubscribe(sid, opt_max=nil)
    function drain (line 551) | def drain(&blk)
    function subscription_count (line 593) | def subscription_count
    function timeout (line 601) | def timeout(sid, timeout, opts={}, &callback)
    function request (line 623) | def request(subject, data=nil, opts={}, &cb)
    function start_resp_mux_sub! (line 691) | def start_resp_mux_sub!
    function flush (line 732) | def flush(&blk)
    function on_connect (line 738) | def on_connect(&callback)
    function on_error (line 744) | def on_error(&callback)
    function on_reconnect (line 750) | def on_reconnect(&callback)
    function on_disconnect (line 756) | def on_disconnect(&callback)
    function on_close (line 762) | def on_close(&callback)
    function close (line 767) | def close
    function pending_data_size (line 776) | def pending_data_size
    function stats (line 781) | def stats
    function user_err_cb? (line 790) | def user_err_cb? # :nodoc:
    function auth_connection? (line 794) | def auth_connection?
    function connect_command (line 798) | def connect_command #:nodoc:
    function send_connect_command (line 833) | def send_connect_command #:nodoc:
    function queue_server_rt (line 837) | def queue_server_rt(&cb) #:nodoc:
    function on_msg (line 843) | def on_msg(subject, sid, reply, msg) #:nodoc:
    function flush_pending (line 876) | def flush_pending #:nodoc:
    function receive_data (line 882) | def receive_data(data) #:nodoc:
    function process_connect_init (line 944) | def process_connect_init(info) # :nodoc:
    function process_info (line 992) | def process_info(info_line) #:nodoc:
    function client_using_secure_connection? (line 1029) | def client_using_secure_connection?
    function server_using_secure_connection? (line 1033) | def server_using_secure_connection?
    function ssl_verify_peer (line 1037) | def ssl_verify_peer(cert)
    function cancel_ping_timer (line 1049) | def cancel_ping_timer
    function connection_completed (line 1056) | def connection_completed #:nodoc:
    function ssl_handshake_completed (line 1068) | def ssl_handshake_completed
    function process_connect (line 1072) | def process_connect #:nodoc:
    function send_ping (line 1115) | def send_ping #:nodoc:
    function process_pong (line 1127) | def process_pong
    function should_delay_connect? (line 1132) | def should_delay_connect?(server)
    function schedule_reconnect (line 1143) | def schedule_reconnect #:nodoc:
    function unbind (line 1149) | def unbind #:nodoc:
    function multiple_servers_available? (line 1167) | def multiple_servers_available?
    function had_error? (line 1171) | def had_error?
    function should_not_reconnect? (line 1175) | def should_not_reconnect?
    function cancel_reconnect_timer (line 1179) | def cancel_reconnect_timer
    function disconnect_error_string (line 1186) | def disconnect_error_string
    function process_disconnect (line 1191) | def process_disconnect #:nodoc:
    function can_reuse_server? (line 1210) | def can_reuse_server?(server) #:nodoc:
    function attempt_reconnect (line 1216) | def attempt_reconnect #:nodoc:
    function send_command (line 1235) | def send_command(command, priority = false) #:nodoc:
    function setup_nkeys_connect (line 1252) | def setup_nkeys_connect
    function process_uri_options (line 1332) | def process_uri_options #:nodoc
    function connected_server (line 1341) | def connected_server
    function discovered_servers (line 1347) | def discovered_servers
    function bind_primary (line 1351) | def bind_primary #:nodoc:
    function schedule_primary_and_connect (line 1360) | def schedule_primary_and_connect #:nodoc:
    function inspect (line 1387) | def inspect #:nodoc:
    class MonotonicTime (line 1391) | class MonotonicTime
      method now (line 1395) | def now
      method now (line 1399) | def now
      method now (line 1403) | def now

FILE: lib/nats/ext/bytesize.rb
  class String (line 16) | class String #:nodoc:
    method bytesize (line 17) | def bytesize; self.size; end

FILE: lib/nats/ext/em.rb
  class EM::Connection (line 24) | class EM::Connection
    method get_outbound_data_size (line 25) | def get_outbound_data_size; return 0; end

FILE: lib/nats/nuid.rb
  type NATS (line 16) | module NATS
    class NUID (line 17) | class NUID
      method initialize (line 28) | def initialize
      method next (line 36) | def next
      method randomize_prefix! (line 57) | def randomize_prefix!
      method reset_sequential! (line 67) | def reset_sequential!

FILE: lib/nats/server/cluster.rb
  type NATSD (line 3) | module NATSD #:nodoc: all
    class Server (line 5) | class Server
      method connected_routes (line 13) | def connected_routes
      method add_route (line 17) | def add_route(route)
      method remove_route (line 21) | def remove_route(route)
      method route_info_string (line 25) | def route_info_string
      method route_key (line 38) | def route_key(route_url)
      method route_auth_ok? (line 43) | def route_auth_ok?(user, pass)
      method solicit_routes (line 47) | def solicit_routes #:nodoc:
      method try_to_connect_routes (line 55) | def try_to_connect_routes #:nodoc:
      method broadcast_proto_to_routes (line 63) | def broadcast_proto_to_routes(proto)
      method rsid_qsub (line 67) | def rsid_qsub(rsid)
      method parse_rsid (line 76) | def parse_rsid(rsid)
      method routed_sid (line 81) | def routed_sid(sub)
      method route_sub_proto (line 85) | def route_sub_proto(sub)
      method broadcast_sub_to_routes (line 90) | def broadcast_sub_to_routes(sub)
      method broadcast_unsub_to_routes (line 94) | def broadcast_unsub_to_routes(sub)

FILE: lib/nats/server/connection.rb
  type NATSD (line 1) | module NATSD #:nodoc: all
    type Connection (line 3) | module Connection #:nodoc: all
      function flush_data (line 9) | def flush_data
      function queue_data (line 15) | def queue_data(data)
      function client_info (line 22) | def client_info
      function info (line 27) | def info
      function max_connections_exceeded? (line 41) | def max_connections_exceeded?
      function post_init (line 48) | def post_init
      function send_ping (line 70) | def send_ping
      function connect_auth_timeout (line 81) | def connect_auth_timeout
      function connect_ssl_timeout (line 86) | def connect_ssl_timeout
      function receive_data (line 91) | def receive_data(data)
      function send_info (line 196) | def send_info
      function process_info (line 201) | def process_info(info)
      function auth_ok? (line 204) | def auth_ok?(user, pass)
      function process_connect_config (line 208) | def process_connect_config(config)
      function delete_subscriber (line 224) | def delete_subscriber(sub)
      function error_close (line 230) | def error_close(msg)
      function debug_print_controlline_too_big (line 237) | def debug_print_controlline_too_big(line_size)
      function debug_print_msg_too_big (line 242) | def debug_print_msg_too_big(msg_size)
      function inc_connections (line 247) | def inc_connections
      function dec_connections (line 252) | def dec_connections
      function process_unbind (line 257) | def process_unbind
      function unbind (line 269) | def unbind
      function ssl_handshake_completed (line 274) | def ssl_handshake_completed
      function ssl_verify_peer (line 282) | def ssl_verify_peer(cert)
      function ctrace (line 286) | def ctrace(*args)
      function strip_op (line 290) | def strip_op(op='')
      function is_route? (line 294) | def is_route?
      function type (line 298) | def type

FILE: lib/nats/server/connz.rb
  type NATSD (line 1) | module NATSD #:nodoc: all
    class Connz (line 3) | class Connz
      method call (line 4) | def call(env)
    class Server (line 34) | class Server
      method dump_connections (line 36) | def dump_connections

FILE: lib/nats/server/const.rb
  type NATSD (line 2) | module NATSD #:nodoc:

FILE: lib/nats/server/options.rb
  type NATSD (line 4) | module NATSD
    class Server (line 5) | class Server
      method parser (line 8) | def parser
      method read_config_file (line 59) | def read_config_file
      method setup_logs (line 131) | def setup_logs
      method open_syslog (line 138) | def open_syslog
      method close_syslog (line 143) | def close_syslog
      method symbolize_users (line 147) | def symbolize_users(users)
      method finalize_options (line 156) | def finalize_options

FILE: lib/nats/server/route.rb
  type NATSD (line 1) | module NATSD #:nodoc: all
    class Route (line 4) | class Route < EventMachine::Connection #:nodoc:
      method initialize (line 12) | def initialize(route=nil)
      method solicited? (line 16) | def solicited?
      method connection_completed (line 20) | def connection_completed
      method post_init (line 30) | def post_init
      method send_local_subs_to_route (line 57) | def send_local_subs_to_route
      method process_connect_route_config (line 66) | def process_connect_route_config(config)
      method connect_auth_timeout (line 83) | def connect_auth_timeout
      method receive_data (line 88) | def receive_data(data)
      method send_auth (line 214) | def send_auth
      method send_info (line 220) | def send_info
      method process_info (line 224) | def process_info(info_json)
      method auth_ok? (line 230) | def auth_ok?(user, pass)
      method inc_connections (line 234) | def inc_connections
      method dec_connections (line 239) | def dec_connections
      method try_reconnect (line 244) | def try_reconnect
      method cancel_reconnect (line 249) | def cancel_reconnect
      method unbind (line 255) | def unbind
      method ctrace (line 265) | def ctrace(*args)
      method is_route? (line 269) | def is_route?
      method type (line 273) | def type

FILE: lib/nats/server/server.rb
  type NATSD (line 3) | module NATSD #:nodoc: all
    class Server (line 8) | class Server
      method version (line 20) | def version; "nats-server version #{NATSD::VERSION}" end
      method host (line 22) | def host; @options[:addr] end
      method port (line 23) | def port; @options[:port] end
      method pid_file (line 24) | def pid_file; @options[:pid_file] end
      method process_options (line 26) | def process_options(argv=[])
      method setup (line 38) | def setup(argv)
      method subscribe (line 94) | def subscribe(sub, is_route=false)
      method unsubscribe (line 99) | def unsubscribe(sub, is_route=false)
      method deliver_to_subscriber (line 104) | def deliver_to_subscriber(sub, subject, reply, msg)
      method route_to_subscribers (line 130) | def route_to_subscribers(subject, reply, msg, is_route=false)
      method auth_ok? (line 182) | def auth_ok?(user, pass)
      method cid (line 187) | def cid
      method rid (line 191) | def rid
      method info_string (line 195) | def info_string
      method start_http_server (line 200) | def start_http_server

FILE: lib/nats/server/sublist.rb
  class Sublist (line 13) | class Sublist #:nodoc:
    method initialize (line 25) | def initialize(options = {})
    method disable_cache (line 42) | def disable_cache; @cache = nil; end
    method enable_cache (line 43) | def enable_cache;  @cache ||= {};  end
    method clear_cache (line 44) | def clear_cache; @cache = {} if @cache; end
    method prune_cache (line 47) | def prune_cache
    method insert (line 54) | def insert(subject, subscriber)
    method remove (line 73) | def remove(subject, subscriber)
    method match (line 79) | def match(subject)
    method matchAll (line 94) | def matchAll(level, tokens)
    method prune_level (line 113) | def prune_level(level, node, token)
    method remove_level (line 126) | def remove_level(level, tokens, subscriber)
    method node_count_level (line 153) | def node_count_level(level, nc)
    method node_count (line 163) | def node_count

FILE: lib/nats/server/util.rb
  function fast_uuid (line 3) | def fast_uuid #:nodoc:
  function syslog (line 9) | def syslog(args, priority) #:nodoc:
  function log (line 13) | def log(*args) #:nodoc:
  function debug (line 19) | def debug(*args) #:nodoc:
  function trace (line 25) | def trace(*args) #:nodoc:
  function log_error (line 31) | def log_error(e=$!) #:nodoc:
  function uptime_string (line 35) | def uptime_string(delta)
  function pretty_size (line 46) | def pretty_size(size, prec=1)
  function num_cpu_cores (line 54) | def num_cpu_cores
  function shutdown (line 66) | def shutdown #:nodoc:
  function dump_connection_state (line 80) | def dump_connection_state

FILE: lib/nats/server/varz.rb
  type NATSD (line 1) | module NATSD #:nodoc: all
    class Varz (line 3) | class Varz
      method call (line 4) | def call(env)
    class Server (line 12) | class Server
      method update_varz (line 15) | def update_varz

FILE: lib/nats/version.rb
  type NATS (line 15) | module NATS

FILE: spec/client/client_spec.rb
  function process_pong (line 396) | def c.process_pong
  function send_ping (line 411) | def c.send_ping

FILE: spec/client/reconnect_spec.rb
  class SomeException (line 78) | class SomeException < StandardError; end

FILE: spec/spec_helper.rb
  function timeout_nats_on_failure (line 7) | def timeout_nats_on_failure(to=0.25)
  function timeout_em_on_failure (line 13) | def timeout_em_on_failure(to=0.25)
  function with_em_timeout (line 19) | def with_em_timeout(to=1)
  function wait_on_connections (line 36) | def wait_on_connections(conns)
  function flush_routes (line 47) | def flush_routes(conns, &blk)
  function wait_on_routes_connected (line 51) | def wait_on_routes_connected(conns)
  class NatsServerControl (line 73) | class NatsServerControl
    method init_with_config (line 80) | def init_with_config(config_file)
    method init_with_config_from_string (line 90) | def init_with_config_from_string(config_string, config={})
    method initialize (line 110) | def initialize(uri='nats://127.0.0.1:4222', pid_file='/tmp/test-nats.p...
    method server_pid (line 117) | def server_pid
    method server_mem_mb (line 121) | def server_mem_mb
    method start_server (line 127) | def start_server(wait_for_server=true, monitoring: false)
    method kill_server (line 150) | def kill_server
  class RubyNatsServerControl (line 162) | class RubyNatsServerControl < NatsServerControl
    method start_server (line 163) | def start_server(wait_for_server=true)
  type EchoServer (line 185) | module EchoServer
    function post_init (line 191) | def post_init
    function receive_data (line 195) | def receive_data(data)
    function start (line 200) | def start(&blk)
    function stop (line 207) | def stop
  type SilentServer (line 213) | module SilentServer
    function post_init (line 219) | def post_init
    function receive_data (line 224) | def receive_data(data)
    function start (line 228) | def start(&blk)
    function stop (line 235) | def stop
  type OldInfoServer (line 241) | module OldInfoServer
    function post_init (line 247) | def post_init
    function receive_data (line 251) | def receive_data(data)
    function start (line 255) | def start(&blk)
    function stop (line 262) | def stop
  type OldProtocolInfoServer (line 268) | module OldProtocolInfoServer
    function post_init (line 274) | def post_init
    function receive_data (line 278) | def receive_data(data)
    function start (line 282) | def start(&blk)
    function stop (line 289) | def stop