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
}
var _ = Describe("AgentListener", func() {
var (
listener listeners.Listener
dataChannel <-chan []byte
listenerStopped chan struct{}
address string
)
BeforeEach(func() {
listenerStopped = make(chan struct{})
loggertesthelper.TestLoggerSink.Clear()
port := 3456 + config.GinkgoConfig.ParallelNode
address = net.JoinHostPort("127.0.0.1", strconv.Itoa(port))
listener, dataChannel = listeners.NewUDPListener(address, loggertesthelper.Logger(), "udpListener")
go func() {
listener.Start()
close(listenerStopped)
}()
Eventually(loggertesthelper.TestLoggerSink.LogContents).Should(ContainSubstring("Listening on port " + address))
})
AfterEach(func() {
listener.Stop()
Eventually(listenerStopped).Should(BeClosed())
})
Context("with a listner running", func() {
It("listens to the socket and forwards log lines", func() {
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
}
