func init() {
// This needs be unbuffered as the channel we get from the
// agent listener is unbuffered?
dataReadChannel = make(chan []byte, 10)
TestSinkServer = NewSinkServer(messagestore.NewMessageStore(10), testhelpers.Logger(), testhelpers.SuccessfulAuthorizer, 50*time.Millisecond)
go TestSinkServer.Start(dataReadChannel, "localhost:"+SERVER_PORT)
time.Sleep(1 * time.Millisecond)
}
func TestEndtoEndMessage(t *testing.T) {
logger := gosteno.NewLogger("TestLogger")
listener := agentlistener.NewAgentListener("localhost:3456", logger)
dataChannel := listener.Start()
sinkServer := sinkserver.NewSinkServer(messagestore.NewMessageStore(10), logger, testhelpers.SuccessfulAuthorizer, 30*time.Second)
go sinkServer.Start(dataChannel, "localhost:8081")
time.Sleep(1 * time.Millisecond)
receivedChan := make(chan []byte)
ws, _, _ := testhelpers.AddWSSink(t, receivedChan, "8081", "/tail/?app=myApp", testhelpers.VALID_SPACE_AUTHENTICATION_TOKEN)
defer ws.Close()
time.Sleep(50 * time.Millisecond)
connection, err := net.Dial("udp", "localhost:3456")
expectedMessageString := "Some Data"
expectedMessage := testhelpers.MarshalledLogMessage(t, expectedMessageString, "myApp")
_, err = connection.Write(expectedMessage)
assert.NoError(t, err)
testhelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, <-receivedChan)
}
func main() {
flag.Parse()
if *version {
fmt.Printf("\n\nversion: %s\ngitSha: %s\n\n", versionNumber, gitSha)
return
}
runtime.GOMAXPROCS(runtime.NumCPU())
logger := cfcomponent.NewLogger(*logLevel, *logFilePath, "loggregator")
config := &Config{SourcePort: 3456, WebPort: 8080, UaaVerificationKeyFile: *uaaVerificationKeyFile}
err := cfcomponent.ReadConfigInto(config, *configFile)
if err != nil {
panic(err)
}
err = config.validate(logger)
if err != nil {
panic(err)
}
listener := agentlistener.NewAgentListener(fmt.Sprintf("0.0.0.0:%d", config.SourcePort), logger)
incomingData := listener.Start()
authorizer := authorization.NewLogAccessAuthorizer(config.decoder, config.ApiHost)
sinkServer := sinkserver.NewSinkServer(
messagestore.NewMessageStore(config.MaxRetainedLogMessages),
logger,
authorizer,
30*time.Second,
)
cfc, err := cfcomponent.NewComponent(
config.WebPort,
"LoggregatorServer",
config.Index,
&LoggregatorServerHealthMonitor{},
config.VarzPort,
[]string{config.VarzUser, config.VarzPass},
[]instrumentation.Instrumentable{listener, sinkServer},
)
if err != nil {
panic(err)
}
rr := routerregistrar.NewRouterRegistrar(config.MbusClient, logger)
uri := servernamer.ServerName(
net.JoinHostPort(cfc.IpAddress, strconv.Itoa(int(config.SourcePort))),
"loggregator."+config.SystemDomain)
err = rr.RegisterWithRouter(cfc.IpAddress, config.WebPort, []string{uri})
if err != nil {
logger.Fatalf("Did not get response from router when greeting. Using default keep-alive for now. Err: %v.", err)
}
cr := collectorregistrar.NewCollectorRegistrar(config.MbusClient, logger)
err = cr.RegisterWithCollector(cfc)
if err != nil {
logger.Warnf("Unable to register with collector. Err: %v.", err)
}
go func() {
err := cfc.StartMonitoringEndpoints()
if err != nil {
panic(err)
}
}()
go sinkServer.Start(incomingData, fmt.Sprintf("0.0.0.0:%d", config.WebPort))
killChan := make(chan os.Signal)
signal.Notify(killChan, os.Kill)
for {
select {
case <-cfcomponent.RegisterGoRoutineDumpSignalChannel():
cfcomponent.DumpGoRoutine()
case <-killChan:
rr.UnregisterFromRouter(cfc.IpAddress, cfc.WebPort, []string{uri})
break
}
}
}