public void MultipleAnnounce()
{
var announceCount = 0;
var random = new Random();
var handle = new ManualResetEvent(false);
for (var i = 0; i < 20; i++)
{
var infoHash = new InfoHash(new byte[20]);
random.NextBytes(infoHash.Hash);
var tier = new TrackerTier(new[] {_uri.ToString()});
tier.Trackers[0].AnnounceComplete += (sender, args) =>
{
if (++announceCount == 20)
handle.Set();
};
var id = new TrackerConnectionID(tier.Trackers[0], false, TorrentEvent.Started,
new ManualResetEvent(false));
var parameters = new AnnounceParameters(0, 0, 0, TorrentEvent.Started,
infoHash, false, new string('1', 20),
string.Empty, 1411);
tier.Trackers[0].Announce(parameters, id);
}
Assert.IsTrue(handle.WaitOne(5000, true), "Some of the responses weren't received");
}
public override void Announce(AnnounceParameters parameters, object state)
{
//LastUpdated = DateTime.Now;
if (!hasConnected && amConnecting)
{
return;
}
if (!hasConnected)
{
amConnecting = true;
try
{
Connect(new ConnectAnnounceState(parameters, ConnectAnnounceCallback, state));
}
catch (SocketException)
{
DoAnnounceComplete(false, state, new List <Peer>());
return;
}
}
else
{
DoAnnounce(parameters, state);
}
}
private void DoAnnounce(AnnounceParameters parameters, object state)
{
ConnectAnnounceState announceState = new ConnectAnnounceState(parameters, AnnounceCallback, state);
announceState.Message = new AnnounceMessage(DateTime.Now.GetHashCode(), connectionId, parameters);
try
{
SendAndReceive(announceState);
}
catch (SocketException)
{
DoAnnounceComplete(false, state, new List <Peer>());
}
}
private Uri CreateAnnounceString(AnnounceParameters parameters)
{
var builder = new UriQueryBuilder(Uri);
builder.Add("info_hash", parameters.InfoHash.UrlEncode())
.Add("peer_id", parameters.PeerId)
.Add("port", parameters.Port)
.Add("uploaded", parameters.BytesUploaded)
.Add("downloaded", parameters.BytesDownloaded)
.Add("left", parameters.BytesLeft)
.Add("compact", 1)
.Add("numwant", 100);
if (parameters.SupportsEncryption)
{
builder.Add("supportcrypto", 1);
}
if (parameters.RequireEncryption)
{
builder.Add("requirecrypto", 1);
}
if (!builder.Contains("key"))
{
builder.Add("key", Key);
}
if (!string.IsNullOrEmpty(parameters.Ipaddress))
{
builder.Add("ip", parameters.Ipaddress);
}
// If we have not successfully sent the started event to this tier, override the passed in started event
// Otherwise append the event if it is not "none"
//if (!parameters.Id.Tracker.Tier.SentStartedEvent)
//{
// sb.Append("&event=started");
// parameters.Id.Tracker.Tier.SendingStartedEvent = true;
//}
if (parameters.ClientEvent != TorrentEvent.None)
{
builder.Add("event", parameters.ClientEvent.ToString().ToLower());
}
if (!string.IsNullOrEmpty(_trackerId))
{
builder.Add("trackerid", _trackerId);
}
return(builder.ToUri());
}
private WaitHandle Announce(Tracker tracker, TorrentEvent clientEvent, bool trySubsequent,
ManualResetEvent waitHandle)
{
var engine = _manager.Engine;
// If the engine is null, we have been unregistered
if (engine == null)
{
waitHandle.Set();
return(waitHandle);
}
_updateSucceeded = true;
_lastUpdated = DateTime.Now;
var e = engine.Settings.AllowedEncryption;
var requireEncryption = !Toolbox.HasEncryption(e, EncryptionTypes.PlainText);
var supportsEncryption = Toolbox.HasEncryption(e, EncryptionTypes.RC4Full) ||
Toolbox.HasEncryption(e, EncryptionTypes.RC4Header);
requireEncryption = requireEncryption && ClientEngine.SupportsEncryption;
supportsEncryption = supportsEncryption && ClientEngine.SupportsEncryption;
var reportedAddress = engine.Settings.ReportedAddress;
var ip = reportedAddress == null ? null : reportedAddress.Address.ToString();
var port = reportedAddress == null ? engine.Listener.Endpoint.Port : reportedAddress.Port;
// FIXME: In metadata mode we need to pretend we need to download data otherwise
// tracker optimisations might result in no peers being sent back.
long bytesLeft = 1000;
if (_manager.HasMetadata)
{
bytesLeft = (long)((1 - _manager.Bitfield.PercentComplete / 100.0) * _manager.Torrent.Size);
}
var parameters = new AnnounceParameters(_manager.Monitor.DataBytesDownloaded,
_manager.Monitor.DataBytesUploaded,
bytesLeft,
clientEvent, _infoHash, requireEncryption, _manager.Engine.PeerId,
ip, port)
{
SupportsEncryption = supportsEncryption
};
var id = new TrackerConnectionID(tracker, trySubsequent, clientEvent, waitHandle);
tracker.Announce(parameters, id);
return(waitHandle);
}
public override void Announce(AnnounceParameters parameters, object state)
{
try
{
var announceString = CreateAnnounceString(parameters);
var request = (HttpWebRequest)WebRequest.Create(announceString);
request.UserAgent = VersionInfo.ClientVersion;
request.Proxy = new WebProxy(); // If i don't do this, i can't run the webrequest. It's wierd.
RaiseBeforeAnnounce();
BeginRequest(request, AnnounceReceived, new[] { request, state });
}
catch (Exception ex)
{
Status = TrackerState.Offline;
FailureMessage = ("Could not initiate announce request: " + ex.Message);
RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, state, false));
}
}
public void AnnounceTest()
{
var t = (HTTPTracker) TrackerFactory.Create(new Uri(Prefix));
var id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));
AnnounceResponseEventArgs p = null;
t.AnnounceComplete += (o, e) =>
{
p = e;
id.WaitHandle.Set();
};
var pars = new AnnounceParameters
{
PeerId = "id",
InfoHash = new InfoHash(new byte[20])
};
t.Announce(pars, id);
Wait(id.WaitHandle);
Assert.IsNotNull(p, "#1");
Assert.IsTrue(p.Successful);
Assert.AreEqual(_keys[0], t.Key, "#2");
}
public abstract void Announce(AnnounceParameters parameters, object state);
public void ScrapeTest()
{
var t = TrackerFactory.Create(new Uri(Prefix.Substring(0, Prefix.Length - 1)));
Assert.IsTrue(t.CanScrape, "#1");
var id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));
AnnounceResponseEventArgs p = null;
t.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e)
{
p = e;
id.WaitHandle.Set();
};
var pars = new AnnounceParameters {PeerId = "id", InfoHash = new InfoHash(new byte[20])};
t.Announce(pars, id);
Wait(id.WaitHandle);
Assert.IsNotNull(p, "#2");
Assert.IsTrue(p.Successful, "#3");
Assert.AreEqual(1, t.Complete, "#1");
Assert.AreEqual(0, t.Incomplete, "#2");
Assert.AreEqual(0, t.Downloaded, "#3");
}
public override void Announce(AnnounceParameters parameters, object state)
{
}
public override void Announce(AnnounceParameters parameters, object state)
{
RaiseBeforeAnnounce();
AnnouncedAt.Add(DateTime.Now);
RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, state, !FailAnnounce));
}
public override void Announce(AnnounceParameters parameters, object state)
{
RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, state, true));
}
public void KeyTest()
{
var pars = new AnnounceParameters
{
PeerId = "id",
InfoHash = new InfoHash(new byte[20])
};
var t = TrackerFactory.Create(new Uri(Prefix + "?key=value"));
var id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));
t.AnnounceComplete += delegate { id.WaitHandle.Set(); };
t.Announce(pars, id);
Wait(id.WaitHandle);
Assert.AreEqual("value", _keys[0], "#1");
}
public ConnectAnnounceState(AnnounceParameters parameters, AsyncCallback callback, object state)
: base(callback, state)
{
Parameters = parameters;
}
public abstract void Announce(AnnounceParameters parameters, object state);
private void OfflineAnnounceTest()
{
var udpTracker = (UdpTracker) TrackerFactory.Create(new Uri("udp://127.0.0.1:57532/announce"));
udpTracker.RetryDelay = TimeSpan.FromMilliseconds(500);
var id = new TrackerConnectionID(udpTracker, false, TorrentEvent.Started, new ManualResetEvent(false));
AnnounceResponseEventArgs p = null;
udpTracker.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e)
{
p = e;
id.WaitHandle.Set();
};
var pars = new AnnounceParameters
{
InfoHash = new InfoHash(new byte[20]),
PeerId = ""
};
udpTracker.Announce(pars, id);
Wait(id.WaitHandle);
Assert.IsNotNull(p, "#1");
Assert.IsFalse(p.Successful);
}
public void AnnounceTest()
{
var udpTracker = (UdpTracker) TrackerFactory.Create(new Uri(Prefix));
var id = new TrackerConnectionID(udpTracker, false, TorrentEvent.Started, new ManualResetEvent(false));
AnnounceResponseEventArgs p = null;
udpTracker.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e)
{
p = e;
id.WaitHandle.Set();
};
var pars = new AnnounceParameters
{
InfoHash = new InfoHash(new byte[20]),
PeerId = ""
};
udpTracker.Announce(pars, id);
Wait(id.WaitHandle);
Assert.IsNotNull(p, "#1");
Assert.IsTrue(p.Successful);
//Assert.AreEqual(keys[0], t.Key, "#2");
}
