private void DownloadChosenMiner()
{
MinerDescriptor miner = MinerFactory.Instance.GetDefaultMiner();
string minerName = miner.Name;
string minerPath = Path.Combine("Miners", minerName);
string destinationFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, minerPath);
downloadingMinerLabel.Text = String.Format("Please wait while {0} is downloaded from {2} and installed into the folder {1}", minerName, destinationFolder, new Uri(miner.Url).Authority);
System.Windows.Forms.Application.DoEvents();
Cursor = Cursors.WaitCursor;
MinerInstaller.InstallMiner(UserAgent.AgentString, miner, destinationFolder);
Cursor = Cursors.Default;
wizardTabControl.SelectedTab = chooseCoinPage;
}
private Process LaunchMinerProcess(Xgminer.Data.Configuration.Miner minerConfiguration, string reason)
{
minerConfiguration.Priority = this.engineConfiguration.XgminerConfiguration.Priority;
//we launch 1 process per device kind now
DeviceKind deviceKind = minerConfiguration.DeviceDescriptors.First().Kind;
MinerDescriptor descriptor = MinerFactory.Instance.GetMiner(deviceKind, minerConfiguration.Algorithm, engineConfiguration.XgminerConfiguration.AlgorithmMiners);
Xgminer.Miner miner = new Xgminer.Miner(minerConfiguration, descriptor.LegacyApi);
miner.LogLaunch += this.LogProcessLaunch;
miner.LaunchFailed += this.ProcessLaunchFailed;
miner.AuthenticationFailed += this.ProcessAuthenticationFailed;
Process process = miner.Launch(reason);
return(process);
}
private MinerProcess StoreMinerProcess(Process process, MinerDescriptor miner, string coinSymbol, Xgminer.Data.Configuration.Miner minerConfiguration, int apiPort)
{
MinerProcess minerProcess = new MinerProcess()
{
Process = process,
Miner = miner,
ApiPort = apiPort,
MinerConfiguration = minerConfiguration,
CoinSymbol = coinSymbol
};
setupProcessStartInfo(minerProcess);
minerProcesses.Add(minerProcess);
return(minerProcess);
}
private void LaunchMiners(ref int apiPort, string coinSymbol, DeviceKind deviceKind, bool terminateProcess)
{
Xgminer.Data.Configuration.Miner minerConfiguration = CreateMinerConfiguration(apiPort, coinSymbol, deviceKind);
//null if no pools configured
if (minerConfiguration != null)
{
Process process = LaunchMinerProcess(minerConfiguration, "Starting mining");
if (!process.HasExited)
{
MinerDescriptor miner = MinerFactory.Instance.GetMiner(deviceKind, minerConfiguration.Algorithm, engineConfiguration.XgminerConfiguration.AlgorithmMiners);
MinerProcess minerProcess = StoreMinerProcess(process, miner, coinSymbol, minerConfiguration, apiPort);
minerProcess.TerminateProcess = terminateProcess;
}
apiPort++;
}
}
private static void RegisterMiners()
{
MinerFactory factory = MinerFactory.Instance;
//BFGMiner as the default SHA-2 and Scrypt miner
MinerDescriptor miner = factory.RegisterMiner("BFGMiner", "BFGMiner", false);
factory.DefaultMiners[CoinAlgorithm.SHA256] = miner;
factory.DefaultMiners[CoinAlgorithm.Scrypt] = miner;
//Kalroth SJ-CGMiner as the default Scrypt-Jane miner
miner = factory.RegisterMiner("KalrothSJCGMiner", "CGMiner", true);
factory.DefaultMiners[CoinAlgorithm.ScryptJane] = miner;
//SGMiner is the default Scrypt-N miner
miner = factory.RegisterMiner("SGMiner", "SGMiner", true);
factory.DefaultMiners[CoinAlgorithm.ScryptN] = miner;
//LasyBear SPH-SGMiner as the default X11, X13 miner
miner = factory.RegisterMiner("LBSPHSGMiner", "SGMiner", true);
factory.DefaultMiners[CoinAlgorithm.X11] = miner;
factory.DefaultMiners[CoinAlgorithm.X13] = miner;
//AZNBoy SGMiner as the default X14, X15 miner
miner = factory.RegisterMiner("AZNSGMiner", "SGMiner", true);
factory.DefaultMiners[CoinAlgorithm.X14] = miner;
factory.DefaultMiners[CoinAlgorithm.X15] = miner;
//SPH-SGMiner as the default Quark and Groestl miner
miner = factory.RegisterMiner("SPHSGMiner", "SGMiner", true);
factory.DefaultMiners[CoinAlgorithm.Quark] = miner;
factory.DefaultMiners[CoinAlgorithm.Groestl] = miner;
//MaxcoinCGMiner is the default Keccak miner
miner = factory.RegisterMiner("MaxcoinCGMiner", "CGMiner", true);
factory.DefaultMiners[CoinAlgorithm.Keccak] = miner;
string minersDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Miners");
factory.RegisterMiners(minersDirectory);
}
private void PopulateBackendMinerVersion()
{
MinerDescriptor miner = MinerFactory.Instance.Miners[backendMinerIndex];
string xgminerName = miner.Name;
string xgminerPath = MinerPath.GetPathToInstalledMiner(miner);
string xgminerVersion = String.Empty;
if (File.Exists(xgminerPath))
{
xgminerVersion = MinerInstaller.GetInstalledMinerVersion(xgminerPath, miner.LegacyApi);
}
if (string.IsNullOrEmpty(xgminerVersion))
{
bfgminerLabel.Text = String.Format("{0} not installed", xgminerName);
}
else
{
bfgminerLabel.Text = String.Format("{0} {1} installed", xgminerName, xgminerVersion);
}
}
private static void PopulateXgminerVersion(Label targetLabel)
{
MinerDescriptor miner = MinerFactory.Instance.GetDefaultMiner();
string xgminerName = miner.Name;
string xgminerPath = MinerPath.GetPathToInstalledMiner(miner);
string xgminerVersion = String.Empty;
if (File.Exists(xgminerPath))
{
xgminerVersion = MinerInstaller.GetInstalledMinerVersion(miner, xgminerPath, miner.LegacyApi);
}
if (string.IsNullOrEmpty(xgminerVersion))
{
targetLabel.Text = String.Format("{0} not installed", xgminerName);
}
else
{
targetLabel.Text = String.Format("{0} {1} installed", xgminerName, xgminerVersion);
}
}
private Xgminer.Data.Configuration.Miner CreateBasicConfiguration(
MinerDescriptor miner,
Data.Configuration.Coin coinConfiguration,
int apiPort)
{
Xgminer.Data.Configuration.Miner minerConfiguration = new Xgminer.Data.Configuration.Miner()
{
ExecutablePath = MinerPath.GetPathToInstalledMiner(miner),
Algorithm = coinConfiguration.CryptoCoin.Algorithm,
ApiPort = apiPort,
ApiListen = true,
AllowedApiIps = engineConfiguration.XgminerConfiguration.AllowedApiIps,
CoinName = coinConfiguration.CryptoCoin.Name,
DisableGpu = engineConfiguration.XgminerConfiguration.DisableGpu
};
SetupConfigurationPools(minerConfiguration, coinConfiguration);
SetupConfigurationArguments(minerConfiguration, coinConfiguration);
return(minerConfiguration);
}
public static string GetPathToInstalledMiner(MinerDescriptor miner)
{
string executablePath;
switch (OSVersionPlatform.GetConcretePlatform())
{
case PlatformID.MacOSX:
executablePath = GetPathToMinerOnMacOSX(miner.Name, miner.FileName);
break;
//support Unix - there is no bin folder for the executables like on Mac OS X
case PlatformID.Unix:
//file launching is case-sensitive, lower-case the filename
executablePath = GetPathToMinerOnLinux(miner.FileName, miner.FileName.ToLower());
break;
default:
executablePath = GetPathToMinerOnWindows(miner.Name, miner.FileName);
break;
}
return(executablePath);
}
public List <Device> GetDevices(MinerDescriptor minerDescriptor, string executablePath)
{
Xgminer.Data.Configuration.Miner minerConfiguration = new Xgminer.Data.Configuration.Miner()
{
ExecutablePath = executablePath,
DisableGpu = xgminerConfiguration.DisableGpu,
DisableUsbProbe = xgminerConfiguration.DisableUsbProbe,
ScanArguments = xgminerConfiguration.ScanArguments
};
Xgminer.Miner miner = new Xgminer.Miner(minerConfiguration, false);
Version minerVersion = new Version(MinerInstaller.GetInstalledMinerVersion(minerDescriptor, executablePath, false));
List <Device> detectedDevices = miner.ListDevices(true, minerVersion);
if (xgminerConfiguration.StratumProxy)
{
for (int i = 0; i < xgminerConfiguration.StratumProxies.Count; i++)
{
MultiMiner.Engine.Data.Configuration.Xgminer.ProxyDescriptor proxy = xgminerConfiguration.StratumProxies[i];
detectedDevices.Add(new Device()
{
Kind = DeviceKind.PXY,
Driver = "proxy",
Name = String.Format("Stratum Proxy #{0}", (i + 1)),
//we want the path in the ViewModel for Remoting
//can't rely on having the Stratum Proxy settings
Path = String.Format("{0}:{1}", proxy.GetworkPort, proxy.StratumPort),
RelativeIndex = i
});
}
}
SortDevices(detectedDevices);
return(detectedDevices);
}
public MinerDescriptor GetMiner(DeviceKind deviceKind, CoinAlgorithm algorithm, SerializableDictionary <string, string> miners)
{
if (deviceKind != DeviceKind.GPU)
{
return(GetDefaultMiner());
}
string algorithmName = algorithm.Name;
MinerDescriptor result = null;
if (miners.ContainsKey(algorithmName))
{
// SingleOrDefault - the user may have a config file with a backend
// miner registered that no longer exists in their Miners\ folder
result = Miners.SingleOrDefault(m => m.Name.Equals(miners[algorithmName], StringComparison.OrdinalIgnoreCase));
}
if ((result == null) && (algorithm.DefaultMiner != null))
{
result = Miners.Single(m => m.Name.Equals(algorithm.DefaultMiner, StringComparison.OrdinalIgnoreCase));
}
return(result);
}
