private MinerConfiguration CreateMinerConfiguration(int port, string coinSymbol, DeviceKind includeKinds) { CoinConfiguration coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.Coin.Symbol.Equals(coinSymbol)); IList <DeviceConfiguration> enabledConfigurations = engineConfiguration.DeviceConfigurations.Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList(); MinerConfiguration minerConfiguration = new MinerConfiguration() { ExecutablePath = MinerPath.GetPathToInstalledMiner(), Algorithm = coinConfiguration.Coin.Algorithm, ApiPort = port, ApiListen = true, AllowedApiIps = engineConfiguration.XgminerConfiguration.AllowedApiIps, CoinName = coinConfiguration.Coin.Name, DisableGpu = engineConfiguration.XgminerConfiguration.DisableGpu }; SetupConfigurationPools(minerConfiguration, coinConfiguration); int deviceCount = SetupConfigurationDevices(minerConfiguration, includeKinds, enabledConfigurations); if (deviceCount == 0) { return(null); } SetupConfigurationArguments(minerConfiguration, coinConfiguration); return(minerConfiguration); }
private void StartMining() { IEnumerable <string> coinSymbols = engineConfiguration.DeviceConfigurations .Where(c => c.Enabled && !string.IsNullOrEmpty(c.CoinSymbol)) .Select(c => c.CoinSymbol) .Distinct(); int port = 4028; foreach (string coinSymbol in coinSymbols) { MinerConfiguration minerConfiguration = CreateMinerConfiguration(port, coinSymbol); Process process = LaunchMinerProcess(minerConfiguration, "Starting mining"); if (!process.HasExited) { MinerProcess minerProcess = new MinerProcess(); minerProcess.Process = process; minerProcess.ApiPort = port; minerProcess.MinerConfiguration = minerConfiguration; setupProcessStartInfo(minerProcess); minerProcesses.Add(minerProcess); } port++; } mining = true; }
private void SetupConfigurationArguments(MinerConfiguration minerConfiguration, CoinConfiguration coinConfiguration) { string arguments = string.Empty; //apply algorithm-specific parameters if (engineConfiguration.XgminerConfiguration.AlgorithmFlags.ContainsKey(coinConfiguration.Coin.Algorithm)) { arguments = String.Format("{0} {1}", arguments, engineConfiguration.XgminerConfiguration.AlgorithmFlags[coinConfiguration.Coin.Algorithm]); } //apply coin-specific parameters if (!string.IsNullOrEmpty(coinConfiguration.MinerFlags)) { arguments = string.Format("{0} {1}", arguments, coinConfiguration.MinerFlags); } if (engineConfiguration.XgminerConfiguration.DesktopMode) { arguments = arguments + " -I D"; } if (donationPercent > 0) { arguments = arguments + " --load-balance"; } minerConfiguration.LaunchArguments = arguments; }
private int SetupConfigurationDevices(MinerConfiguration minerConfiguration, DeviceKind deviceKinds, IList <DeviceConfiguration> deviceConfigurations) { int deviceCount = 0; for (int i = 0; i < deviceConfigurations.Count; i++) { DeviceConfiguration enabledConfiguration = deviceConfigurations[i]; Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration)); if ((deviceKinds & device.Kind) == 0) { continue; } deviceCount++; //don't actually add stratum device as a device index if (device.Kind != DeviceKind.PXY) { minerConfiguration.DeviceDescriptors.Add(device); } else { //only enable the stratum proxy if these devices contain the PXY device minerConfiguration.StratumProxy = engineConfiguration.XgminerConfiguration.StratumProxy; minerConfiguration.StratumProxyPort = engineConfiguration.XgminerConfiguration.StratumProxyPort; minerConfiguration.StratumProxyStratumPort = engineConfiguration.XgminerConfiguration.StratumProxyStratumPort; } } return(deviceCount); }
private Process LaunchMinerProcess(MinerConfiguration minerConfiguration, string reason) { minerConfiguration.Priority = this.engineConfiguration.XgminerConfiguration.Priority; Miner miner = new Miner(minerConfiguration); miner.LogLaunch += this.LogProcessLaunch; miner.LaunchFailed += this.ProcessLaunchFailed; Process process = miner.Launch(reason); return(process); }
private void StoreMinerProcess(Process process, MinerConfiguration minerConfiguration, int port) { MinerProcess minerProcess = new MinerProcess(); minerProcess.Process = process; minerProcess.ApiPort = port; minerProcess.MinerConfiguration = minerConfiguration; setupProcessStartInfo(minerProcess); minerProcesses.Add(minerProcess); }
private MinerConfiguration CreateMinerConfiguration(int port, string coinSymbol) { CoinConfiguration coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.Coin.Symbol.Equals(coinSymbol)); IEnumerable <DeviceConfiguration> coinGpuConfigurations = engineConfiguration.DeviceConfigurations.Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)); MinerConfiguration minerConfiguration = new MinerConfiguration(); minerConfiguration.MinerBackend = engineConfiguration.XgminerConfiguration.MinerBackend; minerConfiguration.ExecutablePath = MinerPath.GetPathToInstalledMiner(minerConfiguration.MinerBackend); minerConfiguration.ErupterDriver = engineConfiguration.XgminerConfiguration.ErupterDriver; minerConfiguration.Pools = coinConfiguration.Pools; minerConfiguration.Algorithm = coinConfiguration.Coin.Algorithm; minerConfiguration.ApiPort = port; minerConfiguration.ApiListen = true; minerConfiguration.AllowedApiIps = engineConfiguration.XgminerConfiguration.AllowedApiIps; minerConfiguration.CoinName = coinConfiguration.Coin.Name; minerConfiguration.DisableGpu = engineConfiguration.XgminerConfiguration.DisableGpu; foreach (DeviceConfiguration coinGpuConfiguration in coinGpuConfigurations) { minerConfiguration.DeviceIndexes.Add(coinGpuConfiguration.DeviceIndex); } string arguments = string.Empty; //apply algorithm-specific parameters if (engineConfiguration.XgminerConfiguration.AlgorithmFlags.ContainsKey(coinConfiguration.Coin.Algorithm)) { arguments = String.Format("{0} {1}", arguments, engineConfiguration.XgminerConfiguration.AlgorithmFlags[coinConfiguration.Coin.Algorithm]); } //apply coin-specific parameters if (!string.IsNullOrEmpty(coinConfiguration.MinerFlags)) { arguments = string.Format("{0} {1}", arguments, coinConfiguration.MinerFlags); } if (engineConfiguration.XgminerConfiguration.DesktopMode) { arguments = arguments + " -I D"; } minerConfiguration.Arguments = arguments; return(minerConfiguration); }
private MinerProcess StoreMinerProcess(Process process, string coinSymbol, MinerConfiguration minerConfiguration, int port) { MinerProcess minerProcess = new MinerProcess(); minerProcess.Process = process; minerProcess.ApiPort = port; minerProcess.MinerConfiguration = minerConfiguration; minerProcess.CoinSymbol = coinSymbol; setupProcessStartInfo(minerProcess); minerProcesses.Add(minerProcess); return(minerProcess); }
public void EnumerateDevices_ReturnsNoDevices() { //arrange MinerConfiguration minerConfiguration = new MinerConfiguration(); minerConfiguration.ExecutablePath = executablePath; minerConfiguration.DisableGpu = true; Miner miner = new Miner(minerConfiguration); //act List<Device> devices = miner.EnumerateDevices(); //assert Assert.IsTrue(devices.Count == 0); }
//test setup is a single Block Erupter //GPU is disabled //should return 0 devices as --ndevs is used w/bfgminer public void EnumerateDevices_ReturnsNoDevices() { //arrange MinerConfiguration minerConfiguration = new MinerConfiguration(); minerConfiguration.ExecutablePath = executablePath; minerConfiguration.DisableGpu = true; Miner miner = new Miner(minerConfiguration); //act List <Device> devices = miner.EnumerateDevices(); //assert Assert.IsTrue(devices.Count == 0); }
public void DeviceList_ReturnsDevices() { //arrange MinerConfiguration minerConfiguration = new MinerConfiguration(); minerConfiguration.ExecutablePath = executablePath; minerConfiguration.DisableGpu = true; Miner miner = new Miner(minerConfiguration); //act List<Device> devices = miner.ListDevices(); //assert Assert.IsTrue(devices.Count > 0); Assert.IsTrue(devices.First().Kind == DeviceKind.USB); }
//test setup is a single Block Erupter //GPU is disabled //should return 1 device as -d? is used public void DeviceList_ReturnsDevices() { //arrange MinerConfiguration minerConfiguration = new MinerConfiguration(); minerConfiguration.ExecutablePath = executablePath; minerConfiguration.DisableGpu = true; Miner miner = new Miner(minerConfiguration); //act List <Device> devices = miner.ListDevices(); //assert Assert.IsTrue(devices.Count > 0); Assert.IsTrue(devices.First().Kind == DeviceKind.USB); }
private readonly Random random = new Random(Guid.NewGuid().GetHashCode()); //seed so we don't keep getting the same indexes private void AddDonationPool(string coinSymbol, MinerConfiguration minerConfiguration) { MiningPool donationPool = null; CoinConfiguration donationConfiguration = this.donationConfigurations.SingleOrDefault(dc => dc.Coin.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase)); if (donationConfiguration != null) { //inclusive lower, exclusive upper int index = random.Next(0, donationConfiguration.Pools.Count); donationPool = donationConfiguration.Pools[index]; } if (donationPool != null) { donationPool.Quota = 1; //1% donation minerConfiguration.Pools.Add(donationPool); } }
private void SetupConfigurationPools(MinerConfiguration minerConfiguration, CoinConfiguration coinConfiguration) { //minerConfiguration.Pools = coinConfiguration.Pools; foreach (MiningPool pool in coinConfiguration.Pools) { pool.Quota = 0; minerConfiguration.Pools.Add(pool); } //using bfgminer quotas for failover, that way we can augment for donations minerConfiguration.Pools.First().Quota = 100 - donationPercent; if (donationPercent > 0) { AddDonationPool(coinConfiguration.Coin.Symbol, minerConfiguration); } foreach (MiningPool pool in minerConfiguration.Pools) { pool.QuotaEnabled = donationPercent > 0; } }
private void StartMining() { IEnumerable <string> coinSymbols = engineConfiguration.DeviceConfigurations .Where(c => c.Enabled && !string.IsNullOrEmpty(c.CoinSymbol)) .Select(c => c.CoinSymbol) .Distinct(); int port = engineConfiguration.XgminerConfiguration.StartingApiPort; foreach (string coinSymbol in coinSymbols) { //launch separate processes for CPU & GPU vs USB & PXY (for stability) MinerConfiguration minerConfiguration = CreateMinerConfiguration(port, coinSymbol, DeviceKind.CPU | DeviceKind.GPU); if (minerConfiguration != null) { Process process = LaunchMinerProcess(minerConfiguration, "Starting mining"); if (!process.HasExited) { MinerProcess minerProcess = StoreMinerProcess(process, coinSymbol, minerConfiguration, port); minerProcess.TerminateProcess = engineConfiguration.XgminerConfiguration.TerminateGpuMiners; } port++; } minerConfiguration = CreateMinerConfiguration(port, coinSymbol, DeviceKind.PXY | DeviceKind.USB); if (minerConfiguration != null) { Process process = LaunchMinerProcess(minerConfiguration, "Starting mining"); if (!process.HasExited) { StoreMinerProcess(process, coinSymbol, minerConfiguration, port); } port++; } } mining = true; }
private readonly Random random = new Random(Guid.NewGuid().GetHashCode()); //seed so we don't keep getting the same indexes private void AddDonationPool(string coinSymbol, MinerConfiguration minerConfiguration) { MiningPool donationPool = null; CoinConfiguration donationConfiguration = this.donationConfigurations.SingleOrDefault(dc => dc.Coin.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase)); if (donationConfiguration != null) { //inclusive lower, exclusive upper //int index = random.Next(0, donationConfiguration.Pools.Count); //for now just use the first pool, too many donors is *not* an issue //if it becomes an issue we can revert to the above int index = 0; donationPool = donationConfiguration.Pools[index]; } if (donationPool != null) { donationPool.Quota = donationPercent; minerConfiguration.Pools.Add(donationPool); } }
static void Main(string[] args) { //examples of using MultiMiner.Xgminer.dll and MultiMiner.Xgminer.Api.dll //download and install the latest version of bfgminer const string executablePath = @"D:\bfgminer\"; const string executableName = "bfgminer.exe"; MinerBackend minerBackend = MinerBackend.Bfgminer; Console.WriteLine("Downloading and installing {0} from {1} to the directory {2}", executableName, Xgminer.Installer.GetMinerDownloadRoot(minerBackend), executablePath); //download and install bfgminer from the official website Xgminer.Installer.InstallMiner(minerBackend, executablePath); try { //create an instance of Miner with the downloaded executable MinerConfiguration minerConfiguration = new MinerConfiguration() { MinerBackend = minerBackend, ExecutablePath = Path.Combine(executablePath, executableName) }; Miner miner = new Miner(minerConfiguration); //use it to iterate through devices List <Device> deviceList = miner.DeviceList(); Console.WriteLine("Using {0} to list available mining devices", executableName); //output devices foreach (Device device in deviceList) { Console.WriteLine("Device detected: {0}\t{1}\t{2}", device.Kind, device.Driver, device.Identifier); } //start mining if there are devices if (deviceList.Count > 0) { Console.WriteLine("{0} device(s) detected, mining Bitcoin on Bitminter using all devices", deviceList.Count); //setup a pool MiningPool pool = new MiningPool() { Host = "mint.bitminter.com", Port = 3333, Username = "******", Password = "******" }; minerConfiguration.Pools.Add(pool); //specify algorithm minerConfiguration.Algorithm = CoinAlgorithm.SHA256; //disable GPU mining minerConfiguration.DisableGpu = true; //specify device indexes to use for (int i = 0; i < deviceList.Count; i++) { minerConfiguration.DeviceIndexes.Add(i); } //enable RPC API minerConfiguration.ApiListen = true; minerConfiguration.ApiPort = 4028; Console.WriteLine("Launching {0}", executableName); //start mining miner = new Miner(minerConfiguration); System.Diagnostics.Process minerProcess = miner.Launch(); try { //get an API context Xgminer.Api.ApiContext apiContext = new Xgminer.Api.ApiContext(minerConfiguration.ApiPort); try { //mine for one minute, monitoring hashrate via the API for (int i = 0; i < 6; i++) { Thread.Sleep(1000 * 10); //sleep 10s //query the miner process via its RPC API for device information List <Xgminer.Api.DeviceInformation> deviceInformation = apiContext.GetDeviceInformation(); //output device information foreach (Xgminer.Api.DeviceInformation item in deviceInformation) { Console.WriteLine("Hasrate for device {0}: {1} current, {2} average", item.Index, item.CurrentHashrate, item.AverageHashrate); } } } finally { Console.WriteLine("Quitting mining via the RPC API"); //stop mining, try the API first apiContext.QuitMining(); } } finally { Console.WriteLine("Killing any remaining process"); //then kill the process try { minerProcess.Kill(); minerProcess.WaitForExit(); minerProcess.Close(); } catch (InvalidOperationException ex) { //already closed } } } else { Console.WriteLine("No devices capable of mining detected"); } } finally { Console.WriteLine("Cleaning up, deleting directory {0}", executablePath); Directory.Delete(executablePath, true); } Console.WriteLine("Press any key to exit"); Console.ReadKey(); }
private MinerConfiguration CreateMinerConfiguration(int port, string coinSymbol, DeviceKind includeKinds) { CoinConfiguration coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.Coin.Symbol.Equals(coinSymbol)); IList <DeviceConfiguration> enabledConfigurations = engineConfiguration.DeviceConfigurations.Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList(); MinerConfiguration minerConfiguration = new MinerConfiguration(); minerConfiguration.ExecutablePath = MinerPath.GetPathToInstalledMiner(); //minerConfiguration.Pools = coinConfiguration.Pools; foreach (MiningPool pool in coinConfiguration.Pools) { pool.Quota = 0; minerConfiguration.Pools.Add(pool); } //using bfgminer quotas for failover, that way we can augment for donations minerConfiguration.Pools.First().Quota = 100; if (donating) { minerConfiguration.Pools.First().Quota--; //99% AddDonationPool(coinSymbol, minerConfiguration); } minerConfiguration.Algorithm = coinConfiguration.Coin.Algorithm; minerConfiguration.ApiPort = port; minerConfiguration.ApiListen = true; minerConfiguration.AllowedApiIps = engineConfiguration.XgminerConfiguration.AllowedApiIps; minerConfiguration.CoinName = coinConfiguration.Coin.Name; minerConfiguration.DisableGpu = engineConfiguration.XgminerConfiguration.DisableGpu; int deviceCount = 0; for (int i = 0; i < enabledConfigurations.Count; i++) { DeviceConfiguration enabledConfiguration = enabledConfigurations[i]; Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration)); if ((includeKinds & device.Kind) == 0) { continue; } deviceCount++; //don't actually add stratum device as a device index if (device.Kind != DeviceKind.PXY) { minerConfiguration.DeviceDescriptors.Add(device); } else { //only enable the stratum proxy if these devices contain the PXY device minerConfiguration.StratumProxy = engineConfiguration.XgminerConfiguration.StratumProxy; minerConfiguration.StratumProxyPort = engineConfiguration.XgminerConfiguration.StratumProxyPort; minerConfiguration.StratumProxyStratumPort = engineConfiguration.XgminerConfiguration.StratumProxyStratumPort; } } if (deviceCount == 0) { return(null); } string arguments = string.Empty; //apply algorithm-specific parameters if (engineConfiguration.XgminerConfiguration.AlgorithmFlags.ContainsKey(coinConfiguration.Coin.Algorithm)) { arguments = String.Format("{0} {1}", arguments, engineConfiguration.XgminerConfiguration.AlgorithmFlags[coinConfiguration.Coin.Algorithm]); } //apply coin-specific parameters if (!string.IsNullOrEmpty(coinConfiguration.MinerFlags)) { arguments = string.Format("{0} {1}", arguments, coinConfiguration.MinerFlags); } if (engineConfiguration.XgminerConfiguration.DesktopMode) { arguments = arguments + " -I D"; } if (donating) { arguments = arguments + " --load-balance"; } minerConfiguration.Arguments = arguments; return(minerConfiguration); }