func New(host string, config *config.Config, logger *gosteno.Logger, storeAdapter storeadapter.StoreAdapter, messageDrainBufferSize uint, dropsondeOrigin string, dialTimeout time.Duration) *Doppler {
cfcomponent.Logger = logger
keepAliveInterval := 30 * time.Second
appStoreCache := cache.NewAppServiceCache()
appStoreWatcher, newAppServiceChan, deletedAppServiceChan := store.NewAppServiceStoreWatcher(storeAdapter, appStoreCache)
var dropsondeUDPListener agentlistener.Listener
var dropsondeTLSListener agentlistener.Listener
var dropsondeBytesChan <-chan []byte
listenerEnvelopeChan := make(chan *events.Envelope)
if config.EnableTLSTransport {
tlsConfig := &tls.Config{
Certificates: []tls.Certificate{config.TLSListenerConfig.Cert},
InsecureSkipVerify: config.TLSListenerConfig.InsecureSkipVerify,
}
dropsondeTLSListener = tlslistener.New(fmt.Sprintf("%s:%d", host, config.TLSListenerConfig.Port), tlsConfig, listenerEnvelopeChan, logger)
}
dropsondeUDPListener, dropsondeBytesChan = agentlistener.NewAgentListener(fmt.Sprintf("%s:%d", host, config.DropsondeIncomingMessagesPort), logger, "dropsondeListener")
signatureVerifier := signature.NewVerifier(logger, config.SharedSecret)
unmarshallerCollection := dropsonde_unmarshaller.NewDropsondeUnmarshallerCollection(logger, config.UnmarshallerCount)
blacklist := blacklist.New(config.BlackListIps)
metricTTL := time.Duration(config.ContainerMetricTTLSeconds) * time.Second
sinkTimeout := time.Duration(config.SinkInactivityTimeoutSeconds) * time.Second
sinkIOTimeout := time.Duration(config.SinkIOTimeoutSeconds) * time.Second
sinkManager := sinkmanager.New(config.MaxRetainedLogMessages, config.SkipCertVerify, blacklist, logger, messageDrainBufferSize, dropsondeOrigin, sinkTimeout, sinkIOTimeout, metricTTL, dialTimeout)
return &Doppler{
Logger: logger,
dropsondeUDPListener: dropsondeUDPListener,
dropsondeTLSListener: dropsondeTLSListener,
sinkManager: sinkManager,
messageRouter: sinkserver.NewMessageRouter(sinkManager, logger),
websocketServer: websocketserver.New(fmt.Sprintf("%s:%d", host, config.OutgoingPort), sinkManager, keepAliveInterval, config.MessageDrainBufferSize, dropsondeOrigin, logger),
newAppServiceChan: newAppServiceChan,
deletedAppServiceChan: deletedAppServiceChan,
appStoreWatcher: appStoreWatcher,
storeAdapter: storeAdapter,
dropsondeBytesChan: dropsondeBytesChan,
dropsondeUnmarshallerCollection: unmarshallerCollection,
envelopeChan: listenerEnvelopeChan,
wrappedEnvelopeChan: make(chan *events.Envelope),
signatureVerifier: signatureVerifier,
dropsondeVerifiedBytesChan: make(chan []byte),
uptimeMonitor: monitor.NewUptimeMonitor(time.Duration(config.MonitorIntervalSeconds) * time.Second),
}
}
func New(host string, config *config.Config, logger *gosteno.Logger, storeAdapter storeadapter.StoreAdapter, dropsondeOrigin string) *Doppler {
cfcomponent.Logger = logger
keepAliveInterval := 30 * time.Second
appStoreCache := cache.NewAppServiceCache()
appStoreWatcher, newAppServiceChan, deletedAppServiceChan := store.NewAppServiceStoreWatcher(storeAdapter, appStoreCache)
dropsondeListener, dropsondeBytesChan := agentlistener.NewAgentListener(fmt.Sprintf("%s:%d", host, config.DropsondeIncomingMessagesPort), logger, "dropsondeListener")
signatureVerifier := signature.NewVerifier(logger, config.SharedSecret)
unmarshallerCollection := dropsonde_unmarshaller.NewDropsondeUnmarshallerCollection(logger, config.UnmarshallerCount)
blacklist := blacklist.New(config.BlackListIps)
metricTTL := time.Duration(config.ContainerMetricTTLSeconds) * time.Second
sinkTimeout := time.Duration(config.SinkInactivityTimeoutSeconds) * time.Second
sinkManager := sinkmanager.New(config.MaxRetainedLogMessages, config.SkipCertVerify, blacklist, logger, dropsondeOrigin, sinkTimeout, metricTTL)
return &Doppler{
Logger: logger,
dropsondeListener: dropsondeListener,
sinkManager: sinkManager,
messageRouter: sinkserver.NewMessageRouter(sinkManager, logger),
websocketServer: websocketserver.New(fmt.Sprintf("%s:%d", host, config.OutgoingPort), sinkManager, keepAliveInterval, config.WSMessageBufferSize, dropsondeOrigin, logger),
newAppServiceChan: newAppServiceChan,
deletedAppServiceChan: deletedAppServiceChan,
appStoreWatcher: appStoreWatcher,
storeAdapter: storeAdapter,
dropsondeBytesChan: dropsondeBytesChan,
dropsondeUnmarshallerCollection: unmarshallerCollection,
envelopeChan: make(chan *events.Envelope),
wrappedEnvelopeChan: make(chan *events.Envelope),
signatureVerifier: signatureVerifier,
dropsondeVerifiedBytesChan: make(chan []byte),
}
}
newAppServiceChan := make(chan appservice.AppService)
deletedAppServiceChan := make(chan appservice.AppService)
emptyBlacklist := blacklist.New(nil)
sinkManager = sinkmanager.New(1024, false, emptyBlacklist, logger, 100, "dropsonde-origin",
2*time.Second, 0, 1*time.Second, 500*time.Millisecond)
services.Add(1)
goRoutineSpawned.Add(1)
go func() {
goRoutineSpawned.Done()
defer services.Done()
sinkManager.Start(newAppServiceChan, deletedAppServiceChan)
}()
TestMessageRouter = sinkserver.NewMessageRouter(sinkManager, logger)
services.Add(1)
goRoutineSpawned.Add(1)
go func() {
goRoutineSpawned.Done()
defer services.Done()
TestMessageRouter.Start(dataReadChannel)
}()
apiEndpoint := "localhost:" + serverPort
TestWebsocketServer = websocketserver.New(apiEndpoint, sinkManager, 10*time.Second, 100, "dropsonde-origin", logger)
services.Add(1)
goRoutineSpawned.Add(1)
go func() {
func New(logger *gosteno.Logger,
host string,
config *config.Config,
storeAdapter storeadapter.StoreAdapter,
messageDrainBufferSize uint,
dropsondeOrigin string,
websocketWriteTimeout time.Duration,
dialTimeout time.Duration) (*Doppler, error) {
keepAliveInterval := 30 * time.Second
appStoreCache := cache.NewAppServiceCache()
appStoreWatcher, newAppServiceChan, deletedAppServiceChan := store.NewAppServiceStoreWatcher(storeAdapter, appStoreCache, logger)
var udpListener listeners.Listener
var tlsListener listeners.Listener
var dropsondeBytesChan <-chan []byte
var err error
listenerEnvelopeChan := make(chan *events.Envelope)
if config.EnableTLSTransport {
tlsListener, err = listeners.NewTLSListener("tlsListener", fmt.Sprintf("%s:%d", host, config.TLSListenerConfig.Port), config.TLSListenerConfig, listenerEnvelopeChan, logger)
if err != nil {
return nil, err
}
}
udpListener, dropsondeBytesChan = listeners.NewUDPListener(fmt.Sprintf("%s:%d", host, config.DropsondeIncomingMessagesPort), logger, "dropsondeListener")
signatureVerifier := signature.NewVerifier(logger, config.SharedSecret)
unmarshallerCollection := dropsonde_unmarshaller.NewDropsondeUnmarshallerCollection(logger, config.UnmarshallerCount)
blacklist := blacklist.New(config.BlackListIps)
metricTTL := time.Duration(config.ContainerMetricTTLSeconds) * time.Second
sinkTimeout := time.Duration(config.SinkInactivityTimeoutSeconds) * time.Second
sinkIOTimeout := time.Duration(config.SinkIOTimeoutSeconds) * time.Second
sinkManager := sinkmanager.New(config.MaxRetainedLogMessages, config.SinkSkipCertVerify, blacklist, logger, messageDrainBufferSize, dropsondeOrigin, sinkTimeout, sinkIOTimeout, metricTTL, dialTimeout)
websocketServer, err := websocketserver.New(fmt.Sprintf("%s:%d", host, config.OutgoingPort), sinkManager, websocketWriteTimeout, keepAliveInterval, config.MessageDrainBufferSize, dropsondeOrigin, logger)
if err != nil {
return nil, fmt.Errorf("Failed to create the websocket server: %s", err.Error())
}
return &Doppler{
Logger: logger,
udpListener: udpListener,
tlsListener: tlsListener,
sinkManager: sinkManager,
messageRouter: sinkserver.NewMessageRouter(sinkManager, logger),
websocketServer: websocketServer,
newAppServiceChan: newAppServiceChan,
deletedAppServiceChan: deletedAppServiceChan,
appStoreWatcher: appStoreWatcher,
storeAdapter: storeAdapter,
dropsondeBytesChan: dropsondeBytesChan,
dropsondeUnmarshallerCollection: unmarshallerCollection,
envelopeChan: listenerEnvelopeChan,
signatureVerifier: signatureVerifier,
dropsondeVerifiedBytesChan: make(chan []byte),
uptimeMonitor: monitor.NewUptimeMonitor(time.Duration(config.MonitorIntervalSeconds) * time.Second),
}, nil
}
func New(
logger *gosteno.Logger,
host string,
config *doppler_config.Config,
storeAdapter storeadapter.StoreAdapter,
messageDrainBufferSize uint,
dropsondeOrigin string,
websocketWriteTimeout time.Duration,
dialTimeout time.Duration,
) (*Doppler, error) {
doppler := &Doppler{
Logger: logger,
storeAdapter: storeAdapter,
dropsondeVerifiedBytesChan: make(chan []byte),
}
keepAliveInterval := 30 * time.Second
appStoreCache := cache.NewAppServiceCache()
doppler.appStoreWatcher, doppler.newAppServiceChan, doppler.deletedAppServiceChan = store.NewAppServiceStoreWatcher(storeAdapter, appStoreCache, logger)
doppler.batcher = initializeMetrics(config.MetricBatchIntervalMilliseconds)
doppler.envelopeChan = make(chan *events.Envelope)
doppler.udpListener, doppler.dropsondeBytesChan = listeners.NewUDPListener(
fmt.Sprintf("%s:%d", host, config.IncomingUDPPort),
doppler.batcher,
logger,
"udpListener",
)
var err error
if config.EnableTLSTransport {
tlsConfig := &config.TLSListenerConfig
addr := fmt.Sprintf("%s:%d", host, tlsConfig.Port)
contextName := "tlsListener"
doppler.tlsListener, err = listeners.NewTCPListener(contextName, addr, tlsConfig, doppler.envelopeChan, doppler.batcher, logger)
if err != nil {
return nil, err
}
}
addr := fmt.Sprintf("%s:%d", host, config.IncomingTCPPort)
contextName := "tcpListener"
doppler.tcpListener, err = listeners.NewTCPListener(contextName, addr, nil, doppler.envelopeChan, doppler.batcher, logger)
doppler.signatureVerifier = signature.NewVerifier(logger, config.SharedSecret)
doppler.dropsondeUnmarshallerCollection = dropsonde_unmarshaller.NewDropsondeUnmarshallerCollection(logger, config.UnmarshallerCount)
blacklist := blacklist.New(config.BlackListIps, logger)
metricTTL := time.Duration(config.ContainerMetricTTLSeconds) * time.Second
sinkTimeout := time.Duration(config.SinkInactivityTimeoutSeconds) * time.Second
sinkIOTimeout := time.Duration(config.SinkIOTimeoutSeconds) * time.Second
doppler.sinkManager = sinkmanager.New(
config.MaxRetainedLogMessages,
config.SinkSkipCertVerify,
blacklist,
logger,
messageDrainBufferSize,
dropsondeOrigin,
sinkTimeout,
sinkIOTimeout,
metricTTL,
dialTimeout,
)
doppler.Infof("Listening for GRPC connections on %d", config.GRPCPort)
grpcListener, err := net.Listen("tcp", fmt.Sprintf(":%d", config.GRPCPort))
if err != nil {
return nil, err
}
grpcServer := grpc.NewServer()
plumbing.RegisterDopplerServer(grpcServer, doppler.sinkManager)
go grpcServer.Serve(grpcListener)
doppler.messageRouter = sinkserver.NewMessageRouter(doppler.sinkManager, logger)
doppler.websocketServer, err = websocketserver.New(
fmt.Sprintf(":%d", config.OutgoingPort),
doppler.sinkManager,
websocketWriteTimeout,
keepAliveInterval,
config.MessageDrainBufferSize,
dropsondeOrigin,
doppler.batcher,
logger,
)
if err != nil {
return nil, fmt.Errorf("Failed to create the websocket server: %s", err.Error())
}
monitorInterval := time.Duration(config.MonitorIntervalSeconds) * time.Second
doppler.openFileMonitor = monitor.NewLinuxFD(monitorInterval, logger)
doppler.uptimeMonitor = monitor.NewUptime(monitorInterval)
return doppler, nil
}
}
func (f *fakeSinkManager) drains() [][]string {
f.RLock()
defer f.RUnlock()
return f.receivedDrains
}
var _ = Describe("Message Router", func() {
var fakeManager *fakeSinkManager
var messageRouter *sinkserver.MessageRouter
BeforeEach(func() {
fakeManager = &fakeSinkManager{receivedMessages: make([]*events.Envelope, 0), receivedDrains: make([][]string, 0)}
messageRouter = sinkserver.NewMessageRouter(fakeManager, loggertesthelper.Logger())
})
Describe("Start", func() {
Context("with an incoming message", func() {
var incomingLogChan chan *events.Envelope
BeforeEach(func() {
incomingLogChan = make(chan *events.Envelope)
go messageRouter.Start(incomingLogChan)
})
AfterEach(func() {
messageRouter.Stop()
})
It("sends the message to the sink manager if it is an app message", func() {