gonatsd

type AuthConfig struct {
	Users           map[string]string `yaml:"users"`
	Timeout         string            `yaml:"timeout"`
	TimeoutDuration time.Duration
}

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

type BadRequest struct {
	Error *NATSError
}

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

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

type ClientCmd interface {
	// Process the command in context of the client dispatch loop.
	Process(Conn)
}

type CloseCmd struct {
}

type Config struct {
	BindAddress string        `yaml:"bind_address"`
	Ping        PingConfig    `yaml:"ping"`
	Profile     ProfileConfig `yaml:"pprof"`
	Varz        VarzConfig    `yaml:"varz"`
	Auth        AuthConfig    `yaml:"auth"`
	Log         LogConfig     `yaml:"logging"`
	Limits      LimitsConfig  `yaml:"limits"`
}

type Conn interface {
	// Serve a subscribed message on the dispatch loop.
	ServeMessage(*SubscribedMessage)

	// Serve a client request on the dispatch loop.
	ServeRequest(Request)

	// Serve a client command on the dispatch loop.
	ServeCommand(ClientCmd)

	// Read from the client.
	Read([]byte) (int, error)

	// Read a single NATS control line from the client.
	ReadControlLine() (string, error)

	// Write a response to the client.
	Write(*Response)

	// Send a command to the server.
	SendServerCmd(ServerCmd)

	// Start the connection handling.
	Start()

	// Close the connection.
	Close()

	// Returns true iff the connection is closing/closed.
	Closed() bool

	// Close the connection and send the error to the client.
	CloseWithError(*NATSError)

	// Return a map<SID, subscription>.
	Subscriptions() map[int]*Subscription

	// Server reference.
	Server() Server

	// Return the connection heartbeat helper.
	HeartbeatHelper() HeartbeatHelper

	// Returns the connection options.
	Options() *ConnOptions

	// Returns the client remote address.
	RemoteAddr() net.Addr
}

type ConnOptions struct {
	Verbose  bool
	Pedantic bool
}

type ConnectRequest struct {
	Verbose  *bool   `json:"verbose"`
	Pedantic *bool   `json:"pedantic"`
	User     *string `json:"user"`
	Password *string `json:"pass"`
}

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

type ErrorCmd struct {
	Error error
}

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

type HasSize interface {
	Size() int32
}

type HeartbeatHelper interface {
	Ticker() <-chan time.Time
	Ping()
	Pong()
	Stop()
}

type Info struct {
	ServerId     string `json:"server_id"`
	Host         string `json:"host"`
	Port         int    `json:"port"`
	Version      string `json:"version"`
	AuthRequired bool   `json:"auth_required"`
	SslRequired  bool   `json:"ssl_required"`
	MaxPayload   int    `json:"max_payload"`
}

type InfoRequest struct {
}

type LimitsConfig struct {
	Payload     int `yaml:"payload"`
	Pending     int `yaml:"pending"`
	ControlLine int `yaml:"control"`
	Connections int `yaml:"connections"`
}

type LogConfig struct {
	MinLevel string `yaml:"level"`
	Out      string `yaml:"file"`
}

type Logger interface {
	steno.Logger
}

type Matcher func(*trieNode, string) ([]*trieNode, []*trieNode)

type Message struct {
	Subject string
	ReplyTo string
	Content []byte
}

type NATSError struct {
	Message string
	Close   bool
}

type PingConfig struct {
	Interval         string `yaml:"interval"`
	IntervalDuration time.Duration
	MaxOutstanding   int `yaml:"max_outstanding"`
}

type PingRequest struct {
}

type PongRequest struct {
}

type ProfileConfig struct {
	BindAddress string `yaml:"bind_address"`
}

type PublishCmd struct {
	Message *Message
}

type PublishRequest struct {
	Message *Message
}

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

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

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

type Request interface {

	// Serves the request by returning an optional payload to the client.
	Serve(Conn) *Response

	// Dispatches the request to the proper processing channel(s).
	Dispatch(Conn)
}

type Response struct {
	Value *string
	Bytes *[]byte
}

type Server interface {
	Start()
	DeliverMessage(subscription *Subscription, message *Message)
	Commands() chan<- ServerCmd
	Subscriptions() *Trie
	Info() *[]byte
	Stats() *Stats
	Config() *Config
}

type ServerCmd interface {
	Process(Server)
}

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

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

type SubscribeCmd struct {
	Subscription *Subscription
	Done         chan bool
}

type SubscribedMessage struct {
	Subscription *Subscription
	Message      *Message
	Last         bool
}

type Subscription struct {
	Id           int
	Subject      string
	Queue        *string
	Conn         Conn
	MaxResponses int
	Responses    uint64
}

type SubscriptionRequest struct {
	Subscription *Subscription
	Done         chan bool
}

type TCPConn interface {
	net.Conn
	CloseRead() error
}

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

type UnregisterConnCmd struct {
	Conn Conn
	Done chan bool
}

type UnsubscribeCmd struct {
	Subscription *Subscription
	MaxResponses int
	Unsubscribed chan bool
}

type UnsubscriptionRequest struct {
	SubscriptionId int
	MaxResponses   int
}

type VarzConfig struct {
	BindAddress string            `yaml:"bind_address"`
	Users       map[string]string `yaml:"users"`
}