func NewProposal(pm *ProposerManager, txnId *common.TxnId, txn *msgs.Txn, fInc int, ballots []*eng.Ballot, instanceRMId common.RMId, acceptors []common.RMId, skipPhase1 bool) *proposal {
allocs := txn.Allocations()
activeRMIds := make(map[common.RMId]uint32, allocs.Len())
for idx, l := 0, allocs.Len(); idx < l; idx++ {
alloc := allocs.At(idx)
bootCount := alloc.Active()
if bootCount == 0 {
break
}
rmId := common.RMId(alloc.RmId())
activeRMIds[rmId] = bootCount
}
p := &proposal{
proposerManager: pm,
instanceRMId: instanceRMId,
acceptors: acceptors,
activeRMIds: activeRMIds,
fInc: fInc,
txn: txn,
txnId: txnId,
skipPhase1: skipPhase1,
instances: make(map[common.VarUUId]*proposalInstance, len(ballots)),
pending: make([]*proposalInstance, 0, len(ballots)),
finished: false,
}
for _, ballot := range ballots {
pi := newProposalInstance(p, ballot)
p.instances[*ballot.VarUUId] = pi
pi.init()
pi.start()
}
return p
}
func NewBallotAccumulator(txnId *common.TxnId, txn *msgs.Txn) *BallotAccumulator {
actions := txn.Actions()
ba := &BallotAccumulator{
Txn: txn,
txnId: txnId,
vUUIdToBallots: make(map[common.VarUUId]*varBallot),
outcome: nil,
incompleteVars: actions.Len(),
dirty: false,
}
vBallots := make([]varBallot, ba.incompleteVars)
for idx := 0; idx < ba.incompleteVars; idx++ {
action := actions.At(idx)
vUUId := common.MakeVarUUId(action.VarId())
vBallot := &vBallots[idx]
vBallot.vUUId = vUUId
ba.vUUIdToBallots[*vUUId] = vBallot
}
allocs := txn.Allocations()
for idx, l := 0, allocs.Len(); idx < l; idx++ {
alloc := allocs.At(idx)
if alloc.Active() == 0 {
break
}
indices := alloc.ActionIndices()
for idy, m := 0, indices.Len(); idy < m; idy++ {
vBallots[int(indices.At(idy))].voters++
}
}
return ba
}
func AllocForRMId(txn *msgs.Txn, rmId common.RMId) *msgs.Allocation {
allocs := txn.Allocations()
for idx, l := 0, allocs.Len(); idx < l; idx++ {
alloc := allocs.At(idx)
if common.RMId(alloc.RmId()) == rmId {
return &alloc
}
}
return nil
}
func MakeAbortBallots(txn *msgs.Txn, alloc *msgs.Allocation) []*eng.Ballot {
actions := txn.Actions()
actionIndices := alloc.ActionIndices()
ballots := make([]*eng.Ballot, actionIndices.Len())
for idx, l := 0, actionIndices.Len(); idx < l; idx++ {
action := actions.At(int(actionIndices.At(idx)))
vUUId := common.MakeVarUUId(action.VarId())
ballots[idx] = eng.NewBallot(vUUId, eng.AbortDeadlock, nil)
}
return ballots
}
func GetAcceptorsFromTxn(txnCap *msgs.Txn) common.RMIds {
fInc := int(txnCap.FInc())
twoFInc := fInc + fInc - 1
acceptors := make([]common.RMId, twoFInc)
allocations := txnCap.Allocations()
idx := 0
for l := allocations.Len(); idx < l && idx < twoFInc; idx++ {
alloc := allocations.At(idx)
acceptors[idx] = common.RMId(alloc.RmId())
}
// Danger! For the initial topology txns, there are _not_ twoFInc acceptors
return acceptors[:idx]
}
func NewProposer(pm *ProposerManager, txnId *common.TxnId, txnCap *msgs.Txn, mode ProposerMode) *Proposer {
p := &Proposer{
proposerManager: pm,
mode: mode,
txnId: txnId,
acceptors: GetAcceptorsFromTxn(txnCap),
fInc: int(txnCap.FInc()),
}
if mode == ProposerActiveVoter {
p.txn = eng.TxnFromCap(pm.Exe, pm.VarDispatcher, p, pm.RMId, txnCap)
}
p.init()
return p
}
func TxnFromCap(exe *dispatcher.Executor, vd *VarDispatcher, stateChange TxnLocalStateChange, ourRMId common.RMId, txnCap *msgs.Txn) *Txn {
txnId := common.MakeTxnId(txnCap.Id())
actions := txnCap.Actions()
txn := &Txn{
Id: txnId,
Retry: txnCap.Retry(),
writes: make([]*common.VarUUId, 0, actions.Len()),
TxnCap: txnCap,
exe: exe,
vd: vd,
stateChange: stateChange,
}
allocations := txnCap.Allocations()
for idx, l := 0, allocations.Len(); idx < l; idx++ {
alloc := allocations.At(idx)
rmId := common.RMId(alloc.RmId())
if ourRMId == rmId {
txn.populate(alloc.ActionIndices(), actions)
break
}
}
return txn
}
func (sts *SimpleTxnSubmitter) SubmitTransaction(txnCap *msgs.Txn, activeRMs []common.RMId, continuation TxnCompletionConsumer, delay time.Duration) {
seg := capn.NewBuffer(nil)
msg := msgs.NewRootMessage(seg)
msg.SetTxnSubmission(*txnCap)
txnId := common.MakeTxnId(txnCap.Id())
server.Log(txnId, "Submitting txn")
txnSender := paxos.NewRepeatingSender(server.SegToBytes(seg), activeRMs...)
if delay == 0 {
sts.connectionManager.AddSender(txnSender)
} else {
go func() {
// fmt.Printf("%v ", delay)
time.Sleep(delay)
sts.connectionManager.AddSender(txnSender)
}()
}
acceptors := paxos.GetAcceptorsFromTxn(txnCap)
shutdownFun := func(shutdown bool) {
delete(sts.outcomeConsumers, *txnId)
// fmt.Printf("sts%v ", len(sts.outcomeConsumers))
sts.connectionManager.RemoveSenderAsync(txnSender)
paxos.NewOneShotSender(paxos.MakeTxnSubmissionCompleteMsg(txnId), sts.connectionManager, acceptors...)
if shutdown {
if txnCap.Retry() {
paxos.NewOneShotSender(paxos.MakeTxnSubmissionAbortMsg(txnId), sts.connectionManager, activeRMs...)
}
continuation(txnId, nil)
}
}
shutdownFunPtr := &shutdownFun
sts.onShutdown[shutdownFunPtr] = server.EmptyStructVal
outcomeAccumulator := paxos.NewOutcomeAccumulator(int(txnCap.FInc()), acceptors)
consumer := func(sender common.RMId, txnId *common.TxnId, outcome *msgs.Outcome) {
if outcome, _ = outcomeAccumulator.BallotOutcomeReceived(sender, outcome); outcome != nil {
delete(sts.onShutdown, shutdownFunPtr)
shutdownFun(false)
continuation(txnId, outcome)
}
}
sts.outcomeConsumers[*txnId] = consumer
// fmt.Printf("sts%v ", len(sts.outcomeConsumers))
}
func TxnToRootBytes(txn *msgs.Txn) []byte {
seg := capn.NewBuffer(nil)
txnCap := msgs.NewRootTxn(seg)
txnCap.SetId(txn.Id())
txnCap.SetRetry(txn.Retry())
txnCap.SetSubmitter(txn.Submitter())
txnCap.SetSubmitterBootCount(txn.SubmitterBootCount())
txnCap.SetActions(txn.Actions())
txnCap.SetAllocations(txn.Allocations())
txnCap.SetFInc(txn.FInc())
txnCap.SetTopologyVersion(txn.TopologyVersion())
return server.SegToBytes(seg)
}
func (pd *ProposerDispatcher) TxnReceived(sender common.RMId, txn *msgs.Txn) {
txnId := common.MakeTxnId(txn.Id())
pd.withProposerManager(txnId, func(pm *ProposerManager) { pm.TxnReceived(txnId, txn) })
}
func isDeflated(txn *msgs.Txn) bool {
actions := txn.Actions()
return actions.Len() != 0 && actions.At(0).Which() == msgs.ACTION_MISSING
}
func deflateTxn(txn *msgs.Txn, seg *capn.Segment) *msgs.Txn {
if isDeflated(txn) {
return txn
}
deflatedTxn := msgs.NewTxn(seg)
deflatedTxn.SetId(txn.Id())
deflatedTxn.SetRetry(txn.Retry())
deflatedTxn.SetSubmitter(txn.Submitter())
deflatedTxn.SetSubmitterBootCount(txn.SubmitterBootCount())
deflatedTxn.SetFInc(txn.FInc())
deflatedTxn.SetTopologyVersion(txn.TopologyVersion())
deflatedTxn.SetAllocations(txn.Allocations())
actionsList := txn.Actions()
deflatedActionsList := msgs.NewActionList(seg, actionsList.Len())
deflatedTxn.SetActions(deflatedActionsList)
for idx, l := 0, actionsList.Len(); idx < l; idx++ {
deflatedAction := deflatedActionsList.At(idx)
deflatedAction.SetVarId(actionsList.At(idx).VarId())
deflatedAction.SetMissing()
}
return &deflatedTxn
}