func main() {
// Put os.Exit in a deferred statement so that other defers get executed prior to
// the os.Exit call.
exitCode := 0
defer func() {
os.Exit(exitCode)
}()
// Metron is intended to be light-weight so we occupy only one core
runtime.GOMAXPROCS(1)
flag.Parse()
config, err := config.ParseConfig(*configFilePath)
if err != nil {
panic(err)
}
log := logger.NewLogger(*debug, *logFilePath, "metron", config.Syslog)
log.Info("Startup: Setting up the Metron agent")
profiler := profiler.New(*cpuprofile, *memprofile, 1*time.Second, log)
profiler.Profile()
defer profiler.Stop()
dopplerClientPool, err := initializeDopplerPool(config, log)
if err != nil {
log.Errorf("Failed to initialize the doppler pool: %s", err.Error())
os.Exit(-1)
}
dopplerForwarder := dopplerforwarder.New(dopplerClientPool, []byte(config.SharedSecret), uint(config.BufferSize), config.EnableBuffer, log)
messageTagger := tagger.New(config.Deployment, config.Job, config.Index, dopplerForwarder)
aggregator := messageaggregator.New(messageTagger, log)
statsStopChan := make(chan struct{})
initializeMetrics(messageTagger, config, statsStopChan, log)
dropsondeUnmarshaller := eventunmarshaller.New(aggregator, log)
metronAddress := fmt.Sprintf("127.0.0.1:%d", config.DropsondeIncomingMessagesPort)
dropsondeReader, err := networkreader.New(metronAddress, "dropsondeAgentListener", dropsondeUnmarshaller, log)
if err != nil {
log.Errorf("Failed to listen on %s: %s", metronAddress, err)
exitCode = 1
return
}
log.Info("metron started")
go dopplerForwarder.Run()
go dropsondeReader.Start()
dumpChan := signalmanager.RegisterGoRoutineDumpSignalChannel()
killChan := signalmanager.RegisterKillSignalChannel()
for {
select {
case <-dumpChan:
signalmanager.DumpGoRoutine()
case <-killChan:
log.Info("Shutting down")
dopplerForwarder.Stop()
close(statsStopChan)
return
}
}
}
func main() {
seed := time.Now().UnixNano()
rand.Seed(seed)
// Put os.Exit in a deferred statement so that other defers get executed prior to
// the os.Exit call.
exitCode := 0
defer func() {
os.Exit(exitCode)
}()
flag.Parse()
runtime.GOMAXPROCS(runtime.NumCPU())
localIp, err := localip.LocalIP()
if err != nil {
panic(errors.New("Unable to resolve own IP address: " + err.Error()))
}
conf, err := config.ParseConfig(*configFile)
if err != nil {
panic(err)
}
log := logger.NewLogger(*logLevel, *logFilePath, "doppler", conf.Syslog)
log.Info("Startup: Setting up the doppler server")
profiler := profiler.New(*cpuprofile, *memprofile, 1*time.Second, log)
profiler.Profile()
defer profiler.Stop()
dropsonde.Initialize(conf.MetronAddress, DOPPLER_ORIGIN)
storeAdapter := NewStoreAdapter(conf.EtcdUrls, conf.EtcdMaxConcurrentRequests)
doppler, err := New(log, localIp, conf, storeAdapter, conf.MessageDrainBufferSize, DOPPLER_ORIGIN, time.Duration(conf.WebsocketWriteTimeoutSeconds)*time.Second, time.Duration(conf.SinkDialTimeoutSeconds)*time.Second)
if err != nil {
log.Errorf("Failed to create doppler: %s", err.Error())
exitCode = -1
return
}
go doppler.Start()
log.Info("Startup: doppler server started.")
killChan := signalmanager.RegisterKillSignalChannel()
dumpChan := signalmanager.RegisterGoRoutineDumpSignalChannel()
releaseNodeChan := dopplerservice.Announce(localIp, config.HeartbeatInterval, conf, storeAdapter, log)
legacyReleaseNodeChan := dopplerservice.AnnounceLegacy(localIp, config.HeartbeatInterval, conf, storeAdapter, log)
for {
select {
case <-dumpChan:
signalmanager.DumpGoRoutine()
case <-killChan:
log.Info("Shutting down")
stopped := make(chan bool)
legacyStopped := make(chan bool)
releaseNodeChan <- stopped
legacyReleaseNodeChan <- legacyStopped
doppler.Stop()
<-stopped
<-legacyStopped
return
}
}
}
var memProfilePath string
var logger = loggertesthelper.Logger()
BeforeEach(func() {
tmpDir, err := ioutil.TempDir("/tmp", "tc-test")
if err != nil {
Fail(err.Error())
}
cpuProfilePath = tmpDir + "/cpu.pprof"
memProfilePath = tmpDir + "/mem.pprof"
})
Describe("cpu profiling", func() {
It("profiles cpu usage", func() {
profiler := profiler.New(cpuProfilePath, "", 1*time.Millisecond, logger)
profiler.Profile()
profiler.Stop()
f, err := os.Open(cpuProfilePath)
Expect(err).NotTo(HaveOccurred())
_, err = parser.NewCpuProfParser(f)
Expect(err).NotTo(HaveOccurred())
memProfile := profiler.GetMemProfileHandle()
Expect(memProfile).To(BeNil())
})
It("panics when there is an error", func() {
func main() {
// Put os.Exit in a deferred statement so that other defers get executed prior to
// the os.Exit call.
exitCode := 0
defer func() {
os.Exit(exitCode)
}()
flag.Parse()
config, err := config.ParseConfig(*logLevel, *configFile, *logFilePath)
if err != nil {
panic(err)
}
log := logger.NewLogger(*logLevel, *logFilePath, "loggregator trafficcontroller", config.Syslog)
log.Info("Startup: Setting up the loggregator traffic controller")
dropsonde.Initialize("127.0.0.1:"+strconv.Itoa(config.MetronPort), "LoggregatorTrafficController")
profiler := profiler.New(*cpuprofile, *memprofile, 1*time.Second, log)
profiler.Profile()
defer profiler.Stop()
uptimeMonitor := monitor.NewUptimeMonitor(time.Duration(config.MonitorIntervalSeconds) * time.Second)
go uptimeMonitor.Start()
defer uptimeMonitor.Stop()
etcdAdapter := DefaultStoreAdapterProvider(config.EtcdUrls, config.EtcdMaxConcurrentRequests)
err = etcdAdapter.Connect()
if err != nil {
log.Errorf("Cannot connect to ETCD: %s", err.Error())
exitCode = -1
return
}
ipAddress, err := localip.LocalIP()
if err != nil {
panic(err)
}
logAuthorizer := authorization.NewLogAccessAuthorizer(*disableAccessControl, config.ApiHost, config.SkipCertVerify)
uaaClient := uaa_client.NewUaaClient(config.UaaHost, config.UaaClientId, config.UaaClientSecret, config.SkipCertVerify)
adminAuthorizer := authorization.NewAdminAccessAuthorizer(*disableAccessControl, &uaaClient)
preferredServers := func(string) bool { return false }
finder := dopplerservice.NewLegacyFinder(etcdAdapter, int(config.DopplerPort), preferredServers, nil, log)
finder.Start()
dopplerCgc := channel_group_connector.NewChannelGroupConnector(finder, newDropsondeWebsocketListener, marshaller.DropsondeLogMessage, log)
dopplerProxy := dopplerproxy.NewDopplerProxy(logAuthorizer, adminAuthorizer, dopplerCgc, dopplerproxy.TranslateFromDropsondePath, "doppler."+config.SystemDomain, log)
startOutgoingProxy(net.JoinHostPort(ipAddress, strconv.FormatUint(uint64(config.OutgoingDropsondePort), 10)), dopplerProxy)
legacyCgc := channel_group_connector.NewChannelGroupConnector(finder, newLegacyWebsocketListener, marshaller.LoggregatorLogMessage, log)
legacyProxy := dopplerproxy.NewDopplerProxy(logAuthorizer, adminAuthorizer, legacyCgc, dopplerproxy.TranslateFromLegacyPath, "loggregator."+config.SystemDomain, log)
startOutgoingProxy(net.JoinHostPort(ipAddress, strconv.FormatUint(uint64(config.OutgoingPort), 10)), legacyProxy)
killChan := signalmanager.RegisterKillSignalChannel()
dumpChan := signalmanager.RegisterGoRoutineDumpSignalChannel()
for {
select {
case <-dumpChan:
signalmanager.DumpGoRoutine()
case <-killChan:
log.Info("Shutting down")
return
}
}
}