func testSimpleEvent(t *testing.T, factory clientFactory) {
enableLogging([]string{"*"})
mock := transptest.NewMockServerTCP(t, 1*time.Second, "", nil)
server, _ := v2.NewWithListener(mock.Listener)
defer server.Close()
transp, err := mock.Connect()
if err != nil {
t.Fatalf("Failed to connect: %v", err)
}
client := factory(transp)
defer transp.Close()
defer client.Stop()
event := common.MapStr{"type": "test", "name": "me", "line": 10}
go client.Publish([]common.MapStr{event})
// try to receive event from server
batch := server.Receive()
batch.ACK()
// validate
events := batch.Events
assert.Equal(t, 1, len(events))
msg := events[0].(map[string]interface{})
assert.Equal(t, "me", msg["name"])
assert.Equal(t, 10.0, msg["line"])
}
func testStructuredEvent(t *testing.T, factory clientFactory) {
enableLogging([]string{"*"})
mock := transptest.NewMockServerTCP(t, 1*time.Second, "", nil)
server, _ := v2.NewWithListener(mock.Listener)
defer server.Close()
transp, err := mock.Connect()
if err != nil {
t.Fatalf("Failed to connect: %v", err)
}
client := factory(transp)
defer transp.Close()
defer client.Stop()
event := common.MapStr{
"type": "test",
"name": "test",
"struct": common.MapStr{
"field1": 1,
"field2": true,
"field3": []int{1, 2, 3},
"field4": []interface{}{
1,
"test",
common.MapStr{
"sub": "field",
},
},
"field5": common.MapStr{
"sub1": 2,
},
},
}
go client.Publish([]common.MapStr{event})
defer client.Stop()
// try to receive event from server
batch := server.Receive()
batch.ACK()
events := batch.Events
assert.Equal(t, 1, len(events))
msg := events[0]
assert.Equal(t, "test", eventGet(msg, "name"))
assert.Equal(t, 1.0, eventGet(msg, "struct.field1"))
assert.Equal(t, true, eventGet(msg, "struct.field2"))
assert.Equal(t, 2.0, eventGet(msg, "struct.field5.sub1"))
}
func testMultiFailMaxTimeouts(t *testing.T, factory clientFactory) {
enableLogging([]string{"*"})
mock := transptest.NewMockServerTCP(t, 100*time.Millisecond, "", nil)
server, _ := v2.NewWithListener(mock.Listener)
defer server.Close()
transp, err := mock.Transp()
if err != nil {
t.Fatalf("Failed to connect: %v", err)
}
client := factory(transp)
defer transp.Close()
defer client.Stop()
N := 8
event := outputs.Data{Event: common.MapStr{"type": "test", "name": "me", "line": 10}}
for i := 0; i < N; i++ {
// reconnect client
client.Close()
client.Connect()
// publish event. With client returning on timeout, we have to send
// messages again
go client.Publish([]outputs.Data{event})
// read batch + never ACK in order to enforce timeout
server.Receive()
// wait for max connection timeout ensuring ACK receive fails
time.Sleep(100 * time.Millisecond)
}
client.Stop()
returns := client.Returns()
if len(returns) != N {
t.Fatalf("PublishEvents did not return")
}
for _, ret := range returns {
assert.Equal(t, 0, ret.n)
assert.NotNil(t, ret.err)
}
}
func testConnectionType(
t *testing.T,
mock *transptest.MockServer,
makeOutputer func() outputs.BulkOutputer,
) {
t.Log("testConnectionType")
server, _ := v2.NewWithListener(mock.Listener)
// worker loop
go func() {
t.Log("start worker loop")
defer t.Log("stop worker loop")
t.Log("make outputter")
output := makeOutputer()
t.Logf("new outputter: %v", output)
signal := op.NewSignalChannel()
t.Log("publish event")
output.PublishEvent(signal, testOptions, testEvent())
t.Log("wait signal")
assert.True(t, signal.Wait() == op.SignalCompleted)
server.Close()
}()
for batch := range server.ReceiveChan() {
batch.ACK()
events := batch.Events
assert.Equal(t, 1, len(events))
msg := events[0].(map[string]interface{})
assert.Equal(t, 10.0, msg["extra"])
assert.Equal(t, "message", msg["message"])
}
}
func newServer(l net.Listener, opts ...Option) (Server, error) {
cfg, err := applyOptions(opts)
if err != nil {
return nil, err
}
var servers []func(net.Listener) (Server, byte, error)
log.Printf("Server config: %#v", cfg)
if cfg.v1 {
servers = append(servers, func(l net.Listener) (Server, byte, error) {
s, err := v1.NewWithListener(l,
v1.Timeout(cfg.timeout),
v1.Channel(cfg.ch),
v1.TLS(cfg.tls))
return s, '1', err
})
}
if cfg.v2 {
servers = append(servers, func(l net.Listener) (Server, byte, error) {
s, err := v2.NewWithListener(l,
v2.Keepalive(cfg.keepalive),
v2.Timeout(cfg.timeout),
v2.Channel(cfg.ch),
v2.TLS(cfg.tls),
v2.JSONDecoder(cfg.decoder))
return s, '2', err
})
}
if len(servers) == 0 {
return nil, ErrNoVersionEnabled
}
if len(servers) == 1 {
s, _, err := servers[0](l)
return s, err
}
ownCH := false
if cfg.ch == nil {
ownCH = true
cfg.ch = make(chan *lj.Batch, 128)
}
mux := make([]muxServer, len(servers))
for i, mk := range servers {
muxL := newMuxListener(l)
log.Printf("mk: %v", i)
s, b, err := mk(muxL)
if err != nil {
return nil, err
}
mux[i] = muxServer{
mux: b,
l: muxL,
server: s,
}
}
s := &server{
ch: cfg.ch,
ownCH: ownCH,
netListener: l,
mux: mux,
done: make(chan struct{}),
}
s.wg.Add(1)
go s.run()
return s, nil
}