public override void Bind(Instance r)
{
WaitQuorum(r, MessageType.Propose, msgs =>
{
var x = PickMostFrequentValue(
msgs.Where(m => Archiver.CanCommit(m.Value))
);
var v = x.Count > r.Proposers.Count / 2 ? x.Value : null;
Broadcast(r, MessageType.Select, v);
});
WaitQuorum(r, MessageType.Select, msgs =>
{
var x = PickMostFrequentValue(msgs.Where(m => m.Value != null));
if (x.Count >= f + 1)
{
Terminate(r, x.Value);
Proposer.Reset();
}
else
{
if (x.Count > 0)
{
Proposer.Set(x.Value);
}
else
{
Proposer.Reset();
}
}
});
}
public NkProcess(Archiver archiver, Proposer proposer, int k)
: base(archiver, proposer)
{
this.k = k;
counter = 0;
sync = new object();
blockchains = new Dictionary <string, LinkedList <Block> >();
AddGenesisChain();
}
public override int GetHashCode()
{
int hash = 1;
if (proposer_ != null)
{
hash ^= Proposer.GetHashCode();
}
if (Status != 0)
{
hash ^= Status.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public void MergeFrom(ContractProposingInput other)
{
if (other == null)
{
return;
}
if (other.proposer_ != null)
{
if (proposer_ == null)
{
Proposer = new global::AElf.Types.Address();
}
Proposer.MergeFrom(other.Proposer);
}
if (other.Status != 0)
{
Status = other.Status;
}
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
}
private void BindAsProposer(Instance r)
{
WaitQuorum(r, MessageType.Ack, msgs =>
{
var v = PickHighestNumberedValue(msgs)?.Value ?? Proposer.GetProposal();
if (Archiver.CanCommit(v))
{
var x = new NumberedValue(v, proposalNumber);
Broadcast(r, MessageType.Select, x);
}
});
WaitMessage(r, MessageType.Nack, msg =>
{
if (msg.Value != null)
{
var n = (long)msg.Value;
if (n > minNumber)
{
minNumber = Math.Max(n, minNumber);
if (RandomExtensions.Tryout(0.5))
{
Propose(r);
}
}
}
});
WaitQuorum(r, MessageType.Accept, msgs =>
{
var m = msgs.Select(m => m.Value).Distinct();
if (m.Count() == 1)
{
var x = m.Single() as NumberedValue;
Terminate(r, x);
Broadcast(r, MessageType.Decide, x);
}
});
}
protected virtual void SelectNewMasterOnTopologyChanged(object sender, NodeMetadata nodeMetadata)
{
if (nodeMetadata.ChangeType == TopologyChangeType.MasterSelected)
{
return; //nothing to do here
}
MasterSelectedByQuorum = null; // Who is the master is in doubt, because the topology changed
var others = topologyState.Keys.ToArray();
var acceptor = new Acceptor(this, myAddress, others);
var proposer = new Proposer(this, acceptor, myAddress, others);
var learner = new Learner(this, others);
learner.OnAcceptedValue += LearnerOnOnAcceptedValue;
agents = new Agent[] { acceptor, proposer, learner };
proposer.StartProposing(new SwitchMasterCommand
{
NewMaster = others.OrderBy(x => x.AbsoluteUri).First()
});
}
private Block MineBlock(Instance r)
{
Block b = null;
var found = false;
var v = Proposer.GetProposal();
var c = counter;
while (!IsTerminated(r) && Archiver.CanCommit(v) && !found)
{
if (b == null || counter > c)
{
c = counter;
var h = GetHeadFromLongestChain(v);
if (h == null)
{
break;
}
b = new Block(v, h);
}
b.IncrementPoW();
found = b.VerifyPoW();
}
return(found ? b : null);
}
public CTProcess(Archiver archiver, Proposer proposer)
: base(archiver, proposer)
{
}
public BOProcess(Archiver archiver, Proposer proposer, int f)
: base(archiver, proposer)
{
this.f = f;
}
private static int Score(Proposer proposer, Accepter accepter) => proposer.PreferenceOrder.ToList().IndexOf(accepter);
public Result <IReadOnlyList <PublisherGame> > GetNewPublisherGamesFromTrade(Instant completionTime)
{
var dateOfAcquisition = completionTime.ToEasternDate();
var proposerGameDictionary = Proposer.PublisherGames.Where(x => x.MasterGame is not null).ToDictionary(x => x.GetMasterGameYearWithCounterPick() !);
var counterPartyGameDictionary = CounterParty.PublisherGames.Where(x => x.MasterGame is not null).ToDictionary(x => x.GetMasterGameYearWithCounterPick() !);
List <PotentialPublisherSlot> newlyOpenProposerSlotNumbers = new List <PotentialPublisherSlot>();
foreach (var game in ProposerMasterGames)
{
var existingPublisherGame = proposerGameDictionary[game];
newlyOpenProposerSlotNumbers.Add(new PotentialPublisherSlot(existingPublisherGame.SlotNumber, game.CounterPick));
}
List <PotentialPublisherSlot> newlyOpenCounterPartySlotNumbers = new List <PotentialPublisherSlot>();
foreach (var game in CounterPartyMasterGames)
{
var existingPublisherGame = counterPartyGameDictionary[game];
newlyOpenCounterPartySlotNumbers.Add(new PotentialPublisherSlot(existingPublisherGame.SlotNumber, game.CounterPick));
}
var alreadyOpenProposerSlotNumbers = Proposer.GetPublisherSlots(LeagueYear.Options).Where(x => x.PublisherGame is null).Select(x => new PotentialPublisherSlot(x.SlotNumber, x.CounterPick));
var alreadyOpenCounterPartySlotNumbers = CounterParty.GetPublisherSlots(LeagueYear.Options).Where(x => x.PublisherGame is null).Select(x => new PotentialPublisherSlot(x.SlotNumber, x.CounterPick));
var allOpenProposerSlotNumbers = alreadyOpenProposerSlotNumbers.Concat(newlyOpenProposerSlotNumbers).Distinct().OrderBy(x => x.CounterPick).ThenBy(x => x.SlotNumber).ToList();
var allOpenCounterPartySlotNumbers = alreadyOpenCounterPartySlotNumbers.Concat(newlyOpenCounterPartySlotNumbers).Distinct().OrderBy(x => x.CounterPick).ThenBy(x => x.SlotNumber).ToList();
List <PublisherGame> newPublisherGames = new List <PublisherGame>();
foreach (var game in ProposerMasterGames)
{
var existingPublisherGame = proposerGameDictionary[game];
var eligibilityFactors = LeagueYear.GetEligibilityFactorsForMasterGame(game.MasterGameYear.MasterGame, dateOfAcquisition);
var openSlotNumbers = allOpenCounterPartySlotNumbers.Where(x => x.CounterPick == game.CounterPick).Select(x => x.SlotNumber);
var slotResult = SlotEligibilityService.GetTradeSlotResult(CounterParty, LeagueYear.Options, game, eligibilityFactors, openSlotNumbers);
if (!slotResult.HasValue)
{
return(Result.Failure <IReadOnlyList <PublisherGame> >($"Cannot find an appropriate slot for: {game.MasterGameYear.MasterGame.GameName}"));
}
allOpenCounterPartySlotNumbers = allOpenCounterPartySlotNumbers.Where(x => !(x.SlotNumber == slotResult.Value && x.CounterPick == game.CounterPick)).ToList();
PublisherGame newPublisherGame = new PublisherGame(CounterParty.PublisherID, Guid.NewGuid(), game.MasterGameYear.MasterGame.GameName, completionTime,
game.CounterPick, existingPublisherGame.ManualCriticScore, existingPublisherGame.ManualWillNotRelease, existingPublisherGame.FantasyPoints, game.MasterGameYear, slotResult.Value, null, null, null, TradeID);
newPublisherGames.Add(newPublisherGame);
}
foreach (var game in CounterPartyMasterGames)
{
var existingPublisherGame = counterPartyGameDictionary[game];
var eligibilityFactors = LeagueYear.GetEligibilityFactorsForMasterGame(game.MasterGameYear.MasterGame, dateOfAcquisition);
var openSlotNumbers = allOpenProposerSlotNumbers.Where(x => x.CounterPick == game.CounterPick).Select(x => x.SlotNumber);
var slotResult = SlotEligibilityService.GetTradeSlotResult(Proposer, LeagueYear.Options, game, eligibilityFactors, openSlotNumbers);
if (!slotResult.HasValue)
{
return(Result.Failure <IReadOnlyList <PublisherGame> >($"Cannot find an appropriate slot for: {game.MasterGameYear.MasterGame.GameName}"));
}
allOpenProposerSlotNumbers = allOpenProposerSlotNumbers.Where(x => !(x.SlotNumber == slotResult.Value && x.CounterPick == game.CounterPick)).ToList();
PublisherGame newPublisherGame = new PublisherGame(Proposer.PublisherID, Guid.NewGuid(), game.MasterGameYear.MasterGame.GameName, completionTime,
game.CounterPick, existingPublisherGame.ManualCriticScore, existingPublisherGame.ManualWillNotRelease, existingPublisherGame.FantasyPoints, game.MasterGameYear, slotResult.Value, null, null, null, TradeID);
newPublisherGames.Add(newPublisherGame);
}
return(newPublisherGames);
}
public PxProcess(Archiver archiver, Proposer proposer)
: base(archiver, proposer)
{
proposalNumber = -1;
minNumber = 0;
}
