gnatsd: github.com/nats-io/gnatsd/server Index | Files | Directories

package server

import "github.com/nats-io/gnatsd/server"

Index

Package Files

accounts.go auth.go ciphersuites.go client.go const.go errors.go events.go gateway.go jwt.go leafnode.go log.go monitor.go monitor_sort_opts.go nkey.go opts.go parser.go reload.go ring.go route.go server.go service.go signal.go sublist.go util.go

Constants

const (
    // CLIENT is an end user.
    CLIENT = iota
    // ROUTER represents another server in the cluster.
    ROUTER
    // GATEWAY is a link between 2 clusters.
    GATEWAY
    // SYSTEM is an internal system client.
    SYSTEM
    // LEAF is for leaf node connections.
    LEAF
)

Type of client connection.

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

Valid Command values.

const (
    // VERSION is the current version for the server.
    VERSION = "2.1.1-RC4"

    // 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

    // DEFAULT_LEAF_NODE_RECONNECT LeafNode reconnect interval.
    DEFAULT_LEAF_NODE_RECONNECT = time.Second

    // DEFAULT_LEAF_TLS_TIMEOUT TLS timeout for LeafNodes
    DEFAULT_LEAF_TLS_TIMEOUT = 2 * 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_MAX_CLOSED_CLIENTS is the maximum number of closed connections we hold onto.
    DEFAULT_MAX_CLOSED_CLIENTS = 10000

    // DEFAULT_MAX_ACCOUNT_AE_RESPONSE_MAPS is for auto-expire response maps for imports.
    DEFAULT_MAX_ACCOUNT_AE_RESPONSE_MAPS = 100000

    // DEFAULT_MAX_ACCOUNT_INTERNAL_RESPONSE_MAPS is for non auto-expire response maps for imports.
    // These are present for non-singleton response types.
    DEFAULT_MAX_ACCOUNT_INTERNAL_RESPONSE_MAPS = 100000

    // DEFAULT_TTL_AE_RESPONSE_MAP is the default time to expire auto-response map entries.
    DEFAULT_TTL_AE_RESPONSE_MAP = 10 * time.Minute

    // 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 = 2 * time.Minute

    // DEFAULT_LEAFNODE_INFO_WAIT Route dial timeout.
    DEFAULT_LEAFNODE_INFO_WAIT = 1 * time.Second

    // DEFAULT_LEAFNODE_PORT is the default port for remote leafnode connections.
    DEFAULT_LEAFNODE_PORT = 7422

    // DEFAULT_CONNECT_ERROR_REPORTS is the number of attempts at which a
    // repeated failed route, gateway or leaf node connection is reported.
    // This is used for initial connection, that is, when the server has
    // never had a connection to the given endpoint. Once connected, and
    // if a disconnect occurs, DEFAULT_RECONNECT_ERROR_REPORTS is used
    // instead.
    // The default is to report every 3600 attempts (roughly every hour).
    DEFAULT_CONNECT_ERROR_REPORTS = 3600

    // DEFAULT_RECONNECT_ERROR_REPORTS is the default number of failed
    // attempt to reconnect a route, gateway or leaf node connection.
    // The default is to report every attempt.
    DEFAULT_RECONNECT_ERROR_REPORTS = 1

    // DEFAULT_RTT_MEASUREMENT_INTERVAL is how often we want to measure RTT from
    // this server to clients, routes, gateways or leafnode connections.
    DEFAULT_RTT_MEASUREMENT_INTERVAL = time.Hour

    // DEFAULT_ALLOW_RESPONSE_MAX_MSGS is the default number of responses allowed
    // for a reply subject.
    DEFAULT_ALLOW_RESPONSE_MAX_MSGS = 1

    // DEFAULT_ALLOW_RESPONSE_EXPIRATION is the default time allowed for a given
    // dynamic response permission.
    DEFAULT_ALLOW_RESPONSE_EXPIRATION = 2 * time.Minute

    // DEFAULT_SERVICE_LATENCY_SAMPLING is the default sampling rate for service
    // latency metrics
    DEFAULT_SERVICE_LATENCY_SAMPLING = 100
)
const (
    // ConnOpen filters on open clients.
    ConnOpen = ConnState(iota)
    // ConnClosed filters on closed clients.
    ConnClosed
    // ConnAll returns all clients.
    ConnAll
)
const (
    OP_START parserState = 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_R
    MSG_END_N
    OP_S
    OP_SU
    OP_SUB
    OP_SUB_SPC
    SUB_ARG
    OP_A
    OP_ASUB
    OP_ASUB_SPC
    ASUB_ARG
    OP_AUSUB
    OP_AUSUB_SPC
    AUSUB_ARG
    OP_L
    OP_LS
    OP_R
    OP_RS
    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

const (
    // RouteProtoZero is the original Route protocol from 2009.
    // http://nats.io/documentation/internals/nats-protocol/
    RouteProtoZero = iota
    // RouteProtoInfo signals a route can receive more then the original INFO block.
    // This can be used to update remote cluster permissions, etc...
    RouteProtoInfo
    // RouteProtoV2 is the new route/cluster protocol that provides account support.
    RouteProtoV2
)
const (
    ConProto  = "CONNECT %s" + _CRLF_
    InfoProto = "INFO %s" + _CRLF_
)

Route protocol constants

const (
    RootPath     = "/"
    VarzPath     = "/varz"
    ConnzPath    = "/connz"
    RoutezPath   = "/routez"
    GatewayzPath = "/gatewayz"
    LeafzPath    = "/leafz"
    SubszPath    = "/subsz"
    StackszPath  = "/stacksz"
)

HTTP endpoints

const DefaultConnListSize = 1024

DefaultConnListSize is the default size of the connection list.

const DefaultSubListSize = 1024

DefaultSubListSize is the default size of the subscriptions list.

const (
    InboxPrefix = "$SYS._INBOX."
)

Copied from go client. We could use serviceReply here instead to save some code. I prefer these semantics for the moment, when tracing you know what this is.

Variables

var (
    // ErrConnectionClosed represents an error condition on a closed connection.
    ErrConnectionClosed = errors.New("connection closed")

    // ErrAuthentication represents an error condition on failed authentication.
    ErrAuthentication = errors.New("authentication error")

    // ErrAuthTimeout represents an error condition on failed authorization due to timeout.
    ErrAuthTimeout = errors.New("authentication timeout")

    // ErrAuthExpired represents an expired authorization due to timeout.
    ErrAuthExpired = errors.New("authentication expired")

    // 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")

    // ErrBadPublishSubject represents an error condition for an invalid publish subject.
    ErrBadPublishSubject = errors.New("invalid publish subject")

    // ErrBadClientProtocol signals a client requested an invalid 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")

    // ErrTooManyAccountConnections signals that an account has reached its maximum number of active
    // connections.
    ErrTooManyAccountConnections = errors.New("maximum account active 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")

    // ErrClientConnectedToLeafNodePort represents an error condition when a client
    // attempted to connect to the leaf node listen port.
    ErrClientConnectedToLeafNodePort = errors.New("attempted to connect to leaf node port")

    // ErrAccountExists is returned when an account is attempted to be registered
    // but already exists.
    ErrAccountExists = errors.New("account exists")

    // ErrBadAccount represents a malformed or incorrect account.
    ErrBadAccount = errors.New("bad account")

    // ErrReservedAccount represents a reserved account that can not be created.
    ErrReservedAccount = errors.New("reserved account")

    // ErrMissingAccount is returned when an account does not exist.
    ErrMissingAccount = errors.New("account missing")

    // ErrMissingService is returned when an account does not have an exported service.
    ErrMissingService = errors.New("service missing")

    // ErrBadServiceType is returned when latency tracking is being applied to non-singleton response types.
    ErrBadServiceType = errors.New("bad service response type")

    // ErrBadSampling is returned when the sampling for latency tracking is not 1 >= sample <= 100.
    ErrBadSampling = errors.New("bad sampling percentage, should be 1-100")

    // ErrAccountValidation is returned when an account has failed validation.
    ErrAccountValidation = errors.New("account validation failed")

    // ErrAccountExpired is returned when an account has expired.
    ErrAccountExpired = errors.New("account expired")

    // ErrNoAccountResolver is returned when we attempt an update but do not have an account resolver.
    ErrNoAccountResolver = errors.New("account resolver missing")

    // ErrAccountResolverUpdateTooSoon is returned when we attempt an update too soon to last request.
    ErrAccountResolverUpdateTooSoon = errors.New("account resolver update too soon")

    // ErrAccountResolverSameClaims is returned when same claims have been fetched.
    ErrAccountResolverSameClaims = errors.New("account resolver no new claims")

    // ErrStreamImportAuthorization is returned when a stream import is not authorized.
    ErrStreamImportAuthorization = errors.New("stream import not authorized")

    // ErrStreamImportBadPrefix is returned when a stream import prefix contains wildcards.
    ErrStreamImportBadPrefix = errors.New("stream import prefix can not contain wildcard tokens")

    // ErrServiceImportAuthorization is returned when a service import is not authorized.
    ErrServiceImportAuthorization = errors.New("service import not authorized")

    // ErrClientOrRouteConnectedToGatewayPort represents an error condition when
    // a client or route attempted to connect to the Gateway port.
    ErrClientOrRouteConnectedToGatewayPort = errors.New("attempted to connect to gateway port")

    // ErrWrongGateway represents an error condition when a server receives a connect
    // request from a remote Gateway with a destination name that does not match the server's
    // Gateway's name.
    ErrWrongGateway = errors.New("wrong gateway")

    // ErrNoSysAccount is returned when an attempt to publish or subscribe is made
    // when there is no internal system account defined.
    ErrNoSysAccount = errors.New("system account not setup")

    // ErrRevocation is returned when a credential has been revoked.
    ErrRevocation = errors.New("credentials have been revoked")

    // Used to signal an error that a server is not running.
    ErrServerNotRunning = errors.New("server is not running")
)
var (
    ErrInvalidSubject = errors.New("sublist: invalid subject")
    ErrNotFound       = errors.New("sublist: no matches found")
)

Sublist related errors

var IsPublicExport = []*Account(nil)

IsPublicExport is a placeholder to denote a public export.

func GenTLSConfig Uses

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

GenTLSConfig loads TLS related configuration parameters.

func IsValidLiteralSubject Uses

func IsValidLiteralSubject(subject string) bool

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

func IsValidPublishSubject Uses

func IsValidPublishSubject(subject string) bool

IsValidPublishSubject returns true if a subject is valid and a literal, false otherwise

func IsValidSubject Uses

func IsValidSubject(subject string) bool

IsValidSubject returns true if a subject is valid, false otherwise

func NoErrOnUnknownFields Uses

func NoErrOnUnknownFields(noError bool)

NoErrOnUnknownFields can be used to change the behavior the processing of a configuration file. By default, an error is reported if unknown fields are found. If `noError` is set to true, no error will be reported if top-level unknown fields are found.

func PrintAndDie Uses

func PrintAndDie(msg string)

PrintAndDie is exported for access in other packages.

func PrintServerAndExit Uses

func PrintServerAndExit()

PrintServerAndExit will print our version and exit.

func PrintTLSHelpAndDie Uses

func PrintTLSHelpAndDie()

PrintTLSHelpAndDie prints TLS usage and exits.

func ProcessCommandLineArgs Uses

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 Uses

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 nats-server. 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 ReadOperatorJWT Uses

func ReadOperatorJWT(jwtfile string) (*jwt.OperatorClaims, error)

ReadOperatorJWT will read a jwt file for an operator claim. This can be a decorated file.

func RemoveSelfReference Uses

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

RemoveSelfReference removes this server from an array of routes

func ResetGatewaysSolicitDelay Uses

func ResetGatewaysSolicitDelay()

ResetGatewaysSolicitDelay resets the initial delay before gateways connections are initiated to its default values. Used by tests.

func ResponseHandler Uses

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

ResponseHandler handles responses for monitoring routes

func RoutesFromStr Uses

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

RoutesFromStr parses route URLs from a string

func Run Uses

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 SetGatewaysSolicitDelay Uses

func SetGatewaysSolicitDelay(delay time.Duration)

SetGatewaysSolicitDelay sets the initial delay before gateways connections are initiated. Used by tests.

func SetProcessName Uses

func SetProcessName(name string)

SetProcessName allows to change the expected name of the process.

type Account Uses

type Account struct {
    Name   string
    Nkey   string
    Issuer string
    // contains filtered or unexported fields
}

Account are subject namespace definitions. By default no messages are shared between accounts. You can share via Exports and Imports of Streams and Services.

func NewAccount Uses

func NewAccount(name string) *Account

NewAccount creates a new unlimited account with the given name.

func (*Account) AddServiceExport Uses

func (a *Account) AddServiceExport(subject string, accounts []*Account) error

AddServiceExport will configure the account with the defined export.

func (*Account) AddServiceExportWithResponse Uses

func (a *Account) AddServiceExportWithResponse(subject string, respType ServiceRespType, accounts []*Account) error

AddServiceExportWithresponse will configure the account with the defined export and response type.

func (*Account) AddServiceImport Uses

func (a *Account) AddServiceImport(destination *Account, from, to string) error

AddServiceImport will add a route to an account to send published messages / requests to the destination account. From is the local subject to map, To is the subject that will appear on the destination account. Destination will need to have an import rule to allow access via addService.

func (*Account) AddServiceImportWithClaim Uses

func (a *Account) AddServiceImportWithClaim(destination *Account, from, to string, imClaim *jwt.Import) error

AddServiceImportWithClaim will add in the service import via the jwt claim.

func (*Account) AddStreamExport Uses

func (a *Account) AddStreamExport(subject string, accounts []*Account) error

AddStreamExport will add an export to the account. If accounts is nil it will signify a public export, meaning anyone can impoort.

func (*Account) AddStreamImport Uses

func (a *Account) AddStreamImport(account *Account, from, prefix string) error

AddStreamImport will add in the stream import from a specific account.

func (*Account) AddStreamImportWithClaim Uses

func (a *Account) AddStreamImportWithClaim(account *Account, from, prefix string, imClaim *jwt.Import) error

AddStreamImportWithClaim will add in the stream import from a specific account with optional token.

func (*Account) AutoExpireTTL Uses

func (a *Account) AutoExpireTTL() time.Duration

AutoExpireTTL returns the ttl for response maps.

func (*Account) IsExpired Uses

func (a *Account) IsExpired() bool

IsExpired returns expiration status.

func (*Account) IsExportService Uses

func (a *Account) IsExportService(service string) bool

IsExportService will indicate if this service exists. Will check wildcard scenarios.

func (*Account) IsExportServiceTracking Uses

func (a *Account) IsExportServiceTracking(service string) bool

IsExportServiceTracking will indicate if given publish subject is an export service with tracking enabled.

func (*Account) MaxActiveConnections Uses

func (a *Account) MaxActiveConnections() int

MaxActiveConnections return the set limit for the account system wide for total number of active connections.

func (*Account) MaxActiveLeafNodes Uses

func (a *Account) MaxActiveLeafNodes() int

MaxActiveLeafNodes return the set limit for the account system wide for total number of leavenode connections. NOTE: these are tracked separately.

func (*Account) MaxAutoExpireResponseMaps Uses

func (a *Account) MaxAutoExpireResponseMaps() int

MaxAutoExpireResponseMaps return the maximum number of auto expire response maps we will allow.

func (*Account) MaxResponseMaps Uses

func (a *Account) MaxResponseMaps() int

MaxResponseMaps return the maximum number of non auto-expire response maps we will allow.

func (*Account) MaxTotalConnectionsReached Uses

func (a *Account) MaxTotalConnectionsReached() bool

MaxTotalConnectionsReached returns if we have reached our limit for number of connections.

func (*Account) MaxTotalLeafNodesReached Uses

func (a *Account) MaxTotalLeafNodesReached() bool

MaxTotalLeafNodesReached returns if we have reached our limit for number of leafnodes.

func (*Account) NumConnections Uses

func (a *Account) NumConnections() int

NumConnections returns active number of clients for this account for all known servers.

func (*Account) NumLeafNodes Uses

func (a *Account) NumLeafNodes() int

NumLeafNodes returns the active number of local and remote leaf node connections.

func (*Account) NumLocalConnections Uses

func (a *Account) NumLocalConnections() int

NumLocalConnections returns active number of clients for this account on this server.

func (*Account) NumRemoteConnections Uses

func (a *Account) NumRemoteConnections() int

NumRemoteConnections returns the number of client or leaf connections that are not on this server.

func (*Account) NumRemoteLeafNodes Uses

func (a *Account) NumRemoteLeafNodes() int

NumRemoteLeafNodes returns the active number of remote leaf node connections.

func (*Account) NumServiceImports Uses

func (a *Account) NumServiceImports() int

NumServiceImports return number of service imports we have.

func (*Account) RoutedSubs Uses

func (a *Account) RoutedSubs() int

RoutedSubs returns how many subjects we would send across a route when first connected or expressing interest. Local client subs.

func (*Account) SetAutoExpireTTL Uses

func (a *Account) SetAutoExpireTTL(ttl time.Duration)

SetAutoExpireTTL sets the ttl for response maps.

func (*Account) SetMaxAutoExpireResponseMaps Uses

func (a *Account) SetMaxAutoExpireResponseMaps(max int)

SetMaxAutoExpireResponseMaps sets the max outstanding auto expire response maps.

func (*Account) SetMaxResponseMaps Uses

func (a *Account) SetMaxResponseMaps(max int)

SetMaxResponseMaps sets the max outstanding non auto-expire response maps.

func (*Account) TotalSubs Uses

func (a *Account) TotalSubs() int

TotalSubs returns total number of Subscriptions for this account.

func (*Account) TrackServiceExport Uses

func (a *Account) TrackServiceExport(service, results string) error

TrackServiceExport will enable latency tracking of the named service. Results will be published in this account to the given results subject.

func (*Account) TrackServiceExportWithSampling Uses

func (a *Account) TrackServiceExportWithSampling(service, results string, sampling int) error

TrackServiceExportWithSampling will enable latency tracking of the named service for the given sampling rate (1-100). Results will be published in this account to the given results subject.

func (*Account) UnTrackServiceExport Uses

func (a *Account) UnTrackServiceExport(service string)

UnTrackServiceExport will disable latency tracking of the named service.

type AccountGatewayz Uses

type AccountGatewayz struct {
    Name                  string `json:"name"`
    InterestMode          string `json:"interest_mode"`
    NoInterestCount       int    `json:"no_interest_count,omitempty"`
    InterestOnlyThreshold int    `json:"interest_only_threshold,omitempty"`
    TotalSubscriptions    int    `json:"num_subs,omitempty"`
    NumQueueSubscriptions int    `json:"num_queue_subs,omitempty"`
}

AccountGatewayz represents interest mode for this account

type AccountNumConns Uses

type AccountNumConns struct {
    Server     ServerInfo `json:"server"`
    Account    string     `json:"acc"`
    Conns      int        `json:"conns"`
    LeafNodes  int        `json:"leafnodes"`
    TotalConns int        `json:"total_conns"`
}

AccountNumConns is an event that will be sent from a server that is tracking a given account when the number of connections changes. It will also HB updates in the absence of any changes.

type AccountResolver Uses

type AccountResolver interface {
    Fetch(name string) (string, error)
    Store(name, jwt string) error
}

AccountResolver interface. This is to fetch Account JWTs by public nkeys

type Authentication Uses

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

Authentication is an interface for implementing authentication

type ClientAuthentication Uses

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 ClientInfo Uses

type ClientInfo struct {
    Start   time.Time  `json:"start,omitempty"`
    Host    string     `json:"host,omitempty"`
    ID      uint64     `json:"id"`
    Account string     `json:"acc"`
    User    string     `json:"user,omitempty"`
    Name    string     `json:"name,omitempty"`
    Lang    string     `json:"lang,omitempty"`
    Version string     `json:"ver,omitempty"`
    RTT     string     `json:"rtt,omitempty"`
    Stop    *time.Time `json:"stop,omitempty"`
}

ClientInfo is detailed information about the client forming a connection.

type ClosedState Uses

type ClosedState int

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

func (ClosedState) String Uses

func (reason ClosedState) String() string

type ClusterOpts Uses

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:"-"`
    TLSMap         bool              `json:"-"`
    ListenStr      string            `json:"-"`
    Advertise      string            `json:"-"`
    NoAdvertise    bool              `json:"-"`
    ConnectRetries int               `json:"-"`
}

ClusterOpts are options for clusters. NOTE: This structure is no longer used for monitoring endpoints and json tags are deprecated and may be removed in the future.

type ClusterOptsVarz Uses

type ClusterOptsVarz struct {
    Host        string   `json:"addr,omitempty"`
    Port        int      `json:"cluster_port,omitempty"`
    AuthTimeout float64  `json:"auth_timeout,omitempty"`
    URLs        []string `json:"urls,omitempty"`
}

ClusterOptsVarz contains monitoring cluster information

type Command Uses

type Command string

Command is a signal used to control a running nats-server process.

type ConnInfo Uses

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"`
    Account        string     `json:"account,omitempty"`
    Subs           []string   `json:"subscriptions_list,omitempty"`
}

