func TestForwardFailOver(t *testing.T) {
log.Println("---- TestForwardFailOver ----")
counter := int64(0)
primaryAddr, primaryCloser := runMockServer(t, "", &counter)
close(primaryCloser) // shutdown primary server immediately
sleep(1)
primaryConfigServer := newConfigServer(primaryAddr)
secondaryAddr, secondaryCloser := runMockServer(t, "", &counter)
secondaryConfigServer := newConfigServer(secondaryAddr)
configServers := []*hydra.ConfigServer{
primaryConfigServer,
secondaryConfigServer,
}
c := hydra.NewContext()
outForward, err := hydra.NewOutForward(configServers)
if err != nil {
t.Error(err)
return
}
c.RunProcess(outForward)
sleep(1)
recordSet := prepareRecordSet()
c.MessageCh <- recordSet
sleep(1)
if n := atomic.LoadInt64(&counter); n != int64(len(TestMessageLines)) {
t.Error("insufficient recieved messages. sent", len(TestMessageLines), "recieved", n)
}
c.Shutdown()
close(secondaryCloser)
sleep(1)
}
func run(config *hydra.Config) {
messageCh, monitorCh := hydra.NewChannel()
if config.ReadBufferSize > 0 {
hydra.ReadBufferSize = config.ReadBufferSize
log.Println("[info] set ReadBufferSize", hydra.ReadBufferSize)
}
// start monitor server
monitor, err := hydra.NewMonitor(config, monitorCh)
if err != nil {
log.Println("[error] Couldn't start monitor server.", err)
} else {
go monitor.Run()
}
// start out_forward
outForward, err := hydra.NewOutForward(config.Servers, messageCh, monitorCh)
if err != nil {
log.Println("[error]", err)
} else {
outForward.RoundRobin = config.ServerRoundRobin
if outForward.RoundRobin {
log.Println("[info] ServerRoundRobin enabled")
}
go outForward.Run()
}
// start watcher && in_tail
if len(config.Logs) > 0 {
watcher, err := hydra.NewWatcher()
if err != nil {
log.Println("[error]", err)
}
for _, configLogfile := range config.Logs {
tail, err := hydra.NewInTail(configLogfile, watcher, messageCh, monitorCh)
if err != nil {
log.Println("[error]", err)
} else {
go tail.Run()
}
}
go watcher.Run()
}
// start in_forward
if config.Receiver != nil {
if runtime.GOMAXPROCS(0) < 2 {
log.Println("[warning] When using Receiver, recommend to set GOMAXPROCS >= 2.")
}
inForward, err := hydra.NewInForward(config.Receiver, messageCh, monitorCh)
if err != nil {
log.Println("[error]", err)
} else {
go inForward.Run()
}
}
}
func TestForwardReconnect(t *testing.T) {
log.Println("---- TestForwardReconnect ----")
counter := int64(0)
addr, mockCloser := runMockServer(t, "", &counter)
configServer := newConfigServer(addr)
c := hydra.NewContext()
outForward, err := hydra.NewOutForward([]*hydra.ConfigServer{configServer})
if err != nil {
t.Error(err)
}
c.RunProcess(outForward)
recordSet := prepareRecordSet()
c.MessageCh <- recordSet
sleep(1)
t.Log("notify shutdown mockServer")
close(mockCloser)
t.Log("waiting for shutdown complated 3 sec")
sleep(3)
t.Log("restarting mock server on same addr", addr)
_, mockCloser = runMockServer(t, addr, &counter)
sleep(1)
c.MessageCh <- recordSet // Afeter unexpected server closing, first Write() will be succeeded and lost...
sleep(1)
c.MessageCh <- recordSet
t.Log("waiting for reconnect & resend completed 5 sec")
sleep(3)
if n := atomic.LoadInt64(&counter); n != int64(len(TestMessageLines)*2) {
t.Error("insufficient recieved messages. sent", len(TestMessageLines)*2, "recieved", n)
}
close(mockCloser)
c.Shutdown()
sleep(1)
}
func TestForwardSingle(t *testing.T) {
log.Println("---- TestForwardSingle ----")
counter := int64(0)
addr, mockCloser := runMockServer(t, "", &counter)
configServer := newConfigServer(addr)
c := hydra.NewContext()
outForward, err := hydra.NewOutForward([]*hydra.ConfigServer{configServer})
if err != nil {
t.Error(err)
}
c.RunProcess(outForward)
recordSet := prepareRecordSet()
c.MessageCh <- recordSet
sleep(3)
if n := atomic.LoadInt64(&counter); n != int64(len(TestMessageLines)) {
t.Error("insufficient recieved messages. sent", len(TestMessageLines), "recieved", n)
}
c.Shutdown()
close(mockCloser)
sleep(1)
}