func initializeServer(
bbsClient bbs.Client,
executorClient executor.Client,
evacuatable evacuation_context.Evacuatable,
evacuationReporter evacuation_context.EvacuationReporter,
logger lager.Logger,
stackMap rep.StackPathMap,
supportedProviders []string,
) (ifrit.Runner, string) {
lrpStopper := initializeLRPStopper(*cellID, executorClient, logger)
auctionCellRep := auction_cell_rep.New(*cellID, stackMap, supportedProviders, *zone, generateGuid, executorClient, evacuationReporter, logger)
handlers := handlers.New(auctionCellRep, lrpStopper, executorClient, evacuatable, logger)
router, err := rata.NewRouter(rep.Routes, handlers)
if err != nil {
logger.Fatal("failed-to-construct-router", err)
}
ip, err := localip.LocalIP()
if err != nil {
logger.Fatal("failed-to-fetch-ip", err)
}
port := strings.Split(*listenAddr, ":")[1]
address := fmt.Sprintf("http://%s:%s", ip, port)
return http_server.New(*listenAddr, router), address
}
func initializeServerRegistration(logger lager.Logger) (registration natbeat.RegistryMessage) {
domains := strings.Split(*serverDomainNames, ",")
addressComponents := strings.Split(*serverAddress, ":")
if len(addressComponents) != 2 {
logger.Error("server-address-invalid", fmt.Errorf("%s is not a valid serverAddress", *serverAddress))
os.Exit(1)
}
host, err := localip.LocalIP()
if err != nil {
logger.Error("local-ip-invalid", err)
os.Exit(1)
}
port, err := strconv.Atoi(addressComponents[1])
if err != nil {
logger.Error("server-address-invalid", fmt.Errorf("%s does not have a valid port", *serverAddress))
os.Exit(1)
}
return natbeat.RegistryMessage{
URIs: domains,
Host: host,
Port: port,
}
}
func AddWSSink(receivedChan chan []byte, port string, path string) (*websocket.Conn, <-chan struct{}) {
connectionDroppedChannel := make(chan struct{}, 1)
var ws *websocket.Conn
ip, _ := localip.LocalIP()
fullURL := "ws://" + ip + ":" + port + path
Eventually(func() error {
var err error
ws, _, err = websocket.DefaultDialer.Dial(fullURL, http.Header{})
return err
}, 5, 1).ShouldNot(HaveOccurred(), fmt.Sprintf("Unable to connect to server at %s.", fullURL))
ws.SetPingHandler(func(message string) error {
ws.WriteControl(websocket.PongMessage, []byte(message), time.Time{})
return nil
})
go func() {
for {
_, data, err := ws.ReadMessage()
if err != nil {
close(connectionDroppedChannel)
close(receivedChan)
return
}
receivedChan <- data
}
}()
return ws, connectionDroppedChannel
}
func main() {
// 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(fmt.Errorf("Unable to parse config: %s", err))
}
localIp, err := localip.LocalIP()
if err != nil {
panic(fmt.Errorf("Unable to resolve own IP address: %s", err))
}
log := logger.NewLogger(*debug, *logFilePath, "metron", config.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 Metron agent")
marshaller, err := initializeDopplerPool(config, log)
if err != nil {
panic(fmt.Errorf("Could not initialize doppler connection pool: %s", err))
}
messageTagger := tagger.New(config.Deployment, config.Job, config.Index, marshaller)
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.IncomingUDPPort)
dropsondeReader, err := networkreader.New(metronAddress, "dropsondeAgentListener", dropsondeUnmarshaller, log)
if err != nil {
panic(fmt.Errorf("Failed to listen on %s: %s", metronAddress, err))
}
log.Info("metron started")
go dropsondeReader.Start()
dumpChan := signalmanager.RegisterGoRoutineDumpSignalChannel()
killChan := signalmanager.RegisterKillSignalChannel()
for {
select {
case <-dumpChan:
signalmanager.DumpGoRoutine()
case <-killChan:
log.Info("Shutting down")
close(statsStopChan)
return
}
}
}
func (d *DatadogFirehoseNozzle) createClient() {
ipAddress, err := localip.LocalIP()
if err != nil {
panic(err)
}
d.client = datadogclient.New(d.config.DataDogURL, d.config.DataDogAPIKey, d.config.MetricPrefix, d.config.Deployment, ipAddress)
}
func initiateFirehoseConnection() (*noaa.Consumer, chan *events.Envelope) {
localIP, _ := localip.LocalIP()
firehoseConnection := noaa.NewConsumer("ws://"+localIP+":49629", &tls.Config{InsecureSkipVerify: true}, nil)
msgChan := make(chan *events.Envelope, 2000)
errorChan := make(chan error)
go firehoseConnection.Firehose("uniqueId", "", msgChan, errorChan)
return firehoseConnection, msgChan
}
func main() {
flag.Parse()
config, logger, err := config.ParseConfig(logLevel, configFile, logFilePath)
if err != nil {
panic(err)
}
profiler := profiler.NewProfiler(*cpuprofile, *memprofile, 1*time.Second, logger)
profiler.Profile()
defer profiler.Stop()
uptimeMonitor := monitor.NewUptimeMonitor(time.Duration(config.MonitorIntervalSeconds) * time.Second)
go uptimeMonitor.Start()
defer uptimeMonitor.Stop()
dropsonde.Initialize("localhost:"+strconv.Itoa(config.MetronPort), "LoggregatorTrafficController")
adapter := DefaultStoreAdapterProvider(config.EtcdUrls, config.EtcdMaxConcurrentRequests)
adapter.Connect()
ipAddress, err := localip.LocalIP()
if err != nil {
panic(err)
}
dopplerProxy := makeDopplerProxy(adapter, config, logger)
startOutgoingDopplerProxy(net.JoinHostPort(ipAddress, strconv.FormatUint(uint64(config.OutgoingDropsondePort), 10)), dopplerProxy)
legacyProxy := makeLegacyProxy(adapter, config, logger)
startOutgoingProxy(net.JoinHostPort(ipAddress, strconv.FormatUint(uint64(config.OutgoingPort), 10)), legacyProxy)
rr := routerregistrar.NewRouterRegistrar(config.MbusClient, logger)
uri := "loggregator." + config.SystemDomain
err = rr.RegisterWithRouter(ipAddress, config.OutgoingPort, []string{uri})
if err != nil {
logger.Fatalf("Startup: Did not get response from router when greeting. Using default keep-alive for now. Err: %v.", err)
}
uri = "doppler." + config.SystemDomain
err = rr.RegisterWithRouter(ipAddress, config.OutgoingDropsondePort, []string{uri})
if err != nil {
logger.Fatalf("Startup: Did not get response from router when greeting. Using default keep-alive for now. Err: %v.", err)
}
killChan := make(chan os.Signal)
signal.Notify(killChan, os.Kill, os.Interrupt)
for {
select {
case <-cfcomponent.RegisterGoRoutineDumpSignalChannel():
cfcomponent.DumpGoRoutine()
case <-killChan:
rr.UnregisterFromRouter(ipAddress, config.OutgoingPort, []string{uri})
break
}
}
}
func (d *InfluxDbFirehoseNozzle) createClient() {
ipAddress, err := localip.LocalIP()
if err != nil {
panic(err)
}
d.client = influxdbclient.New(d.config.InfluxDbUrl, d.config.InfluxDbDatabase, d.config.InfluxDbUser,
d.config.InfluxDbPassword, d.config.MetricPrefix, d.config.Deployment, ipAddress)
}
func New(deploymentName string, job string, index uint, outputWriter writers.EnvelopeWriter) *Tagger {
ip, _ := localip.LocalIP()
return &Tagger{
deploymentName: deploymentName,
job: job,
index: strconv.Itoa(int(index)),
ip: ip,
outputWriter: outputWriter,
}
}
func basicTaggedHttpStartStopMessage(envelope events.Envelope) *events.Envelope {
ip, _ := localip.LocalIP()
envelope.Deployment = proto.String("test-deployment")
envelope.Job = proto.String("test-job")
envelope.Index = proto.String("2")
envelope.Ip = proto.String(ip)
return &envelope
}
func (c *VcapComponent) Start() error {
if c.Type == "" {
log.Error("Component type is required")
return errors.New("type is required")
}
c.quitCh = make(chan struct{}, 1)
c.StartTime = Time(time.Now())
uuid, err := GenerateUUID()
if err != nil {
return err
}
c.UUID = fmt.Sprintf("%d-%s", c.Index, uuid)
if c.Host == "" {
host, err := localip.LocalIP()
if err != nil {
log.Error(err.Error())
return err
}
port, err := localip.LocalPort()
if err != nil {
log.Error(err.Error())
return err
}
c.Host = fmt.Sprintf("%s:%d", host, port)
}
if c.Credentials == nil || len(c.Credentials) != 2 {
user, err := GenerateUUID()
if err != nil {
return err
}
password, err := GenerateUUID()
if err != nil {
return err
}
c.Credentials = []string{user, password}
}
if c.Logger != nil {
log = c.Logger
}
c.Varz.NumCores = runtime.NumCPU()
c.Varz.component = *c
procStat = NewProcessStatus()
c.ListenAndServe()
return nil
}
func NewDiegoExecutor() *DiegoExecutor {
ip, _ := localip.LocalIP()
address := fmt.Sprintf("http://%s:%v", ip, 1800)
repClientFactory := rep.NewClientFactory(cf_http.NewClient())
cellClient := repClientFactory.CreateClient(address)
return &DiegoExecutor{
cellClient: cellClient,
taskStateMap: map[string]mesos.TaskState{},
}
}
func defaultExternalIP(ip IPFlag) (net.IP, error) {
if ip != nil {
return ip.IP(), nil
}
localIP, err := localip.LocalIP()
if err != nil {
return nil, fmt.Errorf("Couldn't determine local IP to use for --external-ip parameter. You can use the --external-ip flag to pass an external IP explicitly.")
}
return net.ParseIP(localIP), nil
}
func main() {
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("localhost:"+strconv.Itoa(config.MetronPort), "LoggregatorTrafficController")
profiler := profiler.NewProfiler(*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()
dopplerAdapter := DefaultStoreAdapterProvider(config.EtcdUrls, config.EtcdMaxConcurrentRequests)
dopplerAdapter.Connect()
legacyAdapter := DefaultStoreAdapterProvider(config.EtcdUrls, config.EtcdMaxConcurrentRequests)
legacyAdapter.Connect()
ipAddress, err := localip.LocalIP()
if err != nil {
panic(err)
}
dopplerProxy := makeDopplerProxy(dopplerAdapter, config, log)
startOutgoingDopplerProxy(net.JoinHostPort(ipAddress, strconv.FormatUint(uint64(config.OutgoingDropsondePort), 10)), dopplerProxy)
legacyProxy := makeLegacyProxy(legacyAdapter, config, log)
startOutgoingProxy(net.JoinHostPort(ipAddress, strconv.FormatUint(uint64(config.OutgoingPort), 10)), legacyProxy)
killChan := make(chan os.Signal)
signal.Notify(killChan, os.Kill, os.Interrupt)
dumpChan := registerGoRoutineDumpSignalChannel()
for {
select {
case <-dumpChan:
logger.DumpGoRoutine()
case <-killChan:
break
}
}
}
func (o *OpenTSDBFirehoseNozzle) createClient() {
ipAddress, err := localip.LocalIP()
if err != nil {
panic(err)
}
var transporter opentsdbclient.Poster
if o.config.UseTelnetAPI {
transporter = poster.NewTelnetPoster(o.config.OpenTSDBURL)
} else {
transporter = poster.NewHTTPPoster(o.config.OpenTSDBURL)
}
o.client = opentsdbclient.New(transporter, o.config.MetricPrefix, o.config.Deployment, o.config.Job, o.config.Index, ipAddress)
}
func (c *Config) Process() {
var err error
if c.GoMaxProcs == -1 {
c.GoMaxProcs = runtime.NumCPU()
}
c.PruneStaleDropletsInterval = time.Duration(c.PruneStaleDropletsIntervalInSeconds) * time.Second
c.DropletStaleThreshold = time.Duration(c.DropletStaleThresholdInSeconds) * time.Second
c.PublishActiveAppsInterval = time.Duration(c.PublishActiveAppsIntervalInSeconds) * time.Second
c.StartResponseDelayInterval = time.Duration(c.StartResponseDelayIntervalInSeconds) * time.Second
c.EndpointTimeout = time.Duration(c.EndpointTimeoutInSeconds) * time.Second
c.RouteServiceTimeout = time.Duration(c.RouteServiceTimeoutInSeconds) * time.Second
c.Logging.JobName = "router_" + c.Zone + "_" + strconv.Itoa(int(c.Index))
if c.StartResponseDelayInterval > c.DropletStaleThreshold {
c.DropletStaleThreshold = c.StartResponseDelayInterval
log := steno.NewLogger("config.logger")
log.Warnf("DropletStaleThreshold (%s) cannot be less than StartResponseDelayInterval (%s); setting both equal to StartResponseDelayInterval and continuing", c.DropletStaleThreshold, c.StartResponseDelayInterval)
}
drain := c.DrainTimeoutInSeconds
if drain == 0 {
drain = c.EndpointTimeoutInSeconds
}
c.DrainTimeout = time.Duration(drain) * time.Second
c.Ip, err = localip.LocalIP()
if err != nil {
panic(err)
}
if c.EnableSSL {
c.CipherSuites = c.processCipherSuites()
cert, err := tls.LoadX509KeyPair(c.SSLCertPath, c.SSLKeyPath)
if err != nil {
panic(err)
}
c.SSLCertificate = cert
}
if c.RouteServiceSecrets != nil && len(c.RouteServiceSecrets) > 0 {
c.RouteServiceEnabled = true
c.RouteServiceSecret = c.RouteServiceSecrets[0]
if len(c.RouteServiceSecrets) > 1 {
c.RouteServiceSecretPrev = c.RouteServiceSecrets[1]
}
}
}
func (r *Router) greetMessage() ([]byte, error) {
host, err := localip.LocalIP()
if err != nil {
return nil, err
}
d := vcap.RouterStart{
Id: r.component.UUID,
Hosts: []string{host},
MinimumRegisterIntervalInSeconds: r.config.StartResponseDelayIntervalInSeconds,
PruneThresholdInSeconds: r.config.DropletStaleThresholdInSeconds,
}
return json.Marshal(d)
}
func parseExternalIP(ip string) (net.IP, error) {
if *externalIP == "" {
localIP, err := localip.LocalIP()
if err != nil {
return nil, fmt.Errorf("Couldn't determine local IP to use for -externalIP parameter. You can use the -externalIP flag to pass an external IP")
}
externalIP = &localIP
}
externalIPAddr := net.ParseIP(*externalIP)
if externalIPAddr == nil {
return nil, fmt.Errorf("Value of -externalIP %s could not be converted to an IP", *externalIP)
}
return externalIPAddr, nil
}
func (c *Config) Process() {
var err error
if c.GoMaxProcs == -1 {
c.GoMaxProcs = runtime.NumCPU()
}
c.PruneStaleDropletsInterval = time.Duration(c.PruneStaleDropletsIntervalInSeconds) * time.Second
c.DropletStaleThreshold = time.Duration(c.DropletStaleThresholdInSeconds) * time.Second
c.PublishActiveAppsInterval = time.Duration(c.PublishActiveAppsIntervalInSeconds) * time.Second
c.StartResponseDelayInterval = time.Duration(c.StartResponseDelayIntervalInSeconds) * time.Second
c.EndpointTimeout = time.Duration(c.EndpointTimeoutInSeconds) * time.Second
c.RouteServiceTimeout = time.Duration(c.RouteServiceTimeoutInSeconds) * time.Second
c.TokenFetcherRetryInterval = time.Duration(c.TokenFetcherRetryIntervalInSeconds) * time.Second
c.Logging.JobName = "gorouter"
if c.StartResponseDelayInterval > c.DropletStaleThreshold {
c.DropletStaleThreshold = c.StartResponseDelayInterval
c.logger.Info(fmt.Sprintf("DropletStaleThreshold (%s) cannot be less than StartResponseDelayInterval (%s); setting both equal to StartResponseDelayInterval and continuing", c.DropletStaleThreshold, c.StartResponseDelayInterval))
}
c.DrainTimeout = c.EndpointTimeout
if c.DrainTimeoutInSeconds > 0 {
c.DrainTimeout = time.Duration(c.DrainTimeoutInSeconds) * time.Second
}
if c.DrainWaitInSeconds > 0 {
c.DrainWait = time.Duration(c.DrainWaitInSeconds) * time.Second
}
c.Ip, err = localip.LocalIP()
if err != nil {
panic(err)
}
if c.EnableSSL {
c.CipherSuites = c.processCipherSuites()
cert, err := tls.LoadX509KeyPair(c.SSLCertPath, c.SSLKeyPath)
if err != nil {
panic(err)
}
c.SSLCertificate = cert
}
if c.RouteServiceSecret != "" {
c.RouteServiceEnabled = true
}
}
func main() {
runtime.GOMAXPROCS(4)
var interval = flag.String("interval", "1s", "Interval for reported results")
var writeRate = flag.Int("writeRate", 15000, "Number of writes per second to send to doppler")
var stopAfter = flag.String("stopAfter", "5m", "How long to run the experiment for")
var sharedSecret string
flag.StringVar(&sharedSecret, "sharedSecret", "", "Shared secret used by Doppler to verify message validity")
var dopplerOutgoingPort = flag.Int("dopplerOutgoingPort", 8080, "Outgoing port from doppler")
var dopplerIncomingDropsondePort = flag.Int("dopplerIncomingDropsondePort", 3457, "Incoming dropsonde port to doppler")
flag.Parse()
duration, err := time.ParseDuration(*interval)
if err != nil {
log.Fatalf("Invalid duration %s\n", *interval)
}
stopAfterDuration, err := time.ParseDuration(*stopAfter)
if err != nil {
log.Fatalf("Invalid duration %s\n", *stopAfter)
}
reporter := metricsreporter.New(duration, os.Stdout)
ip, err := localip.LocalIP()
if err != nil {
panic(err)
}
generator := messagegenerator.NewValueMetricGenerator()
writer := messagewriter.NewMessageWriter(ip, *dopplerIncomingDropsondePort, sharedSecret, reporter.GetSentCounter())
reader := websocketmessagereader.New(fmt.Sprintf("%s:%d", ip, *dopplerOutgoingPort), reporter.GetReceivedCounter())
defer reader.Close()
writeStrategy := writestrategies.NewConstantWriteStrategy(generator, writer, *writeRate)
exp := experiment.NewExperiment(reader)
exp.AddWriteStrategy(writeStrategy)
go reporter.Start()
go exp.Start()
timer := time.NewTimer(stopAfterDuration)
<-timer.C
exp.Stop()
reporter.Stop()
}
func setupMetron() *gexec.Session {
pathToMetronExecutable, err := gexec.Build("metron")
Expect(err).ShouldNot(HaveOccurred())
command := exec.Command(pathToMetronExecutable, "--config=fixtures/metron.json", "--debug")
metronSession, err := gexec.Start(command, gexec.NewPrefixedWriter("[o][metron]", GinkgoWriter), gexec.NewPrefixedWriter("[e][metron]", GinkgoWriter))
Expect(err).ShouldNot(HaveOccurred())
localIPAddress, _ := localip.LocalIP()
// wait for server to be up
Eventually(func() error {
_, err := http.Get("http://" + localIPAddress + ":1234")
return err
}, 3).ShouldNot(HaveOccurred())
return metronSession
}
func NewVarzMessage(name string, instrumentables []Instrumentable) (*VarzMessage, error) {
contexts := make([]Context, len(instrumentables))
for i, instrumentable := range instrumentables {
contexts[i] = instrumentable.Emit()
}
memStats := new(runtime.MemStats)
runtime.ReadMemStats(memStats)
ip, err := localip.LocalIP()
if err != nil {
return &VarzMessage{}, err
}
tags := map[string]string{
"ip": ip,
}
return &VarzMessage{name, runtime.NumCPU(), runtime.NumGoroutine(), mapMemStats(memStats), tags, contexts}, nil
}
func main() {
ip, _ := localip.LocalIP()
conn, err := net.ListenPacket("udp", net.JoinHostPort(ip, "8888"))
if err != nil {
panic(err)
}
readBuffer := make([]byte, 1000)
fmt.Printf("Listening on %s:8888", ip)
for {
readCount, _, err := conn.ReadFrom(readBuffer)
if err != nil {
panic(err)
}
fmt.Printf("Read %d bytes", readCount)
fmt.Println(string(readBuffer))
}
}
func NewComponent(logger *gosteno.Logger, componentType string, index uint, heathMonitor HealthMonitor, statusPort uint16, statusCreds []string, instrumentables []instrumentation.Instrumentable) (Component, error) {
ip, err := localip.LocalIP()
if err != nil {
return Component{}, err
}
if statusPort == 0 {
statusPort, err = localip.LocalPort()
if err != nil {
return Component{}, err
}
}
uuid, err := uuid.NewV4()
if err != nil {
return Component{}, err
}
if len(statusCreds) == 0 || statusCreds[username] == "" || statusCreds[password] == "" {
randUser := make([]byte, 42)
randPass := make([]byte, 42)
rand.Read(randUser)
rand.Read(randPass)
en := base64.URLEncoding
user := en.EncodeToString(randUser)
pass := en.EncodeToString(randPass)
statusCreds = []string{user, pass}
}
return Component{
Logger: logger,
IpAddress: ip,
Type: componentType,
Index: index,
UUID: uuid.String(),
HealthMonitor: heathMonitor,
StatusPort: statusPort,
StatusCredentials: statusCreds,
Instrumentables: instrumentables,
}, nil
}
func initializeLockMaintainer(logger lager.Logger, serviceClient auctioneer.ServiceClient, port int) ifrit.Runner {
uuid, err := uuid.NewV4()
if err != nil {
logger.Fatal("Couldn't generate uuid", err)
}
localIP, err := localip.LocalIP()
if err != nil {
logger.Fatal("Couldn't determine local IP", err)
}
address := fmt.Sprintf("%s://%s:%d", serverProtocol, localIP, port)
auctioneerPresence := auctioneer.NewPresence(uuid.String(), address)
lockMaintainer, err := serviceClient.NewAuctioneerLockRunner(logger, auctioneerPresence, *lockRetryInterval, *lockTTL)
if err != nil {
logger.Fatal("Couldn't create lock maintainer", err)
}
return lockMaintainer
}
func NewMessageWriter(port int, sharedSecret string, reporter sentMessagesReporter) *messageWriter {
ip, err := localip.LocalIP()
if err != nil {
panic(err)
}
output, err := net.Dial("udp", fmt.Sprintf("%s:%d", ip, port))
if err != nil {
fmt.Printf("DIAL Error: %s\n", err.Error())
}
var writer writers.ByteArrayWriter
writer = networkWriter{
reporter: reporter,
conn: output,
}
if len(sharedSecret) > 0 {
writer = signer.New(sharedSecret, writer)
}
return &messageWriter{
writer: writer,
}
}
if gorouterSession != nil && gorouterSession.ExitCode() == -1 {
stopGorouter(gorouterSession)
}
})
Context("Drain", func() {
var config *config.Config
var localIP string
var statusPort uint16
var proxyPort uint16
var cfgFile string
BeforeEach(func() {
var err error
localIP, err = localip.LocalIP()
Expect(err).ToNot(HaveOccurred())
statusPort = test_util.NextAvailPort()
proxyPort = test_util.NextAvailPort()
cfgFile = filepath.Join(tmpdir, "config.yml")
config = createConfig(cfgFile, statusPort, proxyPort)
})
JustBeforeEach(func() {
gorouterSession = startGorouterSession(cfgFile)
})
It("waits for all requests to finish", func() {
mbusClient, err := newMessageBus(config)
})
})
Describe("StartHeartbeats", func() {
var adapter *fakestoreadapter.FakeStoreAdapter
BeforeEach(func() {
adapter = fakestoreadapter.New()
})
Context("when store adapter is nil", func() {
var conf config.Config
var localIp string
BeforeEach(func() {
localIp, _ = localip.LocalIP()
conf = config.Config{
JobName: "doppler_z1",
Index: 0,
EtcdMaxConcurrentRequests: 10,
EtcdUrls: []string{"test:123", "test:456"},
Zone: "z1",
DropsondeIncomingMessagesPort: 1234,
}
})
It("should panic", func() {
Expect(func() {
main.StartHeartbeats(localIp, time.Second, &conf, nil, loggertesthelper.Logger())
}).Should(Panic())
})
package localip_test
import (
"net"
"github.com/pivotal-golang/localip"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Localip", func() {
Describe("LocalIP", func() {
It("returns a local IP", func() {
ip, err := localip.LocalIP()
Ω(err).ShouldNot(HaveOccurred())
// http://golang.org/pkg/net/#ParseIP
// If s is not a valid textual representation of an IP address, ParseIP returns nil.
Ω(net.ParseIP(ip)).ShouldNot(BeNil())
})
})
Describe("LocalPort", func() {
It("returns a local port", func() {
port, err := localip.LocalPort()
Ω(err).ShouldNot(HaveOccurred())
Ω(port).Should(BeNumerically(">", 0))
})
})
})
pathToGoStatsdClient, err = gexec.Build("statsd-injector/tools/statsdGoClient")
Expect(err).NotTo(HaveOccurred())
command := exec.Command(pathToMetronExecutable, "--config=fixtures/metron.json", "--debug")
metronSession, err = gexec.Start(command, gexec.NewPrefixedWriter("[o][metron]", GinkgoWriter), gexec.NewPrefixedWriter("[e][metron]", GinkgoWriter))
Expect(err).ShouldNot(HaveOccurred())
pathToStatsdInjectorExecutable, err := gexec.Build("statsd-injector")
Expect(err).NotTo(HaveOccurred())
command = exec.Command(pathToStatsdInjectorExecutable, "-statsdPort=51162", "-metronPort=51161", "-logLevel=debug")
statsdInjectorSession, err = gexec.Start(command, gexec.NewPrefixedWriter("[o][statsdInjector]", GinkgoWriter), gexec.NewPrefixedWriter("[e][statsdInjector]", GinkgoWriter))
Expect(err).ShouldNot(HaveOccurred())
localIPAddress, _ = localip.LocalIP()
etcdPort = 5800 + (config.GinkgoConfig.ParallelNode-1)*10
etcdRunner = etcdstorerunner.NewETCDClusterRunner(etcdPort, 1, nil)
etcdRunner.Start()
Eventually(metronSession, 1).Should(gbytes.Say("metron started"))
Eventually(statsdInjectorSession).Should(gbytes.Say("Listening for statsd on host :51162"))
})
var _ = AfterSuite(func() {
metronSession.Kill().Wait()
statsdInjectorSession.Kill().Wait()
gexec.CleanupBuildArtifacts()
etcdRunner.Adapter(nil).Disconnect()