ConnInfo has detailed information on a per connection basis.

type ConnInfos Uses

type ConnInfos []*ConnInfo

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

func (ConnInfos) Len Uses

func (cl ConnInfos) Len() int

For sorting Len returns length for sorting.

func (ConnInfos) Swap Uses

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

Swap will sawap the elements.

type ConnState Uses

type ConnState int

ConnState is for filtering states of connections. We will only have two, open and closed.

type ConnectEventMsg Uses

type ConnectEventMsg struct {
    Server ServerInfo `json:"server"`
    Client ClientInfo `json:"client"`
}

ConnectEventMsg is sent when a new connection is made that is part of an account.

type Connz Uses

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 Uses

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"`

    // Filter by username.
    User string `json:"user"`

    // Filter by account.
    Account string `json:"acc"`
}

ConnzOptions are the options passed to Connz()

type DataStats Uses

type DataStats struct {
    Msgs  int64 `json:"msgs"`
    Bytes int64 `json:"bytes"`
}

DataStats reports how may msg and bytes. Applicable for both sent and received.

type DisconnectEventMsg Uses

type DisconnectEventMsg struct {
    Server   ServerInfo `json:"server"`
    Client   ClientInfo `json:"client"`
    Sent     DataStats  `json:"sent"`
    Received DataStats  `json:"received"`
    Reason   string     `json:"reason"`
}

