// The lease not having enough time left on it to finish migrations should
// cause the process to exit via a call to log.Fatal.
func TestLeaseExpiration(t *testing.T) {
db := &fakeDB{kvs: make(map[string][]byte)}
mgr := Manager{
stopper: stop.NewStopper(),
leaseManager: &fakeLeaseManager{leaseTimeRemaining: time.Nanosecond},
db: db,
}
defer mgr.stopper.Stop()
oldLeaseRefreshInterval := leaseRefreshInterval
leaseRefreshInterval = time.Microsecond
defer func() { leaseRefreshInterval = oldLeaseRefreshInterval }()
exitCalled := make(chan bool)
log.SetExitFunc(func(int) { exitCalled <- true })
defer log.SetExitFunc(os.Exit)
waitForExitMigration := migrationDescriptor{
name: "wait for exit to be called",
workFn: func(context.Context, runner) error {
select {
case <-exitCalled:
return nil
case <-time.After(10 * time.Second):
return fmt.Errorf("timed out waiting for exit to be called")
}
},
}
backwardCompatibleMigrations = []migrationDescriptor{waitForExitMigration}
if err := mgr.EnsureMigrations(context.Background()); err != nil {
t.Error(err)
}
}
func main() {
flag.Parse()
c := localcluster.New(*numNodes)
defer c.Close()
log.SetExitFunc(func(code int) {
c.Close()
os.Exit(code)
})
signalCh := make(chan os.Signal, 1)
signal.Notify(signalCh, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
a := newAllocSim(c)
go func() {
var exitStatus int
select {
case s := <-signalCh:
log.Infof(context.Background(), "signal received: %v", s)
exitStatus = 1
case <-time.After(*duration):
log.Infof(context.Background(), "finished run of: %s", *duration)
}
a.finalStatus()
c.Close()
os.Exit(exitStatus)
}()
c.Start("allocsim", *workers, flag.Args(), []string{})
c.UpdateZoneConfig(1, 1<<20)
a.run(*workers)
}
func main() {
flag.Parse()
c := localcluster.New(*numNodes)
defer c.Close()
log.SetExitFunc(func(code int) {
c.Close()
os.Exit(code)
})
signalCh := make(chan os.Signal, 1)
signal.Notify(signalCh, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
go func() {
s := <-signalCh
log.Infof(context.Background(), "signal received: %v", s)
c.Close()
os.Exit(1)
}()
c.Start("zerosum", *workers, flag.Args(), nil)
z := newZeroSum(c, *numAccounts, *chaosType)
z.run(*workers, *monkeys)
}
func main() {
flag.Parse()
c := localcluster.New(*numNodes)
defer c.Close()
log.SetExitFunc(func(code int) {
c.Close()
os.Exit(code)
})
signalCh := make(chan os.Signal, 1)
signal.Notify(signalCh, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
go func() {
s := <-signalCh
log.Infof(context.Background(), "signal received: %v", s)
c.Close()
os.Exit(1)
}()
c.Start("allocsim", *workers, flag.Args(),
[]string{"COCKROACH_METRICS_SAMPLE_INTERVAL=2s"})
c.UpdateZoneConfig(1, 1<<20)
a := newAllocSim(c)
a.run(*workers)
}
func initBacktrace(logDir string) *stop.Stopper {
const ptracePath = "/opt/backtrace/bin/ptrace"
if _, err := os.Stat(ptracePath); err != nil {
log.Infof(context.TODO(), "backtrace disabled: %s", err)
return stop.NewStopper()
}
if err := bcd.EnableTracing(); err != nil {
log.Infof(context.TODO(), "unable to enable backtrace: %s", err)
return stop.NewStopper()
}
bcd.UpdateConfig(bcd.GlobalConfig{
PanicOnKillFailure: true,
ResendSignal: true,
RateLimit: time.Second * 3,
SynchronousPut: true,
})
// Use the default tracer implementation.
// false: Exclude system goroutines.
tracer := bcd.New(bcd.NewOptions{
IncludeSystemGs: false,
})
if err := tracer.SetOutputPath(logDir, 0755); err != nil {
log.Infof(context.TODO(), "unable to set output path: %s", err)
// Not a fatal error, continue.
}
// Enable WARNING log output from the tracer.
tracer.AddOptions(nil, "-L", "WARNING")
info := build.GetInfo()
tracer.AddKV(nil, "cgo-compiler", info.CgoCompiler)
tracer.AddKV(nil, "go-version", info.GoVersion)
tracer.AddKV(nil, "platform", info.Platform)
tracer.AddKV(nil, "tag", info.Tag)
tracer.AddKV(nil, "time", info.Time)
// Register for traces on signal reception.
tracer.SetSigset(
[]os.Signal{
syscall.SIGABRT,
syscall.SIGFPE,
syscall.SIGSEGV,
syscall.SIGILL,
syscall.SIGBUS}...)
bcd.Register(tracer)
// Hook log.Fatal*.
log.SetExitFunc(func(code int) {
_ = bcd.Trace(tracer, fmt.Errorf("exit %d", code), nil)
os.Exit(code)
})
stopper := stop.NewStopper(stop.OnPanic(func(val interface{}) {
err, ok := val.(error)
if !ok {
err = fmt.Errorf("%v", val)
}
_ = bcd.Trace(tracer, err, nil)
panic(val)
}))
// Internally, backtrace uses an external program (/opt/backtrace/bin/ptrace)
// to generate traces. We direct the stdout for this program to a file for
// debugging our usage of backtrace.
if f, err := os.OpenFile(filepath.Join(logDir, "backtrace.out"),
os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666); err != nil {
log.Infof(context.TODO(), "unable to open: %s", err)
} else {
stopper.AddCloser(stop.CloserFn(func() {
f.Close()
}))
tracer.SetPipes(nil, f)
}
tracer.SetLogLevel(bcd.LogMax)
log.Infof(context.TODO(), "backtrace enabled")
return stopper
}
