blob: 557f7eb932f280531b43656c75dd5e85862e5232 [file] [log] [blame]
// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package syncbased_vine implements syncbased, the Syncbase daemon, with a
// VINE server to enable test-specific network configuration.
package syncbased_vine
import (
"fmt"
"os"
"path/filepath"
"runtime/pprof"
"time"
"v.io/v23"
"v.io/v23/rpc"
"v.io/v23/security"
"v.io/x/lib/gosh"
"v.io/x/ref/lib/signals"
"v.io/x/ref/runtime/protocols/vine"
"v.io/x/ref/services/syncbase/syncbaselib"
)
func Main(vineServerName string, vineTag string, opts syncbaselib.Opts) {
ctx, shutdown := v23.Init()
defer shutdown()
// Start a goroutine that repeatedly captures pprof data every minute.
pprofDir := filepath.Join(opts.RootDir, "pprof")
panicOnErr(os.MkdirAll(pprofDir, 0755))
done := make(chan struct{})
defer close(done)
go func() {
for {
select {
case <-done:
return
case <-time.After(time.Minute):
capturePprof(pprofDir)
}
}
}()
// Start a VINE Server and modify our ctx to use the "vine" protocol.
// The final argument is the discoveryTTL, which uses a sensible default if
// called with 0.
ctx = v23.WithListenSpec(ctx, rpc.ListenSpec{
Addrs: rpc.ListenAddrs{{"tcp", "127.0.0.1:0"}},
})
ctx, err := vine.Init(ctx, vineServerName, security.AllowEveryone(), vineTag, 0)
if err != nil {
panic(err)
}
// Syncbase now uses a modified rpc.ListenSpec which has been set to use
// the VINE protocol.
s, _, cleanup := syncbaselib.Serve(ctx, opts)
if eps := s.Status().Endpoints; len(eps) == 0 {
panic("s.Status().Endpoints is empty")
}
gosh.SendVars(map[string]string{
"ENDPOINT": s.Status().Endpoints[0].String(),
})
defer cleanup()
ctx.Info("Received signal ", <-signals.ShutdownOnSignals(ctx))
}
func capturePprof(dir string) {
now := time.Now().Format(time.RFC3339)
heapFile, err := os.Create(filepath.Join(dir, fmt.Sprintf("heap-%s", now)))
panicOnErr(err)
panicOnErr(pprof.Lookup("heap").WriteTo(heapFile, 1))
panicOnErr(heapFile.Close())
goroutineFile, err := os.Create(filepath.Join(dir, fmt.Sprintf("goroutine-%s", now)))
panicOnErr(err)
panicOnErr(pprof.Lookup("goroutine").WriteTo(goroutineFile, 1))
panicOnErr(goroutineFile.Close())
}
func panicOnErr(err error) {
if err != nil {
panic(err)
}
}