func (s *store) StartDisk() error { log.Printf("Starting disk server on %v", s.dir) disk, err := mdbs.NewMDBServer(s.dir, 0, 0600, server.MDBInitialSize, 2, 10*time.Millisecond, db.DB) if err != nil { return err } s.db = disk.(*db.Databases) return nil }
func main() { log.SetPrefix(common.ProductName + " ") log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds) log.Println(os.Args) procs := runtime.NumCPU() if procs < 2 { procs = 2 } runtime.GOMAXPROCS(procs) var vUUIdStr string flag.StringVar(&vUUIdStr, "var", "", "var to interrogate") flag.Parse() dirs := flag.Args() if len(dirs) == 0 { log.Fatal("No dirs supplied") } vars := make(map[common.VarUUId]*varstate) for _, d := range dirs { dir := d log.Printf("...loading from %v\n", dir) disk, err := mdbs.NewMDBServer(dir, 0, 0600, server.OneTB, 1, time.Millisecond, db.DB) if err != nil { log.Println(err) continue } loadVars(disk, vars) disk.Shutdown() } log.Printf("Found %v unique vars", len(vars)) if vUUIdStr != "" { vUUId := common.MakeVarUUIdFromStr(vUUIdStr) if vUUId == nil { log.Printf("Unable to parse %v as vUUId\n", vUUIdStr) } if state, found := vars[*vUUId]; found { log.Println(state) } else { log.Printf("Unable to find %v\n", vUUId) } } }
func (s *server) start() { os.Stdin.Close() procs := runtime.NumCPU() if procs < 2 { procs = 2 } runtime.GOMAXPROCS(procs) commandLineConfig, err := s.commandLineConfig() s.maybeShutdown(err) if commandLineConfig == nil { commandLineConfig = configuration.BlankTopology("").Configuration } nodeCertPrivKeyPair, err := certs.GenerateNodeCertificatePrivateKeyPair(s.certificate) for idx := range s.certificate { s.certificate[idx] = 0 } s.certificate = nil s.maybeShutdown(err) disk, err := mdbs.NewMDBServer(s.dataDir, 0, 0600, goshawk.MDBInitialSize, procs/2, time.Millisecond, db.DB) s.maybeShutdown(err) db := disk.(*db.Databases) s.addOnShutdown(db.Shutdown) cm, transmogrifier := network.NewConnectionManager(s.rmId, s.bootCount, procs, db, nodeCertPrivKeyPair, s.port, s, commandLineConfig) s.addOnShutdown(func() { cm.Shutdown(paxos.Sync) }) s.addOnShutdown(transmogrifier.Shutdown) s.connectionManager = cm s.transmogrifier = transmogrifier go s.signalHandler() listener, err := network.NewListener(s.port, cm) s.maybeShutdown(err) s.addOnShutdown(listener.Shutdown) defer s.shutdown(nil) <-s.shutdownChan }
func main() { log.SetPrefix("MDB Soak Test ") log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds) log.Println(os.Args) procs := runtime.NumCPU() if procs < 2 { procs = 2 } runtime.GOMAXPROCS(procs) var records, readers int var rewriter bool flag.IntVar(&records, "records", 1000, "Number of records to write to database (default 1000)") flag.IntVar(&readers, "readers", 1, "Number of concurrent readers to use (default 1)") flag.BoolVar(&rewriter, "rewriter", false, "Run a rewriter concurrently (default false)") flag.Parse() if records < 1 || readers < 0 { log.Fatal("records must be > 0 and readers must be >= 0") } dir, err := ioutil.TempDir("", "mdb_soak_test") if err != nil { log.Fatal("Cannot create temporary directory") } defer os.RemoveAll(dir) err = os.MkdirAll(dir, 0770) if err != nil { log.Fatal("Cannot create directory:", dir) } log.Println("Using dir", dir) dbs := &DBs{ Test: &mdbs.DBISettings{Flags: mdb.CREATE | mdb.INTEGERKEY}, } server, err := mdbs.NewMDBServer(dir, openFlags, 0600, terabyte, 0, 2*time.Millisecond, dbs) if err != nil { log.Fatal("Cannot start server:", err) } defer server.Shutdown() popStart := time.Now() if err = populate(records, server, dbs); err != nil { log.Fatal(err) } popEnd := time.Now() popTime := popEnd.Sub(popStart) popRate := float64(int64(records)*time.Second.Nanoseconds()) / float64(popTime.Nanoseconds()) log.Println("Populating DB with", records, "records took", popTime, "(", popRate, "records/sec )") for idx := 0; idx < readers; idx++ { go worker(int64(records), server, dbs, readers, idx, false) } if rewriter { go worker(int64(records), server, dbs, 1, -1, true) } sigs := make(chan os.Signal, 1) signal.Notify(sigs, syscall.SIGTERM, os.Interrupt) <-sigs }
func (s *server) start() { procs := runtime.NumCPU() if procs < 2 { procs = 2 } runtime.GOMAXPROCS(procs) disk, err := mdbs.NewMDBServer(s.dataDir, mdb.WRITEMAP, 0600, goshawk.OneTB, procs/2, time.Millisecond, db.DB) s.maybeShutdown(err) s.addOnShutdown(disk.Shutdown) cm, lc := network.NewConnectionManager(s.rmId, s.bootCount, procs, disk, s.passwordHash) s.connectionManager = cm s.addOnShutdown(cm.Shutdown) s.addOnShutdown(lc.Shutdown) s.Add(1) go s.signalHandler() topologyLocal, err := network.GetTopologyFromLocalDatabase(cm, cm.Dispatchers.VarDispatcher, lc) s.maybeShutdown(err) topology, err := s.chooseTopology(topologyLocal) s.maybeShutdown(err) if topologyLocal == nil { topologyTxnId, err := network.CreateTopologyZero(cm, topology, lc) s.maybeShutdown(err) topology.DBVersion = topologyTxnId } cm.SetTopology(topology) cm.Dispatchers.VarDispatcher.ApplyToVar(func(v *eng.Var, err error) { if err != nil { log.Println("Error trying to subscribe to topology:", err) return } emptyTxnId := common.MakeTxnId([]byte{}) v.AddWriteSubscriber(emptyTxnId, func(v *eng.Var, value []byte, refs *msgs.VarIdPos_List, txn *eng.Txn) { var rootVarPosPtr *msgs.VarIdPos if refs.Len() == 1 { root := refs.At(0) rootVarPosPtr = &root } topology, err := goshawk.TopologyDeserialize(txn.Id, rootVarPosPtr, value) if err != nil { log.Println("Unable to deserialize new topology:", err) } cm.SetTopology(topology) disk.WithEnv(func(env *mdb.Env) (interface{}, error) { return nil, env.SetFlags(mdb.MAPASYNC, topology.AsyncFlush) }) }) }, false, goshawk.TopologyVarUUId) cm.AddSender(network.NewTopologyWriter(topology, lc, cm)) localHost, remoteHosts, err := topology.LocalRemoteHosts(s.port) s.maybeShutdown(err) log.Printf(">==> We are %v (%v) <==<\n", localHost, s.rmId) listener, err := network.NewListener(s.port, cm) s.maybeShutdown(err) s.addOnShutdown(listener.Shutdown) cm.SetDesiredServers(localHost, remoteHosts) defer s.shutdown(nil) s.Wait() }