DisconnectEventMsg is sent when a new connection previously defined from a ConnectEventMsg is closed.

type GatewayInterestMode Uses

type GatewayInterestMode byte

GatewayInterestMode represents an account interest mode for a gateway connection

const (
    // optimistic is the default mode where a cluster will send
    // to a gateway unless it is been told that there is no interest
    // (this is for plain subscribers only).
    Optimistic GatewayInterestMode = iota
    // transitioning is when a gateway has to send too many
    // no interest on subjects to the remote and decides that it is
    // now time to move to modeInterestOnly (this is on a per account
    // basis).
    Transitioning
    // interestOnly means that a cluster sends all it subscriptions
    // interest to the gateway, which in return does not send a message
    // unless it knows that there is explicit interest.
    InterestOnly
)

GatewayInterestMode values

func (GatewayInterestMode) String Uses

func (im GatewayInterestMode) String() string

type GatewayOpts Uses

type GatewayOpts struct {
    Name           string               `json:"name"`
    Host           string               `json:"addr,omitempty"`
    Port           int                  `json:"port,omitempty"`
    Username       string               `json:"-"`
    Password       string               `json:"-"`
    AuthTimeout    float64              `json:"auth_timeout,omitempty"`
    TLSConfig      *tls.Config          `json:"-"`
    TLSTimeout     float64              `json:"tls_timeout,omitempty"`
    TLSMap         bool                 `json:"-"`
    Advertise      string               `json:"advertise,omitempty"`
    ConnectRetries int                  `json:"connect_retries,omitempty"`
    Gateways       []*RemoteGatewayOpts `json:"gateways,omitempty"`
    RejectUnknown  bool                 `json:"reject_unknown,omitempty"`
    // contains filtered or unexported fields
}

