func startPopulatingRoutes() {
job := publisher.Job{
PublishingEndpoint: *natsEndpoint,
BackendHost: *backendHost,
BackendPort: *backendPort,
AppDomain: *appDomain,
AppName: *appName,
StartRange: 0,
EndRange: *numRoutes,
}
numCPU := runtime.NumCPU()
// Heuristic to avoid spawning more goroutines than needed
if *numRoutes < 1000 {
numCPU = 1
}
interval := time.Duration(*heartbeatInterval) * time.Second
r := runner.NewRunner(createNATSConnection, job, numCPU, interval)
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
// Stop the runner if we receive an interrupt
go func() {
sig := <-sigs
fmt.Fprintf(os.Stderr, "Received signal %s\n", sig)
r.Stop()
}()
err := r.Start()
if err != nil {
fmt.Fprintf(os.Stderr, "Error starting runner: %s\n", err)
}
err = r.Wait()
if err != nil {
fmt.Fprintf(os.Stderr, "Error running: %s\n", err)
}
}
It("publishes once as soon as the runner is started", func(done Done) {
defer close(done)
var allMessages string
msgLock := &sync.Mutex{}
c := &fakes.FakePublishingConnection{}
c.PublishStub = func(subj string, data []byte) error {
msgLock.Lock()
allMessages = allMessages + string(data)
msgLock.Unlock()
return nil
}
createConnection := func(endpoint string) (publisher.PublishingConnection, error) {
return c, nil
}
r := runner.NewRunner(createConnection, validJob, numGoRoutines, 10*time.Second)
err := r.Start()
Expect(err).ToNot(HaveOccurred())
r.Stop()
err = r.Wait()
Expect(err).ToNot(HaveOccurred())
Expect(c.PublishCallCount()).To(Equal(5))
for i := validJob.StartRange; i < validJob.EndRange; i += 1 {
Expect(allMessages).To(ContainSubstring("some-app-%d.apps.com", i))
}
}, 1)
It("publishes on an interval", func(done Done) {
defer close(done)
c := &fakes.FakePublishingConnection{}
createConnection := func(endpoint string) (publisher.PublishingConnection, error) {
return c, nil