func main() { var ( publish = flag.String("publish", fmt.Sprintf("localhost:%d", xfer.AppPort), "publish target") publishInterval = flag.Duration("publish.interval", 1*time.Second, "publish (output) interval") ) flag.Parse() if len(flag.Args()) != 1 { log.Fatal("usage: fixprobe [--args] report.json") } f, err := os.Open(flag.Arg(0)) if err != nil { log.Fatal(err) } var fixedReport report.Report if err := json.NewDecoder(f).Decode(&fixedReport); err != nil { log.Fatal(err) } f.Close() _, publisher, err := xfer.NewHTTPPublisher(*publish, *publish, "fixprobe", "fixprobe", false) if err != nil { log.Fatal(err) } rp := xfer.NewReportPublisher(publisher) for range time.Tick(*publishInterval) { rp.Publish(fixedReport) } }
// New makes a new Probe. func New(spyInterval, publishInterval time.Duration, publisher xfer.Publisher) *Probe { result := &Probe{ spyInterval: spyInterval, publishInterval: publishInterval, publisher: xfer.NewReportPublisher(publisher), quit: make(chan struct{}), spiedReports: make(chan report.Report, reportBufferSize), shortcutReports: make(chan report.Report, reportBufferSize), } return result }
func main() { var ( publish = flag.String("publish", fmt.Sprintf("localhost:%d", xfer.AppPort), "publish target") publishInterval = flag.Duration("publish.interval", 1*time.Second, "publish (output) interval") hostCount = flag.Int("hostcount", 10, "Number of demo hosts to generate") ) flag.Parse() _, publisher, err := xfer.NewHTTPPublisher(*publish, *publish, "demoprobe", "demoprobe", false) if err != nil { log.Fatal(err) } rp := xfer.NewReportPublisher(publisher) rand.Seed(time.Now().UnixNano()) for range time.Tick(*publishInterval) { if err := rp.Publish(demoReport(*hostCount)); err != nil { log.Print(err) } } }
func main() { var ( targets = []string{fmt.Sprintf("localhost:%d", xfer.AppPort), fmt.Sprintf("scope.weave.local:%d", xfer.AppPort)} token = flag.String("token", "default-token", "probe token") httpListen = flag.String("http.listen", "", "listen address for HTTP profiling and instrumentation server") publishInterval = flag.Duration("publish.interval", 3*time.Second, "publish (output) interval") spyInterval = flag.Duration("spy.interval", time.Second, "spy (scan) interval") prometheusEndpoint = flag.String("prometheus.endpoint", "/metrics", "Prometheus metrics exposition endpoint (requires -http.listen)") spyProcs = flag.Bool("processes", true, "report processes (needs root)") dockerEnabled = flag.Bool("docker", false, "collect Docker-related attributes for processes") dockerInterval = flag.Duration("docker.interval", 10*time.Second, "how often to update Docker attributes") dockerBridge = flag.String("docker.bridge", "docker0", "the docker bridge name") weaveRouterAddr = flag.String("weave.router.addr", "", "IP address or FQDN of the Weave router") procRoot = flag.String("proc.root", "/proc", "location of the proc filesystem") printVersion = flag.Bool("version", false, "print version number and exit") useConntrack = flag.Bool("conntrack", true, "also use conntrack to track connections") logPrefix = flag.String("log.prefix", "<probe>", "prefix for each log line") ) flag.Parse() if *printVersion { fmt.Println(version) return } if !strings.HasSuffix(*logPrefix, " ") { *logPrefix += " " } log.SetPrefix(*logPrefix) defer log.Print("probe exiting") if *spyProcs && os.Getegid() != 0 { log.Printf("warning: -process=true, but that requires root to find everything") } var ( hostName = hostname() hostID = hostName // TODO(pb): we should sanitize the hostname probeID = hostName // TODO(pb): does this need to be a random string instead? ) log.Printf("probe starting, version %s, ID %s", version, probeID) addrs, err := net.InterfaceAddrs() if err != nil { log.Fatal(err) } localNets := report.Networks{} for _, addr := range addrs { // Not all addrs are IPNets. if ipNet, ok := addr.(*net.IPNet); ok { localNets = append(localNets, ipNet) } } if len(flag.Args()) > 0 { targets = flag.Args() } log.Printf("publishing to: %s", strings.Join(targets, ", ")) factory := func(endpoint string) (string, xfer.Publisher, error) { id, publisher, err := xfer.NewHTTPPublisher(endpoint, *token, probeID) if err != nil { return "", nil, err } return id, xfer.NewBackgroundPublisher(publisher), nil } publishers := xfer.NewMultiPublisher(factory) defer publishers.Stop() resolver := newStaticResolver(targets, publishers.Set) defer resolver.Stop() endpointReporter := endpoint.NewReporter(hostID, hostName, *spyProcs, *useConntrack) defer endpointReporter.Stop() processCache := process.NewCachingWalker(process.NewWalker(*procRoot)) var ( tickers = []Ticker{processCache} reporters = []Reporter{endpointReporter, host.NewReporter(hostID, hostName, localNets), process.NewReporter(processCache, hostID)} taggers = []Tagger{newTopologyTagger(), host.NewTagger(hostID)} ) dockerTagger, dockerReporter, dockerRegistry := func() (*docker.Tagger, *docker.Reporter, docker.Registry) { if !*dockerEnabled { return nil, nil, nil } if err := report.AddLocalBridge(*dockerBridge); err != nil { log.Printf("Docker: problem with bridge %s: %v", *dockerBridge, err) return nil, nil, nil } registry, err := docker.NewRegistry(*dockerInterval) if err != nil { log.Printf("Docker: failed to start registry: %v", err) return nil, nil, nil } return docker.NewTagger(registry, processCache), docker.NewReporter(registry, hostID), registry }() if dockerTagger != nil { taggers = append(taggers, dockerTagger) } if dockerReporter != nil { reporters = append(reporters, dockerReporter) } if dockerRegistry != nil { defer dockerRegistry.Stop() } if *weaveRouterAddr != "" { weave := overlay.NewWeave(hostID, *weaveRouterAddr) tickers = append(tickers, weave) taggers = append(taggers, weave) reporters = append(reporters, weave) } if *httpListen != "" { go func() { log.Printf("Profiling data being exported to %s", *httpListen) log.Printf("go tool pprof http://%s/debug/pprof/{profile,heap,block}", *httpListen) if *prometheusEndpoint != "" { log.Printf("exposing Prometheus endpoint at %s%s", *httpListen, *prometheusEndpoint) http.Handle(*prometheusEndpoint, makePrometheusHandler()) } log.Printf("Profiling endpoint %s terminated: %v", *httpListen, http.ListenAndServe(*httpListen, nil)) }() } quit, done := make(chan struct{}), sync.WaitGroup{} done.Add(2) defer func() { done.Wait() }() // second, wait for the main loops to be killed defer close(quit) // first, kill the main loops var rpt syncReport rpt.swap(report.MakeReport()) go func() { defer done.Done() spyTick := time.Tick(*spyInterval) for { select { case <-spyTick: start := time.Now() for _, ticker := range tickers { if err := ticker.Tick(); err != nil { log.Printf("error doing ticker: %v", err) } } localReport := rpt.copy() localReport = localReport.Merge(doReport(reporters)) localReport = Apply(localReport, taggers) rpt.swap(localReport) if took := time.Since(start); took > *spyInterval { log.Printf("report generation took too long (%s)", took) } case <-quit: return } } }() go func() { defer done.Done() var ( pubTick = time.Tick(*publishInterval) p = xfer.NewReportPublisher(publishers) ) for { select { case <-pubTick: publishTicks.WithLabelValues().Add(1) localReport := rpt.swap(report.MakeReport()) localReport.Window = *publishInterval if err := p.Publish(localReport); err != nil { log.Printf("publish: %v", err) } case <-quit: return } } }() log.Printf("%s", <-interrupt()) }
func TestHTTPPublisher(t *testing.T) { var ( token = "abcdefg" id = "1234567" rpt = report.MakeReport() done = make(chan struct{}) ) handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == "/api" { _ = json.NewEncoder(w).Encode(map[string]string{"id": "irrelevant"}) return } if want, have := xfer.AuthorizationHeader(token), r.Header.Get("Authorization"); want != have { t.Errorf("want %q, have %q", want, have) } if want, have := id, r.Header.Get(xfer.ScopeProbeIDHeader); want != have { t.Errorf("want %q, have %q", want, have) } var have report.Report reader := r.Body var err error if strings.Contains(r.Header.Get("Content-Encoding"), "gzip") { reader, err = gzip.NewReader(r.Body) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } defer reader.Close() } if err := gob.NewDecoder(reader).Decode(&have); err != nil { t.Error(err) return } if want := rpt; !reflect.DeepEqual(want, have) { t.Error(test.Diff(want, have)) return } w.WriteHeader(http.StatusOK) close(done) }) s := httptest.NewServer(handlers.CompressHandler(handler)) defer s.Close() _, p, err := xfer.NewHTTPPublisher(s.URL, token, id) if err != nil { t.Fatal(err) } rp := xfer.NewReportPublisher(p) if err := rp.Publish(rpt); err != nil { t.Error(err) } select { case <-done: case <-time.After(time.Millisecond): t.Error("timeout") } }