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 MonoTorrentClient(string applicationDataDirectoryPath)
{
// Make directories.
var monoTorrentClientApplicationDataDirectoryPath = Path.Combine (applicationDataDirectoryPath, this.GetType().Name);
if (!Directory.Exists (monoTorrentClientApplicationDataDirectoryPath))
Directory.CreateDirectory (monoTorrentClientApplicationDataDirectoryPath);
TorrentFileDirectory = Path.Combine (monoTorrentClientApplicationDataDirectoryPath, "torrents");
if (!Directory.Exists (TorrentFileDirectory))
Directory.CreateDirectory (TorrentFileDirectory);
BrokenTorrentFileDirectory = Path.Combine (monoTorrentClientApplicationDataDirectoryPath, "broken");
if (!Directory.Exists (BrokenTorrentFileDirectory))
Directory.CreateDirectory (BrokenTorrentFileDirectory);
// Make files.
DHTNodeFile = Path.Combine (monoTorrentClientApplicationDataDirectoryPath, "dhtNodes");
FastResumeFile = Path.Combine (monoTorrentClientApplicationDataDirectoryPath, "fastResume");
TorrentMappingsCacheFile = Path.Combine (monoTorrentClientApplicationDataDirectoryPath, "torrentMappingsCache");
// Make mappings cache.
TorrentMappingsCache = new ListFile<TorrentMapping> (TorrentMappingsCacheFile);
// Make default torrent settings.
DefaultTorrentSettings = new TorrentSettings (DefaultTorrentUploadSlots, DefaultTorrentOpenConnections, 0, 0);
}
public TorrentManager(MagnetLink magnetLink, string savePath, TorrentSettings settings, string torrentSave)
{
Check.MagnetLink(magnetLink);
Check.InfoHash(magnetLink.InfoHash);
Check.SavePath(savePath);
Check.Settings(settings);
Check.TorrentSave(torrentSave);
this.InfoHash = magnetLink.InfoHash;
this.Settings = settings;
this.torrentSave = torrentSave;
IList <RawTrackerTier> announces = new RawTrackerTiers();
if (magnetLink.AnnounceUrls != null)
{
announces.Add(magnetLink.AnnounceUrls);
}
if (MonoTorrent.Common.Torrent.TryLoad(torrentSave, out Torrent torrent) && torrent.InfoHash == magnetLink.InfoHash)
{
Torrent = torrent;
}
Initialise(savePath, "", announces);
if (Torrent != null)
{
ChangePicker(CreateStandardPicker());
}
}
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 TorrentManager(MagnetLink magnetLink, string savePath, TorrentSettings settings, string torrentSave)
{
Check.MagnetLink(magnetLink);
Check.InfoHash(magnetLink.InfoHash);
Check.SavePath(savePath);
Check.Settings(settings);
Check.TorrentSave(torrentSave);
this.infohash = magnetLink.InfoHash;
this.settings = settings;
this.torrentSave = torrentSave;
IList <RawTrackerTier> announces = new RawTrackerTiers();
if (magnetLink.AnnounceUrls != null)
{
announces.Add(magnetLink.AnnounceUrls);
}
this.webseeds = new List <String>();
if (magnetLink.Webseeds != null)
{
foreach (string webseed in magnetLink.Webseeds)
{
this.webseeds.Add(webseed);
}
}
Initialise(savePath, "", announces);
}
public override bool Equals(object obj)
{
TorrentSettings settings = obj as TorrentSettings;
return (settings == null) ? false : this.initialSeedingEnabled == settings.initialSeedingEnabled &&
this.maxConnections == settings.maxConnections &&
this.maxDownloadSpeed == settings.maxDownloadSpeed &&
this.maxUploadSpeed == settings.maxUploadSpeed &&
this.uploadSlots == settings.uploadSlots;
}
public TorrentStorage(string torrentPath, string savePath, TorrentSettings settings, TorrentState state, long uploadedData, long downloadedData)
{
this.torrentPath = torrentPath;
this.savePath = savePath;
this.settings = settings;
this.state = state;
this.uploadedData = uploadedData;
this.downloadedData = downloadedData;
}
public TorrentSettingWindow(TorrentSettings defaultSettings, string savePath)
{
InitializeComponent();
UploadSlotsNumericUpDown.Value = defaultSettings.UploadSlots;
MaxConnectionsNumericUpDown.Value = defaultSettings.MaxConnections;
MaxDownloadSpeedNumericUpDown.Value = defaultSettings.MaxDownloadSpeed;
MaxUploadSpeedNumericUpDown.Value = defaultSettings.MaxUploadSpeed;
FastResumeCheckBox.Checked = defaultSettings.FastResumeEnabled;
SavePathTextBox.Text = savePath;
}
public void Deserialize(BEncodedDictionary dict)
{
fastResume = new FastResume ((BEncodedDictionary) dict["FastResume"]);
savePath = dict["SavePath"].ToString ();
torrentPath = dict["TorrentPath"].ToString ();
string sb = dict["Settings"].ToString ();
XmlSerializer s = new XmlSerializer (typeof (TorrentSettings));
using (System.IO.TextReader reader = new System.IO.StringReader (sb))
settings = (TorrentSettings) s.Deserialize (reader);
}
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);
}
/// <summary>
/// Creates a new TorrentManager instance.
/// </summary>
/// <param name="torrent">The torrent to load in</param>
/// <param name="savePath">The directory to save downloaded files to</param>
/// <param name="settings">The settings to use for controlling connections</param>
/// <param name="baseDirectory">In the case of a multi-file torrent, the name of the base directory containing the files. Defaults to Torrent.Name</param>
public TorrentManager(Torrent torrent, string savePath, TorrentSettings settings, string baseDirectory)
{
Check.Torrent(torrent);
Check.SavePath(savePath);
Check.Settings(settings);
Check.BaseDirectory(baseDirectory);
this.torrent = torrent;
this.infohash = torrent.infoHash;
this.settings = settings;
Initialise(savePath, baseDirectory, torrent.AnnounceUrls);
ChangePicker(CreateStandardPicker());
}
public TorrentManager(InfoHash infoHash, string savePath, TorrentSettings settings, string torrentSave, IList <RawTrackerTier> announces)
{
Check.InfoHash(infoHash);
Check.SavePath(savePath);
Check.Settings(settings);
Check.TorrentSave(torrentSave);
Check.Announces(announces);
this.infohash = infoHash;
this.settings = settings;
this.torrentSave = torrentSave;
Initialise(savePath, "", announces);
}
/// <summary>
/// Adds the file to download. This method returns when the torrent is
/// added and doesn't wait for the download to complete.
/// </summary>
/// <param name="torrent">The torrent.</param>
/// <param name="savePath">The save path.</param>
public void StartDownloadingFile(Torrent torrent, string savePath, int lastPieceInProfile)
{
TorrentSettings torrentDefaults = new TorrentSettings(4, 150, 0, 0);
var tm = new TorrentManager(torrent, savePath, torrentDefaults, "", lastPieceInProfile);
// There is no need to scrape since we manage the tracker.
tm.TrackerManager.CurrentTracker.CanScrape = false;
_clientEngine.Register(tm);
tm.TrackerManager.CurrentTracker.AnnounceComplete +=
new EventHandler<AnnounceResponseEventArgs>(
TorrentEventHandlers.HandleAnnounceComplete);
tm.TrackerManager.CurrentTracker.ScrapeComplete += delegate(object o, ScrapeResponseEventArgs e) {
logger.DebugFormat("Scrape completed. Successful={0}, Tracker={1}",
e.Successful, e.Tracker.Uri);
};
tm.TorrentStateChanged +=
new EventHandler<TorrentStateChangedEventArgs>(
TorrentEventHandlers.HandleTorrentStateChanged);
tm.PieceHashed +=
new EventHandler<PieceHashedEventArgs>(
TorrentEventHandlers.HandlePieceHashed);
tm.PeerConnected += delegate(object o, PeerConnectionEventArgs e) {
// Only log three connections.
if (e.TorrentManager.OpenConnections < 4) {
logger.DebugFormat(
"Peer ({0}) Connected. Currently {1} open connection.",
e.PeerID.Uri, e.TorrentManager.OpenConnections);
}
};
tm.PieceManager.BlockReceived += delegate(object o, BlockEventArgs e) {
logger.DebugFormat("Block {0} from piece {1} is received.", e.Block.StartOffset / Piece.BlockSize, e.Piece.Index);
};
// We really only deal with one file.
foreach (var file in tm.Torrent.Files) {
_torrentManagerTable[file.FullPath] = tm;
}
tm.Start();
logger.DebugFormat(
"Starting to download torrent: {0}. Torrent manager started.",
tm.Torrent.Name);
}
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);
}
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();
}
internal TorrentManager(MagnetLink magnetLink, string savePath, TorrentSettings settings, string torrentSave)
{
Check.MagnetLink(magnetLink);
Check.InfoHash(magnetLink.InfoHash);
Check.SavePath(savePath);
Check.Settings(settings);
Check.TorrentSave(torrentSave);
this.InfoHash = magnetLink.InfoHash;
this.Settings = settings;
this.torrentSave = torrentSave;
IList <RawTrackerTier> announces = new RawTrackerTiers();
if (magnetLink.AnnounceUrls != null)
{
announces.Add(magnetLink.AnnounceUrls);
}
Initialise(savePath, "", announces);
}
/// <summary>
/// Creates a new TorrentManager instance.
/// </summary>
/// <param name="torrent">The torrent to load in</param>
/// <param name="savePath">The directory to save downloaded files to</param>
/// <param name="settings">The settings to use for controlling connections</param>
/// <param name="baseDirectory">In the case of a multi-file torrent, the name of the base directory containing the files. Defaults to Torrent.Name</param>
public TorrentManager(Torrent torrent, string savePath, TorrentSettings settings, string baseDirectory)
{
Check.Torrent(torrent);
Check.SavePath(savePath);
Check.Settings(settings);
Check.BaseDirectory(baseDirectory);
this.torrent = torrent;
this.infohash = torrent.InfoHash;
this.settings = settings;
this.webseeds = new List <String>();
if (torrent.GetRightHttpSeeds != null)
{
foreach (string webseed in torrent.GetRightHttpSeeds)
{
this.webseeds.Add(webseed);
}
}
Initialise(savePath, baseDirectory, torrent.AnnounceUrls);
ChangePicker(CreateStandardPicker());
}
public TorrentManager(InfoHash infoHash, string savePath, TorrentSettings settings, string torrentSave, IList <RawTrackerTier> announces, IList <String> webseeds = null)
{
Check.InfoHash(infoHash);
Check.SavePath(savePath);
Check.Settings(settings);
Check.TorrentSave(torrentSave);
Check.Announces(announces);
this.infohash = infoHash;
this.settings = settings;
this.torrentSave = torrentSave;
this.webseeds = new List <String>();
if (webseeds != null)
{
foreach (string webseed in webseeds)
{
this.webseeds.Add(webseed);
}
}
Initialise(savePath, "", announces);
}
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
}
public TorrentManager(MagnetLink magnetLink, string savePath, TorrentSettings settings, string torrentSave)
{
Torrent torrent;
Check.MagnetLink(magnetLink);
Check.InfoHash(magnetLink.InfoHash);
Check.SavePath(savePath);
Check.Settings(settings);
Check.TorrentSave(torrentSave);
this.infohash = magnetLink.InfoHash;
this.settings = settings;
this.torrentSave = torrentSave;
IList <RawTrackerTier> announces = new RawTrackerTiers();
if (magnetLink.AnnounceUrls != null)
{
announces.Add(magnetLink.AnnounceUrls);
}
this.webseeds = new List <String>();
if (magnetLink.Webseeds != null)
{
foreach (string webseed in magnetLink.Webseeds)
{
this.webseeds.Add(webseed);
}
}
if (Torrent.TryLoad(torrentSave, out torrent) && torrent.InfoHash == magnetLink.InfoHash)
{
this.torrent = torrent;
Initialise(savePath, "", announces);
ChangePicker(CreateStandardPicker());
return;
}
Initialise(savePath, "", announces);
}
/// <summary>
/// Initializes the Torrent client and its basic core members
/// </summary>
public TorrentClient()
{
saveDirectory = GlobalSettings.DownloadDirectory;
metaSaveDirectory = GlobalSettings.DEFAULT_METADATA_DIRECTORY;
dhtNodeFile = GlobalSettings.DHT_FILE;
resumeFile = GlobalSettings.RESUME_FILE;
Port = GlobalSettings.IncomingPort;
CreateDir(saveDirectory);
CreateDir(metaSaveDirectory);
//initialize engine settings
engineSettings = new EngineSettings();
engineSettings = new EngineSettings(saveDirectory, Port);
engineSettings.AllowedEncryption = MonoTorrent.Client.Encryption.EncryptionTypes.All;
engineSettings.PreferEncryption = GlobalSettings.UseEncryption;
engineSettings.GlobalMaxConnections = GlobalSettings.GlobalMaxConnections;
//initialize torrent settings
torrentSettings = new TorrentSettings();
torrentSettings.EnablePeerExchange = GlobalSettings.UsePeerExchange;
torrentSettings.UseDht = GlobalSettings.UseDht;
torrentSettings.MaxConnections = GlobalSettings.TorrentMaxConnections;
}
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 TorrentController()
{
this.defaultTorrentSettings = SettingsManager.DefaultTorrentSettings;
this.SelectedDownloads = new List<Download> ();
Ticker.Tick ();
fastResume = LoadFastResume();
Ticker.Tock ("Fast Resume");
Ticker.Tick ();
engine = new ClientEngine(SettingsManager.EngineSettings);
Ticker.Tock ("Client engine");
allTorrents = new List<Download>();
Added += delegate(object sender, DownloadAddedEventArgs e) {
e.Download.Priority = allTorrents.Count + 1;
};
Removed += delegate(object sender, DownloadAddedEventArgs e) {
for (int i=0; i < allTorrents.Count; i++)
if (allTorrents [i].Priority > e.Download.Priority)
allTorrents[i].Priority--;
};
}
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();
}
/* Constructor */
/// <summary>
/// Initializes a new instance of the <see cref="TorrentsData" /> class.
/// </summary>
public TorrentsData()
{
this.baseDir = Environment.CurrentDirectory;
this.GetValues(out this.torrentsDir, out this.downloadDir, out this.uploadSpeed, out this.downloadSpeed);
this.fastResumeFile = Path.Combine(this.torrentsDir, "fastresume.data");
this.dhtNodeFile = Path.Combine(this.baseDir, "DhtNodes");
this.torrentManagers = new List<TorrentManager>();
this.topTrackers = new TopListeners(10);
Console.CancelKeyPress += delegate { this.Shutdown(); };
AppDomain.CurrentDomain.ProcessExit += delegate { this.Shutdown(); };
AppDomain.CurrentDomain.UnhandledException += delegate(object sender, UnhandledExceptionEventArgs e) { Console.WriteLine(e.ExceptionObject); this.Shutdown(); };
Thread.GetDomain().UnhandledException += delegate(object sender, UnhandledExceptionEventArgs e) { Console.WriteLine(e.ExceptionObject); this.Shutdown(); };
this.InitializeEngine();
this.torrentDefaults = new TorrentSettings(4, 150, this.downloadSpeed, this.uploadSpeed);
}
public async Task <TorrentManager> AddAsync(Torrent torrent, string saveDirectory, TorrentSettings settings)
{
await MainLoop.SwitchThread();
var metadata = new BEncodedDictionary {
{ "info", BEncodedValue.Decode(torrent.InfoMetadata) }
};
var metadataCachePath = Settings.GetMetadataPath(torrent.InfoHash);
Directory.CreateDirectory(Path.GetDirectoryName(metadataCachePath));
File.WriteAllBytes(metadataCachePath, metadata.Encode());
return(await AddAsync(null, torrent, saveDirectory, settings));
}
private ObjectPath Load(TorrentAdapter tAdapter, TorrentSettings settings, TorrentManager manager)
{
ObjectPath managerPath = new ObjectPath (string.Format (DownloaderPath, downloaderNumber++));
ObjectPath settingsPath = new ObjectPath (string.Format ("{0}/settings", managerPath.ToString ()));
TorrentSettingsAdapter sAdapter = new TorrentSettingsAdapter(settings, settingsPath);
TorrentManagerAdapter mAdapter = new TorrentManagerAdapter(manager, tAdapter, sAdapter, managerPath);
TorrentService.Bus.Register (sAdapter.Path, sAdapter);
TorrentService.Bus.Register (mAdapter.Path, mAdapter);
engine.Register (manager);
downloaders.Add (mAdapter.Path, mAdapter);
return mAdapter.Path;
}
public static void ConfigureUnityContainer(IUnityContainer container)
{
#region Common
var dhtTrackerListenerPort =
Int32.Parse(ConfigurationManager.AppSettings["DhtTrackerListeningPort"]);
var infoServerListeningPort = Int32.Parse(ConfigurationManager.AppSettings[
"HttpPieceInfoServerListeningPort"]); // listeningPort
#endregion
#region TorrentSettings
// 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);
container.RegisterInstance<TorrentSettings>(torrentDefaults);
#endregion
#region ClientEngine
// DefaultListenPort = 52138;
var engineSettings = new EngineSettings();
engineSettings.PreferEncryption = false;
engineSettings.AllowedEncryption = EncryptionTypes.All;
var clientEngine = new ClientEngine(engineSettings);
container.RegisterInstance<ClientEngine>(clientEngine);
#endregion
#region DhtProxy
var peerTtlSecs = 60 * 50;
container.RegisterType<DictionaryServiceProxy>(
new InjectionConstructor(typeof(DictionaryServiceBase),
peerTtlSecs));
#endregion
#region DhtTracker
// Singleton.
container.RegisterType<DictionaryServiceTracker>(new ContainerControlledLifetimeManager(),
new InjectionConstructor(
typeof(DictionaryServiceProxy),
string.Format("http://*:{0}/", dhtTrackerListenerPort))); // listeningPrefix
#endregion
#region TorrentHelper
// Singleton.
var cacheBaseDirPath =
ConfigurationManager.AppSettings["BitTorrentManagerBaseDirPath"];
IPAddress ip = NetUtil.GetLocalIPByInterface(
ConfigurationManager.AppSettings["DhtTrackerIface"]);
int gsserverPort = Int32.Parse(ConfigurationManager.AppSettings["GSServerPort"]);
var bittorrentCache = new BitTorrentCache(cacheBaseDirPath);
container.RegisterInstance<BitTorrentCache>(bittorrentCache);
var torrentHelper = new TorrentHelper(
bittorrentCache, ip, dhtTrackerListenerPort, gsserverPort);
container.RegisterInstance<TorrentHelper>(torrentHelper);
#endregion
#region BitTorrentManager
// Singleton.
container.RegisterType<BitTorrentManager>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
typeof(BitTorrentCache),
ConfigurationManager.AppSettings["BitTorrentManagerSelfNamespace"],
typeof(DictionaryServiceProxy),
typeof(DictionaryServiceTracker),
typeof(ClientEngine),
typeof(TorrentSettings),
typeof(TorrentHelper),
Boolean.Parse(ConfigurationManager.AppSettings[
"BitTorrentManagerStartSeedingAtStartup"])
));
#endregion
#region IPieceInfoServer
// Singleton.
//container.RegisterType<IPieceInfoServer, HttpPieceInfoServer>(
// new ContainerControlledLifetimeManager(),
// new InjectionConstructor(
// infoServerListeningPort,
// typeof(PieceLevelTorrentManager)));
#endregion
#region PieceLevelTorrentManager
container.RegisterType<PieceLevelTorrentManager>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
typeof(BitTorrentManager),
typeof(BitTorrentCache),
typeof(DictionaryServiceProxy),
typeof(TorrentHelper),
infoServerListeningPort));
#endregion
}
public void LoadTorrent(string path, bool autoStart, bool moveToStorage, bool removeOriginal, TorrentSettings settings, string savePath, bool isUrl)
{
#warning URL based torrents arent being loaded
//return torrentController.addTorrent(path, autoStart, moveToStorage, removeOriginal, settings, savePath, isUrl);
}
/// <summary>
/// Gets default settings for torrent
/// </summary>
/// <returns></returns>
private TorrentSettings GetDefaultTorrentSettings()
{
// 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
var torrentDefaults = new TorrentSettings(4, 150, 0, 0);
return torrentDefaults;
}
public Task <TorrentManager> AddStreamingAsync(Torrent torrent, string saveDirectory, TorrentSettings settings) => AddStreamingAsync(null, torrent, saveDirectory, settings);
async Task <TorrentManager> AddAsync(MagnetLink magnetLink, Torrent torrent, string saveDirectory, TorrentSettings settings)
{
saveDirectory = string.IsNullOrEmpty(saveDirectory) ? Environment.CurrentDirectory : Path.GetFullPath(saveDirectory);
TorrentManager manager;
if (magnetLink != null)
{
var metadataSaveFilePath = Settings.GetMetadataPath(magnetLink.InfoHash);
manager = new TorrentManager(magnetLink, saveDirectory, settings, metadataSaveFilePath);
if (Settings.AutoSaveLoadMagnetLinkMetadata && Torrent.TryLoad(metadataSaveFilePath, out torrent) && torrent.InfoHash == magnetLink.InfoHash)
{
manager.SetMetadata(torrent);
}
}
else
{
manager = new TorrentManager(torrent, saveDirectory, settings);
}
await Register(manager, true);
await manager.MaybeLoadFastResumeAsync();
return(manager);
}
private void StartEngine(int maxUpload)
{
int port = 54321;
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 = true;
engineSettings.AllowedEncryption = EncryptionTypes.RC4Full | EncryptionTypes.RC4Header;
// 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(100, 150, 0, maxUpload);
// 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);
RemoveReadOnly(torrent);
}
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)
{
};
// 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)
{
}
// 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);
DateTime lastAnnounce = DateTime.Now;
bool firstRun = true;
while (running)
{
if (firstRun || lastAnnounce < DateTime.Now.AddMinutes(-1))
{
foreach (TorrentManager tm in torrents)
{
tm.TrackerManager.Announce();
}
lastAnnounce = DateTime.Now;
firstRun = false;
}
if ((i++) % 10 == 0)
{
sb.Remove(0, sb.Length);
running = torrents.Exists(delegate(TorrentManager m) { return m.State != TorrentState.Stopped; });
TorrentState totalState = torrents.Exists(m => m.State == TorrentState.Hashing) ? TorrentState.Hashing : torrents.Exists(m => m.State == TorrentState.Downloading) ? TorrentState.Downloading : TorrentState.Seeding;
string status = "";
switch (totalState)
{
case TorrentState.Hashing:
double totalHashProgress = 0;
foreach (TorrentManager m in torrents)
{
totalHashProgress += (m.State == TorrentState.Hashing) ? m.Progress : 100;
}
totalHashProgress = totalHashProgress / torrents.Count;
status = String.Format("Checking files ({0:0.00}%)", totalHashProgress);
break;
case TorrentState.Seeding:
status = "";
break;
default:
double totalDownloadProgress = 0;
double totalDownloaded = 0;
double totalToDownload = 0;
double totalDownloadSpeed = 0;
long totalDownloadSize = 0;
foreach (TorrentManager m in torrents)
totalDownloadSize += m.Torrent.Size;
foreach (TorrentManager m in torrents)
{
totalDownloaded += m.Torrent.Size / 1024 * (m.Progress / 100);
totalToDownload += m.Torrent.Size / 1024;
totalDownloadSpeed += m.Monitor.DownloadSpeed;
}
totalDownloadProgress = (totalDownloaded / totalToDownload) * 100;
status = "Status: " + (torrents.Exists(m => m.State == TorrentState.Downloading && m.GetPeers().Count > 0) ? "Downloading" : "Finding peers");
status += "\n" + String.Format("Progress: {0:0.00}%", totalDownloadProgress);
status += "\n" + String.Format("D/L Speed: {0:0.00} kB/s", totalDownloadSpeed / 1024.0);
break;
}
if (installer != null)
installer.Status = status;
#region OLDPROGRESS
//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);
// string status = "";
// switch (manager.State)
// {
// case TorrentState.Hashing:
// status = String.Format("Checking files ({0:0.00}%)", manager.Progress);
// break;
// case TorrentState.Seeding: status = ""; break;
// default:
// status = "Status: " + (manager.GetPeers().Count == 0 ? "Finding Peers" : "Downloading");
// status += "\n" + String.Format("Progress: {0:0.00}%", manager.Progress);
// status += "\n" + String.Format("D/L Speed: {0:0.00} kB/s", manager.Monitor.DownloadSpeed / 1024.0);
// break;
// }
// if (installer != null)
// installer.Status = status;
// 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.Status.ToString());
// AppendFormat(sb, "Warning Message: {0}", tracker == null ? "<no tracker>" : tracker.WarningMessage);
// AppendFormat(sb, "Failure Message: {0}", tracker == null ? "<no tracker>" : tracker.FailureMessage);
//}
////Console.Clear();
//Console.WriteLine(sb.ToString());
#endregion
}
System.Threading.Thread.Sleep(500);
}
}
async Task<TorrentManager> AddAsync (MagnetLink? magnetLink, Torrent? torrent, string saveDirectory, TorrentSettings settings)
{
await MainLoop;
saveDirectory = string.IsNullOrEmpty (saveDirectory) ? Environment.CurrentDirectory : Path.GetFullPath (saveDirectory);
TorrentManager manager;
if (magnetLink != null) {
var metadataSaveFilePath = Settings.GetMetadataPath (magnetLink.InfoHashes);
manager = new TorrentManager (this, magnetLink, saveDirectory, settings);
if (Settings.AutoSaveLoadMagnetLinkMetadata && Torrent.TryLoad (metadataSaveFilePath, out torrent) && torrent.InfoHashes == magnetLink.InfoHashes)
manager.SetMetadata (torrent);
} else if (torrent != null) {
manager = new TorrentManager (this, torrent, saveDirectory, settings);
} else {
throw new InvalidOperationException ($"You must pass a non-null {nameof (magnetLink)} or {nameof (torrent)}");
}
await Register (manager, true);
await manager.MaybeLoadFastResumeAsync ();
return manager;
}
internal static byte[] Serialize(TorrentSettings settings) => Serialize(new TorrentSettingsBuilder(settings));
static void InitMonoTorrent ()
{
queue = new ArrayList ();
engine_settings = new EngineSettings (config.DownloadDir, config.ListenPort);
torrent_settings = new TorrentSettings (config.UploadSlots, config.MaxConnections,
(int) config.UploadSpeed, (int) config.DownloadSpeed);
engine = new ClientEngine (engine_settings);
// Our store
torrent_list = new TorrentList ();
foreach (TorrentDesc td in config.Torrents){
if (File.Exists (td.Filename)){
torrent_list.Add (td.Filename);
}
}
}
public async Task <TorrentManager> AddAsync(string metadataPath, string saveDirectory, TorrentSettings settings)
{
var torrent = await Torrent.LoadAsync(metadataPath).ConfigureAwait(false);
var metadataCachePath = Settings.GetMetadataPath(torrent.InfoHash);
if (metadataPath != metadataCachePath)
{
Directory.CreateDirectory(Path.GetDirectoryName(metadataCachePath));
File.Copy(metadataPath, metadataCachePath, true);
}
return(await AddAsync(null, torrent, saveDirectory, settings));
}
#pragma warning disable CS0618 // Type or member is obsolete
async Task <TorrentManager> AddAsync(MagnetLink magnetLink, Torrent torrent, string saveDirectory, TorrentSettings settings)
{
saveDirectory = string.IsNullOrEmpty(saveDirectory) ? Environment.CurrentDirectory : Path.GetFullPath(saveDirectory);
TorrentManager manager;
if (magnetLink != null)
{
var metadataSaveFilePath = Path.Combine(Settings.MetadataSaveDirectory, magnetLink.InfoHash.ToHex() + ".torrent");
manager = new TorrentManager(magnetLink, saveDirectory, settings, metadataSaveFilePath);
}
else
{
manager = new TorrentManager(torrent, saveDirectory, settings);
}
await Register(manager);
return(manager);
}
internal static BEncodedDictionary Serialize(TorrentSettings settings) => Serialize(new TorrentSettingsBuilder(settings));
public TorrentWrapper(MagnetLink magnetLink, string savePath, TorrentSettings settings, string torrentSave)
: base(magnetLink, savePath, settings, torrentSave)
{
Name = magnetLink.Name;
Name = HttpUtility.HtmlDecode(HttpUtility.UrlDecode(Name));
Size = -1;
IsMagnet = true;
}
/// <summary>
/// Creates a new TorrentManager instance.
/// </summary>
/// <param name="torrent">The torrent to load in</param>
/// <param name="savePath">The directory to save downloaded files to</param>
/// <param name="settings">The settings to use for controlling connections</param>
public TorrentManager(Torrent torrent, string savePath, TorrentSettings settings)
: this(torrent, savePath, settings, torrent.Files.Length == 1 ? "" : torrent.Name)
{
}
public async Task <TorrentManager> AddAsync(Torrent torrent, string saveDirectory, TorrentSettings settings)
{
await MainLoop.SwitchThread();
var editor = new TorrentEditor(new BEncodedDictionary {
{ "info", BEncodedValue.Decode(torrent.InfoMetadata) }
});
editor.SetCustom("name", (BEncodedString)torrent.Name);
if (torrent.AnnounceUrls.Count > 0)
{
if (torrent.AnnounceUrls.Count == 1 && torrent.AnnounceUrls[0].Count == 1)
{
editor.Announce = torrent.AnnounceUrls.Single().Single();
}
else
{
foreach (var tier in torrent.AnnounceUrls)
{
var list = new List <string> ();
foreach (var tracker in tier)
{
list.Add(tracker);
}
editor.Announces.Add(list);
}
}
}
var metadataCachePath = Settings.GetMetadataPath(torrent.InfoHash);
Directory.CreateDirectory(Path.GetDirectoryName(metadataCachePath));
File.WriteAllBytes(metadataCachePath, editor.ToDictionary().Encode());
return(await AddAsync(null, torrent, saveDirectory, settings));
}
public ObjectPath RegisterTorrent(string torrentPath, string savePath)
{
if (torrentPath == null)
throw new ArgumentNullException ("torrent");
if (savePath == null)
throw new ArgumentNullException ("savePath");
// Get the TorrentAdapter object
ObjectPath torrent = LoadTorrent (torrentPath);
// See if there is already a downloader for the torrent
foreach (TorrentManagerAdapter m in downloaders.Values)
if (m.Torrent == torrent)
return m.Path;
// If there is no existing downloader, create a downloader
TorrentSettings settings = new TorrentSettings ();
TorrentManager manager = new TorrentManager (torrents[torrent].Torrent, savePath, settings);
return Load (torrents[torrent], settings, manager);
}
public TorrentWrapper(Torrent torrent, string savePath, TorrentSettings settings)
: base(torrent, savePath, settings)
{
Name = torrent.Name;
Size = torrent.Size;
IsMagnet = false;
Path = savePath;
}
public async Task <TorrentManager> AddStreamingAsync(MagnetLink magnetLink, string saveDirectory, TorrentSettings settings) => await MakeStreamingAsync(await AddAsync(magnetLink, saveDirectory, settings));
public async Task <TorrentManager> AddStreamingAsync(string metadataPath, string saveDirectory, TorrentSettings settings) => await MakeStreamingAsync(await AddAsync(metadataPath, saveDirectory, settings));
public async Task <TorrentManager> AddStreamingAsync(Torrent torrent, string saveDirectory, TorrentSettings settings) => await MakeStreamingAsync(await AddAsync(torrent, saveDirectory, settings));
public async Task <TorrentManager> AddStreamingAsync(string metadataPath, string saveDirectory, TorrentSettings settings) => await AddStreamingAsync(null, await Torrent.LoadAsync(metadataPath), saveDirectory, settings);
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)
{
}
}
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);
}
}
public GuiTorrentSettings(TorrentSettings settings)
{
if (settings == null)
throw new ArgumentNullException("settings");
this.settings = settings;
}
public Task <TorrentManager> AddStreamingAsync(MagnetLink magnetLink, string saveDirectory, TorrentSettings settings) => AddStreamingAsync(magnetLink, null, saveDirectory, settings);
private static void StartDownload(ClientEngine clientEngine,
TorrentSettings torrentDefaults)
{
throw new NotImplementedException();
}
async Task <TorrentManager> AddStreamingAsync(MagnetLink magnetLink, Torrent torrent, string saveDirectory, TorrentSettings settings)
{
var manager = await AddAsync(magnetLink, torrent, saveDirectory, settings);
await manager.ChangePickerAsync(new StreamingPieceRequester());
return(manager);
}
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);
}
}