public override async Task ScrapeAsync(ScrapeParameters parameters, TrackerConnectionID state)
{
try {
if (ConnectionIdTask == null || LastConnected.Elapsed > TimeSpan.FromMinutes(1))
{
ConnectionIdTask = ConnectAsync();
}
await ConnectionIdTask;
var infohashes = new List <byte[]> {
parameters.InfoHash.Hash
};
var message = new ScrapeMessage(DateTime.Now.GetHashCode(), ConnectionIdTask.Result, infohashes);
var response = (ScrapeResponseMessage) await SendAndReceiveAsync(message);
if (response.Scrapes.Count == 1)
{
Complete = response.Scrapes[0].Seeds;
Downloaded = response.Scrapes[0].Complete;
Incomplete = response.Scrapes[0].Leeches;
}
RaiseScrapeComplete(new ScrapeResponseEventArgs(this, state, true));
} catch (Exception e) {
ConnectionIdTask = null;
RaiseScrapeComplete(new ScrapeResponseEventArgs(this, state, false));
throw new Exception("Scrape could not be completed", e);
}
}
public void MultipleAnnounce()
{
var announceCount = 0;
var r = new Random();
var handle = new ManualResetEvent(false);
for (var i = 0; i < 20; i++)
{
var infoHash = new InfoHash(new byte[20]);
r.NextBytes(infoHash.Hash);
var tier = new TrackerTier(new[] {uri.ToString()});
tier.Trackers[0].AnnounceComplete += delegate
{
if (++announceCount == 20)
handle.Set();
};
var id = new TrackerConnectionID(tier.Trackers[0], false, TorrentEvent.Started,
new ManualResetEvent(false));
MonoTorrent.Client.Tracker.AnnounceParameters parameters;
parameters = new MonoTorrent.Client.Tracker.AnnounceParameters(0, 0, 0, TorrentEvent.Started,
infoHash, false, new string('1', 20), "", 1411);
tier.Trackers[0].Announce(parameters, id);
}
Assert.True(handle.WaitOne(5000, true), "Some of the responses weren't received");
}
void AnnounceReceived(WebResponse response, TrackerConnectionID state)
{
FailureMessage = "";
WarningMessage = "";
List <Peer> peers = new List <Peer>();
try
{
BEncodedDictionary dict = DecodeResponse(response);
HandleAnnounce(dict, peers);
Status = TrackerState.Ok;
}
catch (WebException)
{
Status = TrackerState.Offline;
FailureMessage = "The tracker could not be contacted";
}
catch
{
Status = TrackerState.InvalidResponse;
FailureMessage = "The tracker returned an invalid or incomplete response";
}
finally
{
RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, state, string.IsNullOrEmpty(FailureMessage), peers));
}
}
public override async Task ScrapeAsync(ScrapeParameters parameters, TrackerConnectionID state)
{
try
{
string url = ScrapeUri.OriginalString;
// If you want to scrape the tracker for *all* torrents, don't append the info_hash.
if (url.IndexOf('?') == -1)
{
url += "?info_hash=" + parameters.InfoHash.UrlEncode();
}
else
{
url += "&info_hash=" + parameters.InfoHash.UrlEncode();
}
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
request.UserAgent = MonoTorrent.Common.VersionInfo.ClientVersion;
var response = await request.GetResponseAsync();
ScrapeReceived(response, state);
}
catch
{
RaiseScrapeComplete(new ScrapeResponseEventArgs(this, state, false));
throw;
}
}
public async void Scrape(ScrapeParameters parameters, TrackerConnectionID state)
{
try {
await ScrapeAsync(parameters, state);
} catch {
// Ignore
}
}
public void AddFailedPeer(Peer p)
{
var id = new TrackerConnectionID(this, true, TorrentEvent.None, null);
var e = new AnnounceResponseEventArgs(this, null, true);
e.Peers.Add(p);
e.Successful = false;
RaiseAnnounceComplete(e);
}
public async void Announce(AnnounceParameters parameters, TrackerConnectionID state)
{
try {
await AnnounceAsync(parameters, state);
} catch {
// Ignore
}
}
public void AddFailedPeer(Peer p)
{
var id = new TrackerConnectionID(this, true, TorrentEvent.None, new ManualResetEvent(false));
var e = new AnnounceResponseEventArgs(this, id, false);
e.Peers.Add(p);
RaiseAnnounceComplete(e);
Assert.True(id.WaitHandle.WaitOne(1000, true), "#2 Tracker never raised the AnnounceComplete event");
}
void Announce()
{
foreach(var t in _trackers)
{
var id = new TrackerConnectionID(t, true, TorrentEvent.None, new ManualResetEvent(false));
Log("Announcing: {0}" , t.Uri);
t.Announce(AParams , id);
}
}
protected TrackerResponseEventArgs(Tracker tracker, object state, bool successful)
{
if (tracker == null)
throw new ArgumentNullException("tracker");
if (!(state is TrackerConnectionID))
throw new ArgumentException("The state object must be the same object as in the call to Announce", "state");
this.id = (TrackerConnectionID)state;
this.successful = successful;
this.tracker = tracker;
}
void ScrapeReceived(WebResponse response, TrackerConnectionID state)
{
string message = "";
try
{
BEncodedDictionary d;
BEncodedDictionary dict = DecodeResponse(response);
// FIXME: Log the failure?
if (!dict.ContainsKey("files"))
{
message = "Response contained no data";
return;
}
BEncodedDictionary files = (BEncodedDictionary)dict["files"];
foreach (KeyValuePair <BEncodedString, BEncodedValue> keypair in files)
{
d = (BEncodedDictionary)keypair.Value;
foreach (KeyValuePair <BEncodedString, BEncodedValue> kp in d)
{
switch (kp.Key.ToString())
{
case ("complete"):
Complete = (int)((BEncodedNumber)kp.Value).Number;
break;
case ("downloaded"):
Downloaded = (int)((BEncodedNumber)kp.Value).Number;
break;
case ("incomplete"):
Incomplete = (int)((BEncodedNumber)kp.Value).Number;
break;
default:
Logger.Log(null, "HttpTracker - Unknown scrape tag received: Key {0} Value {1}", kp.Key.ToString(), kp.Value.ToString());
break;
}
}
}
}
catch (WebException)
{
message = "The tracker could not be contacted";
}
catch
{
message = "The tracker returned an invalid or incomplete response";
}
finally
{
RaiseScrapeComplete(new ScrapeResponseEventArgs(this, state, string.IsNullOrEmpty(message)));
}
}
protected TrackerResponseEventArgs(Tracker tracker, object state, bool successful)
{
if (tracker == null)
{
throw new ArgumentNullException("tracker");
}
if (!(state is TrackerConnectionID))
{
throw new ArgumentException("The state object must be the same object as in the call to Announce", "state");
}
this.id = (TrackerConnectionID)state;
this.successful = successful;
this.tracker = tracker;
}
private WaitHandle Scrape(Tracker tracker, bool trySubsequent)
{
if (tracker == null)
{
throw new ArgumentNullException("tracker");
}
if (!tracker.CanScrape)
{
throw new TorrentException("This tracker does not support scraping");
}
TrackerConnectionID id = new TrackerConnectionID(tracker, trySubsequent, TorrentEvent.None, new ManualResetEvent(false));
tracker.Scrape(new ScrapeParameters(this.infoHash), id);
return(id.WaitHandle);
}
private WaitHandle Announce(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);
}
this.updateSucceeded = true;
this.lastUpdated = DateTime.Now;
EncryptionTypes e = engine.Settings.AllowedEncryption;
bool requireEncryption = !Toolbox.HasEncryption(e, EncryptionTypes.PlainText);
bool supportsEncryption = Toolbox.HasEncryption(e, EncryptionTypes.RC4Full) || Toolbox.HasEncryption(e, EncryptionTypes.RC4Header);
requireEncryption = requireEncryption && ClientEngine.SupportsEncryption;
supportsEncryption = supportsEncryption && ClientEngine.SupportsEncryption;
IPEndPoint reportedAddress = engine.Settings.ReportedAddress;
string ip = reportedAddress == null ? null : reportedAddress.Address.ToString();
int 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 - this.manager.Bitfield.PercentComplete / 100.0) * this.manager.Torrent.Size);
}
AnnounceParameters p = new AnnounceParameters(this.manager.Monitor.DataBytesDownloaded,
this.manager.Monitor.DataBytesUploaded,
bytesLeft,
clientEvent, this.infoHash, requireEncryption, manager.Engine.PeerId,
ip, port);
p.SupportsEncryption = supportsEncryption;
TrackerConnectionID id = new TrackerConnectionID(tracker, trySubsequent, clientEvent, waitHandle);
tracker.Announce(p, id);
return(waitHandle);
}
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.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 override async Task AnnounceAsync(AnnounceParameters parameters, TrackerConnectionID state)
{
try {
if (ConnectionIdTask == null || LastConnected.Elapsed > TimeSpan.FromMinutes(1))
{
ConnectionIdTask = ConnectAsync();
}
await ConnectionIdTask;
var message = new AnnounceMessage(DateTime.Now.GetHashCode(), ConnectionIdTask.Result, parameters);
var announce = (AnnounceResponseMessage) await SendAndReceiveAsync(message);
MinUpdateInterval = announce.Interval;
RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, state, true, announce.Peers));
} catch (Exception e) {
ConnectionIdTask = null;
RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, state, false));
throw new Exception("Announce could not be completed", e);
}
}
private void OfflineAnnounceTest()
{
var t = (UdpTracker) TrackerFactory.Create(new Uri("udp://127.0.0.1:57532/announce"));
t.RetryDelay = TimeSpan.FromMilliseconds(500);
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();
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 += delegate(object o, AnnounceResponseEventArgs e)
{
p = e;
id.WaitHandle.Set();
};
var pars = new MonoTorrent.Client.Tracker.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);
Assert.Equal(keys[0], t.Key);
}
public override async Task AnnounceAsync(AnnounceParameters parameters, TrackerConnectionID state)
{
try
{
Uri announceString = CreateAnnounceString(parameters);
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(announceString);
request.UserAgent = MonoTorrent.Common.VersionInfo.ClientVersion;
request.Proxy = new WebProxy(); // If i don't do this, i can't run the webrequest. It's wierd.
RaiseBeforeAnnounce();
var response = await request.GetResponseAsync();
AnnounceReceived(response, state);
}
catch (Exception ex)
{
Status = TrackerState.Offline;
FailureMessage = ("Could not initiate announce request: " + ex.Message);
RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, state, false));
throw;
}
}
public void ScrapeTest()
{
Tracker.Tracker t = TrackerFactory.Create(new Uri(prefix.Substring(0, prefix.Length -1)));
Assert.IsTrue(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();
};
MonoTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
pars.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 AnnounceResponseEventArgs(Tracker tracker, TrackerConnectionID state, bool successful)
: this(tracker, state, successful, new List <Peer>())
{
}
public AnnounceResponseEventArgs(Tracker tracker, TrackerConnectionID state, bool successful, List <Peer> peers)
: base(tracker, state, successful)
{
this.peers = peers;
}
public ScrapeResponseEventArgs(Tracker tracker, TrackerConnectionID state, bool successful)
: base(tracker, state, successful)
{
}
public void ScrapeTest()
{
UdpTracker t = (UdpTracker)TrackerFactory.Create(new Uri(prefix));
Assert.IsTrue(t.CanScrape, "#1");
TrackerConnectionID id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));
ScrapeResponseEventArgs p = null;
t.ScrapeComplete += delegate(object o, ScrapeResponseEventArgs e)
{
p = e;
id.WaitHandle.Set();
};
ScrapeParameters pars = new ScrapeParameters(new InfoHash(new byte[20]));
t.Scrape(pars, id);
Wait(id.WaitHandle);
Assert.IsNotNull(p, "#2");
Assert.IsTrue(p.Successful, "#3");
Assert.AreEqual(0, t.Complete, "#1");
Assert.AreEqual(0, t.Incomplete, "#2");
Assert.AreEqual(0, t.Downloaded, "#3");
}
void OfflineScrapeTest()
{
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));
ScrapeResponseEventArgs p = null;
t.ScrapeComplete += delegate(object o, ScrapeResponseEventArgs e)
{
if (e.Successful)
Console.ReadLine();
p = e;
id.WaitHandle.Set();
};
ScrapeParameters pars = new ScrapeParameters(new InfoHash(new byte[20]));
t.Scrape(pars, id);
Wait(id.WaitHandle);
Assert.IsNotNull(p, "#1");
Assert.IsFalse(p.Successful);
}
public abstract Task AnnounceAsync(AnnounceParameters parameters, TrackerConnectionID state);
public abstract Task ScrapeAsync(ScrapeParameters parameters, TrackerConnectionID state);
public void KeyTest()
{
MonoTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
pars.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");
}
public void ScrapeTest()
{
var t = TrackerFactory.Create(new Uri(prefix.Substring(0, prefix.Length - 1)));
Assert.True(t.CanScrape);
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 MonoTorrent.Client.Tracker.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);
Assert.Equal(1, t.Complete);
Assert.Equal(0, t.Incomplete);
Assert.Equal(0, t.Downloaded);
}
protected TrackerResponseEventArgs(Tracker tracker, TrackerConnectionID state, bool successful)
{
this.tracker = tracker ?? throw new ArgumentNullException("tracker");
this.id = (TrackerConnectionID)state;
this.successful = successful;
}
