public BitTorrentManager(BitTorrentCache bittorrentCache, string selfNameSpace, DictionaryServiceProxy dhtProxy, DictionaryServiceTracker dhtTracker, ClientEngine clientEngine, TorrentSettings torrentDefaults, TorrentHelper torrentHelper, bool startSeedingAtStartup) { _bittorrentCache = bittorrentCache; SelfNameSpace = selfNameSpace; _dictProxy = dhtProxy; _dictTracker = dhtTracker; _torrentDefaults = torrentDefaults; _startSeedingAtStartup = startSeedingAtStartup; RegisterClientEngineEventHandlers(clientEngine); _clientEngine = clientEngine; _torrentHelper = torrentHelper; try { _fastResumeData = BEncodedValue.Decode<BEncodedDictionary>( File.ReadAllBytes(_bittorrentCache.FastResumeFilePath)); } catch { _fastResumeData = new BEncodedDictionary(); } // CacheRegistry is created here because the default cache registry file path is // defined here. CacheRegistry = new CacheRegistry(_bittorrentCache.CacheRegistryFilePath, selfNameSpace); CacheRegistry.LoadCacheDir(_bittorrentCache.DownloadsDirPath); }
public TorrentController(MainWindow mainWindow) { this.userTorrentSettings = mainWindow.userTorrentSettings; this.userEngineSettings = mainWindow.userEngineSettings; this.prefSettings = mainWindow.prefSettings; this.labels = mainWindow.labels; this.torrentListStore = mainWindow.torrentListStore; this.torrents = mainWindow.torrents; this.mainWindow = mainWindow; this.pieces = mainWindow.pieces; this.torrentPreviousUpload = new Dictionary<MonoTorrent.Client.TorrentManager,long>(); this.torrentPreviousDownload = new Dictionary<MonoTorrent.Client.TorrentManager,long>(); engineSettings = new EngineSettings(userEngineSettings.SavePath, userEngineSettings.ListenPort, userEngineSettings.GlobalMaxConnections, userEngineSettings.GlobalMaxHalfOpenConnections, userEngineSettings.GlobalMaxDownloadSpeed, userEngineSettings.GlobalMaxUploadSpeed, EngineSettings.DefaultSettings().MinEncryptionLevel, userEngineSettings.AllowLegacyConnections); torrentSettings = new TorrentSettings(userTorrentSettings.UploadSlots, userTorrentSettings.MaxConnections, userTorrentSettings.MaxDownloadSpeed, userTorrentSettings.MaxUploadSpeed, userTorrentSettings.FastResumeEnabled); engine = new ClientEngine(engineSettings); engine.ConnectionManager.PeerMessageTransferred += OnPeerMessageTransferred; hashProgress = new Dictionary<MonoTorrent.Client.TorrentManager,int>(); torrentSwarm = new Dictionary<MonoTorrent.Client.TorrentManager,int>(); torrentsDownloading = new ArrayList(); torrentsSeeding = new ArrayList(); allTorrents = new ArrayList(); }
public void Initialize(SettingsManager settingsManager) { SettingsManager = settingsManager; Torrents = new ObservableCollection<PeriodicTorrent>(); Torrents.CollectionChanged += Torrents_CollectionChanged; var port = SettingsManager.IncomingPort; if (SettingsManager.UseRandomPort) port = new Random().Next(1, 65536); var settings = new EngineSettings(SettingsManager.DefaultDownloadLocation, port); settings.PreferEncryption = SettingsManager.EncryptionSettings != EncryptionTypes.PlainText; // Always prefer encryption unless it's disabled settings.AllowedEncryption = SettingsManager.EncryptionSettings; Client = new ClientEngine(settings); Client.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, port)); if (SettingsManager.EnableDHT) { var listener = new DhtListener(new IPEndPoint(IPAddress.Any, port)); var dht = new DhtEngine(listener); Client.RegisterDht(dht); listener.Start(); if (File.Exists(SettingsManager.DhtCachePath)) dht.Start(File.ReadAllBytes(SettingsManager.DhtCachePath)); else dht.Start(); } SettingsManager.PropertyChanged += SettingsManager_PropertyChanged; }
public TorrentServer(string downloadsPath, int listenPort) { this.downloadsPath = downloadsPath; var engineSettings = new EngineSettings(downloadsPath, listenPort); engine = new ClientEngine(engineSettings); }
internal ListenManager(ClientEngine engine) { Engine = engine; Listeners = new MonoTorrentCollection<PeerListener>(); endCheckEncryptionCallback = ClientEngine.MainLoop.Wrap(EndCheckEncryption); handshakeReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => onPeerHandshakeReceived(a, b, c)); }
public void Init() { //get general settings in file GuiGeneralSettings genSettings = settingsBase.LoadSettings<GuiGeneralSettings>("General Settings"); clientEngine = new ClientEngine(genSettings.GetEngineSettings()); // Create Torrents path if (!Directory.Exists(genSettings.TorrentsPath)) Directory.CreateDirectory(genSettings.TorrentsPath); // Add torrents from startup paramters to torrents folder foreach (string file in Global.TorrentFiles) { if (File.Exists(file) && file.EndsWith(".torrent")) { // FIXME: This isn't cross platform. Use the "Path" class to do this string newFile = genSettings.TorrentsPath + file.Substring(file.LastIndexOf("\\")); if (!File.Exists(newFile)) File.Copy(file, newFile); } } //load all torrents in torrents folder foreach (string file in Directory.GetFiles(genSettings.TorrentsPath, "*.torrent")) { GuiTorrentSettings torrentSettings = settingsBase.LoadSettings<GuiTorrentSettings>("Torrent Settings for " + file); Add(file, torrentSettings.GetTorrentSettings(), string.IsNullOrEmpty(torrentSettings.SavePath) ? clientEngine.Settings.SavePath : torrentSettings.SavePath); } //subscribe to event for update clientEngine.StatsUpdate += OnUpdateStats; }
public EngineAdapter(string name, EngineSettingsAdapter settings, ObjectPath path) { this.name = name; this.engine = new ClientEngine(settings.Settings); this.engineSettings = settings; this.path = path; DownloaderPath = path.ToString () + "/downloaders/{0}"; StoragePath = Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData); StoragePath = System.IO.Path.Combine (StoragePath, "monotorrent-dbus"); EnsurePath (StoragePath); StoragePath = System.IO.Path.Combine (StoragePath, string.Format ("engine-{0}", name)); EnsurePath (StoragePath); downloaders = new Dictionary<ObjectPath, TorrentManagerAdapter> (new ObjectPathComparer()); torrents = new Dictionary<ObjectPath,TorrentAdapter> (); engine.StatsUpdate += delegate { StatsUpdateHandler h = StatsUpdate; if (h != null) h (); }; LoadState (); }
public CriticalExceptionEventArgs(Exception ex, ClientEngine engine) { if (ex == null) throw new ArgumentNullException("ex"); if (engine == null) throw new ArgumentNullException("engine"); this.engine = engine; this.ex = ex; }
public TorrentService(ILogger <TorrentService> logger, IServiceScopeFactory scopeFactory) { _logger = logger; _httpClient = new HttpClient(); _scope = scopeFactory; _engine = new MonoTorrent.Client.ClientEngine(); _timer = new Timer(_TimerCallback, null, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30)); }
public EngineTestRig(string savePath, int piecelength, PieceWriter writer) { if (writer == null) writer = new MemoryWriter(new NullWriter()); Listener = new CustomListener(); Engine = new ClientEngine(new EngineSettings(), Listener, writer); TorrentDict = CreateTorrent(piecelength); Torrent = Torrent.Load(TorrentDict); Manager = new TorrentManager(Torrent, savePath, new TorrentSettings()); Engine.Register(Manager); //manager.Start(); }
static void Main(string[] args) { var traceListener = new ConsoleTraceListener(); Debug.Listeners.Add(traceListener); var torrentDefaults = new TorrentSettings(4, 150, 0, 0); torrentDefaults.UseDht = false; var engineSettings = new EngineSettings(); engineSettings.PreferEncryption = false; engineSettings.AllowedEncryption = EncryptionTypes.All; var clientEngine = new ClientEngine(engineSettings); StartDownload(clientEngine, torrentDefaults); }
public EpisodeManager(List<TvShowTile> SubbscribedShows) { _subbedShows = new List<TvShow>(); SubbscribedShows.ForEach((s) => _subbedShows.Add(s.TvShow)); _timerCheckForNewEpisode = new Timer(); //_timerCheckForNewEpisode.AutoReset = true; _timerCheckForNewEpisode.Elapsed += _timerCheckForNewEpisode_Elapsed; _timerCheckForNewEpisode.Interval = 1000; // TODO: Change to 1 second _repo = TvShowRepo.Repo; _engine = new ClientEngine(new EngineSettings()); _client = new TorrentClient(); //_strikeClient = new Strike(); _timerCheckForNewEpisode.Start(); }
private static void StartDownload(ClientEngine clientEngine, TorrentSettings torrentDefaultSettings) { string baseDir = Path.Combine(Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.Personal), "var"), "MonoTorrent"); Debug.WriteLine(string.Format("Base Dir is {0}", baseDir)); var torrent = Torrent.Load(Path.Combine(baseDir, TorrentFileName)); var torrentManager = new TorrentManager(torrent, Path.Combine(baseDir, "Downloads"), torrentDefaultSettings, "", -1); clientEngine.Register(torrentManager); torrentManager.Start(); Console.Read(); }
public static void Main(string[] args) { BasicConfigurator.Configure(new ConsoleAppender() { Layout = new PatternLayout( "%timestamp [%thread] %-5level %logger{1} - %message%newline") }); var torrentDefaults = new TorrentSettings(4, 150, 0, 0); torrentDefaults.UseDht = false; var engineSettings = new EngineSettings(); engineSettings.PreferEncryption = false; engineSettings.AllowedEncryption = EncryptionTypes.All; var clientEngine = new ClientEngine(engineSettings); StartDownload(clientEngine, torrentDefaults); }
/// <summary> /// /// </summary> /// <param name="settings"></param> public ConnectionManager(ClientEngine engine) { this.engine = engine; this.endCheckEncryptionCallback = delegate(IAsyncResult result) { ClientEngine.MainLoop.Queue(delegate { EndCheckEncryption(result); }); }; this.endSendMessageCallback = delegate(bool s, int c, object o) { ClientEngine.MainLoop.Queue(delegate { EndSendMessage(s, c, o); }); }; this.endCreateConnectionCallback = delegate(bool succeeded, object state) { ClientEngine.MainLoop.Queue(delegate { EndCreateConnection(succeeded, state); }); }; this.incomingConnectionAcceptedCallback = delegate(bool s, int c, object o) { ClientEngine.MainLoop.Queue(delegate { IncomingConnectionAccepted(s, c, o); }); }; this.bitfieldSentCallback = new MessagingCallback(PeerBitfieldSent); this.handshakeSentCallback = new MessagingCallback(this.PeerHandshakeSent); this.handshakeReceievedCallback = delegate(bool s, int c, object o) { ClientEngine.MainLoop.Queue(delegate { PeerHandshakeReceived(s, c, o); }); }; this.messageSentCallback = new MessagingCallback(this.PeerMessageSent); this.torrents = new MonoTorrentCollection<TorrentManager>(); }
/// <summary> /// </summary> /// <param name="settings"></param> public ConnectionManager(ClientEngine engine) { this.engine = engine; endCheckEncryptionCallback = ClientEngine.MainLoop.Wrap(EndCheckEncryption); endSendMessageCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndSendMessage(a, b, c)); endCreateConnectionCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndCreateConnection(a, b, c)); incomingConnectionAcceptedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => IncomingConnectionAccepted(a, b, c)); handshakeSentCallback = PeerHandshakeSent; peerHandshakeReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => PeerHandshakeReceived(a, b, c)); messageSentCallback = PeerMessageSent; messageReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => MessageReceived(a, b, c)); pendingConnects = new List<AsyncConnectState>(); }
public void Initialize() { Torrents = new ObservableCollection<PeriodicTorrent>(); // TODO: Customize most of these settings var settings = new EngineSettings(Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Downloads"), 22239); settings.PreferEncryption = true; settings.AllowedEncryption = EncryptionTypes.RC4Full | EncryptionTypes.RC4Header; Client = new ClientEngine(settings); Client.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, 22239)); var listener = new DhtListener(new IPEndPoint(IPAddress.Any, 22239)); var dht = new DhtEngine(listener); Client.RegisterDht(dht); listener.Start(); if (File.Exists(SettingsManager.DhtCachePath)) dht.Start(File.ReadAllBytes(SettingsManager.DhtCachePath)); else dht.Start(); }
void SetupEngine() { EngineSettings settings = new EngineSettings(); settings.AllowedEncryption = ChooseEncryption(); // If both encrypted and unencrypted connections are supported, an encrypted connection will be attempted // first if this is true. Otherwise an unencrypted connection will be attempted first. settings.PreferEncryption = true; // Torrents will be downloaded here by default when they are registered with the engine settings.SavePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Torrents"); // The maximum upload speed is 200 kilobytes per second, or 204,800 bytes per second settings.GlobalMaxUploadSpeed = 200 * 1024; engine = new ClientEngine(settings); // Tell the engine to listen at port 6969 for incoming connections engine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 6969)); }
public static void TestDownloadFile(string db, string torrentPath, string savePath) { //System.Diagnostics.Debugger.Launch(); var dbs = new ChunkDbService(db, false); var ds = new DeduplicationService(dbs); var writer = new DedupDiskWriter(ds); var engineSettings = new EngineSettings(); engineSettings.PreferEncryption = false; engineSettings.AllowedEncryption = EncryptionTypes.All; int port = 33123; var ip = NetUtil.GetLocalIPByInterface("Local Area Connection"); engineSettings.ReportedAddress = new IPEndPoint(ip, port); var engine = new ClientEngine(engineSettings, new DedupDiskWriter(ds)); var vd = new VirtualDiskDownloadService(engine, new FileInfoTable<TorrentManager>()); var torrent = Torrent.Load(torrentPath); logger.DebugFormat("Loaded torrent file: {0}, piece length: {1}.", torrent.Name, torrent.PieceLength); var filePath = Path.Combine(savePath, torrent.Name); vd.StartDownloadingFile(torrent, savePath, dbs.GetManagedFile(filePath).ChunkMap.LastPieceInProfile); Console.Read(); }
public BitTorrentFileTransferProvider() { MonoTorrent.Client.Logger.AddListener(new System.Diagnostics.ConsoleTraceListener()); string downloadPath = Core.Settings.IncompleteDownloadDir; EngineSettings settings = new EngineSettings (downloadPath, 1); torrentDefaults = new TorrentSettings (4, 60, 0, 0); listener = new MeshworkPeerConnectionListener (); engine = new ClientEngine(settings, listener); Core.FinishedLoading += delegate { Core.FileTransferManager.FileTransferRemoved += Core_FileTransferRemoved; }; #if RIDICULOUS_DEBUG_OUTPUT engine.ConnectionManager.PeerMessageTransferred += delegate (object sender, PeerMessageEventArgs e) { LoggingService.LogDebug("{0}: {1}", e.Direction, e.Message.GetType().Name); }; #endif }
static void StartDownload(ClientEngine clientEngine, TorrentSettings torrentDefaultSettings) { string baseDir = Path.Combine(Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.Personal), "var"), "MonoTorrent"); Debug.WriteLine(string.Format("Base Dir is {0}", baseDir)); var torrent = Torrent.Load(Path.Combine(baseDir, TorrentFileName)); (torrent.Files[0] as TorrentFile).Priority = Priority.Highest; (torrent.Files[1] as TorrentFile).Priority = Priority.DoNotDownload; (torrent.Files[2] as TorrentFile).Priority = Priority.DoNotDownload; long targetDownloadSize = (torrent.Files[0] as TorrentFile).Length; long totalSize = torrent.Size; double targetPercentage = (double)targetDownloadSize / totalSize; Debug.WriteLine(string.Format("Intend to download {0}/{1} = {2}", targetDownloadSize, totalSize, targetPercentage)); var torrentManager = new TorrentManager(torrent, Path.Combine(baseDir, "Downloads"), torrentDefaultSettings); var progressMonitor = new PartialDownloadProgressMonitor(torrentManager); progressMonitor.FileDownloaded += new EventHandler<FileDownloadedEventArgs>(progressMonitor_FileDownloaded); clientEngine.Register(torrentManager); torrentManager.TorrentStateChanged += new EventHandler<TorrentStateChangedEventArgs>(torrentManager_TorrentStateChanged); // Start downloading torrentManager.Start(); // Keep running while the torrent isn't stopped or paused. while (torrentManager.State != TorrentState.Stopped && torrentManager.State != TorrentState.Paused) { Debug.WriteLine(string.Format("Progress: {0}", torrentManager.Progress)); System.Threading.Thread.Sleep(2000); } Console.Read(); }
public Transfer(string path) { this.basePath = Path.GetFullPath(path); this.torrentsPath = Path.Combine(basePath, "Torrents"); this.fastResumePath = Path.Combine(basePath, "fastresume.data"); this.dhtNodes = Path.Combine(basePath, "dhtNodes.data"); this.downloadsPath = Path.Combine(basePath, "Downloads"); EngineSettings settings = new EngineSettings(downloadsPath, enginePort); settings.AllowedEncryption = MonoTorrent.Client.Encryption.EncryptionTypes.All; settings.PreferEncryption = false; this.engine = new ClientEngine(settings); engine.ConnectionManager.PeerMessageTransferred += delegate(object o, PeerMessageEventArgs e) { Console.WriteLine( e.Message); }; this.managerCollection = new List<TorrentManager>(); this.defaultSettings = new TorrentSettings(50, 100, 100000, 100000, false); defaultSettings.UseDht = false; defaultSettings.EnablePeerExchange = true; this.startDHT(); }
private void RunTorrents() { TorrentOptions tOpts = UserSettings.Current.TorrentOptions; if (globalEngine == null) { int listenPort = tOpts.ListeningPort; string mainDownloadsPath = UserSettings.ContentDataPath; // Create the settings which the engine will use // downloadsPath - this is the path where we will save all the files to // port - this is the port we listen for connections on var engineSettings = new EngineSettings(mainDownloadsPath, listenPort); engineSettings.PreferEncryption = true; engineSettings.AllowedEncryption = EncryptionTypes.All; engineSettings.GlobalMaxConnections = tOpts.MaxDLConnsNormalized; engineSettings.GlobalMaxDownloadSpeed = tOpts.MaxDLSpeed*1024; engineSettings.GlobalMaxHalfOpenConnections = 10; engineSettings.GlobalMaxUploadSpeed = tOpts.MaxULSpeed*1024; // Create an instance of the engine. globalEngine = new ClientEngine(engineSettings); globalEngine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, listenPort)); engineListenPort = listenPort; EngineStartedOnPort(engineListenPort); //create a DHT engine and register it with the main engine { var dhtListener = new DhtListener(new IPEndPoint(IPAddress.Any, listenPort)); var dhtEngine = new DhtEngine(dhtListener); dhtListener.Start(); string dhtNodesFileName = ""; byte[] dhtNodesData = null; try { dhtNodesFileName = GetDhtNodesFileName(); if (File.Exists(dhtNodesFileName)) dhtNodesData = File.ReadAllBytes(dhtNodesFileName); } catch (Exception ex) { Console.WriteLine("Error loading dht nodes file '{0}', reason: {1}", dhtNodesFileName, ex.Message); dhtNodesData = null; } dhtEngine.Start(dhtNodesData); globalEngine.RegisterDht(dhtEngine); // We need to cleanup correctly when the user closes the window by using ctrl-c // or an unhandled exception happens Console.CancelKeyPress += delegate { EngineShutdown(); }; AppDomain.CurrentDomain.ProcessExit += delegate { EngineShutdown(); }; AppDomain.CurrentDomain.UnhandledException += delegate(object sender, UnhandledExceptionEventArgs e) { Console.WriteLine(e.ExceptionObject); EngineShutdown(); }; Thread.GetDomain().UnhandledException += delegate(object sender, UnhandledExceptionEventArgs e) { Console.WriteLine(e.ExceptionObject); EngineShutdown(); }; } } else StopAllTorrents(); // Create the default settings which a torrent will have. var torrentDefaults = new TorrentSettings(tOpts.NumULSlotsNormalized); torrentDefaults.UseDht = true; torrentDefaults.EnablePeerExchange = true; // For each file in the torrents path that is a .torrent file, load it into the engine. var managers = new List<TorrentManager>(); foreach (AddOnTorrent newAddOn in addOnTorrents) { Torrent torrent = null; try { torrent = Torrent.Load(File.ReadAllBytes(newAddOn.torrentFileName)); } catch (Exception ex) { updater.Status = "Error loading torrent file"; downloader.Status = ex.Message; downloader.IsRunning = false; return; } try { var fullFilePaths = new List<String>(); { TorrentFile[] torrentFiles = torrent.Files; foreach (TorrentFile theFile in torrentFiles) fullFilePaths.Add(Path.Combine(newAddOn.torrentSavePath, theFile.Path)); } if (Directory.Exists(newAddOn.torrentSavePath)) { string[] actualFilePaths = Directory.GetFiles(newAddOn.torrentSavePath, "*.*", SearchOption.AllDirectories); foreach (string realPath in actualFilePaths) { var fileInfo = new FileInfo(realPath); if ( fullFilePaths.Count( path => { return path.Equals(fileInfo.FullName, StringComparison.InvariantCultureIgnoreCase); }) < 1) { //this is an unwanted file if (fileInfo.IsReadOnly) { fileInfo.IsReadOnly = false; fileInfo.Refresh(); } fileInfo.Delete(); } } } } catch (Exception ex) { updater.Status = "Error deleting unwanted file"; downloader.Status = ex.Message; downloader.IsRunning = false; return; } TorrentManager tm = null; try { tm = new TorrentManager(torrent, globalEngine.Settings.SavePath, torrentDefaults, newAddOn.torrentSavePath); if (!fullSystemCheck && !UserSettings.Current.TorrentOptions.DisableFastResume) //load the fast resume file for this torrent { string fastResumeFilepath = GetFastResumeFileName(tm); if (File.Exists(fastResumeFilepath)) { var bencoded = BEncodedValue.Decode<BEncodedDictionary>(File.ReadAllBytes(fastResumeFilepath)); tm.LoadFastResume(new FastResume(bencoded)); } } } catch (Exception ex) { if (tm == null) //only if critical failure { updater.Status = "Error creating torrent manager"; downloader.Status = ex.Message; downloader.IsRunning = false; return; } } managers.Add(tm); } // If we loaded no torrents, just stop. if (managers.Count < 1) { updater.Status = "Torrent engine error"; downloader.Status = "No torrents have been found"; downloader.IsRunning = false; return; } try { File.WriteAllText(UserSettings.ContentCurrentTagFile, versionString); CalculatedGameSettings.Current.Update(); } catch (Exception ex) { updater.Status = "Tag file write error"; downloader.Status = ex.Message; downloader.IsRunning = false; return; } // Before starting all the managers, clear out the fastresume data // The torrents currently running already have it loaded, and will save it out on stop/finish // So this only clears out fastresume for torrents we aren't currently running, which is what we want IEnumerable<string> staleFastResume = Directory.EnumerateFiles(UserSettings.TorrentJunkPath, "fastresume_*.benc", SearchOption.TopDirectoryOnly); foreach (string sfr in staleFastResume) { try { File.Delete(sfr); } catch (Exception) { } } foreach (TorrentManager manager in managers) { // Add this manager to the global torrent engine globalEngine.Register(manager); // Every time a new peer is added, this is fired. manager.PeersFound += delegate { }; // Every time a piece is hashed, this is fired. manager.PieceHashed += delegate { }; // Every time the state changes (Stopped -> Seeding -> Downloading -> Hashing) this is fired manager.TorrentStateChanged += OnTorrentStateChanged; // Every time the tracker's state changes, this is fired foreach (TrackerTier tier in manager.TrackerManager) { } manager.Start(); } // While the torrents are still running, print out some stats to the screen. // Details for all the loaded torrent managers are shown. int i = 0; bool running = true; var sb = new StringBuilder(1024); DateTime lastAnnounce = DateTime.Now; bool firstRun = true; while (running && globalEngine != null) { IList<TorrentManager> engineTorrents = globalEngine.Torrents; if (firstRun || lastAnnounce < DateTime.Now.AddMinutes(-1)) { foreach (TorrentManager tm in engineTorrents) tm.TrackerManager.Announce(); lastAnnounce = DateTime.Now; firstRun = false; } if ((i++)%2 == 0) { sb.Remove(0, sb.Length); running = engineTorrents.Count(m => { return m.State != TorrentState.Stopped; }) > 0; var totalState = TorrentState.Stopped; if (engineTorrents.Count(m => m.State == TorrentState.Hashing) > 0) totalState = TorrentState.Hashing; else if (engineTorrents.Count(m => m.State == TorrentState.Downloading) > 0) totalState = TorrentState.Downloading; else if (engineTorrents.Count(m => m.State == TorrentState.Seeding) > 0) totalState = TorrentState.Seeding; string status = ""; try { switch (totalState) { case TorrentState.Hashing: { double totalHashingBytes = 0; double totalHashedBytes = 0; foreach (TorrentManager m in engineTorrents) { totalHashingBytes += m.Torrent.Size; if (m.State == TorrentState.Hashing) totalHashedBytes += m.Torrent.Size*(m.Progress/100); else totalHashedBytes += m.Torrent.Size; } double totalHashProgress = totalHashedBytes/totalHashingBytes; status = String.Format("Checking files ({0:0.00}%)", totalHashProgress*100); StatusCallbacks(TorrentState.Hashing, totalHashProgress); } break; case TorrentState.Downloading: { double totalToDownload = 0; double totalDownloaded = 0; double totalDownloadSpeed = 0; double totalUploadSpeed = 0; int totalDownloadConns = 0; int totalUploadConns = 0; foreach (TorrentManager m in engineTorrents) { totalToDownload += m.Torrent.Size; totalDownloaded += m.Torrent.Size*(m.Progress/100); totalDownloadSpeed += m.Monitor.DownloadSpeed; totalUploadSpeed += m.Monitor.UploadSpeed; totalDownloadConns += m.OpenConnections; totalUploadConns += m.UploadingTo; } double totalDownloadProgress = totalDownloaded/totalToDownload; status = "Status: " + ((engineTorrents.Count(m => m.State == TorrentState.Downloading && m.GetPeers().Count > 0) > 0) ? "Downloading" : "Finding peers"); status += "\n" + String.Format("Progress: {0:0.00}%", totalDownloadProgress*100); status += "\n" + String.Format("Download({1}): {0:0.00} KiB/s", totalDownloadSpeed/1024.0, totalDownloadConns); status += "\n" + String.Format("Upload({1}): {0:0.00} KiB/s", totalUploadSpeed/1024.0, totalUploadConns); StatusCallbacks(TorrentState.Downloading, totalDownloadProgress); } break; case TorrentState.Seeding: { double totalUploadSpeed = 0; int totalUploadPeers = 0; foreach (TorrentManager tm in engineTorrents) { totalUploadSpeed += tm.Monitor.UploadSpeed; totalUploadPeers += tm.UploadingTo; } status = String.Format("Seeding({1}): {0:0.00} KiB/s", totalUploadSpeed/1024.0, totalUploadPeers); StatusCallbacks(TorrentState.Seeding, 1); if (UserSettings.Current.TorrentOptions.StopSeeding) globalEngine.StopAll(); } break; default: status = totalState.ToString(); break; } } catch (Exception ex) { status = ex.Message; } if (downloader != null) downloader.Status = status; } Thread.Sleep(50); } }
public LocalPeerListener(ClientEngine engine) : base(new IPEndPoint(IPAddress.Any, 6771)) { this.engine = engine; }
private TestRig(string savePath, int piecelength, TestWriter writer, string[][] trackers, TorrentFile[] files, bool metadataMode) { this.files = files; this.savePath = savePath; this.piecelength = piecelength; tier = trackers; MetadataMode = metadataMode; MetadataPath = "metadataSave.torrent"; Listener = new CustomListener(); Engine = new ClientEngine(new EngineSettings(), Listener, writer); Writer = writer; RecreateManager(); }
internal DiskManager(ClientEngine engine, PieceWriter writer) { this.bufferedReads = new Queue<BufferedIO>(); this.bufferedWrites = new Queue<BufferedIO>(); this.cache = new Cache<BufferedIO>(true).Synchronize (); this.engine = engine; this.readLimiter = new RateLimiter(); this.readMonitor = new SpeedMonitor(); this.writeMonitor = new SpeedMonitor(); this.writeLimiter = new RateLimiter(); this.writer = writer; LoopTask = delegate { if (disposed) return; while (this.bufferedWrites.Count > 0 && writeLimiter.TryProcess(bufferedWrites.Peek ().buffer.Length / 2048)) { BufferedIO write; lock (bufferLock) write = this.bufferedWrites.Dequeue(); try { PerformWrite(write); cache.Enqueue (write); } catch (Exception ex) { if (write.Manager != null) SetError(write.Manager, Reason.WriteFailure, ex); } } while (this.bufferedReads.Count > 0 && readLimiter.TryProcess(bufferedReads.Peek().Count / 2048)) { BufferedIO read; lock(bufferLock) read = this.bufferedReads.Dequeue(); try { PerformRead(read); cache.Enqueue (read); } catch (Exception ex) { if(read.Manager != null) SetError(read.Manager, Reason.ReadFailure, ex); } } }; IOLoop.QueueTimeout(TimeSpan.FromSeconds(1), delegate { if (disposed) return false; readMonitor.Tick(); writeMonitor.Tick(); LoopTask(); return true; }); }
/// <summary> /// /// </summary> public ConnectionManager(ClientEngine engine) { this.engine = engine; PendingConnects = new List <AsyncConnectState>(); }
public VirtualDiskDownloadService(ClientEngine torrentClientEngine, FileInfoTable<TorrentManager> torrentManagerTable) { _clientEngine = torrentClientEngine; _torrentManagerTable = torrentManagerTable; }
internal DiskManager(ClientEngine engine, PieceWriter writer) { this.bufferedReads = new Queue <BufferedIO>(); this.bufferedWrites = new Queue <BufferedIO>(); this.cache = new Cache <BufferedIO>(true).Synchronize(); this.engine = engine; this.readLimiter = new RateLimiter(); this.readMonitor = new SpeedMonitor(); this.writeMonitor = new SpeedMonitor(); this.writeLimiter = new RateLimiter(); this.writer = writer; LoopTask = delegate { if (disposed) { return; } while (this.bufferedWrites.Count > 0 && writeLimiter.TryProcess(bufferedWrites.Peek().buffer.Length / 2048)) { BufferedIO write; lock (bufferLock) write = this.bufferedWrites.Dequeue(); try { PerformWrite(write); cache.Enqueue(write); } catch (Exception ex) { logger.Error("Write error: {0}", ex.Message); if (write.Manager != null) { SetError(write.Manager, Reason.WriteFailure, ex); } } } while (this.bufferedReads.Count > 0 && readLimiter.TryProcess(bufferedReads.Peek().Count / 2048)) { BufferedIO read; lock (bufferLock) read = this.bufferedReads.Dequeue(); try { PerformRead(read); cache.Enqueue(read); } catch (Exception ex) { logger.Error("Read error: {0}", ex.Message); if (read.Manager != null) { SetError(read.Manager, Reason.ReadFailure, ex); } } } }; IOLoop.QueueTimeout(TimeSpan.FromSeconds(1), delegate { if (disposed) { return(false); } readMonitor.Tick(); writeMonitor.Tick(); LoopTask(); return(true); }); }
private static void RegisterClientEngineEventHandlers(ClientEngine clientEngine) { clientEngine.CriticalException += delegate(object sender, CriticalExceptionEventArgs args) { Logger.WriteLineIf(LogLevel.Error, _log_props, string.Format("ClientEngine Critical Exception: {0}", args.Exception)); }; //cliengEngine.StatsUpdate += delegate(object sender, StatsUpdateEventArgs args) { // Logger.WriteLineIf(LogLevel.Verbose, _log_props, // string.Format("ClientEngine Stats Update")); //}; clientEngine.TorrentRegistered += delegate(object sender, TorrentEventArgs args) { Logger.WriteLineIf(LogLevel.Verbose, _log_props, string.Format("ClientEngine Torrent Registered: {0}.", args.TorrentManager.Torrent.Name)); }; //cliengEngine.ConnectionManager.PeerMessageTransferred += delegate(object sender, PeerMessageEventArgs args) { // Logger.WriteLineIf(LogLevel.Verbose, _log_props, string.Format( // "ClientEngine Peer Message Transferred. Direction:{0}, Message: {1}.", // args.Direction, args.Message)); //}; }
internal ListenManager(ClientEngine engine) { Engine = engine ?? throw new ArgumentNullException(nameof(engine)); Listeners = new List <IPeerListener>(); }
private static void EngineShutdown() { if (globalEngine != null) { StopAllTorrents(true); EngineStoppedOnPort(engineListenPort); engineListenPort = 0; string dhtNodesFileName = ""; try { dhtNodesFileName = GetDhtNodesFileName(); File.WriteAllBytes(dhtNodesFileName, globalEngine.DhtEngine.SaveNodes()); } catch (Exception ex) { Console.WriteLine("Error saving dht nodes file '{0}', reason: {1}", dhtNodesFileName, ex.Message); } globalEngine.Dispose(); globalEngine = null; } foreach (TraceListener lst in Debug.Listeners) { lst.Flush(); lst.Close(); } }
internal ListenManager(ClientEngine engine) { Engine = engine; listeners = new MonoTorrentCollection <PeerListener>(); }
internal ListenManager(ClientEngine engine) { Engine = engine ?? throw new ArgumentNullException(nameof(engine)); Listener = new NullPeerListener(); SKeys = Array.Empty <InfoHash> (); }
public CriticalExceptionEventArgs(Exception ex, ClientEngine engine) { Engine = engine ?? throw new ArgumentNullException(nameof(engine)); Exception = ex ?? throw new ArgumentNullException(nameof(ex)); }
private static void StartEngine() { int port; Torrent torrent = null; // Ask the user what port they want to use for incoming connections //Console.Write(Environment.NewLine + "Choose a listen port: "); //while (!Int32.TryParse(Console.ReadLine(), out port)) { } port = 4545; // Create the settings which the engine will use // downloadsPath - this is the path where we will save all the files to // port - this is the port we listen for connections on EngineSettings engineSettings = new EngineSettings(downloadsPath, port); engineSettings.PreferEncryption = false; engineSettings.AllowedEncryption = EncryptionTypes.All; //engineSettings.GlobalMaxUploadSpeed = 30 * 1024; //engineSettings.GlobalMaxDownloadSpeed = 100 * 1024; //engineSettings.MaxReadRate = 1 * 1024 * 1024; // Create the default settings which a torrent will have. // 4 Upload slots - a good ratio is one slot per 5kB of upload speed // 50 open connections - should never really need to be changed // Unlimited download speed - valid range from 0 -> int.Max // Unlimited upload speed - valid range from 0 -> int.Max TorrentSettings torrentDefaults = new TorrentSettings(4, 150, 0, 0); // Create an instance of the engine. engine = new ClientEngine(engineSettings); engine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, port)); byte[] nodes = null; try { nodes = File.ReadAllBytes(dhtNodeFile); } catch { Console.WriteLine("No existing dht nodes could be loaded"); } DhtListener dhtListner = new DhtListener (new IPEndPoint (IPAddress.Any, port)); DhtEngine dht = new DhtEngine (dhtListner); engine.RegisterDht(dht); dhtListner.Start(); engine.DhtEngine.Start(nodes); // If the SavePath does not exist, we want to create it. if (!Directory.Exists(engine.Settings.SavePath)) Directory.CreateDirectory(engine.Settings.SavePath); // If the torrentsPath does not exist, we want to create it if (!Directory.Exists(torrentsPath)) Directory.CreateDirectory(torrentsPath); BEncodedDictionary fastResume; try { fastResume = BEncodedValue.Decode<BEncodedDictionary>(File.ReadAllBytes(fastResumeFile)); } catch { fastResume = new BEncodedDictionary(); } // For each file in the torrents path that is a .torrent file, load it into the engine. foreach (string file in Directory.GetFiles(torrentsPath)) { if (file.EndsWith(".torrent")) { try { // Load the .torrent from the file into a Torrent instance // You can use this to do preprocessing should you need to torrent = Torrent.Load(file); Console.WriteLine(torrent.InfoHash.ToString()); } catch (Exception e) { Console.Write("Couldn't decode {0}: ", file); Console.WriteLine(e.Message); continue; } // When any preprocessing has been completed, you create a TorrentManager // which you then register with the engine. TorrentManager manager = new TorrentManager(torrent, downloadsPath, torrentDefaults); if (fastResume.ContainsKey(torrent.InfoHash.ToHex ())) manager.LoadFastResume(new FastResume ((BEncodedDictionary)fastResume[torrent.InfoHash.ToHex ()])); engine.Register(manager); // Store the torrent manager in our list so we can access it later torrents.Add(manager); manager.PeersFound += new EventHandler<PeersAddedEventArgs>(manager_PeersFound); } } // If we loaded no torrents, just exist. The user can put files in the torrents directory and start // the client again if (torrents.Count == 0) { Console.WriteLine("No torrents found in the Torrents directory"); Console.WriteLine("Exiting..."); engine.Dispose(); return; } // For each torrent manager we loaded and stored in our list, hook into the events // in the torrent manager and start the engine. foreach (TorrentManager manager in torrents) { // Every time a piece is hashed, this is fired. manager.PieceHashed += delegate(object o, PieceHashedEventArgs e) { lock (listener) listener.WriteLine(string.Format("Piece Hashed: {0} - {1}", e.PieceIndex, e.HashPassed ? "Pass" : "Fail")); }; // Every time the state changes (Stopped -> Seeding -> Downloading -> Hashing) this is fired manager.TorrentStateChanged += delegate (object o, TorrentStateChangedEventArgs e) { lock (listener) listener.WriteLine("OldState: " + e.OldState.ToString() + " NewState: " + e.NewState.ToString()); }; // Every time the tracker's state changes, this is fired foreach (TrackerTier tier in manager.TrackerManager) { foreach (MonoTorrent.Client.Tracker.Tracker t in tier.Trackers) { t.AnnounceComplete += delegate(object sender, AnnounceResponseEventArgs e) { listener.WriteLine(string.Format("{0}: {1}", e.Successful, e.Tracker.ToString())); }; } } // Start the torrentmanager. The file will then hash (if required) and begin downloading/seeding manager.Start(); } // While the torrents are still running, print out some stats to the screen. // Details for all the loaded torrent managers are shown. int i = 0; bool running = true; StringBuilder sb = new StringBuilder(1024); while (running) { if ((i++) % 10 == 0) { sb.Remove(0, sb.Length); running = torrents.Exists(delegate(TorrentManager m) { return m.State != TorrentState.Stopped; }); AppendFormat(sb, "Total Download Rate: {0:0.00}kB/sec", engine.TotalDownloadSpeed / 1024.0); AppendFormat(sb, "Total Upload Rate: {0:0.00}kB/sec", engine.TotalUploadSpeed / 1024.0); AppendFormat(sb, "Disk Read Rate: {0:0.00} kB/s", engine.DiskManager.ReadRate / 1024.0); AppendFormat(sb, "Disk Write Rate: {0:0.00} kB/s", engine.DiskManager.WriteRate / 1024.0); AppendFormat(sb, "Total Read: {0:0.00} kB", engine.DiskManager.TotalRead / 1024.0); AppendFormat(sb, "Total Written: {0:0.00} kB", engine.DiskManager.TotalWritten / 1024.0); AppendFormat(sb, "Open Connections: {0}", engine.ConnectionManager.OpenConnections); foreach (TorrentManager manager in torrents) { AppendSeperator(sb); AppendFormat(sb, "State: {0}", manager.State); AppendFormat(sb, "Name: {0}", manager.Torrent == null ? "MetaDataMode" : manager.Torrent.Name); AppendFormat(sb, "Progress: {0:0.00}", manager.Progress); AppendFormat(sb, "Download Speed: {0:0.00} kB/s", manager.Monitor.DownloadSpeed / 1024.0); AppendFormat(sb, "Upload Speed: {0:0.00} kB/s", manager.Monitor.UploadSpeed / 1024.0); AppendFormat(sb, "Total Downloaded: {0:0.00} MB", manager.Monitor.DataBytesDownloaded / (1024.0 * 1024.0)); AppendFormat(sb, "Total Uploaded: {0:0.00} MB", manager.Monitor.DataBytesUploaded / (1024.0 * 1024.0)); MonoTorrent.Client.Tracker.Tracker tracker = manager.TrackerManager.CurrentTracker; //AppendFormat(sb, "Tracker Status: {0}", tracker == null ? "<no tracker>" : tracker.State.ToString()); AppendFormat(sb, "Warning Message: {0}", tracker == null ? "<no tracker>" : tracker.WarningMessage); AppendFormat(sb, "Failure Message: {0}", tracker == null ? "<no tracker>" : tracker.FailureMessage); if (manager.PieceManager != null) AppendFormat(sb, "Current Requests: {0}", manager.PieceManager.CurrentRequestCount()); foreach (PeerId p in manager.GetPeers()) { //CovertChannel.CovertChannel.targetPeerId = ; //CovertChannel.CovertPicker picker = new CovertChannel.CovertPicker (null); AppendFormat (sb, "\t{2} - {1:0.00}/{3:0.00}kB/sec - {0}", p.Peer.ConnectionUri, p.Monitor.DownloadSpeed / 1024.0, p.AmRequestingPiecesCount, p.Monitor.UploadSpeed / 1024.0); } AppendFormat(sb, "", null); if (manager.Torrent != null) foreach (TorrentFile file in manager.Torrent.Files) AppendFormat(sb, "{1:0.00}% - {0}", file.Path, file.BitField.PercentComplete); } //Console.Clear(); Console.WriteLine(sb.ToString()); listener.ExportTo(Console.Out); } System.Threading.Thread.Sleep(500); } }
private void DownloaderWorker_DoWork(object sender, DoWorkEventArgs e) { try { if (e.Argument == null) return; basePath = Environment.CurrentDirectory; dhtNodeFile = System.IO.Path.Combine(basePath, "DhtNodes"); downloadsPath = System.IO.Path.Combine(basePath, "Downloads"); torrentsPath = System.IO.Path.Combine(basePath, "Torrents"); fastResumeFile = System.IO.Path.Combine(torrentsPath, "fastresume.data"); torrents = new List<TorrentManager>(); // The list where all the torrentManagers will be stored that the engine gives us listener = new Top10Listener(10); string torrentpath = e.Argument.ToString(); int port = 6969; Torrent torrent = null; // Create the settings which the engine will use // downloadsPath - this is the path where we will save all the files to // port - this is the port we listen for connections on EngineSettings engineSettings = new EngineSettings(downloadsPath, port); engineSettings.PreferEncryption = false; engineSettings.AllowedEncryption = EncryptionTypes.All; //engineSettings.GlobalMaxUploadSpeed = 30 * 1024; //engineSettings.GlobalMaxDownloadSpeed = 100 * 1024; //engineSettings.MaxReadRate = 1 * 1024 * 1024; // Create the default settings which a torrent will have. // 4 Upload slots - a good ratio is one slot per 5kB of upload speed // 50 open connections - should never really need to be changed // Unlimited download speed - valid range from 0 -> int.Max // Unlimited upload speed - valid range from 0 -> int.Max TorrentSettings torrentDefaults = new TorrentSettings(4, 150, 0, 0); // Create an instance of the engine. engine = new ClientEngine(engineSettings); engine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, port)); byte[] nodes = null; try { nodes = File.ReadAllBytes(dhtNodeFile); } catch { Console.WriteLine("No existing dht nodes could be loaded"); } DhtListener dhtListner = new DhtListener(new IPEndPoint(IPAddress.Any, port)); DhtEngine dht = new DhtEngine(dhtListner); engine.RegisterDht(dht); dhtListner.Start(); engine.DhtEngine.Start(nodes); // If the SavePath does not exist, we want to create it. if (!Directory.Exists(engine.Settings.SavePath)) Directory.CreateDirectory(engine.Settings.SavePath); // If the torrentsPath does not exist, we want to create it if (!Directory.Exists(torrentsPath)) Directory.CreateDirectory(torrentsPath); BEncodedDictionary fastResume; try { fastResume = BEncodedValue.Decode<BEncodedDictionary>(File.ReadAllBytes(fastResumeFile)); } catch { fastResume = new BEncodedDictionary(); } // Load the .torrent from the file into a Torrent instance // You can use this to do preprocessing should you need to torrent = Torrent.Load(torrentpath); // When any preprocessing has been completed, you create a TorrentManager // which you then register with the engine. TorrentManager manager = new TorrentManager(torrent, downloadsPath, torrentDefaults); //if (fastResume.ContainsKey(torrent.InfoHash.ToHex())) // manager.LoadFastResume(new FastResume((BEncodedDictionary)fastResume[torrent.infoHash.ToHex()])); engine.Register(manager); // Store the torrent manager in our list so we can access it later torrents.Add(manager); manager.PeersFound += new EventHandler<PeersAddedEventArgs>(manager_PeersFound); // Every time a piece is hashed, this is fired. manager.PieceHashed += delegate (object o, PieceHashedEventArgs ec) { lock (listener) listener.WriteLine(string.Format("Piece Hashed: {0} - {1}", ec.PieceIndex, ec.HashPassed ? "Pass" : "Fail")); }; // Every time the state changes (Stopped -> Seeding -> Downloading -> Hashing) this is fired manager.TorrentStateChanged += delegate (object o, TorrentStateChangedEventArgs ev) { lock (listener) listener.WriteLine("OldState: " + ev.OldState.ToString() + " NewState: " + ev.NewState.ToString()); }; // Every time the tracker's state changes, this is fired //foreach (TrackerTier tier in manager.TrackerManager) //{ // //foreach (MonoTorrent.Client.Tracker.Tracker t in tier.Trackers) // //{ // // t.AnnounceComplete += delegate (object sender, AnnounceResponseEventArgs e) // // { // // listener.WriteLine(string.Format("{0}: {1}", e.Successful, e.Tracker.ToString())); // // }; // //} //} // Start the torrentmanager. The file will then hash (if required) and begin downloading/seeding manager.Start(); // While the torrents are still running, print out some stats to the screen. // Details for all the loaded torrent managers are shown. bool running = true; StringBuilder sb = new StringBuilder(1024); while (running) { //if ((i++) % 10 == 0) //{ sb.Remove(0, sb.Length); running = torrents.Exists(delegate (TorrentManager m) { return m.State != TorrentState.Stopped; }); //AppendFormat(sb, "Total Download Rate: {0:0.00}kB/sec", engine.TotalDownloadSpeed / 1024.0); downloadspeed = (engine.TotalDownloadSpeed / 1024.0).ToString(); //AppendFormat(sb, "Total Upload Rate: {0:0.00}kB/sec", engine.TotalUploadSpeed / 1024.0); //AppendFormat(sb, "Disk Read Rate: {0:0.00} kB/s", engine.DiskManager.ReadRate / 1024.0); //AppendFormat(sb, "Disk Write Rate: {0:0.00} kB/s", engine.DiskManager.WriteRate / 1024.0); //AppendFormat(sb, "Total Read: {0:0.00} kB", engine.DiskManager.TotalRead / 1024.0); //AppendFormat(sb, "Total Written: {0:0.00} kB", engine.DiskManager.TotalWritten / 1024.0); //AppendFormat(sb, "Open Connections: {0}", engine.ConnectionManager.OpenConnections); //AppendSeperator(sb); //AppendFormat(sb, "State: {0}", manager.State); //AppendFormat(sb, "Name: {0}", manager.Torrent == null ? "MetaDataMode" : manager.Torrent.Name); //AppendFormat(sb, "Progress: {0:0.00}", manager.Progress); //progress = manager.Progress.ToString(); //AppendFormat(sb, "Download Speed: {0:0.00} kB/s", manager.Monitor.DownloadSpeed / 1024.0); //AppendFormat(sb, "Upload Speed: {0:0.00} kB/s", manager.Monitor.UploadSpeed / 1024.0); //AppendFormat(sb, "Total Downloaded: {0:0.00} MB", manager.Monitor.DataBytesDownloaded / (1024.0 * 1024.0)); //AppendFormat(sb, "Total Uploaded: {0:0.00} MB", manager.Monitor.DataBytesUploaded / (1024.0 * 1024.0)); MonoTorrent.Client.Tracker.Tracker tracker = manager.TrackerManager.CurrentTracker; //AppendFormat(sb, "Tracker Status: {0}", tracker == null ? "<no tracker>" : tracker.State.ToString()); //AppendFormat(sb, "Warning Message: {0}", tracker == null ? "<no tracker>" : tracker.WarningMessage); //AppendFormat(sb, "Failure Message: {0}", tracker == null ? "<no tracker>" : tracker.FailureMessage); //if (manager.PieceManager != null) // AppendFormat(sb, "Current Requests: {0}", manager.PieceManager.CurrentRequestCount()); //foreach (PeerId p in manager.GetPeers()) // AppendFormat(sb, "\t{2} - {1:0.00}/{3:0.00}kB/sec - {0}", p.Peer.ConnectionUri, // p.Monitor.DownloadSpeed / 1024.0, // p.AmRequestingPiecesCount, // p.Monitor.UploadSpeed / 1024.0); //AppendFormat(sb, "", null); //if (manager.Torrent != null) // foreach (TorrentFile file in manager.Torrent.Files) // AppendFormat(sb, "{1:0.00}% - {0}", file.Path, file.BitField.PercentComplete); //Console.Clear(); //Console.WriteLine(sb.ToString()); //listener.ExportTo(Console.Out); //} DownloaderWorker.ReportProgress(Convert.ToInt32(manager.Progress), manager.State.ToString()); System.Threading.Thread.Sleep(500); } } catch (Exception ex) { } }