public Engine()
{
DeviceConfigurations = new List <Device>();
CoinConfigurations = new List <Coin>();
XgminerConfiguration = new Xgminer();
StrategyConfiguration = new Strategy();
}
public Engine()
{
DeviceConfigurations = new List<Device>();
CoinConfigurations = new List<Coin>();
XgminerConfiguration = new Xgminer();
StrategyConfiguration = new Strategy();
}
public void LoadMinerConfiguration()
{
Xgminer minerConfiguration = ConfigurationReaderWriter.ReadConfiguration <Xgminer>(XgminerConfigurationFileName());
ObjectCopier.CopyObject(minerConfiguration, this);
UpgradeConfiguration();
if (StratumProxies.Count == 0)
{
AddDefaultProxy();
}
}
private string GetCoinNameForApiContext(Xgminer.Api.ApiContext apiContext)
{
string coinName = string.Empty;
foreach (MinerProcess minerProcess in miningEngine.MinerProcesses)
{
Xgminer.Api.ApiContext loopContext = minerProcess.ApiContext;
if (loopContext == apiContext)
{
coinName = minerProcess.MinerConfiguration.CoinName;
break;
}
}
return coinName;
}
private Engine.Data.Configuration.Coin CoinConfigurationForDevice(Xgminer.Data.Device device)
{
//get the actual device configuration, text in the ListViewItem may be unsaved
Engine.Data.Configuration.Device deviceConfiguration = null;
if (miningEngine.Mining &&
// if the timing is right, we may be .Mining but not yet have data in miningDeviceConfigurations
(miningDeviceConfigurations != null))
deviceConfiguration = miningDeviceConfigurations.SingleOrDefault(dc => dc.Equals(device));
else
deviceConfiguration = engineConfiguration.DeviceConfigurations.SingleOrDefault(dc => dc.Equals(device));
if (deviceConfiguration == null)
return null;
string itemCoinSymbol = deviceConfiguration.CoinSymbol;
List<Engine.Data.Configuration.Coin> configurations;
if (miningEngine.Mining &&
// if the timing is right, we may be .Mining but not yet have data in miningCoinConfigurations
(miningCoinConfigurations != null))
configurations = this.miningCoinConfigurations;
else
configurations = engineConfiguration.CoinConfigurations;
Engine.Data.Configuration.Coin coinConfiguration = configurations.SingleOrDefault(c => c.CryptoCoin.Symbol.Equals(itemCoinSymbol, StringComparison.OrdinalIgnoreCase));
return coinConfiguration;
}
private readonly Random random = new Random(Guid.NewGuid().GetHashCode()); //seed so we don't keep getting the same indexes
private void AddDonationPool(string coinSymbol, Xgminer.Data.Configuration.Miner minerConfiguration)
{
MiningPool donationPool = null;
Data.Configuration.Coin donationConfiguration = this.donationConfigurations.SingleOrDefault(dc => dc.CryptoCoin.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);
}
}
private void SetupConfigurationPools(Xgminer.Data.Configuration.Miner minerConfiguration, Data.Configuration.Coin 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.CryptoCoin.Symbol, minerConfiguration);
foreach (MiningPool pool in minerConfiguration.Pools)
pool.QuotaEnabled = donationPercent > 0;
}
private int SetupConfigurationDevices(Xgminer.Data.Configuration.Miner minerConfiguration, DeviceKind deviceKinds, IList<Engine.Data.Configuration.Device> deviceConfigurations)
{
int deviceCount = 0;
for (int i = 0; i < deviceConfigurations.Count; i++)
{
Engine.Data.Configuration.Device enabledConfiguration = deviceConfigurations[i];
Xgminer.Data.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(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 Process LaunchMinerProcess(Xgminer.Data.Configuration.Miner minerConfiguration, string reason)
{
minerConfiguration.Priority = this.engineConfiguration.XgminerConfiguration.Priority;
Xgminer.Miner miner = new Xgminer.Miner(minerConfiguration);
miner.LogLaunch += this.LogProcessLaunch;
miner.LaunchFailed += this.ProcessLaunchFailed;
miner.AuthenticationFailed += this.ProcessAuthenticationFailed;
Process process = miner.Launch(reason);
return process;
}
private MinerProcess StoreMinerProcess(Process process, string coinSymbol, Xgminer.Data.Configuration.Miner 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 LoadMinerConfiguration()
{
Xgminer minerConfiguration = ConfigurationReaderWriter.ReadConfiguration <Xgminer>(XgminerConfigurationFileName());
ObjectCopier.CopyObject(minerConfiguration, this);
}
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 int SetupConfigurationDevices(Xgminer.Data.Configuration.Miner minerConfiguration, DeviceKind deviceKind, IList<Engine.Data.Configuration.Device> deviceConfigurations)
{
int deviceCount = 0;
for (int i = 0; i < deviceConfigurations.Count; i++)
{
Engine.Data.Configuration.Device enabledConfiguration = deviceConfigurations[i];
Xgminer.Data.Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration));
if (deviceKind != device.Kind)
continue;
deviceCount++;
minerConfiguration.DeviceDescriptors.Add(device);
}
return deviceCount;
}
private double GetNetworkDifficultyFromMiner(Xgminer.Api.ApiContext apiContext)
{
//setup logging
apiContext.LogEvent -= LogApiEvent;
apiContext.LogEvent += LogApiEvent;
NetworkCoinInformation coinInformation = null;
try
{
try
{
coinInformation = apiContext.GetCoinInformation();
}
catch (IOException)
{
//don't fail and crash out due to any issues communicating via the API
coinInformation = null;
}
}
catch (SocketException)
{
//won't be able to connect for the first 5s or so
coinInformation = null;
}
return coinInformation == null ? 0.0 : coinInformation.NetworkDifficulty;
}
private void SetupConfigurationArguments(Xgminer.Data.Configuration.Miner minerConfiguration, Data.Configuration.Coin coinConfiguration)
{
string arguments = string.Empty;
//apply algorithm-specific parameters
if (engineConfiguration.XgminerConfiguration.AlgorithmFlags.ContainsKey(coinConfiguration.CryptoCoin.Algorithm))
arguments = String.Format("{0} {1}", arguments,
engineConfiguration.XgminerConfiguration.AlgorithmFlags[coinConfiguration.CryptoCoin.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 void LogApiEvent(object sender, Xgminer.Api.LogEventArgs eventArgs)
{
ApiLogEntry logEntry = new ApiLogEntry();
logEntry.DateTime = eventArgs.DateTime;
logEntry.Request = eventArgs.Request;
logEntry.Response = eventArgs.Response;
Xgminer.Api.ApiContext apiContext = (Xgminer.Api.ApiContext)sender;
logEntry.CoinName = GetCoinNameForApiContext(apiContext);
logEntry.Machine = apiContext.IpAddress + ":" + apiContext.Port;
this.BeginInvoke((Action)(() =>
{
//code to update UI
apiLogEntryBindingSource.Position = apiLogEntryBindingSource.Add(logEntry);
while (apiLogEntryBindingSource.Count > 1000)
apiLogEntryBindingSource.RemoveAt(0);
}));
LogApiEventToFile(logEntry);
}
private void LogApiEvent(object sender, Xgminer.Api.LogEventArgs eventArgs)
{
ApiLogEntry logEntry = new ApiLogEntry();
logEntry.DateTime = eventArgs.DateTime;
logEntry.Request = eventArgs.Request;
logEntry.Response = eventArgs.Response;
logEntry.CoinName = GetCoinNameForApiContext((Xgminer.Api.ApiContext)sender);
apiLogEntryBindingSource.Position = apiLogEntryBindingSource.Add(logEntry);
while (apiLogEntryBindingSource.Count > 1000)
apiLogEntryBindingSource.RemoveAt(0);
LogApiEventToFile(logEntry);
}
