func main() {
flag.Parse()
config, err := config.ParseConfig(*logLevel, *configFile)
if err != nil {
panic(fmt.Errorf("Unable to parse config: %s", err))
}
httpsetup.SetInsecureSkipVerify(config.SkipCertVerify)
ipAddress, err := localip.LocalIP()
if err != nil {
panic(fmt.Errorf("Unable to resolve own IP address: %s", err))
}
log := logger.NewLogger(*logLevel, *logFilePath, "loggregator trafficcontroller", config.Syslog)
log.Info("Startup: Setting up the loggregator traffic controller")
batcher, err := initializeMetrics("LoggregatorTrafficController", net.JoinHostPort(config.MetronHost, strconv.Itoa(config.MetronPort)))
if err != nil {
log.Errorf("Error initializing dropsonde: %s", err)
}
go func() {
err := http.ListenAndServe(net.JoinHostPort("localhost", pprofPort), nil)
if err != nil {
log.Errorf("Error starting pprof server: %s", err.Error())
}
}()
monitorInterval := time.Duration(config.MonitorIntervalSeconds) * time.Second
uptimeMonitor := monitor.NewUptime(monitorInterval)
go uptimeMonitor.Start()
defer uptimeMonitor.Stop()
openFileMonitor := monitor.NewLinuxFD(monitorInterval, log)
go openFileMonitor.Start()
defer openFileMonitor.Stop()
etcdAdapter := defaultStoreAdapterProvider(config)
err = etcdAdapter.Connect()
if err != nil {
panic(fmt.Errorf("Unable to connect to ETCD: %s", err))
}
logAuthorizer := authorization.NewLogAccessAuthorizer(*disableAccessControl, config.ApiHost)
uaaClient := uaa_client.NewUaaClient(config.UaaHost, config.UaaClient, config.UaaClientSecret)
adminAuthorizer := authorization.NewAdminAccessAuthorizer(*disableAccessControl, &uaaClient)
// TODO: The preferredProtocol of udp tells the finder to pull out the Doppler URLs from the legacy ETCD endpoint.
// Eventually we'll have a separate websocket client pool
finder := dopplerservice.NewFinder(etcdAdapter, int(config.DopplerPort), []string{"udp"}, "", log)
finder.Start()
// Draining the finder's events channel in order to not block the finder from handling etcd events.
go func() {
for {
finder.Next()
}
}()
var accessMiddleware, legacyAccessMiddleware func(middleware.HttpHandler) *middleware.AccessHandler
if config.SecurityEventLog != "" {
accessLog, err := os.OpenFile(config.SecurityEventLog, os.O_APPEND|os.O_WRONLY, os.ModeAppend)
if err != nil {
panic(fmt.Errorf("Unable to open access log: %s", err))
}
defer func() {
accessLog.Sync()
accessLog.Close()
}()
accessLogger := accesslogger.New(accessLog, log)
accessMiddleware = middleware.Access(accessLogger, ipAddress, config.OutgoingDropsondePort, log)
legacyAccessMiddleware = middleware.Access(accessLogger, ipAddress, config.OutgoingPort, log)
}
dopplerCgc := channel_group_connector.NewChannelGroupConnector(finder, newDropsondeWebsocketListener, marshaller.DropsondeLogMessage, batcher, log)
dopplerHandler := http.Handler(dopplerproxy.NewDopplerProxy(logAuthorizer, adminAuthorizer, dopplerCgc, dopplerproxy.TranslateFromDropsondePath, "doppler."+config.SystemDomain, log))
if accessMiddleware != nil {
dopplerHandler = accessMiddleware(dopplerHandler)
}
startOutgoingProxy(net.JoinHostPort(ipAddress, strconv.FormatUint(uint64(config.OutgoingDropsondePort), 10)), dopplerHandler)
legacyCgc := channel_group_connector.NewChannelGroupConnector(finder, newLegacyWebsocketListener, marshaller.LoggregatorLogMessage, batcher, log)
legacyHandler := http.Handler(dopplerproxy.NewDopplerProxy(logAuthorizer, adminAuthorizer, legacyCgc, dopplerproxy.TranslateFromLegacyPath, "loggregator."+config.SystemDomain, log))
if legacyAccessMiddleware != nil {
legacyHandler = legacyAccessMiddleware(legacyHandler)
}
startOutgoingProxy(net.JoinHostPort(ipAddress, strconv.FormatUint(uint64(config.OutgoingPort), 10)), legacyHandler)
killChan := signalmanager.RegisterKillSignalChannel()
dumpChan := signalmanager.RegisterGoRoutineDumpSignalChannel()
for {
select {
case <-dumpChan:
signalmanager.DumpGoRoutine()
case <-killChan:
log.Info("Shutting down")
return
}
}
}
var _ = Describe("DefaultClient", func() {
It("has a 20 second timeout", func() {
Expect(http.DefaultClient.Timeout).To(Equal(20 * time.Second))
})
Describe("DefaultClient.Transport", func() {
var transport *http.Transport
BeforeEach(func() {
var ok bool
transport, ok = http.DefaultClient.Transport.(*http.Transport)
Expect(ok).To(BeTrue(), "Expected http.DefaultClient.Transport to be a *http.Transport")
})
It("has a 10 second handshake timeout", func() {
Expect(transport.TLSHandshakeTimeout).To(Equal(10 * time.Second))
})
It("enables DisableKeepAlives", func() {
Expect(transport.DisableKeepAlives).To(BeTrue())
})
Describe("SetInsecureSkipVerify", func() {
It("sets InsecureSkipVerify on TLSClientConfig", func() {
httpsetup.SetInsecureSkipVerify(true)
Expect(transport.TLSClientConfig.InsecureSkipVerify).To(BeTrue())
})
})
})
})