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()