internal async Task StartAsync()
{
CheckDisposed();
if (!IsRunning)
{
IsRunning = true;
PeerListener.Start();
LocalPeerDiscovery.Start();
await DhtEngine.StartAsync(await MaybeLoadDhtNodes());
if (Settings.AllowPortForwarding)
{
await PortForwarder.StartAsync(CancellationToken.None);
}
if (PeerListener.LocalEndPoint != null)
{
await PortForwarder.RegisterMappingAsync(new Mapping (Protocol.Tcp, PeerListener.LocalEndPoint.Port));
}
if (DhtListener.LocalEndPoint != null)
{
await PortForwarder.RegisterMappingAsync(new Mapping (Protocol.Udp, DhtListener.LocalEndPoint.Port));
}
}
}
internal void Start()
{
CheckDisposed();
isRunning = true;
if (listener.Status == ListenerStatus.NotListening)
{
listener.Start();
}
}
public void PortNotFree()
{
var tcs = new TaskCompletionSource <object> ();
var otherListener = new PeerListener(endpoint);
otherListener.StatusChanged += (o, e) => tcs.SetResult(null);
otherListener.Start();
Assert.AreEqual(ListenerStatus.PortNotFree, otherListener.Status);
Assert.IsTrue(tcs.Task.Wait(1000));
}
async Task UpdateSettingsAsync(EngineSettings oldSettings, EngineSettings newSettings)
{
await DiskManager.UpdateSettingsAsync(newSettings);
if (newSettings.DiskCacheBytes != oldSettings.DiskCacheBytes)
{
await Task.WhenAll(Torrents.Select(t => DiskManager.FlushAsync(t)));
}
ConnectionManager.Settings = newSettings;
if (oldSettings.UsePartialFiles != newSettings.UsePartialFiles)
{
foreach (var manager in Torrents)
{
await manager.UpdateUsePartialFiles(newSettings.UsePartialFiles);
}
}
if (oldSettings.AllowPortForwarding != newSettings.AllowPortForwarding)
{
if (newSettings.AllowPortForwarding)
{
await PortForwarder.StartAsync(CancellationToken.None);
}
else
{
await PortForwarder.StopAsync(removeExistingMappings : true, CancellationToken.None);
}
}
if (oldSettings.DhtEndPoint != newSettings.DhtEndPoint)
{
if (DhtListener.LocalEndPoint != null)
{
await PortForwarder.UnregisterMappingAsync(new Mapping (Protocol.Udp, DhtListener.LocalEndPoint.Port), CancellationToken.None);
}
DhtListener.Stop();
if (newSettings.DhtEndPoint == null)
{
DhtListener = new NullDhtListener();
await RegisterDht(new NullDhtEngine());
}
else
{
DhtListener = Factories.CreateDhtListener(Settings.DhtEndPoint) ?? new NullDhtListener();
if (IsRunning)
{
DhtListener.Start();
}
if (oldSettings.DhtEndPoint == null)
{
var dht = Factories.CreateDht();
await dht.SetListenerAsync(DhtListener);
await RegisterDht(dht);
}
else
{
await DhtEngine.SetListenerAsync(DhtListener);
}
}
if (DhtListener.LocalEndPoint != null)
{
await PortForwarder.RegisterMappingAsync(new Mapping (Protocol.Udp, DhtListener.LocalEndPoint.Port));
}
}
if (!Equals(oldSettings.ListenEndPoint, newSettings.ListenEndPoint))
{
if (PeerListener.LocalEndPoint != null)
{
await PortForwarder.UnregisterMappingAsync(new Mapping (Protocol.Tcp, PeerListener.LocalEndPoint.Port), CancellationToken.None);
}
PeerListener.Stop();
PeerListener = (newSettings.ListenEndPoint == null ? null : Factories.CreatePeerConnectionListener(newSettings.ListenEndPoint)) ?? new NullPeerListener();
listenManager.SetListener(PeerListener);
if (IsRunning)
{
PeerListener.Start();
// The settings could say to listen at port 0, which means 'choose one dynamically'
if (PeerListener.LocalEndPoint != null)
{
await PortForwarder.RegisterMappingAsync(new Mapping (Protocol.Tcp, PeerListener.LocalEndPoint.Port));
}
}
}
if (oldSettings.AllowLocalPeerDiscovery != newSettings.AllowLocalPeerDiscovery)
{
RegisterLocalPeerDiscovery(!newSettings.AllowLocalPeerDiscovery ? null : Factories.CreateLocalPeerDiscovery());
}
}
public void Setup()
{
listener = new PeerListener(new IPEndPoint(IPAddress.Loopback, 0));
listener.Start();
}
public ClientEngine(EngineSettings settings, PeerListener listener, PieceWriter writer)
{
Check.Settings(settings);
Check.Listener(listener);
Check.Writer(writer);
this.listener = listener;
this.settings = settings;
this.connectionManager = new ConnectionManager(this);
this.dhtListener = new UdpListener(new IPEndPoint(IPAddress.Any, settings.ListenPort));
this.dhtEngine = new DhtEngine(dhtListener);
this.diskManager = new DiskManager(this, writer);
this.listenManager = new ListenManager(this);
MainLoop.QueueTimeout(TimeSpan.FromMilliseconds(TickLength), delegate {
if (IsRunning && !disposed)
LogicTick();
return !disposed;
});
this.torrents = new MonoTorrentCollection<TorrentManager>();
this.downloadLimiter = new RateLimiter();
this.uploadLimiter = new RateLimiter();
this.peerId = GeneratePeerId();
listenManager.Register(listener);
dhtEngine.StateChanged += delegate {
if (dhtEngine.State != State.Ready)
return;
MainLoop.Queue(delegate {
foreach (TorrentManager manager in torrents)
{
if (!manager.CanUseDht)
continue;
dhtEngine.Announce(manager.Torrent.infoHash, Listener.Endpoint.Port);
dhtEngine.GetPeers(manager.Torrent.infoHash);
}
});
};
// This means we created the listener in the constructor
if (listener.Endpoint.Port == 0)
listener.ChangeEndpoint(new IPEndPoint(IPAddress.Any, settings.ListenPort));
listener.Start();
}