async Task <long> ConnectAsync()
{
var message = new ConnectMessage();
// Reset the timer so we don't do two concurrent connect requests. It's just an optimisation
// as concurrent requests are fine!
LastConnected.Restart();
// Send our request, which could take a few retries.
(var rawResponse, var errorString) = await SendAndReceiveAsync(message);
// Did we receive an 'ErrorMessage' from the tracker? If so, propagate the failure
if (errorString != null)
{
ConnectionIdTask = null;
throw new TrackerException(errorString);
}
var response = (ConnectResponseMessage)rawResponse;
// Reset the timer after we receive the response so we get maximum benefit from our
// 2 minute allowance to use the connection id.
LastConnected.Restart();
return(response.ConnectionId);
}
void InitializeTyrant()
{
HaveMessageEstimatedDownloadedBytes = 0;
TyrantStartTime.Restart();
UploadRateForRecip = MARKET_RATE;
LastRateReductionTime.Restart();
lastMeasuredDownloadRate = 0;
maxObservedDownloadSpeed = 0;
RoundsChoked = 0;
RoundsUnchoked = 0;
}
public async ReusableTask <AnnounceResponse> AnnounceAsync(AnnounceRequest parameters, CancellationToken token)
{
try {
StatusOverride = TrackerState.Connecting;
var response = LastAnnounceResponse = await Connection.AnnounceAsync(parameters, token);
LastResponse = response;
return(response);
} finally {
StatusOverride = null;
LastAnnounced.Restart();
}
}
async Task Announce(TorrentEvent clientEvent, ITracker referenceTracker)
{
// If the user initiates an Announce we need to go to the correct thread to process it.
await ClientEngine.MainLoop;
LastAnnounce.Restart();
LastUpdated = DateTime.UtcNow;
var p = RequestFactory.CreateAnnounce(clientEvent);
foreach (var tuple in GetNextTracker(referenceTracker))
{
try {
// If we have not announced to this Tracker tier yet then we should replace the ClientEvent.
// But if we end up announcing to a different Tracker tier we may want to send the
// original/unmodified args.
var actualArgs = p;
if (!tuple.Item1.SentStartedEvent)
{
actualArgs = actualArgs.WithClientEvent(TorrentEvent.Started);
}
var peers = await tuple.Item2.AnnounceAsync(actualArgs);
LastAnnounceSucceeded = true;
AnnounceComplete?.InvokeAsync(this, new AnnounceResponseEventArgs(tuple.Item2, true, peers.AsReadOnly()));
return;
} catch {
}
}
LastAnnounceSucceeded = false;
AnnounceComplete?.InvokeAsync(this, new AnnounceResponseEventArgs(null, false));
}
async Task <long> ConnectAsync()
{
var message = new ConnectMessage();
// Reset the timer so we don't do two concurrent connect requests. It's just an optimisation
// as concurrent requests are fine!
LastConnected.Restart();
// Send our request, which could take a few retries.
var response = (ConnectResponseMessage) await SendAndReceiveAsync(message);
// Reset the timer after we receive the response so we get maximum benefit from our
// 2 minute allowance to use the connection id.
LastConnected.Restart();
return(response.ConnectionId);
}
public TimeSpan MeasureQueueDelay()
{
bool shouldSchedule;
TimeSpan delay;
lock (_lockObj)
{
var currentQueueDelay = _queueDelay.Elapsed;
delay = currentQueueDelay > _lastQueueDelay ? currentQueueDelay : _lastQueueDelay;
if (!_scheduled)
{
_scheduled = true;
shouldSchedule = true;
_queueDelay.Restart();
}
else
{
shouldSchedule = false;
}
}
if (shouldSchedule)
{
_ = ThreadPool.UnsafeQueueUserWorkItem(Callback, this);
}
return(delay);
}
public async Task <List <Peer> > AnnounceAsync(AnnounceParameters parameters)
{
var result = await DoAnnounceAsync(parameters);
LastAnnounced.Restart();
return(result);
}
/// <summary>
/// Called when this silo receives a health probe request.
/// </summary>
public void OnReceivedProbeRequest()
{
lock (_lock)
{
_probeRequestStopwatch.Restart();
}
}
public async ReusableTask <AnnounceResponse> AnnounceAsync(AnnounceParameters parameters, CancellationToken token)
{
try {
return(await DoAnnounceAsync(parameters, token));
} finally {
LastAnnounced.Restart();
}
}
internal void DhtAnnounce()
{
if (CanUseDht && (!LastDhtAnnounceTimer.IsRunning || LastDhtAnnounceTimer.Elapsed > MonoTorrent.Dht.DhtEngine.MinimumAnnounceInterval))
{
LastDhtAnnounce = DateTime.UtcNow;
LastDhtAnnounceTimer.Restart();
Engine?.DhtEngine.GetPeers(InfoHash);
}
}
public async Task LocalPeerAnnounceAsync()
{
await ClientEngine.MainLoop;
if (CanUseLocalPeerDiscovery && (!LastLocalPeerAnnounceTimer.IsRunning || LastLocalPeerAnnounceTimer.Elapsed > LocalPeerDiscovery.MinimumAnnounceInternal))
{
LastLocalPeerAnnounce = DateTime.Now;
LastLocalPeerAnnounceTimer.Restart();
await Engine?.LocalPeerDiscovery.Announce(InfoHash);
}
}
ReusableTask Tick(int delta, bool waitForBufferedIO)
{
UpdateTimer.Restart();
ReadMonitor.Tick(delta);
WriteMonitor.Tick(delta);
WriteLimiter.UpdateChunks(Settings.MaximumDiskWriteRate, WriteRate);
ReadLimiter.UpdateChunks(Settings.MaximumDiskReadRate, ReadRate);
var processTask = ProcessBufferedIOAsync();
return(waitForBufferedIO ? processTask : ReusableTask.CompletedTask);
}
/// <summary>
/// Should be called by ChokeUnchokeManager.ExecuteReview
/// Logic taken from BitTyrant implementation
/// </summary>
internal void UpdateTyrantStats()
{
// if we're still being choked, set the time of our last choking
if (IsChoking)
{
RoundsChoked++;
LastChokedTime.Restart();
}
else
{
RoundsUnchoked++;
if (AmInterested)
{
//if we are interested and unchoked, update last measured download rate, unless it is 0
if (Monitor.DownloadSpeed > 0)
{
lastMeasuredDownloadRate = Monitor.DownloadSpeed;
maxObservedDownloadSpeed = Math.Max(lastMeasuredDownloadRate, maxObservedDownloadSpeed);
}
}
}
// last rate wasn't sufficient to achieve reciprocation
if (!AmChoking && IsChoking && IsInterested) // only increase upload rate if he's interested, otherwise he won't request any pieces
{
UploadRateForRecip = (UploadRateForRecip * 12) / 10;
}
// we've been unchoked by this guy for a while....
if (!IsChoking && !AmChoking &&
LastChokedTime.Elapsed.TotalSeconds > 30 &&
LastRateReductionTime.Elapsed.TotalSeconds > 30) // only do rate reduction every 30s
{
UploadRateForRecip = (UploadRateForRecip * 9) / 10;
LastRateReductionTime.Restart();
}
}
internal void Seen(TimeSpan delta)
{
FailedCount = 0;
LastSeenDelta = delta;
LastSeenTimer.Restart();
}
internal void Changed(TimeSpan delta)
{
LastChangedDelta = delta;
LastChangedTimer.Restart();
}