GatewayOpts are options for gateways. NOTE: This structure is no longer used for monitoring endpoints and json tags are deprecated and may be removed in the future.

type GatewayOptsVarz Uses

type GatewayOptsVarz struct {
    Name           string                  `json:"name,omitempty"`
    Host           string                  `json:"host,omitempty"`
    Port           int                     `json:"port,omitempty"`
    AuthTimeout    float64                 `json:"auth_timeout,omitempty"`
    TLSTimeout     float64                 `json:"tls_timeout,omitempty"`
    Advertise      string                  `json:"advertise,omitempty"`
    ConnectRetries int                     `json:"connect_retries,omitempty"`
    Gateways       []RemoteGatewayOptsVarz `json:"gateways,omitempty"`
    RejectUnknown  bool                    `json:"reject_unknown,omitempty"`
}

GatewayOptsVarz contains monitoring gateway information

type GatewayStat Uses

type GatewayStat struct {
    ID         uint64    `json:"gwid"`
    Name       string    `json:"name"`
    Sent       DataStats `json:"sent"`
    Received   DataStats `json:"received"`
    NumInbound int       `json:"inbound_connections"`
}

GatewayStat holds gateway statistics.

type Gatewayz Uses

type Gatewayz struct {
    ID               string                       `json:"server_id"`
    Now              time.Time                    `json:"now"`
    Name             string                       `json:"name,omitempty"`
    Host             string                       `json:"host,omitempty"`
    Port             int                          `json:"port,omitempty"`
    OutboundGateways map[string]*RemoteGatewayz   `json:"outbound_gateways"`
    InboundGateways  map[string][]*RemoteGatewayz `json:"inbound_gateways"`
}

