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 }