func TestSplitBufferSubOp(t *testing.T) {
s := &Server{sl: sublist.New()}
c := &client{srv: s, subs: hashmap.New()}
subop := []byte("SUB foo 1\r\n")
subop1 := subop[:6]
subop2 := subop[6:]
if err := c.parse(subop1); err != nil {
t.Fatalf("Unexpected parse error: %v\n", err)
}
if c.state != SUB_ARG {
t.Fatalf("Expected SUB_ARG state vs %d\n", c.state)
}
if err := c.parse(subop2); err != nil {
t.Fatalf("Unexpected parse error: %v\n", err)
}
if c.state != OP_START {
t.Fatalf("Expected OP_START state vs %d\n", c.state)
}
r := s.sl.Match([]byte("foo"))
if r == nil || len(r) != 1 {
t.Fatalf("Did not match subscription properly: %+v\n", r)
}
sub := r[0].(*subscription)
if !bytes.Equal(sub.subject, []byte("foo")) {
t.Fatalf("Subject did not match expected 'foo' : '%s'\n", sub.subject)
}
if !bytes.Equal(sub.sid, []byte("1")) {
t.Fatalf("Sid did not match expected '1' : '%s'\n", sub.sid)
}
if sub.queue != nil {
t.Fatalf("Received a non-nil queue: '%s'\n", sub.queue)
}
}
func TestSplitBufferUnsubOp(t *testing.T) {
s := &Server{sl: sublist.New()}
c := &client{srv: s, subs: hashmap.New()}
subop := []byte("SUB foo 1024\r\n")
if err := c.parse(subop); err != nil {
t.Fatalf("Unexpected parse error: %v\n", err)
}
if c.state != OP_START {
t.Fatalf("Expected OP_START state vs %d\n", c.state)
}
unsubop := []byte("UNSUB 1024\r\n")
unsubop1 := unsubop[:8]
unsubop2 := unsubop[8:]
if err := c.parse(unsubop1); err != nil {
t.Fatalf("Unexpected parse error: %v\n", err)
}
if c.state != UNSUB_ARG {
t.Fatalf("Expected UNSUB_ARG state vs %d\n", c.state)
}
if err := c.parse(unsubop2); err != nil {
t.Fatalf("Unexpected parse error: %v\n", err)
}
if c.state != OP_START {
t.Fatalf("Expected OP_START state vs %d\n", c.state)
}
r := s.sl.Match([]byte("foo"))
if r != nil && len(r) != 0 {
t.Fatalf("Should be no subscriptions in results: %+v\n", r)
}
}
// New will setup a new server struct after parsing the options.
func New(opts *Options) *Server {
processOptions(opts)
info := Info{
ID: genID(),
Version: VERSION,
Host: opts.Host,
Port: opts.Port,
AuthRequired: false,
SslRequired: false,
MaxPayload: MAX_PAYLOAD_SIZE,
}
// Check for Auth items
if opts.Username != "" || opts.Authorization != "" {
info.AuthRequired = true
}
s := &Server{
info: info,
sl: sublist.New(),
opts: opts,
debug: opts.Debug,
trace: opts.Trace,
done: make(chan bool, 1),
start: time.Now(),
}
s.mu.Lock()
defer s.mu.Unlock()
// Setup logging with flags
s.LogInit()
// For tracking clients
s.clients = make(map[uint64]*client)
// For tracking routes and their remote ids
s.routes = make(map[uint64]*client)
s.remotes = make(map[string]*client)
// Used to kick out all of the route
// connect Go routines.
s.rcQuit = make(chan bool)
// Generate the info json
b, err := json.Marshal(s.info)
if err != nil {
Fatalf("Error marshalling INFO JSON: %+v\n", err)
}
s.infoJSON = []byte(fmt.Sprintf("INFO %s %s", b, CR_LF))
s.handleSignals()
Logf("Starting gnatsd version %s", VERSION)
s.running = true
return s
}
func New(opts *Options) PubSub { // todo: this should return PubSub iface
ps := &pubsub{
opts: opts,
sublist: sublist.New(),
subs: make(map[Subscriber]*set.Set),
topics: make(map[string]*set.Set),
}
// set to random id if not set
if opts.PubSubNodeId == "" {
log.Println("pub sub node id not set, setting to uuid")
// todo: truncate this to say 16 chars?
opts.PubSubNodeId = uuid.NewRandom().String()
}
log.Println("pub sub node id:", opts.PubSubNodeId)
if opts.PubSubMode != PubSubModeNormal && opts.PubSubMode != PubSubModeFirehose {
log.Println("pub sub mode not set using normal mode")
opts.PubSubMode = PubSubModeNormal
}
// Ensure interface compliance
var _ PubSub = ps
return ps
}