Gatewayz represents detailed information on Gateways

type GatewayzOptions Uses

type GatewayzOptions struct {
    // Name will output only remote gateways with this name
    Name string

    // Accounts indicates if accounts with its interest should be included in the results.
    Accounts bool

    // AccountName will limit the list of accounts to that account name (makes Accounts implicit)
    AccountName string
}

GatewayzOptions are the options passed to Gatewayz()

type Info Uses

type Info struct {
    ID                string   `json:"server_id"`
    Name              string   `json:"server_name"`
    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        int32    `json:"max_payload"`
    IP                string   `json:"ip,omitempty"`
    CID               uint64   `json:"client_id,omitempty"`
    Nonce             string   `json:"nonce,omitempty"`
    Cluster           string   `json:"cluster,omitempty"`
    ClientConnectURLs []string `json:"connect_urls,omitempty"` // Contains URLs a client can connect to.

    // Route Specific
    Import *SubjectPermission `json:"import,omitempty"`
    Export *SubjectPermission `json:"export,omitempty"`

    // Gateways Specific
    Gateway           string   `json:"gateway,omitempty"`             // Name of the origin Gateway (sent by gateway's INFO)
    GatewayURLs       []string `json:"gateway_urls,omitempty"`        // Gateway URLs in the originating cluster (sent by gateway's INFO)
    GatewayURL        string   `json:"gateway_url,omitempty"`         // Gateway URL on that server (sent by route's INFO)
    GatewayCmd        byte     `json:"gateway_cmd,omitempty"`         // Command code for the receiving server to know what to do
    GatewayCmdPayload []byte   `json:"gateway_cmd_payload,omitempty"` // Command payload when needed
    GatewayNRP        bool     `json:"gateway_nrp,omitempty"`         // Uses new $GNR. prefix for mapped replies

    // LeafNode Specific
    LeafNodeURLs []string `json:"leafnode_urls,omitempty"` // LeafNode URLs that the server can reconnect to.
}

Info is the information sent to clients, routes, gateways, and leaf nodes, to help them understand information about this server.

type LeafInfo Uses

type LeafInfo struct {
    Account  string   `json:"account"`
    IP       string   `json:"ip"`
    Port     int      `json:"port"`
    RTT      string   `json:"rtt,omitempty"`
    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"`
}

LeafInfo has detailed information on each remote leafnode connection.

type LeafNodeOpts Uses

type LeafNodeOpts struct {
    Host              string        `json:"addr,omitempty"`
    Port              int           `json:"port,omitempty"`
    Username          string        `json:"-"`
    Password          string        `json:"-"`
    Account           string        `json:"-"`
    Users             []*User       `json:"-"`
    AuthTimeout       float64       `json:"auth_timeout,omitempty"`
    TLSConfig         *tls.Config   `json:"-"`
    TLSTimeout        float64       `json:"tls_timeout,omitempty"`
    TLSMap            bool          `json:"-"`
    Advertise         string        `json:"-"`
    NoAdvertise       bool          `json:"-"`
    ReconnectInterval time.Duration `json:"-"`

    // For solicited connections to other clusters/superclusters.
    Remotes []*RemoteLeafOpts `json:"remotes,omitempty"`
    // contains filtered or unexported fields
}

LeafNodeOpts are options for a given server to accept leaf node connections and/or connect to a remote cluster.

type LeafNodeOptsVarz Uses

type LeafNodeOptsVarz struct {
    Host        string               `json:"host,omitempty"`
    Port        int                  `json:"port,omitempty"`
    AuthTimeout float64              `json:"auth_timeout,omitempty"`
    TLSTimeout  float64              `json:"tls_timeout,omitempty"`
    Remotes     []RemoteLeafOptsVarz `json:"remotes,omitempty"`
}

LeafNodeOptsVarz contains monitoring leaf node information

type Leafz Uses

type Leafz struct {
    ID       string      `json:"server_id"`
    Now      time.Time   `json:"now"`
    NumLeafs int         `json:"leafnodes"`
    Leafs    []*LeafInfo `json:"leafs"`
}

Leafz represents detailed information on Leafnodes.

type LeafzOptions Uses

type LeafzOptions struct {
    // Subscriptions indicates that Leafz will return a leafnode's subscriptions
    Subscriptions bool `json:"subscriptions"`
}

LeafzOptions are options passed to Leafz

type Logger Uses

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 MemAccResolver Uses

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

MemAccResolver is a memory only resolver. Mostly for testing.

func (*MemAccResolver) Fetch Uses

func (m *MemAccResolver) Fetch(name string) (string, error)

Fetch will fetch the account jwt claims from the internal sync.Map.

func (*MemAccResolver) Store Uses

func (m *MemAccResolver) Store(name, jwt string) error

Store will store the account jwt claims in the internal sync.Map.

type NATSLatency Uses

type NATSLatency struct {
    Requestor time.Duration `json:"req"`
    Responder time.Duration `json:"resp"`
    System    time.Duration `json:"sys"`
}

NATSLatency represents the internal NATS latencies, including RTTs to clients.

func (*NATSLatency) TotalTime Uses

func (nl *NATSLatency) TotalTime() time.Duration

TotalTime is a helper function that totals the NATS latencies.

type NkeyUser Uses

type NkeyUser struct {
    Nkey        string       `json:"user"`
    Permissions *Permissions `json:"permissions,omitempty"`
    Account     *Account     `json:"account,omitempty"`
    SigningKey  string       `json:"signing_key,omitempty"`
}

NkeyUser is for multiple nkey based users

type Options Uses

