void SendHaveMessagesToAll()
{
for (int i = 0; i < Manager.Peers.ConnectedPeers.Count; i++)
{
if (Manager.Peers.ConnectedPeers[i].Connection == null)
{
continue;
}
MessageBundle bundle = new MessageBundle();
foreach (var haveMessage in Manager.finishedPieces)
{
// If the peer has the piece already, we need to recalculate his "interesting" status.
bool hasPiece = Manager.Peers.ConnectedPeers[i].BitField[haveMessage.PieceIndex];
if (hasPiece)
{
bool isInteresting = Manager.PieceManager.IsInteresting(Manager.Peers.ConnectedPeers[i]);
SetAmInterestedStatus(Manager.Peers.ConnectedPeers[i], isInteresting);
}
// Check to see if have supression is enabled and send the have message accordingly
if (!hasPiece || (hasPiece && !Settings.AllowHaveSuppression))
{
bundle.Messages.Add(haveMessage);
}
}
Manager.Peers.ConnectedPeers[i].Enqueue(bundle);
}
Manager.finishedPieces.Clear();
}
public void PickBundle5()
{
rig.Manager.Bitfield.SetAll(true);
for (int i = 0; i < 20; i++)
{
rig.Manager.Bitfield[i % 2] = false;
rig.Manager.Bitfield[10 + i] = false;
}
peers[0].IsChoking = false;
peers[0].BitField.SetAll(true);
for (int i = 0; i < rig.BlocksPerPiece; i++)
{
picker.PickPiece(peers[0], peers[0].BitField, new List <PeerId>(), 1, 3, 3);
}
for (int i = 0; i < rig.BlocksPerPiece; i++)
{
picker.PickPiece(peers[0], peers[0].BitField, new List <PeerId>(), 1, 6, 6);
}
MessageBundle b = picker.PickPiece(peers[0], new List <PeerId>(), 20 * rig.BlocksPerPiece);
Assert.Equal(20 * rig.BlocksPerPiece, b.Messages.Count);
foreach (RequestMessage m in b.Messages)
{
Assert.True(m.PieceIndex >= 10 && m.PieceIndex < 30);
}
}
// Fixes the language display of the game
internal static void FixLangDisplay(MessageDirector dir)
{
string[] bundles =
{
"achieve", "exchange"
};
foreach (string bundle in bundles)
{
MessageBundle actor = dir.GetBundle(bundle);
ResourceBundle rActor = actor.GetPrivateField <ResourceBundle>("bundle");
FileInfo fActor = new FileInfo(Application.dataPath + $"/{bundle}.yaml");
using (StreamWriter writer = fActor.CreateText())
{
writer.WriteLine("#=====================================");
writer.WriteLine("# AUTO GENERATED FROM THE GAME");
writer.WriteLine("#=====================================");
writer.WriteLine("");
foreach (string key in rActor.GetKeys())
{
writer.WriteLine($"{bundle}:" + key + ": \"" +
actor.Get(key).Replace("\"", "\\\"").Replace("\n", "\\n") + "\"");
}
}
}
}
public override MessageBundle PickPiece(PeerId id, BitField peerBitfield, List <PeerId> otherPeers, int count, int startIndex, int endIndex)
{
if (peerBitfield.AllFalse)
{
return(null);
}
if (count > 1)
{
return(base.PickPiece(id, peerBitfield, otherPeers, count, startIndex, endIndex));
}
GenerateRarestFirst(peerBitfield, otherPeers);
while (rarest.Count > 0)
{
BitField current = rarest.Pop();
MessageBundle bundle = base.PickPiece(id, current, otherPeers, count, startIndex, endIndex);
spares.Push(current);
if (bundle != null)
{
return(bundle);
}
}
return(null);
}
protected virtual MessageBundle GetStandardRequest(PeerId id, BitField current, List <PeerId> otherPeers, int startIndex, int endIndex, int count)
{
int piecesNeeded = (count * Piece.BlockSize) / id.TorrentManager.Torrent.PieceLength;
if ((count * Piece.BlockSize) % id.TorrentManager.Torrent.PieceLength != 0)
{
piecesNeeded++;
}
int checkIndex = CanRequest(current, startIndex, endIndex, ref piecesNeeded);
// Nothing to request.
if (checkIndex == -1)
{
return(null);
}
MessageBundle bundle = new MessageBundle();
for (int i = 0; bundle.Messages.Count < count && i < piecesNeeded; i++)
{
// Request the piece
Piece p = new Piece(checkIndex + i, id.TorrentManager.Torrent.PieceLength, id.TorrentManager.Torrent.Size);
requests.Add(p);
for (int j = 0; j < p.Blocks.Length && bundle.Messages.Count < count; j++)
{
p.Blocks[j].Requested = true;
bundle.Messages.Add(p.Blocks[j].CreateRequest(id));
}
}
return(bundle);
}
internal void RaisePeerMessageTransferred(PeerMessageEventArgs e)
{
if (PeerMessageTransferred == null)
{
return;
}
ThreadPool.QueueUserWorkItem(delegate
{
EventHandler <PeerMessageEventArgs> h = PeerMessageTransferred;
if (h == null)
{
return;
}
if (!(e.Message is MessageBundle))
{
h(e.TorrentManager, e);
}
else
{
// Message bundles are only a convience for internal usage!
MessageBundle b = (MessageBundle)e.Message;
foreach (PeerMessage message in b.Messages)
{
PeerMessageEventArgs args = new PeerMessageEventArgs(e.TorrentManager, message, e.Direction, e.ID);
h(args.TorrentManager, args);
}
}
});
}
private void SendHaveMessagesToAll()
{
foreach (var peerId in _manager.Peers.ConnectedPeers)
{
if (peerId.Connection == null)
{
continue;
}
var bundle = new MessageBundle();
foreach (var pieceIndex in _manager.FinishedPieces)
{
// If the peer has the piece already, we need to recalculate his "interesting" status.
var hasPiece = peerId.BitField[pieceIndex];
if (hasPiece)
{
var isInteresting = _manager.PieceManager.IsInteresting(peerId);
SetAmInterestedStatus(peerId, isInteresting);
}
// Check to see if have supression is enabled and send the have message accordingly
if (!hasPiece || (hasPiece && !_manager.Engine.Settings.HaveSupressionEnabled))
{
bundle.Messages.Add(new HaveMessage(pieceIndex));
}
}
peerId.Enqueue(bundle);
}
_manager.FinishedPieces.Clear();
}
public MessageBundle getBundle(GadgetSpec spec, Locale locale, bool ignoreCache)
{
if (ignoreCache)
{
return(getNestedBundle(spec, locale, true));
}
String key = spec.getUrl().ToString() + '.' + locale.ToString();
MessageBundle cached = HttpRuntime.Cache[key] as MessageBundle;
MessageBundle bundle;
if (cached == null)
{
try
{
bundle = getNestedBundle(spec, locale, ignoreCache);
}
catch (GadgetException)
{
// Enforce negative caching.
bundle = cached ?? MessageBundle.EMPTY;
}
HttpRuntime.Cache.Insert(key, bundle, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromSeconds(refresh));
}
else
{
bundle = cached;
}
return(bundle);
}
public override MessageBundle PickPiece(PeerId id, BitField peerBitfield, List <PeerId> otherPeers, int count, int startIndex, int endIndex)
{
// Fast Path - the peer has nothing to offer
if (peerBitfield.AllFalse)
{
return(null);
}
if (files.Count == 1)
{
if (files[0].File.Priority == Priority.DoNotDownload)
{
return(null);
}
else
{
return(base.PickPiece(id, peerBitfield, otherPeers, count, startIndex, endIndex));
}
}
files.Sort();
// Fast Path - all the files have been set to DoNotDownload
if (files[0].File.Priority == Priority.DoNotDownload)
{
return(null);
}
// Fast Path - If all the files are the same priority, call straight into the base picker
if (files.TrueForAll(AllSamePriority))
{
return(base.PickPiece(id, peerBitfield, otherPeers, count, startIndex, endIndex));
}
temp.From(files[0].Selector);
for (int i = 1; i < files.Count && files[i].File.Priority != Priority.DoNotDownload; i++)
{
if (files[i].File.Priority != files[i - 1].File.Priority)
{
temp.And(peerBitfield);
if (!temp.AllFalse)
{
MessageBundle message = base.PickPiece(id, temp, otherPeers, count, startIndex, endIndex);
if (message != null)
{
return(message);
}
temp.SetAll(false);
}
}
temp.Or(files[i].Selector);
}
if (temp.AllFalse || temp.And(peerBitfield).AllFalse)
{
return(null);
}
return(base.PickPiece(id, temp, otherPeers, count, startIndex, endIndex));
}
public void PickBundle6()
{
rig.Manager.Bitfield.SetAll(false);
peers[0].IsChoking = false;
peers[0].BitField.SetAll(true);
for (int i = 0; i < rig.BlocksPerPiece; i++)
{
picker.PickPiece(peers[0], peers[0].BitField, new List <PeerId>(), 1, 0, 0);
}
for (int i = 0; i < rig.BlocksPerPiece; i++)
{
picker.PickPiece(peers[0], peers[0].BitField, new List <PeerId>(), 1, 1, 1);
}
for (int i = 0; i < rig.BlocksPerPiece; i++)
{
picker.PickPiece(peers[0], peers[0].BitField, new List <PeerId>(), 1, 3, 3);
}
for (int i = 0; i < rig.BlocksPerPiece; i++)
{
picker.PickPiece(peers[0], peers[0].BitField, new List <PeerId>(), 1, 6, 6);
}
MessageBundle b = picker.PickPiece(peers[0], new List <PeerId>(), 2 * rig.BlocksPerPiece);
Assert.AreEqual(2 * rig.BlocksPerPiece, b.Messages.Count);
foreach (RequestMessage m in b.Messages)
{
Assert.IsTrue(m.PieceIndex >= 4 && m.PieceIndex < 6);
}
}
public void Setup()
{
requestedUrl.Clear();
partialData = false;
int i;
for (i = 0; i < 1000; i++)
{
try
{
listener = new HttpListener();
listener.Prefixes.Add(string.Format(listenerURL, i));
listener.Start();
break;
}
catch
{
}
}
listener.BeginGetContext(GotContext, null);
rig = TestRig.CreateMultiFile();
connection = new HttpConnection(new Uri(string.Format(listenerURL, i)));
connection.Manager = rig.Manager;
id = new PeerId(new Peer("this is my id", connection.Uri), rig.Manager);
id.Connection = connection;
id.IsChoking = false;
id.AmInterested = true;
id.BitField.SetAll(true);
id.MaxPendingRequests = numberOfPieces;
requests = rig.Manager.PieceManager.Picker.PickPiece(id, new List <PeerId>(), numberOfPieces);
}
void SendHaveMessagesToAll()
{
for (int i = 0; i < manager.Peers.ConnectedPeers.Count; i++)
{
var connectedPeer = manager.Peers.ConnectedPeers[i];
if (connectedPeer.Connection == null)
{
continue;
}
MessageBundle bundle = new MessageBundle();
foreach (int pieceIndex in manager.finishedPieces)
{
// If the peer has the piece already, we need to recalculate his "interesting" status.
bool hasPiece = connectedPeer.BitField[pieceIndex];
if (hasPiece)
{
bool isInteresting = manager.PieceManager.IsInteresting(manager.Peers.ConnectedPeers[i]);
SetAmInterestedStatus(connectedPeer, isInteresting);
}
// Check to see if have supression is enabled and send the have message accordingly
if (!hasPiece || (hasPiece && !manager.Engine.Settings.HaveSupressionEnabled))
{
bundle.Messages.Add(new HaveMessage(pieceIndex));
}
}
connectedPeer.Enqueue(bundle);
}
manager.finishedPieces.Clear();
}
protected override void AppendBitfieldMessage(PeerId id, MessageBundle bundle)
{
if (id.SupportsFastPeer)
bundle.Messages.Add(new HaveNoneMessage());
else
bundle.Messages.Add(new BitfieldMessage(zero));
}
protected virtual void AppendExtendedHandshake(PeerId id, MessageBundle bundle)
{
if (id.SupportsLTMessages && ClientEngine.SupportsExtended)
{
bundle.Messages.Add(new ExtendedHandshakeMessage(Manager.Torrent?.IsPrivate ?? false, Manager.HasMetadata ? Manager.Torrent.InfoMetadata.Length : 0, Settings.ListenPort));
}
}
void SendHaveMessagesToAll ()
{
if (Manager.finishedPieces.Count == 0)
return;
if (Settings.AllowHaveSuppression) {
for (int i = 0; i < Manager.Peers.ConnectedPeers.Count; i++) {
var bundle = new MessageBundle ();
foreach (HaveMessage haveMessage in Manager.finishedPieces) {
// If the peer has the piece already, we need to recalculate his "interesting" status.
bool hasPiece = Manager.Peers.ConnectedPeers[i].BitField[haveMessage.PieceIndex];
if (!hasPiece)
bundle.Messages.Add (haveMessage);
}
Manager.Peers.ConnectedPeers[i].Enqueue (bundle);
}
} else {
var bundle = new MessageBundle (Manager.finishedPieces.Count);
foreach (HaveMessage haveMessage in Manager.finishedPieces)
bundle.Messages.Add (haveMessage);
foreach (PeerId peer in Manager.Peers.ConnectedPeers)
peer.Enqueue (bundle);
}
foreach (PeerId peer in Manager.Peers.ConnectedPeers) {
bool isInteresting = Manager.PieceManager.IsInteresting (peer);
SetAmInterestedStatus (peer, isInteresting);
}
Manager.finishedPieces.Clear ();
}
public void ChunkedRequest()
{
if (requests.Messages.Count != 0)
{
rig.Manager.PieceManager.Picker.CancelRequests(id);
}
requests = rig.Manager.PieceManager.Picker.PickPiece(id, new List <PeerId>(), 256);
byte[] sendBuffer = requests.Encode();
int offset = 0;
amountSent = Math.Min(sendBuffer.Length - offset, 2048);
IAsyncResult sendResult = connection.BeginSend(sendBuffer, offset, amountSent, null, null);
while (sendResult.AsyncWaitHandle.WaitOne(10, true))
{
Assert.AreEqual(amountSent, connection.EndSend(sendResult), "#1." + amountSent);
offset += amountSent;
amountSent = Math.Min(sendBuffer.Length - offset, 2048);
if (amountSent == 0)
{
Assert.Fail("This should never happen");
}
sendResult = connection.BeginSend(sendBuffer, offset, amountSent, null, null);
}
byte[] buffer = new byte[1024 * 1024 * 3];
IAsyncResult receiveResult = connection.BeginReceive(buffer, 0, 4, null, null);
CompleteSendOrReceiveFirst(buffer, receiveResult, sendResult);
}
protected virtual void AppendExtendedHandshake(PeerId id, MessageBundle bundle)
{
if (id.SupportsLTMessages && ClientEngine.SupportsExtended)
{
bundle.Messages.Add(new ExtendedHandshakeMessage(manager.HasMetadata ? manager.Torrent.Metadata.Length : 0));
}
}
protected virtual void AppendFastPieces (PeerId id, MessageBundle bundle)
{
// Now we will enqueue a FastPiece message for each piece we will allow the peer to download
// even if they are choked
if (ClientEngine.SupportsFastPeer && id.SupportsFastPeer)
for (int i = 0; i < id.AmAllowedFastPieces.Count; i++)
bundle.Messages.Add (new AllowedFastMessage (id.AmAllowedFastPieces[i]));
}
public virtual void HandlePeerConnected(PeerId id, Direction direction)
{
MessageBundle bundle = new MessageBundle();
AppendBitfieldMessage(id, bundle);
AppendExtendedHandshake(id, bundle);
AppendFastPieces(id, bundle);
id.Enqueue(bundle);
}
public override MessageBundle PickPiece(PeerId id, BitField peerBitfield, List <PeerId> otherPeers, int count, int startIndex, int endIndex)
{
MessageBundle bundle = ActivePicker.PickPiece(id, peerBitfield, otherPeers, count, startIndex, endIndex);
if (bundle == null && TryEnableEndgame())
{
return(ActivePicker.PickPiece(id, peerBitfield, otherPeers, count, startIndex, endIndex));
}
return(bundle);
}
protected override void AppendBitfieldMessage(PeerId id, MessageBundle bundle)
{
if (id.SupportsFastPeer)
{
bundle.Add(HaveNoneMessage.Instance, default);
}
else
{
bundle.Add(new BitfieldMessage(zero), default);
}
}
protected override void AppendBitfieldMessage(PeerId id, MessageBundle bundle)
{
if (id.SupportsFastPeer)
{
bundle.Messages.Add(new HaveNoneMessage());
}
else
{
bundle.Messages.Add(new BitfieldMessage(zero));
}
}
public void RequestBlock()
{
peer.IsChoking = false;
peer.BitField.SetAll(true);
for (int i = 0; i < 1000; i++)
{
MessageBundle b = picker.PickPiece(peer, peers, i);
Assert.AreEqual(Math.Min(i, rig.TotalBlocks), b.Messages.Count);
picker.CancelRequests(peer);
}
}
protected override void AppendBitfieldMessage(PeerId id, MessageBundle bundle)
{
if (ClientEngine.SupportsFastPeer && id.SupportsFastPeer)
{
bundle.Messages.Add(new HaveNoneMessage());
}
// If the fast peer extensions are not supported we must not send a
// bitfield message because we don't know how many pieces the torrent
// has. We could probably send an invalid one and force the connection
// to close.
}
protected virtual void AppendFastPieces(PeerId id, MessageBundle bundle)
{
// Now we will enqueue a FastPiece message for each piece we will allow the peer to download
// even if they are choked
if (ClientEngine.SupportsFastPeer && id.SupportsFastPeer)
{
foreach (var pieceIndex in id.AmAllowedFastPieces)
{
bundle.Messages.Add(new AllowedFastMessage(pieceIndex));
}
}
}
public void DoesntHaveSuggestedPiece()
{
peer.IsChoking = false;
peer.SupportsFastPeer = true;
peer.SuggestedPieces.AddRange(new int[] { 1, 2, 3, 4 });
peer.BitField.SetAll(true);
picker = new StandardPicker();
picker.Initialise(rig.Manager.Bitfield, rig.Torrent.Files, new List <Piece>());
MessageBundle bundle = picker.PickPiece(peer, new MonoTorrent.Common.BitField(peer.BitField.Length), peers, 1, 0, peer.BitField.Length);
Assert.IsNull(bundle);
}
public override MessageBundle PickPiece(PeerId id, BitField peerBitfield, List <PeerId> otherPeers, int count, int startIndex, int endIndex)
{
RequestMessage message;
MessageBundle bundle = null;
// If there is already a request on this peer, try to request the next block. If the peer is choking us, then the only
// requests that could be continued would be existing "Fast" pieces.
if ((message = ContinueExistingRequest(id)) != null)
{
return(bundle = new MessageBundle(message));
}
// Then we check if there are any allowed "Fast" pieces to download
if (id.IsChoking && (message = GetFromList(id, peerBitfield, id.IsAllowedFastPieces)) != null)
{
return(bundle = new MessageBundle(message));
}
// If the peer is choking, then we can't download from them as they had no "fast" pieces for us to download
if (id.IsChoking)
{
return(null);
}
// If we are only requesting 1 piece, then we can continue any existing. Otherwise we should try
// to request the full amount first, then try to continue any existing.
if (count == 1 && (message = ContinueAnyExisting(id)) != null)
{
return(bundle = new MessageBundle(message));
}
// We see if the peer has suggested any pieces we should request
if ((message = GetFromList(id, peerBitfield, id.SuggestedPieces)) != null)
{
return(bundle = new MessageBundle(message));
}
// Now we see what pieces the peer has that we don't have and try and request one
if ((bundle = GetStandardRequest(id, peerBitfield, otherPeers, startIndex, endIndex, count)) != null)
{
return(bundle);
}
// If all else fails, ignore how many we're requesting and try to continue any existing
if ((message = ContinueAnyExisting(id)) != null)
{
return(bundle = new MessageBundle(message));
}
return(null);
}
/// <summary>Constructor that creates an extraction error message for the specified message.</summary>
/// <param name="messageId">the id of the message to create an extraction error for.</param>
/// <param name="destination">the endpoint identifier that the extraction error message will be sent to.</param>
/// <param name="source">the endpoint identifier that the extraction error message will be sent from.</param>
public ExtractionErrorMessage(string messageId, string destination, string source = "http://nchs.cdc.gov/vrdr_submission") : base("http://nchs.cdc.gov/vrdr_extraction_error")
{
Header.Source.Endpoint = source;
this.MessageDestination = destination;
MessageHeader.ResponseComponent resp = new MessageHeader.ResponseComponent();
resp.Identifier = messageId;
resp.Code = MessageHeader.ResponseType.FatalError;
Header.Response = resp;
this.details = new OperationOutcome();
this.details.Id = Guid.NewGuid().ToString();
MessageBundle.AddResourceEntry(this.details, "urn:uuid:" + this.details.Id);
Header.Response.Details = new ResourceReference("urn:uuid:" + this.details.Id);
}
public void ChunkedRequest()
{
if (requests.Messages.Count != 0)
{
rig.Manager.PieceManager.Picker.CancelRequests(id);
}
requests = rig.Manager.PieceManager.Picker.PickPiece(id, new List <PeerId>(), 256);
byte[] sendBuffer = requests.Encode();
var sendTask = Send(sendBuffer, 0, sendBuffer.Length, 1);
Assert.ThrowsAsync <ArgumentException>(() => sendTask);
}
/**
* Injects message bundles into the gadget output.
* @throws GadgetException If we are unable to retrieve the message bundle.
*/
private void InjectMessageBundles(Gadget gadget, Node scriptTag)
{
GadgetContext context = gadget.getContext();
MessageBundle bundle = messageBundleFactory.getBundle(
gadget.getSpec(), context.getLocale(), context.getIgnoreCache());
String msgs = bundle.ToJSONString();
Text text = scriptTag.getOwnerDocument().createTextNode("gadgets.Prefs.setMessages_(");
text.appendData(msgs);
text.appendData(");");
scriptTag.appendChild(text);
}
public override MessageBundle PickPiece(PeerId id, BitField peerBitfield, List <PeerId> otherPeers, int count, int startIndex, int endIndex)
{
MessageBundle bundle = base.PickPiece(id, peerBitfield, otherPeers, count, startIndex, endIndex);
if (bundle != null)
{
foreach (RequestMessage m in bundle.Messages)
{
HandleRequest(id, m);
}
}
return(bundle);
}
protected override void AppendBitfieldMessage(PeerId id, MessageBundle bundle)
{
// We can't send a bitfield message in metadata mode as
// we don't know what size the bitfield is
}
public virtual void HandlePeerConnected(PeerId id, Direction direction)
{
var bundle = new MessageBundle();
AppendBitfieldMessage(id, bundle);
AppendExtendedHandshake(id, bundle);
AppendFastPieces(id, bundle);
id.Enqueue(bundle);
}
protected virtual void AppendBitfieldMessage(PeerId id, MessageBundle bundle)
{
if (id.SupportsFastPeer && ClientEngine.SupportsFastPeer)
{
if (_manager.Bitfield.AllFalse)
bundle.Messages.Add(new HaveNoneMessage());
else if (_manager.Bitfield.AllTrue)
bundle.Messages.Add(new HaveAllMessage());
else
bundle.Messages.Add(new BitfieldMessage(_manager.Bitfield));
}
else
{
bundle.Messages.Add(new BitfieldMessage(_manager.Bitfield));
}
}
protected virtual void AppendExtendedHandshake(PeerId id, MessageBundle bundle)
{
if (id.SupportsLTMessages && ClientEngine.SupportsExtended)
bundle.Messages.Add(
new ExtendedHandshakeMessage(_manager.HasMetadata ? _manager.Torrent.Metadata.Length : 0));
}
protected virtual void AppendFastPieces(PeerId id, MessageBundle bundle)
{
// Now we will enqueue a FastPiece message for each piece we will allow the peer to download
// even if they are choked
if (ClientEngine.SupportsFastPeer && id.SupportsFastPeer)
foreach (var pieceIndex in id.AmAllowedFastPieces)
bundle.Messages.Add(new AllowedFastMessage(pieceIndex));
}
private void SendHaveMessagesToAll()
{
foreach (var peerId in _manager.Peers.ConnectedPeers)
{
if (peerId.Connection == null)
continue;
var bundle = new MessageBundle();
foreach (var pieceIndex in _manager.finishedPieces)
{
// If the peer has the piece already, we need to recalculate his "interesting" status.
var hasPiece = peerId.BitField[pieceIndex];
if (hasPiece)
{
var isInteresting = _manager.PieceManager.IsInteresting(peerId);
SetAmInterestedStatus(peerId, isInteresting);
}
// Check to see if have supression is enabled and send the have message accordingly
if (!hasPiece || (hasPiece && !_manager.Engine.Settings.HaveSupressionEnabled))
bundle.Messages.Add(new HaveMessage(pieceIndex));
}
peerId.Enqueue(bundle);
}
_manager.finishedPieces.Clear();
}
