func VarFromData(data []byte, exe *dispatcher.Executor, db *db.Databases, vm *VarManager) (*Var, error) {
seg, _, err := capn.ReadFromMemoryZeroCopy(data)
if err != nil {
return nil, err
}
varCap := msgs.ReadRootVar(seg)
v := newVar(common.MakeVarUUId(varCap.Id()), exe, db, vm)
positions := varCap.Positions()
if positions.Len() != 0 {
v.positions = (*common.Positions)(&positions)
}
writeTxnId := common.MakeTxnId(varCap.WriteTxnId())
writeTxnClock := VectorClockFromCap(varCap.WriteTxnClock())
writesClock := VectorClockFromCap(varCap.WritesClock())
server.Log(v.UUId, "Restored", writeTxnId)
if result, err := db.ReadonlyTransaction(func(rtxn *mdbs.RTxn) interface{} {
return db.ReadTxnBytesFromDisk(rtxn, writeTxnId)
}).ResultError(); err == nil && result != nil {
bites := result.([]byte)
if seg, _, err := capn.ReadFromMemoryZeroCopy(bites); err == nil {
txn := msgs.ReadRootTxn(seg)
actions := txn.Actions()
v.curFrame = NewFrame(nil, v, writeTxnId, &actions, writeTxnClock, writesClock)
v.curFrameOnDisk = v.curFrame
v.varCap = &varCap
return v, nil
} else {
return nil, err
}
} else {
return nil, err
}
}
func (pd *ProposerDispatcher) loadFromDisk(db *db.Databases) {
res, err := db.ReadonlyTransaction(func(rtxn *mdbs.RTxn) interface{} {
res, _ := rtxn.WithCursor(db.Proposers, func(cursor *mdbs.Cursor) interface{} {
// cursor.Get returns a copy of the data. So it's fine for us
// to store and process this later - it's not about to be
// overwritten on disk.
proposerStates := make(map[*common.TxnId][]byte)
txnIdData, proposerState, err := cursor.Get(nil, nil, mdb.FIRST)
for ; err == nil; txnIdData, proposerState, err = cursor.Get(nil, nil, mdb.NEXT) {
txnId := common.MakeTxnId(txnIdData)
proposerStates[txnId] = proposerState
}
if err == mdb.NotFound {
// fine, we just fell off the end as expected.
return proposerStates
} else {
cursor.Error(err)
return nil
}
})
return res
}).ResultError()
if err != nil {
panic(fmt.Sprintf("ProposerDispatcher error loading from disk: %v", err))
} else if res != nil {
proposerStates := res.(map[*common.TxnId][]byte)
for txnId, proposerState := range proposerStates {
proposerStateCopy := proposerState
txnIdCopy := txnId
pd.withProposerManager(txnIdCopy, func(pm *ProposerManager) {
if err := pm.loadFromData(txnIdCopy, proposerStateCopy); err != nil {
log.Printf("ProposerDispatcher error loading %v from disk: %v\n", txnIdCopy, err)
}
})
}
log.Printf("Loaded %v proposers from disk\n", len(proposerStates))
}
}