type Options struct {
    ConfigFile            string        `json:"-"`
    ServerName            string        `json:"server_name"`
    Host                  string        `json:"addr"`
    Port                  int           `json:"port"`
    ClientAdvertise       string        `json:"-"`
    Trace                 bool          `json:"-"`
    Debug                 bool          `json:"-"`
    NoLog                 bool          `json:"-"`
    NoSigs                bool          `json:"-"`
    NoSublistCache        bool          `json:"-"`
    DisableShortFirstPing bool          `json:"-"`
    Logtime               bool          `json:"-"`
    MaxConn               int           `json:"max_connections"`
    MaxSubs               int           `json:"max_subscriptions,omitempty"`
    Nkeys                 []*NkeyUser   `json:"-"`
    Users                 []*User       `json:"-"`
    Accounts              []*Account    `json:"-"`
    SystemAccount         string        `json:"-"`
    AllowNewAccounts      bool          `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        int32         `json:"max_control_line"`
    MaxPayload            int32         `json:"max_payload"`
    MaxPending            int64         `json:"max_pending"`
    Cluster               ClusterOpts   `json:"cluster,omitempty"`
    Gateway               GatewayOpts   `json:"gateway,omitempty"`
    LeafNode              LeafNodeOpts  `json:"leaf,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:"-"`
    TLSMap                bool          `json:"-"`
    TLSCert               string        `json:"-"`
    TLSKey                string        `json:"-"`
    TLSCaCert             string        `json:"-"`
    TLSConfig             *tls.Config   `json:"-"`
    WriteDeadline         time.Duration `json:"-"`
    MaxClosedClients      int           `json:"-"`
    LameDuckDuration      time.Duration `json:"-"`
    // MaxTracedMsgLen is the maximum printable length for traced messages.
    MaxTracedMsgLen int `json:"-"`

    // Operating a trusted NATS server
    TrustedKeys      []string              `json:"-"`
    TrustedOperators []*jwt.OperatorClaims `json:"-"`
    AccountResolver  AccountResolver       `json:"-"`

    CustomClientAuthentication Authentication `json:"-"`
    CustomRouterAuthentication Authentication `json:"-"`

    // CheckConfig configuration file syntax test was successful and exit.
    CheckConfig bool `json:"-"`

    // ConnectErrorReports specifies the number of failed attempts
    // at which point server should report the failure of an initial
    // connection to a route, gateway or leaf node.
    // See DEFAULT_CONNECT_ERROR_REPORTS for default value.
    ConnectErrorReports int

    // ReconnectErrorReports is similar to ConnectErrorReports except
    // that this applies to reconnect events.
    ReconnectErrorReports int
    // contains filtered or unexported fields
}

Options block for nats-server. NOTE: This structure is no longer used for monitoring endpoints and json tags are deprecated and may be removed in the future.

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 Uses

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 Uses

func MergeOptions(fileOpts, flagOpts *Options) *Options

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

func ProcessConfigFile Uses

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

ProcessConfigFile processes a configuration file. FIXME(dlc): A bit hacky

func (*Options) Clone Uses

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 Uses

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 Uses

type Permissions struct {
    Publish   *SubjectPermission  `json:"publish"`
    Subscribe *SubjectPermission  `json:"subscribe"`
    Response  *ResponsePermission `json:"responses,omitempty"`
}

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

type Ports Uses

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 RemoteGatewayOpts Uses

type RemoteGatewayOpts struct {
    Name       string      `json:"name"`
    TLSConfig  *tls.Config `json:"-"`
    TLSTimeout float64     `json:"tls_timeout,omitempty"`
    URLs       []*url.URL  `json:"urls,omitempty"`
}

RemoteGatewayOpts are options for connecting to a remote gateway NOTE: This structure is no longer used for monitoring endpoints and json tags are deprecated and may be removed in the future.

type RemoteGatewayOptsVarz Uses

type RemoteGatewayOptsVarz struct {
    Name       string   `json:"name"`
    TLSTimeout float64  `json:"tls_timeout,omitempty"`
    URLs       []string `json:"urls,omitempty"`
}

RemoteGatewayOptsVarz contains monitoring remote gateway information

type RemoteGatewayz Uses

type RemoteGatewayz struct {
    IsConfigured bool               `json:"configured"`
    Connection   *ConnInfo          `json:"connection,omitempty"`
    Accounts     []*AccountGatewayz `json:"accounts,omitempty"`
}

RemoteGatewayz represents information about an outbound connection to a gateway

type RemoteLeafOpts Uses

type RemoteLeafOpts struct {
    LocalAccount string      `json:"local_account,omitempty"`
    URLs         []*url.URL  `json:"urls,omitempty"`
    Credentials  string      `json:"-"`
    TLS          bool        `json:"-"`
    TLSConfig    *tls.Config `json:"-"`
    TLSTimeout   float64     `json:"tls_timeout,omitempty"`
}

RemoteLeafOpts are options for connecting to a remote server as a leaf node.

type RemoteLeafOptsVarz Uses

type RemoteLeafOptsVarz struct {
    LocalAccount string   `json:"local_account,omitempty"`
    TLSTimeout   float64  `json:"tls_timeout,omitempty"`
    URLs         []string `json:"urls,omitempty"`
}

RemoteLeafOptsVarz contains monitoring remote leaf node information

type ResponsePermission Uses

type ResponsePermission struct {
    MaxMsgs int           `json:"max"`
    Expires time.Duration `json:"ttl"`
}

ResponsePermission can be used to allow responses to any reply subject that is received on a valid subscription.

type RouteInfo Uses

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"`
    RTT          string             `json:"rtt,omitempty"`
    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 Uses

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 RouteStat Uses

type RouteStat struct {
    ID       uint64    `json:"rid"`
    Name     string    `json:"name,omitempty"`
    Sent     DataStats `json:"sent"`
    Received DataStats `json:"received"`
    Pending  int       `json:"pending"`
}

RouteStat holds route statistics.

type RouteType Uses

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 Uses

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 Uses

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 Uses

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

Server is our main struct.

func New Uses

func New(opts *Options) *Server

New will setup a new server struct after parsing the options. DEPRECATED: Use NewServer(opts)

func NewServer Uses

func NewServer(opts *Options) (*Server, error)

NewServer will setup a new server struct after parsing the options. Could return an error if options can not be validated.

func (*Server) AcceptLoop Uses

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

AcceptLoop is exported for easier testing.

func (*Server) AccountResolver Uses

func (s *Server) AccountResolver() AccountResolver

AccountResolver returns the registered account resolver.

func (*Server) Addr Uses

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

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

func (*Server) ClientURL Uses

func (s *Server) ClientURL() string

ClientURL returns the URL used to connect clients. Helpful in testing when we designate a random client port (-1).

func (*Server) ClusterAddr Uses

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

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

