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 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 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) }
func (sinkServer *sinkServer) registerDrainUrls(appId string, drainUrls []string) { if len(drainUrls) == 0 { for _, sink := range sinkServer.drainUrlsForApps[appId] { sinkServer.activeSinksChans.Delete(sink.Channel()) close(sink.Channel()) } delete(sinkServer.drainUrlsForApps, appId) return } if sinkServer.drainUrlsForApps[appId] == nil { sinkServer.drainUrlsForApps[appId] = make(map[string]sinks.Sink, len(drainUrls)) } for _, sink := range sinkServer.drainUrlsForApps[appId] { if contains(sink.Identifier(), drainUrls) { continue } sinkServer.activeSinksChans.Delete(sink.Channel()) close(sink.Channel()) delete(sinkServer.drainUrlsForApps[appId], sink.Identifier()) } for _, drainUrl := range drainUrls { if sinkServer.drainUrlsForApps[appId][drainUrl] == nil { s, err := sinks.NewSyslogSink(appId, drainUrl, sinkServer.logger) if err != nil { sinkServer.logger.Error(err.Error()) continue } go s.Run(sinkServer.sinkCloseChan) sinkServer.activeSinksChans.Register(s.Channel(), appId) sinkServer.drainUrlsForApps[appId][drainUrl] = s } } }
func TestDrainsFor(t *testing.T) { groupedSinks := NewGroupedSinks() target := "789" otherTarget := "790" sink1 := sinks.NewDumpSink(target, 10, loggertesthelper.Logger(), make(chan sinks.Sink, 1), time.Second) sink2 := sinks.NewSyslogSink(target, "url", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message)) sink3 := sinks.NewSyslogSink(otherTarget, "url", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message)) groupedSinks.Register(sink1) groupedSinks.Register(sink2) groupedSinks.Register(sink3) appSinks := groupedSinks.DrainsFor(target) assert.Equal(t, len(appSinks), 1) assert.Equal(t, appSinks[0], sink2) }
func TestDrainsFor(t *testing.T) { groupedSinks := NewGroupedSinks() target := "789" otherTarget := "790" sink1 := sinks.NewDumpSink(target, 10, loggertesthelper.Logger()) sink2 := sinks.NewSyslogSink(target, "url", loggertesthelper.Logger(), syslogWriter) sink3 := sinks.NewSyslogSink(otherTarget, "url", loggertesthelper.Logger(), syslogWriter) groupedSinks.Register(sink1) groupedSinks.Register(sink2) groupedSinks.Register(sink3) appSinks := groupedSinks.DrainsFor(target) assert.Equal(t, len(appSinks), 1) assert.Equal(t, appSinks[0], sink2) }
func TestRegisterReturnsFalseForEmptyIdentifier(t *testing.T) { groupedSinks := NewGroupedSinks() appId := "appId" appSink := sinks.NewSyslogSink(appId, "", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message)) result := groupedSinks.Register(appSink) assert.False(t, result) }
func TestRegisterReturnsFalseForEmptyIdentifier(t *testing.T) { groupedSinks := NewGroupedSinks() appId := "appId" appSink := sinks.NewSyslogSink(appId, "", loggertesthelper.Logger(), syslogWriter) result := groupedSinks.Register(appSink) assert.False(t, result) }
func TestRegisterReturnsFalseWhenAttemptingToAddADuplicateSink(t *testing.T) { groupedSinks := NewGroupedSinks() appId := "789" appSink := sinks.NewSyslogSink(appId, "url", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message)) groupedSinks.Register(appSink) result := groupedSinks.Register(appSink) assert.False(t, result) }
func TestDumpForReturnsNilIfThereIsNone(t *testing.T) { groupedSinks := NewGroupedSinks() target := "789" sink1 := sinks.NewSyslogSink(target, "url1", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message)) groupedSinks.Register(sink1) appSink := groupedSinks.DumpFor(target) assert.Nil(t, appSink) }
func TestRegisterAndFor(t *testing.T) { groupedSinks := NewGroupedSinks() appId := "789" appSink := sinks.NewSyslogSink(appId, "url", loggertesthelper.Logger(), DummySyslogWriter{}, make(chan<- *logmessage.Message)) result := groupedSinks.Register(appSink) appSinks := groupedSinks.For(appId) assert.True(t, result) assert.Equal(t, len(appSinks), 1) assert.Equal(t, appSinks[0], appSink) }
func (messageRouter *messageRouter) manageDrains(activeSinks *groupedsinks.GroupedSinks, appId string, drainUrls []string, sourceName string) { if sourceName != "App" { return } //delete all drains for app if len(drainUrls) == 0 { for _, sink := range activeSinks.DrainsFor(appId) { messageRouter.unregisterSink(sink, activeSinks) } return } //delete all drains that were not sent for _, sink := range activeSinks.DrainsFor(appId) { if contains(sink.Identifier(), drainUrls) { continue } messageRouter.unregisterSink(sink, activeSinks) } //add all drains that didn't exist for _, drainUrl := range drainUrls { if activeSinks.DrainFor(appId, drainUrl) == nil && !messageRouter.urlIsBlackListed(drainUrl) { dl, err := url.Parse(drainUrl) if err != nil { messageRouter.blacklistedURLS = append(messageRouter.blacklistedURLS, drainUrl) errorMessage := fmt.Sprintf("MessageRouter: Error when trying to parse syslog url %v. Requesting close. Err: %v", drainUrl, err) messageRouter.sendLoggregatorErrorMessage(errorMessage, appId) continue } ipNotBlacklisted, err := iprange.IpOutsideOfRanges(*dl, messageRouter.blackListIPs) if err != nil { messageRouter.blacklistedURLS = append(messageRouter.blacklistedURLS, drainUrl) errorMessage := fmt.Sprintf("MessageRouter: Error when trying to check syslog url %v against blacklist ip ranges. Requesting close. Err: %v", drainUrl, err) messageRouter.sendLoggregatorErrorMessage(errorMessage, appId) continue } if ipNotBlacklisted { sysLogger := sinks.NewSyslogWriter(dl.Scheme, dl.Host, appId, messageRouter.skipCertVerify) s := sinks.NewSyslogSink(appId, drainUrl, messageRouter.logger, sysLogger, messageRouter.errorChannel) ok := messageRouter.registerSink(s, activeSinks) if ok { go s.Run() } } else { messageRouter.blacklistedURLS = append(messageRouter.blacklistedURLS, drainUrl) errorMsg := fmt.Sprintf("MessageRouter: Syslog drain url is blacklisted: %s", drainUrl) messageRouter.sendLoggregatorErrorMessage(errorMsg, appId) } } } }
func (sinkManager *SinkManager) registerNewSyslogSinks(appId string, syslogSinkUrls []string) { for _, syslogSinkUrl := range syslogSinkUrls { if sinkManager.sinks.DrainFor(appId, syslogSinkUrl) == nil && !sinkManager.urlBlacklistManager.IsBlacklisted(syslogSinkUrl) { parsedSyslogDrainUrl, err := sinkManager.urlBlacklistManager.CheckUrl(syslogSinkUrl) if err != nil { sinkManager.urlBlacklistManager.BlacklistUrl(syslogSinkUrl) errorMsg := fmt.Sprintf("SinkManager: Invalid syslog drain URL: %s. Err: %v", syslogSinkUrl, err) sinkManager.sendSyslogErrorToLoggregator(errorMsg, appId) } else { syslogWriter := syslogwriter.NewSyslogWriter(parsedSyslogDrainUrl.Scheme, parsedSyslogDrainUrl.Host, appId, sinkManager.skipCertVerify) syslogSink := sinks.NewSyslogSink(appId, syslogSinkUrl, sinkManager.logger, syslogWriter, sinkManager.errorChannel) if sinkManager.RegisterSink(syslogSink) { go syslogSink.Run() } } } } }
func (messageRouter *messageRouter) manageDrains(activeSinks *groupedsinks.GroupedSinks, appId string, drainUrls []string, sourceType logmessage.LogMessage_SourceType) { if sourceType != logmessage.LogMessage_WARDEN_CONTAINER { return } //delete all drains for app if len(drainUrls) == 0 { for _, sink := range activeSinks.DrainsFor(appId) { messageRouter.unregisterSink(sink, activeSinks) } return } //delete all drains that were not sent for _, sink := range activeSinks.DrainsFor(appId) { if contains(sink.Identifier(), drainUrls) { continue } messageRouter.unregisterSink(sink, activeSinks) } //add all drains that didn't exist for _, drainUrl := range drainUrls { if activeSinks.DrainFor(appId, drainUrl) == nil { dl, err := url.Parse(drainUrl) if err != nil { messageRouter.logger.Warnf("MessageRouter: Error when trying to parse syslog url %v. Requesting close. Err: %v", drainUrl, err) continue } sysLogger := sinks.NewSyslogWriter("tcp", dl.Host, appId) s := sinks.NewSyslogSink(appId, drainUrl, messageRouter.logger, sysLogger) ok := messageRouter.registerSink(s, activeSinks) if ok { go s.Run() } } } }
mutex.Lock() defer mutex.Unlock() close(sysLoggerDoneChan) } newSysLoggerDoneChan := func() { mutex.Lock() defer mutex.Unlock() sysLoggerDoneChan = make(chan bool) } BeforeEach(func() { newSysLoggerDoneChan() sysLogger = NewSyslogWriterRecorder() errorChannel = make(chan *logmessage.Message, 10) syslogSink = sinks.NewSyslogSink("appId", "syslog://localhost:24632", loggertesthelper.Logger(), sysLogger, errorChannel) }) AfterEach(func() { select { case <-sysLoggerDoneChan: default: closeSysLoggerDoneChan() } }) Context("when remote syslog server is down", func() { BeforeEach(func() { sysLogger.SetDown(true) go func() { syslogSink.Run()