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