func (*Server) ConfigTime Uses

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

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

func (*Server) ConfigureLogger Uses

func (s *Server) ConfigureLogger()

ConfigureLogger configures and sets the logger for the server.

func (*Server) Connz Uses

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

Connz returns a Connz struct containing information about connections.

func (*Server) Debugf Uses

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

Debugf logs a debug statement

func (*Server) Errorf Uses

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

Errorf logs an error

func (*Server) EventsEnabled Uses

func (s *Server) EventsEnabled() bool

EventsEnabled will report if the server has internal events enabled via a defined system account.

func (*Server) Fatalf Uses

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

Fatalf logs a fatal error

func (*Server) GatewayAddr Uses

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

GatewayAddr returns the net.Addr object for the gateway listener.

func (*Server) Gatewayz Uses

func (s *Server) Gatewayz(opts *GatewayzOptions) (*Gatewayz, error)

Gatewayz returns a Gatewayz struct containing information about gateways.

func (*Server) GetClient Uses

func (s *Server) GetClient(cid uint64) *client

GetClient will return the client associated with cid.

func (*Server) GetLeafNode Uses

func (s *Server) GetLeafNode(cid uint64) *client

GetLeafNode returns the leafnode associated with the cid.

func (*Server) HTTPHandler Uses

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 Uses

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

HandleConnz process HTTP requests for connection information.

func (*Server) HandleGatewayz Uses

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

HandleGatewayz process HTTP requests for route information.

func (*Server) HandleLeafz Uses

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

HandleLeafz process HTTP requests for leafnode information.

func (*Server) HandleRoot Uses

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

HandleRoot will show basic info and links to others handlers.

func (*Server) HandleRoutez Uses

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

HandleRoutez process HTTP requests for route information.

func (*Server) HandleStacksz Uses

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

HandleStacksz processes HTTP requests for getting stacks

func (*Server) HandleSubsz Uses

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

HandleSubsz processes HTTP requests for subjects stats.

func (*Server) HandleVarz Uses

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

HandleVarz will process HTTP requests for server information.

func (*Server) ID Uses

func (s *Server) ID() string

ID returns the server's ID

func (*Server) Leafz Uses

func (s *Server) Leafz(opts *LeafzOptions) (*Leafz, error)

Leafz returns a Leafz structure containing information about leafnodes.

func (*Server) LookupAccount Uses

func (s *Server) LookupAccount(name string) (*Account, error)

LookupAccount is a public function to return the account structure associated with name.

func (*Server) LookupOrRegisterAccount Uses

func (s *Server) LookupOrRegisterAccount(name string) (account *Account, isNew bool)

LookupOrRegisterAccount will return the given account if known or create a new entry.

func (*Server) MonitorAddr Uses

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

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

func (*Server) NewAccountsAllowed Uses

func (s *Server) NewAccountsAllowed() bool

NewAccountsAllowed returns whether or not new accounts can be created on the fly.

func (*Server) NonceRequired Uses

func (s *Server) NonceRequired() bool

NonceRequired tells us if we should send a nonce.

func (*Server) Noticef Uses

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

Noticef logs a notice statement

func (*Server) NumActiveAccounts Uses

func (s *Server) NumActiveAccounts() int32

NumActiveAccounts reports number of active accounts on this server.

func (*Server) NumClients Uses

func (s *Server) NumClients() int

NumClients will report the number of registered clients.

func (*Server) NumLeafNodes Uses

func (s *Server) NumLeafNodes() int

NumLeafNodes will report number of leaf node connections.

func (*Server) NumLoadedAccounts Uses

func (s *Server) NumLoadedAccounts() int

NumLoadedAccounts returns the number of loaded accounts.

func (*Server) NumOutboundGateways Uses

func (s *Server) NumOutboundGateways() int

NumOutboundGateways is public here mostly for testing.

func (*Server) NumRemotes Uses

func (s *Server) NumRemotes() int

NumRemotes will report number of registered remotes.

func (*Server) NumRoutes Uses

func (s *Server) NumRoutes() int

NumRoutes will report the number of registered routes.

func (*Server) NumSlowConsumers Uses

func (s *Server) NumSlowConsumers() int64

NumSlowConsumers will report the number of slow consumers.

func (*Server) NumSubscriptions Uses

func (s *Server) NumSubscriptions() uint32

NumSubscriptions will report how many subscriptions are active.

func (*Server) PortsInfo Uses

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

PortsInfo 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 Uses

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

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

func (*Server) ReOpenLogFile Uses

func (s *Server) ReOpenLogFile()

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 Uses

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

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

func (*Server) RegisterAccount Uses

func (s *Server) RegisterAccount(name string) (*Account, error)

RegisterAccount will register an account. The account must be new or this call will fail.

func (*Server) Reload Uses

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 Uses

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

Routez returns a Routez struct containing information about routes.

func (*Server) SetAccountResolver Uses

func (s *Server) SetAccountResolver(ar AccountResolver)

SetAccountResolver will assign the account resolver.

func (*Server) SetLogger Uses

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

SetLogger sets the logger of the server

func (*Server) SetSystemAccount Uses

func (s *Server) SetSystemAccount(accName string) error

SetSystemAccount will set the internal system account. If root operators are present it will also check validity.

func (*Server) Shutdown Uses

func (s *Server) Shutdown()

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

func (*Server) Start Uses

func (s *Server) Start()

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

func (*Server) StartHTTPMonitoring Uses

func (s *Server) StartHTTPMonitoring()

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

func (*Server) StartHTTPSMonitoring Uses

func (s *Server) StartHTTPSMonitoring()

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

func (*Server) StartMonitoring Uses

func (s *Server) StartMonitoring() error

StartMonitoring starts the HTTP or HTTPs server if needed.

func (*Server) StartProfiler Uses

func (s *Server) StartProfiler()

StartProfiler is called to enable dynamic profiling.

func (*Server) StartRouting Uses

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 Uses

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

Subsz returns a Subsz struct containing subjects statistics

func (*Server) SystemAccount Uses

func (s *Server) SystemAccount() *Account

SystemAccount returns the system account if set.

func (*Server) Tracef Uses

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

Tracef logs a trace statement

func (*Server) TrackedRemoteServers Uses

func (s *Server) TrackedRemoteServers() int

TrackedRemoteServers returns how many remote servers we are tracking from a system events perspective.

func (*Server) UpdateAccountClaims Uses

