func main() { var ( memStore = appdash.NewMemoryStore() Store = appdash.Store(memStore) Queryer = memStore ) app := traceapp.New(nil) app.Store = Store app.Queryer = Queryer var h http.Handler = app var l net.Listener var proto string var err error l, err = net.Listen("tcp", c.CollectorAddr) if err != nil { log.Fatal(err) } proto = "plaintext TCP (no security)" log.Printf("appdash collector listening on %s (%s)", c.CollectorAddr, proto) cs := appdash.NewServer(l, appdash.NewLocalCollector(Store)) go cs.Start() log.Printf("appdash HTTP server listening on %s", c.HTTPAddr) err = http.ListenAndServe(c.HTTPAddr, h) if err != nil { fmt.Println("listenandserver listen err:", err) } }
// Execute execudes the commands with the given arguments and returns an error, // if any. func (c *DemoCmd) Execute(args []string) error { // We create a new in-memory store. All information about traces will // eventually be stored here. store := appdash.NewMemoryStore() // Listen on any available TCP port locally. l, err := net.ListenTCP("tcp", &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0}) if err != nil { log.Fatal(err) } collectorPort := l.Addr().(*net.TCPAddr).Port log.Printf("Appdash collector listening on tcp:%d", collectorPort) // Start an Appdash collection server that will listen for spans and // annotations and add them to the local collector (stored in-memory). cs := appdash.NewServer(l, appdash.NewLocalCollector(store)) cs.Debug = c.Debug // Debug logging cs.Trace = c.Trace // Trace logging go cs.Start() // Print the URL at which the web UI will be running. appdashURLStr := "http://localhost" + c.AppdashHTTPAddr appdashURL, err := url.Parse(appdashURLStr) if err != nil { log.Fatalf("Error parsing http://localhost:%s: %s", c.AppdashHTTPAddr, err) } log.Printf("Appdash web UI running at %s", appdashURL) // Start the web UI in a separate goroutine. tapp := traceapp.New(nil) tapp.Store = store tapp.Queryer = store go func() { log.Fatal(http.ListenAndServe(c.AppdashHTTPAddr, tapp)) }() // Print the URL at which the demo app is running. demoURLStr := "http://localhost" + c.DemoHTTPAddr demoURL, err := url.Parse(demoURLStr) if err != nil { log.Fatalf("Error parsing http://localhost:%s: %s", c.DemoHTTPAddr, err) } log.Println() log.Printf("Appdash demo app running at %s", demoURL) // The Appdash collection server that our demo app will use is running // locally with our HTTP server in this case, so we set this up now. localCollector := appdash.NewRemoteCollector(fmt.Sprintf(":%d", collectorPort)) // Handle the root path of our app. http.Handle("/", &middlewareHandler{ middleware: httptrace.Middleware(localCollector, &httptrace.MiddlewareConfig{ RouteName: func(r *http.Request) string { return r.URL.Path }, SetContextSpan: requestSpans.setRequestSpan, }), next: &demoApp{collector: localCollector, baseURL: demoURL, appdashURL: appdashURL}, }) return http.ListenAndServe(c.DemoHTTPAddr, nil) }
// Execute execudes the commands with the given arguments and returns an error, // if any. func (c *ServeCmd) Execute(args []string) error { var ( memStore = appdash.NewMemoryStore() Store = appdash.Store(memStore) Queryer = memStore ) if c.StoreFile != "" { f, err := os.Open(c.StoreFile) if err != nil && !os.IsNotExist(err) { return err } if f != nil { if n, err := memStore.ReadFrom(f); err == nil { log.Printf("Read %d traces from file %s", n, c.StoreFile) } else if err != nil { f.Close() return err } if err := f.Close(); err != nil { return err } } if c.PersistInterval != 0 { go func() { if err := appdash.PersistEvery(memStore, c.PersistInterval, c.StoreFile); err != nil { log.Fatal(err) } }() } } if c.DeleteAfter > 0 { Store = &appdash.RecentStore{ MinEvictAge: c.DeleteAfter, DeleteStore: memStore, Debug: true, } } url, err := c.urlOrDefault() if err != nil { log.Fatal(err) } app, err := traceapp.New(nil, url) if err != nil { log.Fatal(err) } app.Store = Store app.Queryer = Queryer var h http.Handler if c.BasicAuth != "" { parts := strings.SplitN(c.BasicAuth, ":", 2) if len(parts) != 2 { log.Fatalf("Basic auth must be specified as 'user:passwd'.") } user, passwd := parts[0], parts[1] if user == "" || passwd == "" { log.Fatalf("Basic auth user and passwd must both be nonempty.") } log.Printf("Requiring HTTP Basic auth") h = newBasicAuthHandler(user, passwd, app) } else { h = app } if c.SampleData { sampleData(Store) } var l net.Listener var proto string if c.TLSCert != "" || c.TLSKey != "" { certBytes, err := ioutil.ReadFile(c.TLSCert) if err != nil { log.Fatal(err) } keyBytes, err := ioutil.ReadFile(c.TLSKey) if err != nil { log.Fatal(err) } var tc tls.Config cert, err := tls.X509KeyPair(certBytes, keyBytes) if err != nil { log.Fatal(err) } tc.Certificates = []tls.Certificate{cert} l, err = tls.Listen("tcp", c.CollectorAddr, &tc) if err != nil { log.Fatal(err) } proto = fmt.Sprintf("TLS cert %s, key %s", c.TLSCert, c.TLSKey) } else { var err error l, err = net.Listen("tcp", c.CollectorAddr) if err != nil { log.Fatal(err) } proto = "plaintext TCP (no security)" } log.Printf("appdash collector listening on %s (%s)", c.CollectorAddr, proto) cs := appdash.NewServer(l, appdash.NewLocalCollector(Store)) cs.Debug = c.Debug cs.Trace = c.Trace go cs.Start() if c.TLSCert != "" || c.TLSKey != "" { log.Printf("appdash HTTPS server listening on %s (TLS cert %s, key %s)", c.HTTPAddr, c.TLSCert, c.TLSKey) return http.ListenAndServeTLS(c.HTTPAddr, c.TLSCert, c.TLSKey, h) } log.Printf("appdash HTTP server listening on %s", c.HTTPAddr) return http.ListenAndServe(c.HTTPAddr, h) }