Documentation

Overview

    Package sublist is a routing mechanism to handle subject distribution and provides a facility to match subjects from published messages to interested subscribers. Subscribers can have wildcard subjects to match multiple published subjects.

    Index

    Constants

    View Source
    const (
    	// CLIENT is an end user.
    	CLIENT = iota
    	// ROUTER is another router in the cluster.
    	ROUTER
    )

      Type of client connection.

      View Source
      const (
      	// Original Client protocol from 2009.
      	// http://nats.io/documentation/internals/nats-protocol/
      	ClientProtoZero = iota
      	// This signals a client can receive more then the original INFO block.
      	// This can be used to update clients on other cluster members, etc.
      	ClientProtoInfo
      )
      View Source
      const (
      	ClientClosed = ClosedState(iota + 1)
      	AuthenticationTimeout
      	AuthenticationViolation
      	TLSHandshakeError
      	SlowConsumerPendingBytes
      	SlowConsumerWriteDeadline
      	WriteError
      	ReadError
      	ParseError
      	StaleConnection
      	ProtocolViolation
      	BadClientProtocolVersion
      	WrongPort
      	MaxConnectionsExceeded
      	MaxPayloadExceeded
      	MaxControlLineExceeded
      	DuplicateRoute
      	RouteRemoved
      	ServerShutdown
      )
      View Source
      const (
      	CommandStop   = Command("stop")
      	CommandQuit   = Command("quit")
      	CommandReopen = Command("reopen")
      	CommandReload = Command("reload")
      )

        Valid Command values.

        View Source
        const (
        	// VERSION is the current version for the server.
        	VERSION = "1.4.1"
        
        	// PROTO is the currently supported protocol.
        	// 0 was the original
        	// 1 maintains proto 0, adds echo abilities for CONNECT from the client. Clients
        	// should not send echo unless proto in INFO is >= 1.
        	PROTO = 1
        
        	// DEFAULT_PORT is the default port for client connections.
        	DEFAULT_PORT = 4222
        
        	// RANDOM_PORT is the value for port that, when supplied, will cause the
        	// server to listen on a randomly-chosen available port. The resolved port
        	// is available via the Addr() method.
        	RANDOM_PORT = -1
        
        	// DEFAULT_HOST defaults to all interfaces.
        	DEFAULT_HOST = "0.0.0.0"
        
        	// MAX_CONTROL_LINE_SIZE is the maximum allowed protocol control line size.
        	// 4k should be plenty since payloads sans connect/info string are separate.
        	MAX_CONTROL_LINE_SIZE = 4096
        
        	// MAX_PAYLOAD_SIZE is the maximum allowed payload size. Should be using
        	// something different if > 1MB payloads are needed.
        	MAX_PAYLOAD_SIZE = (1024 * 1024)
        
        	// MAX_PENDING_SIZE is the maximum outbound pending bytes per client.
        	MAX_PENDING_SIZE = (64 * 1024 * 1024)
        
        	// DEFAULT_MAX_CONNECTIONS is the default maximum connections allowed.
        	DEFAULT_MAX_CONNECTIONS = (64 * 1024)
        
        	// TLS_TIMEOUT is the TLS wait time.
        	TLS_TIMEOUT = 500 * time.Millisecond
        
        	// AUTH_TIMEOUT is the authorization wait time.
        	AUTH_TIMEOUT = 2 * TLS_TIMEOUT
        
        	// DEFAULT_PING_INTERVAL is how often pings are sent to clients and routes.
        	DEFAULT_PING_INTERVAL = 2 * time.Minute
        
        	// DEFAULT_PING_MAX_OUT is maximum allowed pings outstanding before disconnect.
        	DEFAULT_PING_MAX_OUT = 2
        
        	// CR_LF string
        	CR_LF = "\r\n"
        
        	// LEN_CR_LF hold onto the computed size.
        	LEN_CR_LF = len(CR_LF)
        
        	// DEFAULT_FLUSH_DEADLINE is the write/flush deadlines.
        	DEFAULT_FLUSH_DEADLINE = 2 * time.Second
        
        	// DEFAULT_HTTP_PORT is the default monitoring port.
        	DEFAULT_HTTP_PORT = 8222
        
        	// ACCEPT_MIN_SLEEP is the minimum acceptable sleep times on temporary errors.
        	ACCEPT_MIN_SLEEP = 10 * time.Millisecond
        
        	// ACCEPT_MAX_SLEEP is the maximum acceptable sleep times on temporary errors
        	ACCEPT_MAX_SLEEP = 1 * time.Second
        
        	// DEFAULT_ROUTE_CONNECT Route solicitation intervals.
        	DEFAULT_ROUTE_CONNECT = 1 * time.Second
        
        	// DEFAULT_ROUTE_RECONNECT Route reconnect intervals.
        	DEFAULT_ROUTE_RECONNECT = 1 * time.Second
        
        	// DEFAULT_ROUTE_DIAL Route dial timeout.
        	DEFAULT_ROUTE_DIAL = 1 * time.Second
        
        	// PROTO_SNIPPET_SIZE is the default size of proto to print on parse errors.
        	PROTO_SNIPPET_SIZE = 32
        
        	// MAX_MSG_ARGS Maximum possible number of arguments from MSG proto.
        	MAX_MSG_ARGS = 4
        
        	// MAX_PUB_ARGS Maximum possible number of arguments from PUB proto.
        	MAX_PUB_ARGS = 3
        
        	// DEFAULT_REMOTE_QSUBS_SWEEPER
        	DEFAULT_REMOTE_QSUBS_SWEEPER = 30 * time.Second
        
        	// DEFAULT_MAX_CLOSED_CLIENTS
        	DEFAULT_MAX_CLOSED_CLIENTS = 10000
        
        	// DEFAULT_LAME_DUCK_DURATION is the time in which the server spreads
        	// the closing of clients when signaled to go in lame duck mode.
        	DEFAULT_LAME_DUCK_DURATION = 30 * time.Second
        )
        View Source
        const (
        	ConnOpen = ConnState(iota)
        	ConnClosed
        	ConnAll
        )
        View Source
        const (
        	OP_START = iota
        	OP_PLUS
        	OP_PLUS_O
        	OP_PLUS_OK
        	OP_MINUS
        	OP_MINUS_E
        	OP_MINUS_ER
        	OP_MINUS_ERR
        	OP_MINUS_ERR_SPC
        	MINUS_ERR_ARG
        	OP_C
        	OP_CO
        	OP_CON
        	OP_CONN
        	OP_CONNE
        	OP_CONNEC
        	OP_CONNECT
        	CONNECT_ARG
        	OP_P
        	OP_PU
        	OP_PUB
        	OP_PUB_SPC
        	PUB_ARG
        	OP_PI
        	OP_PIN
        	OP_PING
        	OP_PO
        	OP_PON
        	OP_PONG
        	MSG_PAYLOAD
        	MSG_END
        	OP_S
        	OP_SU
        	OP_SUB
        	OP_SUB_SPC
        	SUB_ARG
        	OP_U
        	OP_UN
        	OP_UNS
        	OP_UNSU
        	OP_UNSUB
        	OP_UNSUB_SPC
        	UNSUB_ARG
        	OP_M
        	OP_MS
        	OP_MSG
        	OP_MSG_SPC
        	MSG_ARG
        	OP_I
        	OP_IN
        	OP_INF
        	OP_INFO
        	INFO_ARG
        )

          Parser constants

          View Source
          const (
          	ConProto  = "CONNECT %s" + _CRLF_
          	InfoProto = "INFO %s" + _CRLF_
          )

            Route protocol constants

            View Source
            const (
            	RSID  = "RSID"
            	QRSID = "QRSID"
            
            	QRSID_LEN = len(QRSID)
            )

              FIXME(dlc) - Make these reserved and reject if they come in as a sid from a client connection. Route constants

              View Source
              const (
              	RootPath    = "/"
              	VarzPath    = "/varz"
              	ConnzPath   = "/connz"
              	RoutezPath  = "/routez"
              	SubszPath   = "/subsz"
              	StackszPath = "/stacksz"
              )

                HTTP endpoints

                View Source
                const DefaultConnListSize = 1024

                  DefaultConnListSize is the default size of the connection list.

                  View Source
                  const DefaultSubListSize = 1024

                    DefaultSubListSize is the default size of the subscriptions list.

                    Variables

                    View Source
                    var (
                    	// ErrConnectionClosed represents an error condition on a closed connection.
                    	ErrConnectionClosed = errors.New("connection closed")
                    
                    	// ErrAuthorization represents an error condition on failed authorization.
                    	ErrAuthorization = errors.New("authorization error")
                    
                    	// ErrAuthTimeout represents an error condition on failed authorization due to timeout.
                    	ErrAuthTimeout = errors.New("authorization timeout")
                    
                    	// ErrMaxPayload represents an error condition when the payload is too big.
                    	ErrMaxPayload = errors.New("maximum payload exceeded")
                    
                    	// ErrMaxControlLine represents an error condition when the control line is too big.
                    	ErrMaxControlLine = errors.New("maximum control line exceeded")
                    
                    	// ErrReservedPublishSubject represents an error condition when sending to a reserved subject, e.g. _SYS.>
                    	ErrReservedPublishSubject = errors.New("reserved internal subject")
                    
                    	// ErrBadClientProtocol signals a client requested an invalud client protocol.
                    	ErrBadClientProtocol = errors.New("invalid client protocol")
                    
                    	// ErrTooManyConnections signals a client that the maximum number of connections supported by the
                    	// server has been reached.
                    	ErrTooManyConnections = errors.New("maximum connections exceeded")
                    
                    	// ErrTooManySubs signals a client that the maximum number of subscriptions per connection
                    	// has been reached.
                    	ErrTooManySubs = errors.New("maximum subscriptions exceeded")
                    
                    	// ErrClientConnectedToRoutePort represents an error condition when a client
                    	// attempted to connect to the route listen port.
                    	ErrClientConnectedToRoutePort = errors.New("attempted to connect to route port")
                    )
                    View Source
                    var (
                    	ErrInvalidSubject = errors.New("sublist: Invalid Subject")
                    	ErrNotFound       = errors.New("sublist: No Matches Found")
                    )

                      Sublist related errors

                      Functions

                      func GenTLSConfig

                      func GenTLSConfig(tc *TLSConfigOpts) (*tls.Config, error)

                        GenTLSConfig loads TLS related configuration parameters.

                        func IsValidLiteralSubject

                        func IsValidLiteralSubject(subject string) bool

                          IsValidLiteralSubject returns true if a subject is valid and literal (no wildcards), false otherwise

                          func IsValidSubject

                          func IsValidSubject(subject string) bool

                            IsValidSubject returns true if a subject is valid, false otherwise

                            func PrintAndDie

                            func PrintAndDie(msg string)

                              PrintAndDie is exported for access in other packages.

                              func PrintServerAndExit

                              func PrintServerAndExit()

                                PrintServerAndExit will print our version and exit.

                                func PrintTLSHelpAndDie

                                func PrintTLSHelpAndDie()

                                  PrintTLSHelpAndDie prints TLS usage and exits.

                                  func ProcessCommandLineArgs

                                  func ProcessCommandLineArgs(cmd *flag.FlagSet) (showVersion bool, showHelp bool, err error)

                                    ProcessCommandLineArgs takes the command line arguments validating and setting flags for handling in case any sub command was present.

                                    func ProcessSignal

                                    func ProcessSignal(command Command, pidStr string) error

                                      ProcessSignal sends the given signal command to the given process. If pidStr is empty, this will send the signal to the single running instance of gnatsd. If multiple instances are running, it returns an error. This returns an error if the given process is not running or the command is invalid.

                                      func RemoveSelfReference

                                      func RemoveSelfReference(clusterPort int, routes []*url.URL) ([]*url.URL, error)

                                        RemoveSelfReference removes this server from an array of routes

                                        func ResponseHandler

                                        func ResponseHandler(w http.ResponseWriter, r *http.Request, data []byte)

                                          ResponseHandler handles responses for monitoring routes

                                          func RoutesFromStr

                                          func RoutesFromStr(routesStr string) []*url.URL

                                            RoutesFromStr parses route URLs from a string

                                            func Run

                                            func Run(server *Server) error

                                              Run starts the NATS server. This wrapper function allows Windows to add a hook for running NATS as a service.

                                              func SetProcessName

                                              func SetProcessName(name string)

                                                SetProcessName allows to change the expected name of the process.

                                                Types

                                                type Authentication

                                                type Authentication interface {
                                                	// Check if a client is authorized to connect
                                                	Check(c ClientAuthentication) bool
                                                }

                                                  Authentication is an interface for implementing authentication

                                                  type ClientAuthentication

                                                  type ClientAuthentication interface {
                                                  	// Get options associated with a client
                                                  	GetOpts() *clientOpts
                                                  	// If TLS is enabled, TLS ConnectionState, nil otherwise
                                                  	GetTLSConnectionState() *tls.ConnectionState
                                                  	// Optionally map a user after auth.
                                                  	RegisterUser(*User)
                                                  	// RemoteAddress expose the connection information of the client
                                                  	RemoteAddress() net.Addr
                                                  }

                                                    ClientAuthentication is an interface for client authentication

                                                    type ClosedState

                                                    type ClosedState int

                                                      Reason client was closed. This will be passed into calls to clearConnection, but will only be stored in ConnInfo for monitoring.

                                                      func (ClosedState) String

                                                      func (reason ClosedState) String() string

                                                      type ClusterOpts

                                                      type ClusterOpts struct {
                                                      	Host           string            `json:"addr,omitempty"`
                                                      	Port           int               `json:"cluster_port,omitempty"`
                                                      	Username       string            `json:"-"`
                                                      	Password       string            `json:"-"`
                                                      	AuthTimeout    float64           `json:"auth_timeout,omitempty"`
                                                      	Permissions    *RoutePermissions `json:"-"`
                                                      	TLSTimeout     float64           `json:"-"`
                                                      	TLSConfig      *tls.Config       `json:"-"`
                                                      	ListenStr      string            `json:"-"`
                                                      	Advertise      string            `json:"-"`
                                                      	NoAdvertise    bool              `json:"-"`
                                                      	ConnectRetries int               `json:"-"`
                                                      }

                                                        ClusterOpts are options for clusters.

                                                        type Command

                                                        type Command string

                                                          Command is a signal used to control a running gnatsd process.

                                                          type ConnInfo

                                                          type ConnInfo struct {
                                                          	Cid            uint64     `json:"cid"`
                                                          	IP             string     `json:"ip"`
                                                          	Port           int        `json:"port"`
                                                          	Start          time.Time  `json:"start"`
                                                          	LastActivity   time.Time  `json:"last_activity"`
                                                          	Stop           *time.Time `json:"stop,omitempty"`
                                                          	Reason         string     `json:"reason,omitempty"`
                                                          	RTT            string     `json:"rtt,omitempty"`
                                                          	Uptime         string     `json:"uptime"`
                                                          	Idle           string     `json:"idle"`
                                                          	Pending        int        `json:"pending_bytes"`
                                                          	InMsgs         int64      `json:"in_msgs"`
                                                          	OutMsgs        int64      `json:"out_msgs"`
                                                          	InBytes        int64      `json:"in_bytes"`
                                                          	OutBytes       int64      `json:"out_bytes"`
                                                          	NumSubs        uint32     `json:"subscriptions"`
                                                          	Name           string     `json:"name,omitempty"`
                                                          	Lang           string     `json:"lang,omitempty"`
                                                          	Version        string     `json:"version,omitempty"`
                                                          	TLSVersion     string     `json:"tls_version,omitempty"`
                                                          	TLSCipher      string     `json:"tls_cipher_suite,omitempty"`
                                                          	AuthorizedUser string     `json:"authorized_user,omitempty"`
                                                          	Subs           []string   `json:"subscriptions_list,omitempty"`
                                                          }

                                                            ConnInfo has detailed information on a per connection basis.

                                                            type ConnInfos

                                                            type ConnInfos []*ConnInfo

                                                              Represents a connection info list. We use pointers since it will be sorted.

                                                              func (ConnInfos) Len

                                                              func (cl ConnInfos) Len() int

                                                                For sorting

                                                                func (ConnInfos) Swap

                                                                func (cl ConnInfos) Swap(i, j int)

                                                                type ConnState

                                                                type ConnState int

                                                                  For filtering states of connections. We will only have two, open and closed.

                                                                  type Connz

                                                                  type Connz struct {
                                                                  	ID       string      `json:"server_id"`
                                                                  	Now      time.Time   `json:"now"`
                                                                  	NumConns int         `json:"num_connections"`
                                                                  	Total    int         `json:"total"`
                                                                  	Offset   int         `json:"offset"`
                                                                  	Limit    int         `json:"limit"`
                                                                  	Conns    []*ConnInfo `json:"connections"`
                                                                  }

                                                                    Connz represents detailed information on current client connections.

                                                                    type ConnzOptions

                                                                    type ConnzOptions struct {
                                                                    	// Sort indicates how the results will be sorted. Check SortOpt for possible values.
                                                                    	// Only the sort by connection ID (ByCid) is ascending, all others are descending.
                                                                    	Sort SortOpt `json:"sort"`
                                                                    
                                                                    	// Username indicates if user names should be included in the results.
                                                                    	Username bool `json:"auth"`
                                                                    
                                                                    	// Subscriptions indicates if subscriptions should be included in the results.
                                                                    	Subscriptions bool `json:"subscriptions"`
                                                                    
                                                                    	// Offset is used for pagination. Connz() only returns connections starting at this
                                                                    	// offset from the global results.
                                                                    	Offset int `json:"offset"`
                                                                    
                                                                    	// Limit is the maximum number of connections that should be returned by Connz().
                                                                    	Limit int `json:"limit"`
                                                                    
                                                                    	// Filter for this explicit client connection.
                                                                    	CID uint64 `json:"cid"`
                                                                    
                                                                    	// Filter by connection state.
                                                                    	State ConnState `json:"state"`
                                                                    }

                                                                      ConnzOptions are the options passed to Connz()

                                                                      type Info

                                                                      type Info struct {
                                                                      	ID           string `json:"server_id"`
                                                                      	Version      string `json:"version"`
                                                                      	Proto        int    `json:"proto"`
                                                                      	GitCommit    string `json:"git_commit,omitempty"`
                                                                      	GoVersion    string `json:"go"`
                                                                      	Host         string `json:"host"`
                                                                      	Port         int    `json:"port"`
                                                                      	AuthRequired bool   `json:"auth_required,omitempty"`
                                                                      	TLSRequired  bool   `json:"tls_required,omitempty"`
                                                                      	TLSVerify    bool   `json:"tls_verify,omitempty"`
                                                                      	MaxPayload   int    `json:"max_payload"`
                                                                      	IP           string `json:"ip,omitempty"`
                                                                      	CID          uint64 `json:"client_id,omitempty"`
                                                                      
                                                                      	// Route Specific
                                                                      	ClientConnectURLs []string           `json:"connect_urls,omitempty"` // Contains URLs a client can connect to.
                                                                      	Import            *SubjectPermission `json:"import,omitempty"`
                                                                      	Export            *SubjectPermission `json:"export,omitempty"`
                                                                      }

                                                                        Info is the information sent to clients to help them understand information about this server.

                                                                        type Logger

                                                                        type Logger interface {
                                                                        
                                                                        	// Log a notice statement
                                                                        	Noticef(format string, v ...interface{})
                                                                        
                                                                        	// Log a warning statement
                                                                        	Warnf(format string, v ...interface{})
                                                                        
                                                                        	// Log a fatal error
                                                                        	Fatalf(format string, v ...interface{})
                                                                        
                                                                        	// Log an error
                                                                        	Errorf(format string, v ...interface{})
                                                                        
                                                                        	// Log a debug statement
                                                                        	Debugf(format string, v ...interface{})
                                                                        
                                                                        	// Log a trace statement
                                                                        	Tracef(format string, v ...interface{})
                                                                        }

                                                                          Logger interface of the NATS Server

                                                                          type Options

                                                                          type Options struct {
                                                                          	ConfigFile       string        `json:"-"`
                                                                          	Host             string        `json:"addr"`
                                                                          	Port             int           `json:"port"`
                                                                          	ClientAdvertise  string        `json:"-"`
                                                                          	Trace            bool          `json:"-"`
                                                                          	Debug            bool          `json:"-"`
                                                                          	NoLog            bool          `json:"-"`
                                                                          	NoSigs           bool          `json:"-"`
                                                                          	Logtime          bool          `json:"-"`
                                                                          	MaxConn          int           `json:"max_connections"`
                                                                          	MaxSubs          int           `json:"max_subscriptions,omitempty"`
                                                                          	Users            []*User       `json:"-"`
                                                                          	Username         string        `json:"-"`
                                                                          	Password         string        `json:"-"`
                                                                          	Authorization    string        `json:"-"`
                                                                          	PingInterval     time.Duration `json:"ping_interval"`
                                                                          	MaxPingsOut      int           `json:"ping_max"`
                                                                          	HTTPHost         string        `json:"http_host"`
                                                                          	HTTPPort         int           `json:"http_port"`
                                                                          	HTTPSPort        int           `json:"https_port"`
                                                                          	AuthTimeout      float64       `json:"auth_timeout"`
                                                                          	MaxControlLine   int           `json:"max_control_line"`
                                                                          	MaxPayload       int           `json:"max_payload"`
                                                                          	MaxPending       int64         `json:"max_pending"`
                                                                          	Cluster          ClusterOpts   `json:"cluster,omitempty"`
                                                                          	ProfPort         int           `json:"-"`
                                                                          	PidFile          string        `json:"-"`
                                                                          	PortsFileDir     string        `json:"-"`
                                                                          	LogFile          string        `json:"-"`
                                                                          	Syslog           bool          `json:"-"`
                                                                          	RemoteSyslog     string        `json:"-"`
                                                                          	Routes           []*url.URL    `json:"-"`
                                                                          	RoutesStr        string        `json:"-"`
                                                                          	TLSTimeout       float64       `json:"tls_timeout"`
                                                                          	TLS              bool          `json:"-"`
                                                                          	TLSVerify        bool          `json:"-"`
                                                                          	TLSCert          string        `json:"-"`
                                                                          	TLSKey           string        `json:"-"`
                                                                          	TLSCaCert        string        `json:"-"`
                                                                          	TLSConfig        *tls.Config   `json:"-"`
                                                                          	WriteDeadline    time.Duration `json:"-"`
                                                                          	RQSubsSweep      time.Duration `json:"-"`
                                                                          	MaxClosedClients int           `json:"-"`
                                                                          	LameDuckDuration time.Duration `json:"-"`
                                                                          
                                                                          	CustomClientAuthentication Authentication `json:"-"`
                                                                          	CustomRouterAuthentication Authentication `json:"-"`
                                                                          	// contains filtered or unexported fields
                                                                          }

                                                                            Options block for gnatsd server.

                                                                            var FlagSnapshot *Options

                                                                              FlagSnapshot captures the server options as specified by CLI flags at startup. This should not be modified once the server has started.

                                                                              func ConfigureOptions

                                                                              func ConfigureOptions(fs *flag.FlagSet, args []string, printVersion, printHelp, printTLSHelp func()) (*Options, error)

                                                                                ConfigureOptions accepts a flag set and augment it with NATS Server specific flags. On success, an options structure is returned configured based on the selected flags and/or configuration file. The command line options take precedence to the ones in the configuration file.

                                                                                func MergeOptions

                                                                                func MergeOptions(fileOpts, flagOpts *Options) *Options

                                                                                  MergeOptions will merge two options giving preference to the flagOpts if the item is present.

                                                                                  func ProcessConfigFile

                                                                                  func ProcessConfigFile(configFile string) (*Options, error)

                                                                                    ProcessConfigFile processes a configuration file. FIXME(dlc): Hacky

                                                                                    func (*Options) Clone

                                                                                    func (o *Options) Clone() *Options

                                                                                      Clone performs a deep copy of the Options struct, returning a new clone with all values copied.

                                                                                      func (*Options) ProcessConfigFile

                                                                                      func (o *Options) ProcessConfigFile(configFile string) error

                                                                                        ProcessConfigFile updates the Options structure with options present in the given configuration file. This version is convenient if one wants to set some default options and then override them with what is in the config file. For instance, this version allows you to do something such as:

                                                                                        opts := &Options{Debug: true} opts.ProcessConfigFile(myConfigFile)

                                                                                        If the config file contains "debug: false", after this call, opts.Debug would really be false. It would be impossible to achieve that with the non receiver ProcessConfigFile() version, since one would not know after the call if "debug" was not present or was present but set to false.

                                                                                        type Permissions

                                                                                        type Permissions struct {
                                                                                        	Publish   *SubjectPermission `json:"publish"`
                                                                                        	Subscribe *SubjectPermission `json:"subscribe"`
                                                                                        }

                                                                                          Permissions are the allowed subjects on a per publish or subscribe basis.

                                                                                          type Ports

                                                                                          type Ports struct {
                                                                                          	Nats       []string `json:"nats,omitempty"`
                                                                                          	Monitoring []string `json:"monitoring,omitempty"`
                                                                                          	Cluster    []string `json:"cluster,omitempty"`
                                                                                          	Profile    []string `json:"profile,omitempty"`
                                                                                          }

                                                                                            Ports describes URLs that the server can be contacted in

                                                                                            type RouteInfo

                                                                                            type RouteInfo struct {
                                                                                            	Rid          uint64             `json:"rid"`
                                                                                            	RemoteID     string             `json:"remote_id"`
                                                                                            	DidSolicit   bool               `json:"did_solicit"`
                                                                                            	IsConfigured bool               `json:"is_configured"`
                                                                                            	IP           string             `json:"ip"`
                                                                                            	Port         int                `json:"port"`
                                                                                            	Import       *SubjectPermission `json:"import,omitempty"`
                                                                                            	Export       *SubjectPermission `json:"export,omitempty"`
                                                                                            	Pending      int                `json:"pending_size"`
                                                                                            	InMsgs       int64              `json:"in_msgs"`
                                                                                            	OutMsgs      int64              `json:"out_msgs"`
                                                                                            	InBytes      int64              `json:"in_bytes"`
                                                                                            	OutBytes     int64              `json:"out_bytes"`
                                                                                            	NumSubs      uint32             `json:"subscriptions"`
                                                                                            	Subs         []string           `json:"subscriptions_list,omitempty"`
                                                                                            }

                                                                                              RouteInfo has detailed information on a per connection basis.

                                                                                              type RoutePermissions

                                                                                              type RoutePermissions struct {
                                                                                              	Import *SubjectPermission `json:"import"`
                                                                                              	Export *SubjectPermission `json:"export"`
                                                                                              }

                                                                                                RoutePermissions are similar to user permissions but describe what a server can import/export from and to another server.

                                                                                                type RouteType

                                                                                                type RouteType int

                                                                                                  RouteType designates the router type

                                                                                                  const (
                                                                                                  	// This route we learned from speaking to other routes.
                                                                                                  	Implicit RouteType = iota
                                                                                                  	// This route was explicitly configured.
                                                                                                  	Explicit
                                                                                                  )

                                                                                                    Type of Route

                                                                                                    type Routez

                                                                                                    type Routez struct {
                                                                                                    	ID        string             `json:"server_id"`
                                                                                                    	Now       time.Time          `json:"now"`
                                                                                                    	Import    *SubjectPermission `json:"import,omitempty"`
                                                                                                    	Export    *SubjectPermission `json:"export,omitempty"`
                                                                                                    	NumRoutes int                `json:"num_routes"`
                                                                                                    	Routes    []*RouteInfo       `json:"routes"`
                                                                                                    }

                                                                                                      Routez represents detailed information on current client connections.

                                                                                                      type RoutezOptions

                                                                                                      type RoutezOptions struct {
                                                                                                      	// Subscriptions indicates that Routez will return a route's subscriptions
                                                                                                      	Subscriptions bool `json:"subscriptions"`
                                                                                                      }

                                                                                                        RoutezOptions are options passed to Routez

                                                                                                        type Server

                                                                                                        type Server struct {
                                                                                                        	// contains filtered or unexported fields
                                                                                                        }

                                                                                                          Server is our main struct.

                                                                                                          func New

                                                                                                          func New(opts *Options) *Server

                                                                                                            New will setup a new server struct after parsing the options.

                                                                                                            func (*Server) AcceptLoop

                                                                                                            func (s *Server) AcceptLoop(clr chan struct{})

                                                                                                              AcceptLoop is exported for easier testing.

                                                                                                              func (*Server) Addr

                                                                                                              func (s *Server) Addr() net.Addr

                                                                                                                Addr will return the net.Addr object for the current listener.

                                                                                                                func (*Server) ClusterAddr

                                                                                                                func (s *Server) ClusterAddr() *net.TCPAddr

                                                                                                                  ClusterAddr returns the net.Addr object for the route listener.

                                                                                                                  func (*Server) ConfigTime

                                                                                                                  func (s *Server) ConfigTime() time.Time

                                                                                                                    ConfigTime will report the last time the server configuration was loaded.

                                                                                                                    func (*Server) ConfigureLogger

                                                                                                                    func (s *Server) ConfigureLogger()

                                                                                                                      ConfigureLogger configures and sets the logger for the server.

                                                                                                                      func (*Server) Connz

                                                                                                                      func (s *Server) Connz(opts *ConnzOptions) (*Connz, error)

                                                                                                                        Connz returns a Connz struct containing inormation about connections.

                                                                                                                        func (*Server) Debugf

                                                                                                                        func (s *Server) Debugf(format string, v ...interface{})

                                                                                                                          Debugf logs a debug statement

                                                                                                                          func (*Server) Errorf

                                                                                                                          func (s *Server) Errorf(format string, v ...interface{})

                                                                                                                            Errorf logs an error

                                                                                                                            func (*Server) Fatalf

                                                                                                                            func (s *Server) Fatalf(format string, v ...interface{})

                                                                                                                              Fatalf logs a fatal error

                                                                                                                              func (*Server) HTTPHandler

                                                                                                                              func (s *Server) HTTPHandler() http.Handler

                                                                                                                                HTTPHandler returns the http.Handler object used to handle monitoring endpoints. It will return nil if the server is not configured for monitoring, or if the server has not been started yet (Server.Start()).

                                                                                                                                func (*Server) HandleConnz

                                                                                                                                func (s *Server) HandleConnz(w http.ResponseWriter, r *http.Request)

                                                                                                                                  HandleConnz process HTTP requests for connection information.

                                                                                                                                  func (*Server) HandleRoot

                                                                                                                                  func (s *Server) HandleRoot(w http.ResponseWriter, r *http.Request)

                                                                                                                                    HandleRoot will show basic info and links to others handlers.

                                                                                                                                    func (*Server) HandleRoutez

                                                                                                                                    func (s *Server) HandleRoutez(w http.ResponseWriter, r *http.Request)

                                                                                                                                      HandleRoutez process HTTP requests for route information.

                                                                                                                                      func (*Server) HandleStacksz

                                                                                                                                      func (s *Server) HandleStacksz(w http.ResponseWriter, r *http.Request)

                                                                                                                                        HandleStacksz processes HTTP requests for getting stacks

                                                                                                                                        func (*Server) HandleSubsz

                                                                                                                                        func (s *Server) HandleSubsz(w http.ResponseWriter, r *http.Request)

                                                                                                                                          HandleSubsz processes HTTP requests for subjects stats.

                                                                                                                                          func (*Server) HandleVarz

                                                                                                                                          func (s *Server) HandleVarz(w http.ResponseWriter, r *http.Request)

                                                                                                                                            HandleVarz will process HTTP requests for server information.

                                                                                                                                            func (*Server) ID

                                                                                                                                            func (s *Server) ID() string

                                                                                                                                              ID returns the server's ID

                                                                                                                                              func (*Server) MonitorAddr

                                                                                                                                              func (s *Server) MonitorAddr() *net.TCPAddr

                                                                                                                                                MonitorAddr will return the net.Addr object for the monitoring listener.

                                                                                                                                                func (*Server) Noticef

                                                                                                                                                func (s *Server) Noticef(format string, v ...interface{})

                                                                                                                                                  Noticef logs a notice statement

                                                                                                                                                  func (*Server) NumClients

                                                                                                                                                  func (s *Server) NumClients() int

                                                                                                                                                    NumClients will report the number of registered clients.

                                                                                                                                                    func (*Server) NumRemotes

                                                                                                                                                    func (s *Server) NumRemotes() int

                                                                                                                                                      NumRemotes will report number of registered remotes.

                                                                                                                                                      func (*Server) NumRoutes

                                                                                                                                                      func (s *Server) NumRoutes() int

                                                                                                                                                        NumRoutes will report the number of registered routes.

                                                                                                                                                        func (*Server) NumSlowConsumers

                                                                                                                                                        func (s *Server) NumSlowConsumers() int64

                                                                                                                                                          NumSlowConsumers will report the number of slow consumers.

                                                                                                                                                          func (*Server) NumSubscriptions

                                                                                                                                                          func (s *Server) NumSubscriptions() uint32

                                                                                                                                                            NumSubscriptions will report how many subscriptions are active.

                                                                                                                                                            func (*Server) PortsInfo

                                                                                                                                                            func (s *Server) PortsInfo(maxWait time.Duration) *Ports

                                                                                                                                                              Attempts to resolve all the ports. If after maxWait the ports are not resolved, it returns nil. Otherwise it returns a Ports struct describing ports where the server can be contacted

                                                                                                                                                              func (*Server) ProfilerAddr

                                                                                                                                                              func (s *Server) ProfilerAddr() *net.TCPAddr

                                                                                                                                                                ProfilerAddr returns the net.Addr object for the route listener.

                                                                                                                                                                func (*Server) ReOpenLogFile

                                                                                                                                                                func (s *Server) ReOpenLogFile()

                                                                                                                                                                  If the logger is a file based logger, close and re-open the file. This allows for file rotation by 'mv'ing the file then signaling the process to trigger this function.

                                                                                                                                                                  func (*Server) ReadyForConnections

                                                                                                                                                                  func (s *Server) ReadyForConnections(dur time.Duration) bool

                                                                                                                                                                    ReadyForConnections returns `true` if the server is ready to accept client and, if routing is enabled, route connections. If after the duration `dur` the server is still not ready, returns `false`.

                                                                                                                                                                    func (*Server) Reload

                                                                                                                                                                    func (s *Server) Reload() error

                                                                                                                                                                      Reload reads the current configuration file and applies any supported changes. This returns an error if the server was not started with a config file or an option which doesn't support hot-swapping was changed.

                                                                                                                                                                      func (*Server) Routez

                                                                                                                                                                      func (s *Server) Routez(routezOpts *RoutezOptions) (*Routez, error)

                                                                                                                                                                        Routez returns a Routez struct containing inormation about routes.

                                                                                                                                                                        func (*Server) SetLogger

                                                                                                                                                                        func (s *Server) SetLogger(logger Logger, debugFlag, traceFlag bool)

                                                                                                                                                                          SetLogger sets the logger of the server

                                                                                                                                                                          func (*Server) Shutdown

                                                                                                                                                                          func (s *Server) Shutdown()

                                                                                                                                                                            Shutdown will shutdown the server instance by kicking out the AcceptLoop and closing all associated clients.

                                                                                                                                                                            func (*Server) Start

                                                                                                                                                                            func (s *Server) Start()

                                                                                                                                                                              Start up the server, this will block. Start via a Go routine if needed.

                                                                                                                                                                              func (*Server) StartHTTPMonitoring

                                                                                                                                                                              func (s *Server) StartHTTPMonitoring()

                                                                                                                                                                                StartHTTPMonitoring will enable the HTTP monitoring port. DEPRECATED: Should use StartMonitoring.

                                                                                                                                                                                func (*Server) StartHTTPSMonitoring

                                                                                                                                                                                func (s *Server) StartHTTPSMonitoring()

                                                                                                                                                                                  StartHTTPSMonitoring will enable the HTTPS monitoring port. DEPRECATED: Should use StartMonitoring.

                                                                                                                                                                                  func (*Server) StartMonitoring

                                                                                                                                                                                  func (s *Server) StartMonitoring() error

                                                                                                                                                                                    StartMonitoring starts the HTTP or HTTPs server if needed.

                                                                                                                                                                                    func (*Server) StartProfiler

                                                                                                                                                                                    func (s *Server) StartProfiler()

                                                                                                                                                                                      StartProfiler is called to enable dynamic profiling.

                                                                                                                                                                                      func (*Server) StartRouting

                                                                                                                                                                                      func (s *Server) StartRouting(clientListenReady chan struct{})

                                                                                                                                                                                        StartRouting will start the accept loop on the cluster host:port and will actively try to connect to listed routes.

                                                                                                                                                                                        func (*Server) Subsz

                                                                                                                                                                                        func (s *Server) Subsz(opts *SubszOptions) (*Subsz, error)

                                                                                                                                                                                          Subsz returns a Subsz struct containing subjects statistics

                                                                                                                                                                                          func (*Server) Tracef

                                                                                                                                                                                          func (s *Server) Tracef(format string, v ...interface{})

                                                                                                                                                                                            Tracef logs a trace statement

                                                                                                                                                                                            func (*Server) Varz

                                                                                                                                                                                            func (s *Server) Varz(varzOpts *VarzOptions) (*Varz, error)

                                                                                                                                                                                              Varz returns a Varz struct containing the server information.

                                                                                                                                                                                              func (*Server) Warnf

                                                                                                                                                                                              func (s *Server) Warnf(format string, v ...interface{})

                                                                                                                                                                                                Warnf logs a warning error

                                                                                                                                                                                                type SortOpt

                                                                                                                                                                                                type SortOpt string

                                                                                                                                                                                                  SortOpt is a helper type to sort clients

                                                                                                                                                                                                  const (
                                                                                                                                                                                                  	ByCid      SortOpt = "cid"        // By connection ID
                                                                                                                                                                                                  	ByStart    SortOpt = "start"      // By connection start time, same as CID
                                                                                                                                                                                                  	BySubs     SortOpt = "subs"       // By number of subscriptions
                                                                                                                                                                                                  	ByPending  SortOpt = "pending"    // By amount of data in bytes waiting to be sent to client
                                                                                                                                                                                                  	ByOutMsgs  SortOpt = "msgs_to"    // By number of messages sent
                                                                                                                                                                                                  	ByInMsgs   SortOpt = "msgs_from"  // By number of messages received
                                                                                                                                                                                                  	ByOutBytes SortOpt = "bytes_to"   // By amount of bytes sent
                                                                                                                                                                                                  	ByInBytes  SortOpt = "bytes_from" // By amount of bytes received
                                                                                                                                                                                                  	ByLast     SortOpt = "last"       // By the last activity
                                                                                                                                                                                                  	ByIdle     SortOpt = "idle"       // By the amount of inactivity
                                                                                                                                                                                                  	ByUptime   SortOpt = "uptime"     // By the amount of time connections exist
                                                                                                                                                                                                  	ByStop     SortOpt = "stop"       // By the stop time for a closed connection
                                                                                                                                                                                                  	ByReason   SortOpt = "reason"     // By the reason for a closed connection
                                                                                                                                                                                                  
                                                                                                                                                                                                  )

                                                                                                                                                                                                    Possible sort options

                                                                                                                                                                                                    func (SortOpt) IsValid

                                                                                                                                                                                                    func (s SortOpt) IsValid() bool

                                                                                                                                                                                                      IsValid determines if a sort option is valid

                                                                                                                                                                                                      type SubDetail

                                                                                                                                                                                                      type SubDetail struct {
                                                                                                                                                                                                      	Subject string `json:"subject"`
                                                                                                                                                                                                      	Queue   string `json:"qgroup,omitempty"`
                                                                                                                                                                                                      	Sid     string `json:"sid"`
                                                                                                                                                                                                      	Msgs    int64  `json:"msgs"`
                                                                                                                                                                                                      	Max     int64  `json:"max,omitempty"`
                                                                                                                                                                                                      	Cid     uint64 `json:"cid"`
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type SubjectPermission

                                                                                                                                                                                                      type SubjectPermission struct {
                                                                                                                                                                                                      	Allow []string `json:"allow,omitempty"`
                                                                                                                                                                                                      	Deny  []string `json:"deny,omitempty"`
                                                                                                                                                                                                      }

                                                                                                                                                                                                        SubjectPermission is an individual allow and deny struct for publish and subscribe authorizations.

                                                                                                                                                                                                        type Sublist

                                                                                                                                                                                                        type Sublist struct {
                                                                                                                                                                                                        	sync.RWMutex
                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                        }

                                                                                                                                                                                                          A Sublist stores and efficiently retrieves subscriptions.

                                                                                                                                                                                                          func NewSublist

                                                                                                                                                                                                          func NewSublist() *Sublist

                                                                                                                                                                                                            New will create a default sublist

                                                                                                                                                                                                            func (*Sublist) CacheCount

                                                                                                                                                                                                            func (s *Sublist) CacheCount() int

                                                                                                                                                                                                              CacheCount returns the number of result sets in the cache.

                                                                                                                                                                                                              func (*Sublist) Count

                                                                                                                                                                                                              func (s *Sublist) Count() uint32

                                                                                                                                                                                                                Count returns the number of subscriptions.

                                                                                                                                                                                                                func (*Sublist) Insert

                                                                                                                                                                                                                func (s *Sublist) Insert(sub *subscription) error

                                                                                                                                                                                                                  Insert adds a subscription into the sublist

                                                                                                                                                                                                                  func (*Sublist) Match

                                                                                                                                                                                                                  func (s *Sublist) Match(subject string) *SublistResult

                                                                                                                                                                                                                    Match will match all entries to the literal subject. It will return a set of results for both normal and queue subscribers.

                                                                                                                                                                                                                    func (*Sublist) Remove

                                                                                                                                                                                                                    func (s *Sublist) Remove(sub *subscription) error

                                                                                                                                                                                                                      Remove will remove a subscription.

                                                                                                                                                                                                                      func (*Sublist) RemoveBatch

                                                                                                                                                                                                                      func (s *Sublist) RemoveBatch(subs []*subscription) error

                                                                                                                                                                                                                        RemoveBatch will remove a list of subscriptions.

                                                                                                                                                                                                                        func (*Sublist) Stats

                                                                                                                                                                                                                        func (s *Sublist) Stats() *SublistStats

                                                                                                                                                                                                                          Stats will return a stats structure for the current state.

                                                                                                                                                                                                                          type SublistResult

                                                                                                                                                                                                                          type SublistResult struct {
                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            A result structure better optimized for queue subs.

                                                                                                                                                                                                                            type SublistStats

                                                                                                                                                                                                                            type SublistStats struct {
                                                                                                                                                                                                                            	NumSubs      uint32  `json:"num_subscriptions"`
                                                                                                                                                                                                                            	NumCache     uint32  `json:"num_cache"`
                                                                                                                                                                                                                            	NumInserts   uint64  `json:"num_inserts"`
                                                                                                                                                                                                                            	NumRemoves   uint64  `json:"num_removes"`
                                                                                                                                                                                                                            	NumMatches   uint64  `json:"num_matches"`
                                                                                                                                                                                                                            	CacheHitRate float64 `json:"cache_hit_rate"`
                                                                                                                                                                                                                            	MaxFanout    uint32  `json:"max_fanout"`
                                                                                                                                                                                                                            	AvgFanout    float64 `json:"avg_fanout"`
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              Public stats for the sublist

                                                                                                                                                                                                                              type Subsz

                                                                                                                                                                                                                              type Subsz struct {
                                                                                                                                                                                                                              	*SublistStats
                                                                                                                                                                                                                              	Total  int         `json:"total"`
                                                                                                                                                                                                                              	Offset int         `json:"offset"`
                                                                                                                                                                                                                              	Limit  int         `json:"limit"`
                                                                                                                                                                                                                              	Subs   []SubDetail `json:"subscriptions_list,omitempty"`
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                Subsz represents detail information on current connections.

                                                                                                                                                                                                                                type SubszOptions

                                                                                                                                                                                                                                type SubszOptions struct {
                                                                                                                                                                                                                                	// Offset is used for pagination. Subsz() only returns connections starting at this
                                                                                                                                                                                                                                	// offset from the global results.
                                                                                                                                                                                                                                	Offset int `json:"offset"`
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// Limit is the maximum number of subscriptions that should be returned by Subsz().
                                                                                                                                                                                                                                	Limit int `json:"limit"`
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// Subscriptions indicates if subscriptions should be included in the results.
                                                                                                                                                                                                                                	Subscriptions bool `json:"subscriptions"`
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// Test the list against this subject. Needs to be literal since it signifies a publish subject.
                                                                                                                                                                                                                                	// We will only return subscriptions that would match if a message was sent to this subject.
                                                                                                                                                                                                                                	Test string `json:"test,omitempty"`
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  SubszOptions are the options passed to Subsz. As of now, there are no options defined.

                                                                                                                                                                                                                                  type TLSConfigOpts

                                                                                                                                                                                                                                  type TLSConfigOpts struct {
                                                                                                                                                                                                                                  	CertFile         string
                                                                                                                                                                                                                                  	KeyFile          string
                                                                                                                                                                                                                                  	CaFile           string
                                                                                                                                                                                                                                  	Verify           bool
                                                                                                                                                                                                                                  	Timeout          float64
                                                                                                                                                                                                                                  	Ciphers          []uint16
                                                                                                                                                                                                                                  	CurvePreferences []tls.CurveID
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    TLSConfigOpts holds the parsed tls config information, used with flag parsing

                                                                                                                                                                                                                                    type User

                                                                                                                                                                                                                                    type User struct {
                                                                                                                                                                                                                                    	Username    string       `json:"user"`
                                                                                                                                                                                                                                    	Password    string       `json:"password"`
                                                                                                                                                                                                                                    	Permissions *Permissions `json:"permissions"`
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      User is for multiple accounts/users.

                                                                                                                                                                                                                                      type Varz

                                                                                                                                                                                                                                      type Varz struct {
                                                                                                                                                                                                                                      	*Info
                                                                                                                                                                                                                                      	*Options
                                                                                                                                                                                                                                      	Port             int               `json:"port"`
                                                                                                                                                                                                                                      	MaxPayload       int               `json:"max_payload"`
                                                                                                                                                                                                                                      	Start            time.Time         `json:"start"`
                                                                                                                                                                                                                                      	Now              time.Time         `json:"now"`
                                                                                                                                                                                                                                      	Uptime           string            `json:"uptime"`
                                                                                                                                                                                                                                      	Mem              int64             `json:"mem"`
                                                                                                                                                                                                                                      	Cores            int               `json:"cores"`
                                                                                                                                                                                                                                      	CPU              float64           `json:"cpu"`
                                                                                                                                                                                                                                      	Connections      int               `json:"connections"`
                                                                                                                                                                                                                                      	TotalConnections uint64            `json:"total_connections"`
                                                                                                                                                                                                                                      	Routes           int               `json:"routes"`
                                                                                                                                                                                                                                      	Remotes          int               `json:"remotes"`
                                                                                                                                                                                                                                      	InMsgs           int64             `json:"in_msgs"`
                                                                                                                                                                                                                                      	OutMsgs          int64             `json:"out_msgs"`
                                                                                                                                                                                                                                      	InBytes          int64             `json:"in_bytes"`
                                                                                                                                                                                                                                      	OutBytes         int64             `json:"out_bytes"`
                                                                                                                                                                                                                                      	SlowConsumers    int64             `json:"slow_consumers"`
                                                                                                                                                                                                                                      	MaxPending       int64             `json:"max_pending"`
                                                                                                                                                                                                                                      	WriteDeadline    time.Duration     `json:"write_deadline"`
                                                                                                                                                                                                                                      	Subscriptions    uint32            `json:"subscriptions"`
                                                                                                                                                                                                                                      	HTTPReqStats     map[string]uint64 `json:"http_req_stats"`
                                                                                                                                                                                                                                      	ConfigLoadTime   time.Time         `json:"config_load_time"`
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        Varz will output server information on the monitoring port at /varz.

                                                                                                                                                                                                                                        type VarzOptions

                                                                                                                                                                                                                                        type VarzOptions struct{}

                                                                                                                                                                                                                                          VarzOptions are the options passed to Varz(). Currently, there are no options defined.

                                                                                                                                                                                                                                          Directories

                                                                                                                                                                                                                                          Path Synopsis