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 override Task AnnounceAsync(AnnounceParameters parameters, TrackerConnectionID state)
{
RaiseBeforeAnnounce();
AnnouncedAt.Add(DateTime.Now);
RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, state, !FailAnnounce));
return(Task.CompletedTask);
}
/// <summary>
/// Generates the AnnounceParameters from PeerEntry
/// </summary>
private AnnounceParameters GenerateAnnounceParameters(byte[] infoHash, PeerEntry entry)
{
NameValueCollection c = new NameValueCollection();
// "info_hash", "peer_id", "port", "uploaded(bytes)", "downloaded", "left", "compact"
// InfoHash here should be just like what's in HttpRequests
c.Add("info_hash", System.Web.HttpUtility.UrlEncode(infoHash));
c.Add("peer_id", entry.PeerID);
c.Add("port", entry.PeerPort.ToString());
// Fake the mandatory fields, these are solely used to compute the upload/download speed
c.Add("uploaded", "0");
c.Add("downloaded", "0");
c.Add("left", "1000");
c.Add("compact", "1");
// Optional but needs to set for monotorrent tracker
if (entry.PeerState != MonoTorrent.Common.TorrentEvent.None)
{
c.Add("event", entry.PeerEventAsRequestKey);
}
// NOTE: "ip" is optional and we don't supply it.
// AnnounceParameters will set entry.PeerIP as its ClientAddress.
AnnounceParameters par = new AnnounceParameters(c, IPAddress.Parse(entry.PeerIP));
return(par);
}
public byte[] HandleASP(string rawurl, IPAddress ipa, bool isScrape, bool invalidPassKey)
{
RequestParameters parameters;
NameValueCollection collection = ParseQuery(rawurl);
if (isScrape)
{
parameters = new ScrapeParameters(collection, ipa);
}
else
{
parameters = new AnnounceParameters(collection, ipa, invalidPassKey);
}
if (!parameters.IsValid)
{
// The failure reason has already been filled in to the response
return((byte[])parameters.Response.Encode());
}
else
{
if (isScrape)
{
RaiseScrapeReceived((ScrapeParameters)parameters);
}
else
{
RaiseAnnounceReceived((AnnounceParameters)parameters);
}
}
byte[] response = parameters.Response.Encode();
return(response);
}
public virtual BEncodedDictionary Handle(NameValueCollection collection, IPAddress remoteAddress, bool isScrape)
{
if (collection == null)
throw new ArgumentNullException("collection");
if (remoteAddress == null)
throw new ArgumentNullException("remoteAddress");
RequestParameters parameters;
if (isScrape)
parameters = new ScrapeParameters(collection, remoteAddress);
else
parameters = new AnnounceParameters(collection, remoteAddress);
// If the parameters are invalid, the failure reason will be added to the response dictionary
if (!parameters.IsValid)
return parameters.Response;
// Fire the necessary event so the request will be handled and response filled in
if (isScrape)
RaiseScrapeReceived((ScrapeParameters)parameters);
else
RaiseAnnounceReceived((AnnounceParameters)parameters);
// Return the response now that the connection has been handled correctly.
return parameters.Response;
}
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 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");
}
/// <summary>
/// Announces Peer to DHT with AnnounceParameters infomation.
/// </summary>
/// <returns>True if successful</returns>
public void AnnouncePeer(byte[] infoHash, AnnounceParameters pars)
{
PeerEntry entry = new PeerEntry(pars);
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("Peer to be announced to DHT:\n{0}", entry.ToString()));
AnnouncePeer(infoHash, entry);
}
private void RaiseAnnounceReceived(AnnounceParameters e)
{
EventHandler <AnnounceParameters> h = AnnounceReceived;
if (h != null)
{
h(this, e);
}
}
protected override Task <List <Peer> > DoAnnounceAsync(AnnounceParameters parameters)
{
AnnouncedAt.Add(DateTime.Now);
if (FailAnnounce)
{
throw new TrackerException("Deliberately failing announce request", null);
}
return(Task.FromResult(peers));
}
public override Task <List <Peer> > AnnounceAsync(AnnounceParameters parameters)
{
AnnouncedAt.Add(DateTime.Now);
RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, !FailAnnounce));
if (FailAnnounce)
{
throw new TrackerException("Deliberately failing announce request", null);
}
return(Task.FromResult(peers));
}
/// <summary>
/// Listens to event fired by HttpListener and delegates the handling
/// process to DhtListener where a list of peers are retrieved.
/// </summary>
private void OnAnnounceReceived(object sender, AnnounceParameters e) {
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("Annoucement received from {0}", e.RemoteAddress));
try {
_dictListener.HandleAnnounceRequest(e);
} catch (Exception ex) {
Logger.WriteLineIf(LogLevel.Error, _log_props,
string.Format("Exception caught while processing announce request. {0}", ex));
throw;
}
}
/**
* This initializes the PeerEntry to be stored in Dht
* @param pars
*/
public PeerEntry(AnnounceParameters pars)
{
/*
* The ClientAddress here could be ["ip"] in the args of GET request
* or, if it is null, the remote endpoint IP of the request.
* Don't use pars.RemoteAddress
*/
this._peer_endpoint = pars.ClientAddress;
this._peer_id = pars.PeerId;
this._event = pars.Event;
}
public void Setup()
{
keys.Clear();
tracker = (HTTPTracker)TrackerFactory.Create(AnnounceUrl);
announceParams = new AnnounceParameters();
announceParams.PeerId = "id";
announceParams.InfoHash = new InfoHash(new byte[20]);
scrapeParams = new ScrapeParameters(new InfoHash(new byte[20]));
}
protected override ReusableTask <AnnounceResponse> DoAnnounceAsync(AnnounceParameters parameters, CancellationToken token)
{
AnnouncedAt.Add(DateTime.Now);
if (FailAnnounce)
{
throw new TrackerException("Deliberately failing announce request", null);
}
AnnounceParameters.Add(parameters);
return(ReusableTask.FromResult(new AnnounceResponse(peers, null, null)));
}
public void KeyTest()
{
MonoTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
pars.PeerId = "id";
pars.InfoHash = new InfoHash(new byte[20]);
Tracker.Tracker t = TrackerFactory.Create(new Uri(prefix + "?key=value"));
TrackerConnectionID 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");
}
private WaitHandle Announce(Tracker.Tracker tracker, TorrentEvent clientEvent, bool trySubsequent,
ManualResetEvent waitHandle)
{
ClientEngine engine = _manager.Engine;
// If the engine is null, we have been unregistered
if (engine == null)
{
waitHandle.Set();
return(waitHandle);
}
UpdateSucceeded = true;
LastUpdated = DateTime.Now;
EncryptionTypes 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;
IPEndPoint reportedAddress = engine.Settings.ReportedAddress;
var ip = reportedAddress?.Address.ToString();
int port = reportedAddress?.Port ?? engine.Listener.Endpoint.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 p = 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(p, id);
return(waitHandle);
}
public AnnounceMessage(int transactionId, long connectionId, AnnounceParameters parameters)
: base(1, transactionId)
{
this.ConnectionId = connectionId;
if (parameters == null)
return;
Downloaded = parameters.BytesDownloaded;
Infohash = parameters.InfoHash;
Ip = 0;
Key = (uint) DateTime.Now.GetHashCode(); // TODO: Don't do this! It should be constant
Left = parameters.BytesLeft;
NumWanted = 50;
PeerId = parameters.PeerId;
Port = (ushort) parameters.Port;
TorrentEvent = parameters.ClientEvent;
Uploaded = parameters.BytesUploaded;
}
public AnnounceMessage(int transactionId, long connectionId, AnnounceParameters parameters)
: base(1, transactionId)
{
this.connectionId = connectionId;
if (parameters == null)
{
return;
}
this.downloaded = parameters.BytesDownloaded;
this.infoHash = parameters.InfoHash;
this.ip = 0;
this.key = (uint)DateTime.Now.GetHashCode(); // FIXME: Don't do this! It should be constant
this.left = parameters.BytesLeft;
this.numWanted = 50;
this.peerId = parameters.PeerId;
this.port = (ushort)parameters.Port;
this.torrentEvent = parameters.ClientEvent;
this.uploaded = parameters.BytesUploaded;
}
public AnnounceMessage(int transactionId, long connectionId, AnnounceParameters parameters)
: base(1, transactionId)
{
ConnectionId = connectionId;
if (parameters == null)
{
return;
}
Downloaded = parameters.BytesDownloaded;
Infohash = parameters.InfoHash;
Ip = 0;
Key = (uint)DateTime.Now.GetHashCode(); // FIXME: Don't do this! It should be constant
Left = parameters.BytesLeft;
NumWanted = 50;
PeerId = parameters.PeerId;
Port = (ushort)parameters.Port;
TorrentEvent = parameters.ClientEvent;
Uploaded = parameters.BytesUploaded;
}
public virtual BEncodedDictionary Handle(NameValueCollection collection, IPAddress remoteAddress, bool isScrape)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
if (remoteAddress == null)
{
throw new ArgumentNullException("remoteAddress");
}
RequestParameters parameters;
if (isScrape)
{
parameters = new ScrapeParameters(collection, remoteAddress);
}
else
{
parameters = new AnnounceParameters(collection, remoteAddress);
}
// If the parameters are invalid, the failure reason will be added to the response dictionary
if (!parameters.IsValid)
{
return(parameters.Response);
}
// Fire the necessary event so the request will be handled and response filled in
if (isScrape)
{
RaiseScrapeReceived((ScrapeParameters)parameters);
}
else
{
RaiseAnnounceReceived((AnnounceParameters)parameters);
}
// Return the response now that the connection has been handled correctly.
return(parameters.Response);
}
public void AnnounceTest()
{
HTTPTracker t = (HTTPTracker)TrackerFactory.Create(new Uri(prefix));
TrackerConnectionID 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();
};
MonoTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
pars.PeerId = "id";
pars.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].ToLowerInvariant(), t.Key.ToLowerInvariant(), "#2");
}
void listener_AnnounceReceived(object sender, AnnounceParameters e)
{
//insere na base de dados para ser processado posteriormente pelo robô
using (var repositorio = new DataRepository <EventoAnnounce>())
{
var announce = new EventoAnnounce();
announce.IdEventoAnnounce = 0;
announce.HashInfoTorrent = e.InfoHash.ToString();
announce.PasskeyUsuario = e.PassKey;
announce.Evento = e.Event.ToString();
announce.DataEvento = DateTime.Now;
announce.Downloaded = e.Downloaded;
announce.Uploaded = e.Uploaded;
announce.Processado = false;
announce.EnderecoIP = e.ClientAddress.Address.ToString();
announce.PeerID = e.PeerId;
repositorio.Add(announce);
repositorio.SaveChanges();
}
}
public async Task AnnounceTest()
{
announceparams = announceparams
.WithBytesDownloaded(123)
.WithBytesLeft(456)
.WithBytesUploaded(789);
var announceArgsTask = new TaskCompletionSource <MonoTorrent.Tracker.AnnounceEventArgs> ();
server.PeerAnnounced += (o, e) => announceArgsTask.TrySetResult(e);
await tracker.AnnounceAsync(announceparams);
await announceArgsTask.Task;
var args = announceArgsTask.Task.Result;
Assert.AreEqual(PeerId, args.Peer.PeerId, "#1");
Assert.AreEqual(123, args.Peer.Downloaded);
Assert.AreEqual(456, args.Peer.Remaining);
Assert.AreEqual(789, args.Peer.Uploaded);
}
/// <summary>
/// Gets the peers from DHT and generates AnnounceParameters of a list of
/// peers and puts the peer info of this announcing peer to DHT
/// </summary>
/// <param name="parameters">
/// AnnounceParameters from the requesting client. It's modified in method.
/// </param>
internal void HandleAnnounceRequest(AnnounceParameters parameters)
{
IEnumerable <PeerEntry> entries = _proxy.GetPeers(parameters.InfoHash.ToArray());
foreach (PeerEntry entry in entries)
{
AnnounceParameters par = GenerateAnnounceParameters(
parameters.InfoHash.ToArray(), entry);
if (par.IsValid)
{
// Tracker will write to the par.Response but we don't use it
// ListenerBase.Handle use par.ClientAddress to generate
// AnnounceParameters again.
Handle(par.Parameters, par.ClientAddress.Address, false);
}
else
{
Logger.WriteLineIf(LogLevel.Error, _log_props, string.Format(
"Parameters invalid!"));
continue;
}
//Logger.WriteLineIf(LogLevel.Verbose, _log_props,
// string.Format("Tracker's response for this peer {0} from DHT: {1}",
// par.ClientAddress, par.Response.ToString()));
}
// Got all I need, now announce myself to DHT.
try {
_proxy.AnnouncePeer(parameters.InfoHash.ToArray(), parameters);
} catch (Exception ex) {
// It is OK to temporarily unable to announce to Dht. We can try the next time.
Logger.WriteLineIf(LogLevel.Error, _log_props, string.Format(
"Unable to reach Dht. We can try the next time.\n{0}", ex));
}
Logger.WriteLineIf(LogLevel.Info, _log_props,
string.Format("DhtListener finished handling annoucement from {0}",
parameters.RemoteAddress));
}
public void Setup()
{
keys = new List <BEncodedString>();
server = new MonoTorrent.Tracker.TrackerServer();
server.AllowUnregisteredTorrents = true;
server.RegisterListener(listener);
peerEndpoints = new List <IPEndPoint> {
new IPEndPoint(IPAddress.Parse("123.123.123.123"), 12312),
new IPEndPoint(IPAddress.Parse("254.254.254.254"), 3522),
new IPEndPoint(IPAddress.Parse("1.1.1.1"), 123),
new IPEndPoint(IPAddress.Parse("1.2.3.4"), 65000),
};
tracker = (UdpTracker)TrackerFactory.Create(new Uri($"udp://127.0.0.1:{listener.EndPoint.Port}/announce/"));
announceparams = announceparams.WithPort(listener.EndPoint.Port);
listener.IgnoreAnnounces = false;
listener.IgnoreConnects = false;
listener.IgnoreErrors = false;
listener.IgnoreScrapes = false;
}
public void AnnounceTest()
{
UdpTracker t = (UdpTracker)TrackerFactory.Create(new Uri(prefix));
TrackerConnectionID 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();
};
System.Net.BitTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
pars.InfoHash = new InfoHash(new byte[20]);
pars.PeerId = "";
t.Announce(pars, id);
Wait(id.WaitHandle);
Assert.NotNull(p);
Assert.True(p.Successful);
//Assert.Equal(keys[0], t.Key, "#2");
}
void OfflineAnnounceTest()
{
UdpTracker t = (UdpTracker)TrackerFactory.Create(new Uri("udp://127.0.0.1:57532/announce"));
t.RetryDelay = TimeSpan.FromMilliseconds(500);
TrackerConnectionID 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();
};
System.Net.BitTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
pars.InfoHash = new InfoHash(new byte[20]);
pars.PeerId = "";
t.Announce(pars, id);
Wait(id.WaitHandle);
Assert.NotNull(p);
Assert.False(p.Successful);
}
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 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 void ScrapeTest()
{
Tracker.Tracker t = TrackerFactory.Create(new Uri(prefix.Substring(0, prefix.Length - 1)));
Assert.True(t.CanScrape, "#1");
TrackerConnectionID 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();
};
System.Net.BitTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
pars.PeerId = "id";
pars.InfoHash = new InfoHash(new byte[20]);
t.Announce(pars, id);
Wait(id.WaitHandle);
Assert.NotNull(p);
Assert.True(p.Successful, "#3");
Assert.Equal(1, t.Complete);
Assert.Equal(0, t.Incomplete);
Assert.Equal(0, t.Downloaded);
}
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");
}
public override void Announce(AnnounceParameters parameters, object state)
{
var e = new AnnounceResponseEventArgs(this, state, true);
RaiseAnnounceComplete(e);
}
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");
}
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 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");
}
private void RaiseAnnounceReceived(AnnounceParameters e)
{
EventHandler<AnnounceParameters> h = AnnounceReceived;
if (h != null)
h(this, e);
}
public override void Announce(AnnounceParameters parameters, object state)
{
RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, state, true));
}
private void RaiseAnnounceReceived(AnnounceParameters e)
{
var h = AnnounceReceived;
if (h != null)
h(this, e);
}
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 object GetKey(AnnounceParameters parameters)
{
return parameters.ClientAddress;
}
