Esempio n. 1
0
func TestLoggregator(t *testing.T) {

	RegisterFailHandler(Fail)

	etcdPort := 5500 + (config.GinkgoConfig.ParallelNode-1)*10
	etcdRunner := etcdstorerunner.NewETCDClusterRunner(etcdPort, 1)
	etcdRunner.Start()

	etcdUrl := fmt.Sprintf("http://localhost:%d", etcdPort)
	loggregatorConfig := &loggregator.Config{
		EtcdUrls:                  []string{etcdUrl},
		EtcdMaxConcurrentRequests: 10,

		Index:                  0,
		IncomingPort:           3456,
		OutgoingPort:           8083,
		LogFilePath:            "",
		MaxRetainedLogMessages: 100,
		WSMessageBufferSize:    100,
		SharedSecret:           "secret",
		SkipCertVerify:         true,
		BlackListIps:           []iprange.IPRange{},
	}
	cfcomponent.Logger = loggertesthelper.Logger()

	l := loggregator.New("127.0.0.1", loggregatorConfig, loggertesthelper.Logger())
	go l.Start()

	RunSpecs(t, "Loggregator Suite")

	l.Stop()
	etcdRunner.Stop()
}
func TestDrainForReturnsOnly(t *testing.T) {
	groupedSinks := NewGroupedSinks()
	target := "789"

	sink1 := sinks.NewSyslogSink(target, "other sink", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message))
	sink2 := sinks.NewSyslogSink(target, "sink we are searching for", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message))

	groupedSinks.Register(sink1)
	groupedSinks.Register(sink2)

	sinkDrain := groupedSinks.DrainFor(target, "sink we are searching for")
	assert.Equal(t, sink2, sinkDrain)
}
func TestDumpForReturnsOnlyDumpsForTheGivenAppId(t *testing.T) {
	groupedSinks := NewGroupedSinks()
	target := "789"
	otherTarget := "790"

	sink1 := sinks.NewDumpSink(target, 5, loggertesthelper.Logger(), make(chan sinks.Sink, 1), time.Second)
	sink2 := sinks.NewDumpSink(otherTarget, 5, loggertesthelper.Logger(), make(chan sinks.Sink, 1), time.Second)

	groupedSinks.Register(sink1)
	groupedSinks.Register(sink2)

	appSink := groupedSinks.DumpFor(target)
	assert.Equal(t, appSink, sink1)
}
Esempio n. 4
0
func TestOutgoingProxyConfigWithEmptyAZ(t *testing.T) {
	config := &Config{
		Loggregators: map[string][]string{
			"z1": []string{"10.244.0.14"},
			"z2": []string{},
		},
	}

	assert.NotPanics(t, func() {
		makeOutgoingProxy("0.0.0.0", config, loggertesthelper.Logger())
	})

	hashers := makeHashers(config.Loggregators, 3456, loggertesthelper.Logger())
	assert.Equal(t, len(hashers), 1)
}
func TestDumpForReturnsOnyDumps(t *testing.T) {
	groupedSinks := NewGroupedSinks()
	target := "789"

	sink1 := sinks.NewSyslogSink(target, "url1", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message))
	sink2 := sinks.NewSyslogSink(target, "url2", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message))
	sink3 := sinks.NewDumpSink(target, 5, loggertesthelper.Logger(), make(chan sinks.Sink, 1), time.Second)

	groupedSinks.Register(sink1)
	groupedSinks.Register(sink2)
	groupedSinks.Register(sink3)

	appSink := groupedSinks.DumpFor(target)
	assert.Equal(t, appSink, sink3)
}
func TestDumpForReturnsOnyDumps(t *testing.T) {
	groupedSinks := NewGroupedSinks()
	target := "789"

	sink1 := sinks.NewSyslogSink(target, "url1", loggertesthelper.Logger(), syslogWriter)
	sink2 := sinks.NewSyslogSink(target, "url2", loggertesthelper.Logger(), syslogWriter)
	sink3 := sinks.NewDumpSink(target, 5, loggertesthelper.Logger())

	groupedSinks.Register(sink1)
	groupedSinks.Register(sink2)
	groupedSinks.Register(sink3)

	appSink := groupedSinks.DumpFor(target)
	assert.Equal(t, appSink, sink3)
}
func TestThatItDoesNotCreateAnotherSyslogDrainIfItIsAlreadyThere(t *testing.T) {
	logger := loggertesthelper.Logger()
	sinkManager := NewSinkManager(1024, false, nil, logger)
	oldActiveSyslogSinksCounter := sinkManager.Metrics.SyslogSinks
	go sinkManager.Start()

	incomingLogChan := make(chan []byte, 10)
	testMessageRouter := NewMessageRouter(incomingLogChan, testhelpers.UnmarshallerMaker("secret"), sinkManager, 2048, logger)

	go testMessageRouter.Start()
	ourSink := testSink{make(chan *logmessage.Message, 100), false}
	sinkManager.sinkOpenChan <- ourSink
	<-time.After(1 * time.Millisecond)

	message := messagetesthelpers.NewMessage(t, "error msg", "appId")
	message.GetLogMessage().DrainUrls = []string{"http://10.10.123.1"}
	testMessageRouter.outgoingLogChan <- message
	waitForMessageGettingProcessed(t, ourSink, 10*time.Millisecond)

	assert.Equal(t, sinkManager.Metrics.SyslogSinks, oldActiveSyslogSinksCounter+1)

	testMessageRouter.outgoingLogChan <- message
	waitForMessageGettingProcessed(t, ourSink, 10*time.Millisecond)

	assert.Equal(t, sinkManager.Metrics.SyslogSinks, oldActiveSyslogSinksCounter+1)
}
Esempio n. 8
0
func TestDumpWithLotsOfMessagesAndLargeBuffer(t *testing.T) {
	dump := NewDumpSink("myApp", 200, loggertesthelper.Logger(), make(chan Sink, 1), time.Second)

	go dump.Run()

	for i := 0; i < 1000; i++ {
		logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId")
		dump.Channel() <- logMessage
	}

	runtime.Gosched()

	logMessages := dump.Dump()
	assert.Equal(t, len(logMessages), 200)
	assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "800")
	assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "801")

	for i := 1000; i < 2000; i++ {
		logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId")
		dump.Channel() <- logMessage
	}

	runtime.Gosched()

	logMessages = dump.Dump()
	assert.Equal(t, len(logMessages), 200)
	assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "1800")
	assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "1801")

	logMessages = dump.Dump()
	assert.Equal(t, len(logMessages), 200)
	assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "1800")
	assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "1801")
}
Esempio n. 9
0
func TestThatARemovedTaskWillBeRemoved(t *testing.T) {
	writeToFile(t, `{"instances": [{"state": "RUNNING", "instance_index": 123}]}`, true)
	agent := &agent{filePath(), loggertesthelper.Logger()}

	tasksChan := agent.watchInstancesJsonFileForChanges()

	inst, ok := <-tasksChan
	assert.True(t, ok, "Channel is closed")
	assert.NotNil(t, inst)

	os.Remove(filePath())

	select {
	case inst = <-tasksChan:
		t.Errorf("We just got an old task: %v", inst)
	case <-time.After(2 * time.Millisecond):
		// OK
	}

	writeToFile(t, `{"instances": [{"state": "RUNNING", "instance_index": 1234}]}`, true)

	inst, ok = <-tasksChan
	assert.True(t, ok, "Channel is closed")

	expectedInst := task{index: 1234, sourceName: "App"}
	assert.Equal(t, expectedInst, inst)
}
func TestProxyingWithHashingBetweenServers(t *testing.T) {
	go Server("localhost:62024", "Hello World from the server 1", 1)
	go Server("localhost:62025", "Hello World from the server 2", 1)

	proxy := NewProxy(
		"localhost:62026",
		[]*hasher.Hasher{hasher.NewHasher([]string{"localhost:62024", "localhost:62025"})},
		testhelpers.SuccessfulAuthorizer,
		loggertesthelper.Logger(),
	)
	go proxy.Start()
	WaitForServerStart("62024", "/")

	receivedChan := Client(t, "62026", "/?app=0")

	select {
	case data := <-receivedChan:
		assert.Equal(t, string(data), "Hello World from the server 1")
	case <-time.After(1 * time.Second):
		t.Error("Did not receive response within one second")
	}

	receivedChan = Client(t, "62026", "/?app=1")

	select {
	case data := <-receivedChan:
		assert.Equal(t, string(data), "Hello World from the server 2")
	case <-time.After(1 * time.Second):
		t.Error("Did not receive response within one second")
	}
}
func TestProxyWithoutAuthorization(t *testing.T) {
	proxy := NewProxy(
		"localhost:62061",
		[]*hasher.Hasher{
			hasher.NewHasher([]string{"localhost:62032"}),
		},
		testhelpers.SuccessfulAuthorizer,
		loggertesthelper.Logger(),
	)
	go proxy.Start()
	time.Sleep(time.Millisecond * 50)

	config, err := websocket.NewConfig("ws://localhost:62061/?app=myApp", "http://localhost")
	assert.NoError(t, err)
	receivedChan := ClientWithAuth(t, "62061", "/?app=myApp", config)

	select {
	case data := <-receivedChan:
		messagetesthelpers.AssertProtoBufferMessageEquals(t, "Error: Authorization not provided", data)
	case <-time.After(1 * time.Second):
		t.Error("Did not receive response within one second")
	}

	_, stillOpen := <-receivedChan
	assert.False(t, stillOpen)
}
Esempio n. 12
0
func TestThatWeListenToStdErrUnixSocket(t *testing.T) {
	tmpdir, err := ioutil.TempDir("", "testing")
	assert.NoError(t, err)
	defer os.RemoveAll(tmpdir)

	instance := &instance{
		applicationId:       "1234",
		wardenJobId:         56,
		wardenContainerPath: tmpdir,
		index:               4,
		drainUrls:           []string{"syslog://10.20.30.40:8050"}}
	os.MkdirAll(instance.identifier(), 0777)

	stdoutSocketPath := filepath.Join(instance.identifier(), "stdout.sock")
	stderrSocketPath := filepath.Join(instance.identifier(), "stderr.sock")
	os.Remove(stdoutSocketPath)
	os.Remove(stderrSocketPath)
	stdoutListener, err := net.Listen("unix", stdoutSocketPath)
	defer stdoutListener.Close()
	assert.NoError(t, err)
	stderrListener, err := net.Listen("unix", stderrSocketPath)
	defer stderrListener.Close()
	assert.NoError(t, err)

	expectedMessage := "Some Output\n"
	secondLogMessage := "toally different\n"

	mockLoggregatorEmitter := new(MockLoggregatorEmitter)

	mockLoggregatorEmitter.received = make(chan *logmessage.LogMessage)
	instance.startListening(mockLoggregatorEmitter, loggertesthelper.Logger())

	connection, err := stderrListener.Accept()
	defer connection.Close()
	assert.NoError(t, err)

	_, err = connection.Write([]byte(expectedMessage))
	assert.NoError(t, err)

	receivedMessage := <-mockLoggregatorEmitter.received

	assert.Equal(t, "1234", receivedMessage.GetAppId())
	assert.Equal(t, logmessage.LogMessage_WARDEN_CONTAINER, receivedMessage.GetSourceType())
	assert.Equal(t, logmessage.LogMessage_ERR, receivedMessage.GetMessageType())
	assert.Equal(t, expectedMessage, string(receivedMessage.GetMessage()))
	assert.Equal(t, []string{"syslog://10.20.30.40:8050"}, receivedMessage.GetDrainUrls())
	assert.Equal(t, "4", receivedMessage.GetSourceId())

	_, err = connection.Write([]byte(secondLogMessage))
	assert.NoError(t, err)

	receivedMessage = <-mockLoggregatorEmitter.received

	assert.Equal(t, "1234", receivedMessage.GetAppId())
	assert.Equal(t, logmessage.LogMessage_WARDEN_CONTAINER, receivedMessage.GetSourceType())
	assert.Equal(t, logmessage.LogMessage_ERR, receivedMessage.GetMessageType())
	assert.Equal(t, secondLogMessage, string(receivedMessage.GetMessage()))
	assert.Equal(t, []string{"syslog://10.20.30.40:8050"}, receivedMessage.GetDrainUrls())
	assert.Equal(t, "4", receivedMessage.GetSourceId())
}
Esempio n. 13
0
func TestSysLoggerComesUpLate(t *testing.T) {
	sysLogger := NewSyslogWriterRecorder()
	sysLogger.SetUp(false)
	sink := NewSyslogSink("appId", "url_not_used", loggertesthelper.Logger(), sysLogger)

	done := make(chan bool)
	go func() {
		sink.Run()
		done <- true
	}()

	for i := 0; i < 15; i++ {
		msg := fmt.Sprintf("message no %v", i)
		logMessage := messagetesthelpers.NewMessage(t, msg, "appId")

		sink.Channel() <- logMessage
	}
	close(sink.Channel())

	sysLogger.SetUp(true)
	<-done

	data := sysLogger.ReceivedMessages()
	assert.Equal(t, len(data), 10)

	for i := 0; i < 10; i++ {
		msg := fmt.Sprintf("out: message no %v", i+5)
		assert.Equal(t, data[i], msg)
	}
}
func TestDelete(t *testing.T) {
	groupedSinks := NewGroupedSinks()
	target := "789"

	sink1 := sinks.NewSyslogSink(target, "url1", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message))
	sink2 := sinks.NewSyslogSink(target, "url2", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message))

	groupedSinks.Register(sink1)
	groupedSinks.Register(sink2)

	groupedSinks.Delete(sink1)

	appSinks := groupedSinks.For(target)
	assert.Equal(t, len(appSinks), 1)
	assert.Equal(t, appSinks[0], sink2)
}
Esempio n. 15
0
func TestDumpReturnsAllRecentMessagesToMultipleDumpRequests(t *testing.T) {
	testDump := dump.NewDumpSink("myApp", 2, loggertesthelper.Logger(), time.Second)

	dumpRunnerDone := make(chan struct{})
	inputChan := make(chan *logmessage.Message)

	go func() {
		testDump.Run(inputChan)
		close(dumpRunnerDone)
	}()

	logMessage := messagetesthelpers.NewMessage(t, "1", "appId")
	inputChan <- logMessage
	logMessage = messagetesthelpers.NewMessage(t, "2", "appId")
	inputChan <- logMessage
	logMessage = messagetesthelpers.NewMessage(t, "3", "appId")
	inputChan <- logMessage

	close(inputChan)
	<-dumpRunnerDone

	logMessages := testDump.Dump()
	assert.Equal(t, len(logMessages), 2)
	assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "2")
	assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "3")

	logMessages = testDump.Dump()
	assert.Equal(t, len(logMessages), 2)
	assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "2")
	assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "3")
}
func TestProxyingWithMultipleAZs(t *testing.T) {
	go Server("localhost:62027", "Hello World from the server 1 - AZ1", 1)
	go Server("localhost:62028", "Hello World from the server 2 - AZ1", 1)
	go Server("localhost:62029", "Hello World from the server 1 - AZ2", 1)
	go Server("localhost:62030", "Hello World from the server 2 - AZ2", 1)

	proxy := NewProxy(
		"localhost:62031",
		[]*hasher.Hasher{
			hasher.NewHasher([]string{"localhost:62027", "localhost:62028"}),
			hasher.NewHasher([]string{"localhost:62029", "localhost:62030"}),
		},
		testhelpers.SuccessfulAuthorizer,
		loggertesthelper.Logger(),
	)
	go proxy.Start()
	WaitForServerStart("62027", "/")

	receivedChan := Client(t, "62031", "/?app=0")
	messages := ""
	for message := range receivedChan {
		messages = messages + string(message)
	}
	assert.Contains(t, messages, "Hello World from the server 1 - AZ1")
	assert.Contains(t, messages, "Hello World from the server 1 - AZ2")

	receivedChan = Client(t, "62031", "/?app=1")
	messages = ""
	for message := range receivedChan {
		messages = messages + string(message)
	}
	assert.Contains(t, messages, "Hello World from the server 2 - AZ1")
	assert.Contains(t, messages, "Hello World from the server 2 - AZ2")
}
func TestKeepAliveWithMultipleAZs(t *testing.T) {
	keepAliveChan1 := make(chan []byte)
	keepAliveChan2 := make(chan []byte)
	go KeepAliveServer("localhost:62032", keepAliveChan1)
	go KeepAliveServer("localhost:62033", keepAliveChan2)

	proxy := NewProxy(
		"localhost:62034",
		[]*hasher.Hasher{
			hasher.NewHasher([]string{"localhost:62032"}),
			hasher.NewHasher([]string{"localhost:62033"}),
		},
		testhelpers.SuccessfulAuthorizer,
		loggertesthelper.Logger(),
	)
	go proxy.Start()
	WaitForServerStart("62032", "/")

	KeepAliveClient(t, "62034", "/?app=myServerApp1")

	select {
	case data := <-keepAliveChan1:
		assert.Equal(t, string(data), "keep alive")
	case <-time.After(1 * time.Second):
		t.Error("Did not receive response within one second")
	}
	select {
	case data := <-keepAliveChan2:
		assert.Equal(t, string(data), "keep alive")
	case <-time.After(1 * time.Second):
		t.Error("Did not receive response within one second")
	}
}
Esempio n. 18
0
func TestDumpWithLotsOfMessages(t *testing.T) {
	dump := NewDumpSink("myApp", 2, loggertesthelper.Logger())

	for i := 0; i < 100; i++ {
		logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId")
		dump.Channel() <- logMessage
	}

	runtime.Gosched()

	logMessages := dumpAllMessages(dump)
	assert.Equal(t, len(logMessages), 2)
	assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "98")
	assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "99")

	for i := 100; i < 200; i++ {
		logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId")
		dump.Channel() <- logMessage
	}

	runtime.Gosched()

	logMessages = dumpAllMessages(dump)
	assert.Equal(t, len(logMessages), 2)
	assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "198")
	assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "199")

	logMessages = dumpAllMessages(dump)
	assert.Equal(t, len(logMessages), 2)
	assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "198")
	assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "199")
}
func TestProxyWhenAuthorizationFailsThroughQueryParams(t *testing.T) {
	proxy := NewProxy(
		"localhost:62062",
		[]*hasher.Hasher{
			hasher.NewHasher([]string{"localhost:62032"}),
		},
		testhelpers.SuccessfulAuthorizer,
		loggertesthelper.Logger(),
	)
	go proxy.Start()
	time.Sleep(time.Millisecond * 50)

	config, err := websocket.NewConfig("ws://localhost:62061/?app=myApp&authorization="+url.QueryEscape(testhelpers.INVALID_AUTHENTICATION_TOKEN), "http://localhost")
	assert.NoError(t, err)
	receivedChan := ClientWithAuth(t, "62062", "/?app=myApp", config)

	select {
	case data := <-receivedChan:
		messagetesthelpers.AssertProtoBufferMessageEquals(t, "Error: Invalid authorization", data)
	case <-time.After(1 * time.Second):
		t.Error("Did not receive response within one second")
	}

	_, stillOpen := <-receivedChan
	assert.False(t, stillOpen)
}
Esempio n. 20
0
func TestDumpWithLotsOfDumps(t *testing.T) {
	runtime.GOMAXPROCS(runtime.NumCPU())
	dump := NewDumpSink("myApp", 5, loggertesthelper.Logger(), time.Second, fakeTimeProvider)
	dumpRunnerDone := make(chan struct{})
	inputChan := make(chan *logmessage.Message)

	go func() {
		dump.Run(inputChan)
		close(dumpRunnerDone)
	}()

	for i := 0; i < 10; i++ {
		logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId")
		inputChan <- logMessage
	}

	close(inputChan)
	<-dumpRunnerDone

	for i := 0; i < 200; i++ {
		go func() {
			logMessages := dump.Dump()

			assert.Equal(t, len(logMessages), 5)
			assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "5")
			assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "6")
		}()
	}
}
Esempio n. 21
0
func TestThatWeListenToStdErrUnixSocket(t *testing.T) {
	task, tmpdir := setupTask(t, 4)
	defer os.RemoveAll(tmpdir)

	stdoutListener, stderrListener := setupSockets(t, task)
	defer stdoutListener.Close()
	defer stderrListener.Close()

	expectedMessage := "Some Output\n"
	secondLogMessage := "toally different\n"

	receiveChannel := setupEmitter(t, task, loggertesthelper.Logger())

	connection, err := stderrListener.Accept()
	defer connection.Close()
	assert.NoError(t, err)

	_, err = connection.Write([]byte(SOCKET_PREFIX + expectedMessage))
	assert.NoError(t, err)
	receivedMessage := <-receiveChannel
	assert.Equal(t, expectedMessage, string(receivedMessage.GetMessage()))

	_, err = connection.Write([]byte(secondLogMessage))
	assert.NoError(t, err)
	receivedMessage = <-receiveChannel
	assert.Equal(t, secondLogMessage, string(receivedMessage.GetMessage()))
}
Esempio n. 22
0
func xTestDumpSinkClosingTimeIsResetWhenAMessageArrives(t *testing.T) {
	dump := NewDumpSink("myApp", 5, loggertesthelper.Logger(), 10*time.Millisecond, fakeTimeProvider)

	dumpRunnerDone := make(chan struct{})
	inputChan := make(chan *logmessage.Message)

	go func() {
		dump.Run(inputChan)
		close(dumpRunnerDone)
	}()

	fakeTimeProvider.IncrementBySeconds(uint64(5))
	logMessage := messagetesthelpers.NewMessage(t, "0", "appId")
	inputChan <- logMessage
	fakeTimeProvider.IncrementBySeconds(uint64(8))

	fakeTimeProvider.IncrementBySeconds(uint64(3))

	select {
	case sink := <-dumpRunnerDone:
		assert.Equal(t, sink, dump)
	case <-time.After(5 * time.Millisecond):
		assert.Fail(t, "Should have closed")
	}
}
Esempio n. 23
0
func TestSendingToErrorChannelDoesNotBlock(t *testing.T) {
	testMessageRouter := NewMessageRouter(1024, false, nil, loggertesthelper.Logger())
	testMessageRouter.errorChannel = make(chan *logmessage.Message, 1)
	go testMessageRouter.Start()

	sinkChannel := make(chan *logmessage.Message, 10)
	ourSink := testSink{sinkChannel, false}

	testMessageRouter.sinkOpenChan <- ourSink
	<-time.After(1 * time.Millisecond)

	for i := 0; i < 10; i++ {
		badMessage := messagetesthelpers.NewMessage(t, "error msg", "appIdWeDontCareAbout")
		badMessage.GetLogMessage().DrainUrls = []string{fmt.Sprintf("<nil%d>", i)}
		testMessageRouter.parsedMessageChan <- badMessage
	}

	goodMessage := messagetesthelpers.NewMessage(t, "error msg", "appId")
	testMessageRouter.parsedMessageChan <- goodMessage

	select {
	case _ = <-ourSink.Channel():
	case <-time.After(1000 * time.Millisecond):
		t.Error("Should have received a message")
	}
}
Esempio n. 24
0
func TestDumpAlwaysReturnsTheNewestMessages(t *testing.T) {
	dump := NewDumpSink("myApp", 2, loggertesthelper.Logger(), time.Second, fakeTimeProvider)

	dumpRunnerDone := make(chan struct{})

	inputChan := make(chan *logmessage.Message)

	go func() {
		dump.Run(inputChan)
		close(dumpRunnerDone)
	}()

	logMessage := messagetesthelpers.NewMessage(t, "1", "appId")
	inputChan <- logMessage
	logMessage = messagetesthelpers.NewMessage(t, "2", "appId")
	inputChan <- logMessage
	logMessage = messagetesthelpers.NewMessage(t, "3", "appId")
	inputChan <- logMessage

	close(inputChan)
	<-dumpRunnerDone

	logMessages := dump.Dump()
	assert.Equal(t, len(logMessages), 2)
	assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "2")
	assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "3")

}
Esempio n. 25
0
func TestThatThereIsNoLeakingGoRoutine(t *testing.T) {
	logger := loggertesthelper.Logger()
	server := startHTTPServer()
	defer server.Close()

	authorizer := NewLogAccessAuthorizer(server.URL, true)
	authorizer("bearer something", "myAppId", logger)
	time.Sleep(10 * time.Millisecond)

	var buf bytes.Buffer
	goRoutineProfiles := pprof.Lookup("goroutine")
	goRoutineProfiles.WriteTo(&buf, 2)

	match, err := regexp.Match("readLoop", buf.Bytes())
	if err != nil {
		t.Error("Unable to match /readLoop/ regexp against goRoutineProfile")
		goRoutineProfiles.WriteTo(os.Stdout, 2)
	}

	if match {
		t.Error("We are leaking readLoop goroutines.")
	}

	match, err = regexp.Match("writeLoop", buf.Bytes())
	if err != nil {
		t.Error("Unable to match /writeLoop/ regexp against goRoutineProfile")
	}

	if match {
		t.Error("We are leaking writeLoop goroutines.")
		goRoutineProfiles.WriteTo(os.Stdout, 2)
	}
}
Esempio n. 26
0
func TestSysLoggerComesUpLate(t *testing.T) {
	sysLogger := NewSyslogWriterRecorder()
	sysLogger.SetUp(false)
	sink := NewSyslogSink("appId", "url_not_used", loggertesthelper.Logger(), sysLogger, make(chan *logmessage.Message, 10))

	done := make(chan bool)
	go func() {
		sink.Run()
		done <- true
	}()

	for i := 0; i < 105; i++ {
		msg := fmt.Sprintf("message no %v", i)
		logMessage := messagetesthelpers.NewMessage(t, msg, "appId")

		sink.Channel() <- logMessage
	}
	close(sink.Channel())

	sysLogger.SetUp(true)
	<-done

	data := sysLogger.ReceivedMessages()
	assert.Equal(t, len(data), 6)

	msg := "err: Log message output too high. We've dropped 100 messages"
	assert.Equal(t, data[0], msg)
	for i := 0; i < 5; i++ {
		msg := fmt.Sprintf("out: message no %v", i+100)
		assert.Equal(t, data[i+1], msg)
	}
}
Esempio n. 27
0
func TestDumpReturnsAllRecentMessagesToMultipleDumpRequestsWithMessagesCloningInInTheMeantime(t *testing.T) {
	dump := NewDumpSink("myApp", 2, loggertesthelper.Logger(), make(chan Sink, 1), time.Second)

	go dump.Run()

	logMessage := messagetesthelpers.NewMessage(t, "1", "appId")
	dump.Channel() <- logMessage
	logMessage = messagetesthelpers.NewMessage(t, "2", "appId")
	dump.Channel() <- logMessage
	logMessage = messagetesthelpers.NewMessage(t, "3", "appId")
	dump.Channel() <- logMessage

	runtime.Gosched()

	logMessages := dump.Dump()
	assert.Equal(t, len(logMessages), 2)
	assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "2")
	assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "3")

	logMessage = messagetesthelpers.NewMessage(t, "4", "appId")
	dump.Channel() <- logMessage

	runtime.Gosched()

	logMessages = dump.Dump()
	assert.Equal(t, len(logMessages), 2)
	assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "3")
	assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "4")
}
Esempio n. 28
0
func TestSinkReportsErrorsOnTheErrorChannel(t *testing.T) {
	sysLogger := NewSyslogWriterRecorder()
	sysLogger.SetUp(false)

	errorChannel := make(chan *logmessage.Message, 10)
	sink := NewSyslogSink("appId", "url_not_used", loggertesthelper.Logger(), sysLogger, errorChannel)

	done := make(chan bool)
	go func() {
		sink.Run()
		done <- true
	}()

	msg := fmt.Sprintf("first message")
	logMessage := messagetesthelpers.NewMessage(t, msg, "appId")
	sink.Channel() <- logMessage

	select {
	case errorLog := <-errorChannel:
		errorMsg := string(errorLog.GetLogMessage().GetMessage())
		assert.Contains(t, errorMsg, "Syslog Sink url_not_used: Error when dialing out. Backing off for")
		assert.Contains(t, errorMsg, "Err: Error connecting.")
		assert.Equal(t, errorLog.GetLogMessage().GetSourceName(), "LGR")
	case <-time.After(10 * time.Millisecond):
		t.Error("Should have received an error message by now")
	}
}
Esempio n. 29
0
func init() {
	dataReadChannel = make(chan []byte)

	logger := loggertesthelper.Logger()

	sinkManager = NewSinkManager(1024, false, nil, logger)
	go sinkManager.Start()

	TestMessageRouter = NewMessageRouter(dataReadChannel, testhelpers.UnmarshallerMaker(SECRET), sinkManager, 2048, logger)
	go TestMessageRouter.Start()

	apiEndpoint := "localhost:" + SERVER_PORT
	TestWebsocketServer = NewWebsocketServer(apiEndpoint, sinkManager, 10*time.Millisecond, 100, loggertesthelper.Logger())
	go TestWebsocketServer.Start()

	blackListDataReadChannel = make(chan []byte)
	blacklistSinkManager := NewSinkManager(1024, false, []iprange.IPRange{iprange.IPRange{Start: "127.0.0.0", End: "127.0.0.2"}}, logger)
	go blacklistSinkManager.Start()

	blacklistTestMessageRouter := NewMessageRouter(blackListDataReadChannel, testhelpers.UnmarshallerMaker(SECRET), blacklistSinkManager, 2048, logger)
	go blacklistTestMessageRouter.Start()

	blacklistApiEndpoint := "localhost:" + BLACKLIST_SERVER_PORT
	blackListTestWebsocketServer = NewWebsocketServer(blacklistApiEndpoint, blacklistSinkManager, 10*time.Millisecond, 100, loggertesthelper.Logger())
	go blackListTestWebsocketServer.Start()

	time.Sleep(2 * time.Millisecond)
}
Esempio n. 30
0
func TestTLSConnectionRejectsSelfSignedCertsByDefault(t *testing.T) {
	startTLSSyslogServer(loggertesthelper.Logger())

	w := NewSyslogWriter("syslog-tls", "localhost:9999", "appId", false)
	err := w.Connect()
	assert.Error(t, err)
}