func (s *Server) UpdateAccountClaims(a *Account, ac *jwt.AccountClaims)

UpdateAccountClaims will call updateAccountClaims.

func (*Server) Varz Uses

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

Varz returns a Varz struct containing the server information.

func (*Server) Warnf Uses

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

Warnf logs a warning error

type ServerInfo Uses

type ServerInfo struct {
    Name    string    `json:"name"`
    Host    string    `json:"host"`
    ID      string    `json:"id"`
    Cluster string    `json:"cluster,omitempty"`
    Version string    `json:"ver"`
    Seq     uint64    `json:"seq"`
    Time    time.Time `json:"time"`
}

ServerInfo identifies remote servers.

type ServerStats Uses

type ServerStats struct {
    Start            time.Time      `json:"start"`
    Mem              int64          `json:"mem"`
    Cores            int            `json:"cores"`
    CPU              float64        `json:"cpu"`
    Connections      int            `json:"connections"`
    TotalConnections uint64         `json:"total_connections"`
    ActiveAccounts   int            `json:"active_accounts"`
    NumSubs          uint32         `json:"subscriptions"`
    Sent             DataStats      `json:"sent"`
    Received         DataStats      `json:"received"`
    SlowConsumers    int64          `json:"slow_consumers"`
    Routes           []*RouteStat   `json:"routes,omitempty"`
    Gateways         []*GatewayStat `json:"gateways,omitempty"`
}

ServerStats hold various statistics that we will periodically send out.

type ServerStatsMsg Uses

type ServerStatsMsg struct {
    Server ServerInfo  `json:"server"`
    Stats  ServerStats `json:"statsz"`
}

ServerStatsMsg is sent periodically with stats updates.

type ServiceLatency Uses

type ServiceLatency struct {
    AppName        string        `json:"app,omitempty"`
    RequestStart   time.Time     `json:"start"`
    ServiceLatency time.Duration `json:"svc"`
    NATSLatency    NATSLatency   `json:"nats"`
    TotalLatency   time.Duration `json:"total"`
}

ServiceLatency is the JSON message sent out in response to latency tracking for exported services.

type ServiceRespType Uses

type ServiceRespType uint8

ServiceRespType represents the types of service request response types.

const (
    Singleton ServiceRespType = iota
    Stream
    Chunked
)

Service response types. Defaults to a singleton.

func (ServiceRespType) String Uses

func (rt ServiceRespType) String() string

String helper.

type SortOpt Uses

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 Uses

func (s SortOpt) IsValid() bool

IsValid determines if a sort option is valid

type SubDetail Uses

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"`
}

SubDetail is for verbose information for subscriptions.

type SubjectPermission Uses

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 Uses

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

A Sublist stores and efficiently retrieves subscriptions.

func NewSublist Uses

func NewSublist(enableCache bool) *Sublist

NewSublist will create a default sublist with caching enabled per the flag.

func NewSublistNoCache Uses

func NewSublistNoCache() *Sublist

NewSublistNoCache will create a default sublist with caching disabled.

func NewSublistWithCache Uses

func NewSublistWithCache() *Sublist

NewSublistWithCache will create a default sublist with caching enabled.

func (*Sublist) All Uses

func (s *Sublist) All(subs *[]*subscription)

All is used to collect all subscriptions.

func (*Sublist) CacheCount Uses

func (s *Sublist) CacheCount() int

CacheCount returns the number of result sets in the cache.

func (*Sublist) CacheEnabled Uses

func (s *Sublist) CacheEnabled() bool

CacheEnabled returns whether or not caching is enabled for this sublist.

func (*Sublist) Count Uses

func (s *Sublist) Count() uint32

Count returns the number of subscriptions.

func (*Sublist) Insert Uses

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

Insert adds a subscription into the sublist

func (*Sublist) Match Uses

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 Uses

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

Remove will remove a subscription.

func (*Sublist) RemoveAllForClient Uses

func (s *Sublist) RemoveAllForClient(c *client)

RemoveAllForClient will remove all subscriptions for a given client.

func (*Sublist) RemoveBatch Uses

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

RemoveBatch will remove a list of subscriptions.

func (*Sublist) Stats Uses

func (s *Sublist) Stats() *SublistStats

Stats will return a stats structure for the current state.

func (*Sublist) UpdateRemoteQSub Uses

func (s *Sublist) UpdateRemoteQSub(sub *subscription)

UpdateRemoteQSub should be called when we update the weight of an existing remote queue sub.

type SublistResult Uses

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

SublistResult is a result structure better optimized for queue subs.

type SublistStats Uses

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"`
}

SublistStats are public stats for the sublist

type Subsz Uses

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 Uses

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 Uses

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

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

type URLAccResolver Uses

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

URLAccResolver implements an http fetcher.

func NewURLAccResolver Uses

func NewURLAccResolver(url string) (*URLAccResolver, error)

NewURLAccResolver returns a new resolver for the given base URL.

func (*URLAccResolver) Fetch Uses

func (ur *URLAccResolver) Fetch(name string) (string, error)

Fetch will fetch the account jwt claims from the base url, appending the account name onto the end.

func (*URLAccResolver) Store Uses

func (ur *URLAccResolver) Store(name, jwt string) error

Store is not implemented for URL Resolver.

type User Uses

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

User is for multiple accounts/users.

type Varz Uses

type Varz struct {
    ID                string            `json:"server_id"`
    Name              string            `json:"server_name"`
    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"`
    IP                string            `json:"ip,omitempty"`
    ClientConnectURLs []string          `json:"connect_urls,omitempty"`
    MaxConn           int               `json:"max_connections"`
    MaxSubs           int               `json:"max_subscriptions,omitempty"`
    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    int32             `json:"max_control_line"`
    MaxPayload        int               `json:"max_payload"`
    MaxPending        int64             `json:"max_pending"`
    Cluster           ClusterOptsVarz   `json:"cluster,omitempty"`
    Gateway           GatewayOptsVarz   `json:"gateway,omitempty"`
    LeafNode          LeafNodeOptsVarz  `json:"leaf,omitempty"`
    TLSTimeout        float64           `json:"tls_timeout"`
    WriteDeadline     time.Duration     `json:"write_deadline"`
    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"`
    Leafs             int               `json:"leafnodes"`
    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"`
    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 Uses

type VarzOptions struct{}

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

Directories

PathSynopsis
pse

Package server imports 39 packages (graph) and is imported by 136 packages. Updated 2019-11-17. Refresh now. Tools for package owners.