func main() {
seed := time.Now().UnixNano()
rand.Seed(seed)
flag.Parse()
runtime.GOMAXPROCS(runtime.NumCPU())
localIp, err := localip.LocalIP()
if err != nil {
panic(errors.New("Unable to resolve own IP address: " + err.Error()))
}
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
panic(err)
}
pprof.StartCPUProfile(f)
defer func() {
pprof.StopCPUProfile()
f.Close()
}()
}
if *memprofile != "" {
f, err := os.Create(*memprofile)
if err != nil {
panic(err)
}
go func() {
defer f.Close()
ticker := time.NewTicker(time.Second * 1)
defer ticker.Stop()
for {
<-ticker.C
pprof.WriteHeapProfile(f)
}
}()
}
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")
dropsonde.Initialize(conf.MetronAddress, DOPPLER_ORIGIN)
dopplerStoreAdapter := NewStoreAdapter(conf.EtcdUrls, conf.EtcdMaxConcurrentRequests)
legacyStoreAdapter := NewStoreAdapter(conf.EtcdUrls, conf.EtcdMaxConcurrentRequests)
doppler := New(localIp, conf, log, dopplerStoreAdapter, conf.MessageDrainBufferSize, DOPPLER_ORIGIN, time.Duration(conf.SinkDialTimeoutSeconds)*time.Second)
if err != nil {
panic(err)
}
go doppler.Start()
log.Info("Startup: doppler server started.")
killChan := make(chan os.Signal)
signal.Notify(killChan, os.Kill, os.Interrupt)
dumpChan := registerGoRoutineDumpSignalChannel()
releaseNodeChan := announcer.Announce(localIp, config.HeartbeatInterval, conf, dopplerStoreAdapter, log)
legacyReleaseNodeChan := announcer.AnnounceLegacy(localIp, config.HeartbeatInterval, conf, legacyStoreAdapter, log)
for {
select {
case <-dumpChan:
logger.DumpGoRoutine()
case <-killChan:
log.Info("Shutting down")
doppler.Stop()
close(releaseNodeChan)
close(legacyReleaseNodeChan)
return
}
}
}
func main() {
seed := time.Now().UnixNano()
rand.Seed(seed)
flag.Parse()
runtime.GOMAXPROCS(runtime.NumCPU())
localIp, err := localip.LocalIP()
if err != nil {
panic(fmt.Errorf("Unable to resolve own IP address: %s", err))
}
conf, err := config.ParseConfig(*configFile)
if err != nil {
panic(fmt.Errorf("Unable to parse config: %s", err))
}
log := logger.NewLogger(*logLevel, *logFilePath, "doppler", conf.Syslog)
go func() {
err := http.ListenAndServe(net.JoinHostPort(localIp, pprofPort), nil)
if err != nil {
log.Errorf("Error starting pprof server: %s", err.Error())
}
}()
log.Info("Startup: Setting up the doppler server")
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 {
panic(fmt.Errorf("Failed to create doppler: %s", err))
}
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
}
}
}
. "github.com/onsi/gomega"
)
var _ = Describe("Config", func() {
var (
configFile string
)
Context("with minimal config", func() {
BeforeEach(func() {
configFile = "./fixtures/minimal_doppler.json"
})
It("defaults to empty blacklist", func() {
config, _ := config.ParseConfig(configFile)
Expect(config.BlackListIps).To(BeNil())
})
It("returns proper config", func() {
config, err := config.ParseConfig(configFile)
Expect(err).ToNot(HaveOccurred())
Expect(config.DropsondeIncomingMessagesPort).To(Equal(uint32(3456)))
Expect(config.OutgoingPort).To(Equal(uint32(8080)))
Expect(config.MessageDrainBufferSize).To(Equal(uint(100)))
Expect(config.MonitorIntervalSeconds).To(BeEquivalentTo(60))
Expect(config.EnableTLSTransport).To(BeFalse())
})
})
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
}
}
}