func TopologyFromCap(txnId *common.TxnId, root *msgs.VarIdPos, topology *msgs.Topology) *Topology {
t := &Topology{Configuration: &configuration.Configuration{}}
t.ClusterId = topology.ClusterId()
t.Version = topology.Version()
t.Hosts = topology.Hosts().ToArray()
t.F = topology.F()
t.FInc = t.F + 1
t.TwoFInc = (2 * uint16(t.F)) + 1
t.MaxRMCount = topology.MaxRMCount()
t.AsyncFlush = topology.AsyncFlush()
rms := topology.Rms()
t.AllRMs = make([]common.RMId, rms.Len())
for idx := range t.AllRMs {
t.AllRMs[idx] = common.RMId(rms.At(idx))
}
t.DBVersion = txnId
if root != nil && len(root.Id()) == common.KeyLen {
t.RootVarUUId = common.MakeVarUUId(root.Id())
pos := common.Positions(root.Positions())
t.RootPositions = &pos
}
accounts := topology.Accounts()
t.Accounts = make(map[string]string, accounts.Len())
for idx, l := 0, accounts.Len(); idx < l; idx++ {
account := accounts.At(idx)
t.Accounts[account.Username()] = account.Password()
}
return t
}
func (fo *frameOpen) createRollClientTxn() (*msgs.ClientTxn, map[common.VarUUId]*common.Positions) {
var origWrite *msgs.Action
vUUIdBytes := fo.v.UUId[:]
for idx, l := 0, fo.frameTxnActions.Len(); idx < l; idx++ {
action := fo.frameTxnActions.At(idx)
if bytes.Equal(action.VarId(), vUUIdBytes) {
origWrite = &action
break
}
}
seg := capn.NewBuffer(nil)
ctxn := msgs.NewClientTxn(seg)
ctxn.SetRetry(false)
actions := msgs.NewClientActionList(seg, 1)
ctxn.SetActions(actions)
action := actions.At(0)
action.SetVarId(fo.v.UUId[:])
action.SetRoll()
roll := action.Roll()
roll.SetVersion(fo.frameTxnId[:])
var refs msgs.VarIdPos_List
switch origWrite.Which() {
case msgs.ACTION_WRITE:
ow := origWrite.Write()
roll.SetValue(ow.Value())
refs = ow.References()
case msgs.ACTION_READWRITE:
owr := origWrite.Readwrite()
roll.SetValue(owr.Value())
refs = owr.References()
case msgs.ACTION_CREATE:
oc := origWrite.Create()
roll.SetValue(oc.Value())
refs = oc.References()
case msgs.ACTION_ROLL:
owr := origWrite.Roll()
roll.SetValue(owr.Value())
refs = owr.References()
default:
panic(fmt.Sprintf("%v unexpected action type when building roll: %v", fo.frame, origWrite.Which()))
}
posMap := make(map[common.VarUUId]*common.Positions)
posMap[*fo.v.UUId] = fo.v.positions
refVarList := seg.NewDataList(refs.Len())
roll.SetReferences(refVarList)
for idx, l := 0, refs.Len(); idx < l; idx++ {
ref := refs.At(idx)
vUUId := common.MakeVarUUId(ref.Id())
pos := common.Positions(ref.Positions())
posMap[*vUUId] = &pos
refVarList.Set(idx, vUUId[:])
}
return &ctxn, posMap
}
func (cts *ClientTxnSubmitter) addCreatesToCache(outcome *msgs.Outcome) {
actions := outcome.Txn().Actions()
for idx, l := 0, actions.Len(); idx < l; idx++ {
action := actions.At(idx)
if action.Which() == msgs.ACTION_CREATE {
varUUId := common.MakeVarUUId(action.VarId())
positions := common.Positions(action.Create().Positions())
cts.hashCache.AddPosition(varUUId, &positions)
}
}
}
func (cts *ClientTxnSubmitter) translateUpdates(seg *capn.Segment, updates map[*msgs.Update][]*msgs.Action) cmsgs.ClientUpdate_List {
clientUpdates := cmsgs.NewClientUpdateList(seg, len(updates))
idx := 0
for update, actions := range updates {
clientUpdate := clientUpdates.At(idx)
idx++
clientUpdate.SetVersion(update.TxnId())
clientActions := cmsgs.NewClientActionList(seg, len(actions))
clientUpdate.SetActions(clientActions)
for idy, action := range actions {
clientAction := clientActions.At(idy)
clientAction.SetVarId(action.VarId())
switch action.Which() {
case msgs.ACTION_MISSING:
clientAction.SetDelete()
case msgs.ACTION_WRITE:
clientAction.SetWrite()
write := action.Write()
clientWrite := clientAction.Write()
clientWrite.SetValue(write.Value())
references := write.References()
clientReferences := seg.NewDataList(references.Len())
clientWrite.SetReferences(clientReferences)
for idz, n := 0, references.Len(); idz < n; idz++ {
ref := references.At(idz)
clientReferences.Set(idz, ref.Id())
positions := common.Positions(ref.Positions())
cts.hashCache.AddPosition(common.MakeVarUUId(ref.Id()), &positions)
}
default:
panic(fmt.Sprintf("Unexpected action type: %v", action.Which()))
}
}
}
return clientUpdates
}
func (txn *Txn) populate(actionIndices capn.UInt16List, actions msgs.Action_List) {
localActions := make([]localAction, actionIndices.Len())
txn.localActions = localActions
var action *localAction
actionIndicesIdx := 0
actionIndex := -1
if actionIndicesIdx < actionIndices.Len() {
actionIndex = int(actionIndices.At(actionIndicesIdx))
action = &localActions[actionIndicesIdx]
}
for idx, l := 0, actions.Len(); idx < l; idx++ {
actionCap := actions.At(idx)
if idx == actionIndex {
action.Txn = txn
action.vUUId = common.MakeVarUUId(actionCap.VarId())
}
switch actionCap.Which() {
case msgs.ACTION_READ:
if idx == actionIndex {
readCap := actionCap.Read()
readVsn := common.MakeTxnId(readCap.Version())
action.readVsn = readVsn
}
case msgs.ACTION_WRITE:
if idx == actionIndex {
action.writeTxnActions = &actions
action.writeAction = &actionCap
txn.writes = append(txn.writes, action.vUUId)
} else {
txn.writes = append(txn.writes, common.MakeVarUUId(actionCap.VarId()))
}
case msgs.ACTION_READWRITE:
if idx == actionIndex {
readWriteCap := actionCap.Readwrite()
readVsn := common.MakeTxnId(readWriteCap.Version())
action.readVsn = readVsn
action.writeTxnActions = &actions
action.writeAction = &actionCap
txn.writes = append(txn.writes, action.vUUId)
} else {
txn.writes = append(txn.writes, common.MakeVarUUId(actionCap.VarId()))
}
case msgs.ACTION_CREATE:
if idx == actionIndex {
createCap := actionCap.Create()
positions := common.Positions(createCap.Positions())
action.writeTxnActions = &actions
action.writeAction = &actionCap
action.createPositions = &positions
txn.writes = append(txn.writes, action.vUUId)
} else {
txn.writes = append(txn.writes, common.MakeVarUUId(actionCap.VarId()))
}
case msgs.ACTION_ROLL:
if idx == actionIndex {
rollCap := actionCap.Roll()
readVsn := common.MakeTxnId(rollCap.Version())
action.readVsn = readVsn
action.writeTxnActions = &actions
action.writeAction = &actionCap
action.roll = true
txn.writes = append(txn.writes, action.vUUId)
} else {
txn.writes = append(txn.writes, common.MakeVarUUId(actionCap.VarId()))
}
default:
panic(fmt.Sprintf("Unexpected action type: %v", actionCap.Which()))
}
if idx == actionIndex {
actionIndicesIdx++
if actionIndicesIdx < actionIndices.Len() {
actionIndex = int(actionIndices.At(actionIndicesIdx))
action = &localActions[actionIndicesIdx]
}
}
}
if actionIndicesIdx != actionIndices.Len() {
panic(fmt.Sprintf("Expected to find %v local actions, but only found %v", actionIndices.Len(), actionIndicesIdx))
}
}