private void logProcessClose(MinerProcess minerProcess)
{
DateTime startDate = minerProcess.StartDate;
DateTime endDate = DateTime.Now;
string coinName = minerProcess.MinerConfiguration.CoinName;
double priceAtStart = 0;
string coinSymbol = String.Empty;
//coin may not be in CoinChoose.com
if (minerProcess.CoinInformation != null)
{
coinSymbol = minerProcess.CoinInformation.Symbol;
priceAtStart = minerProcess.CoinInformation.Price;
}
double priceAtEnd = priceAtStart;
//can't use Single here - coin info may be gone now and we crash
CoinInformation coinInfo = coinInformation.SingleOrDefault(c => c.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
if (coinInfo != null)
{
priceAtEnd = coinInfo.Price;
}
List <int> deviceIndexes = minerProcess.MinerConfiguration.DeviceIndexes;
logProcessClose(startDate, endDate, coinName, coinSymbol, priceAtStart, priceAtEnd, deviceIndexes);
}
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 DoLogProcessClose(MinerProcess minerProcess)
{
if (LogProcessClose == null)
{
return;
}
DateTime startDate = minerProcess.StartDate;
DateTime endDate = DateTime.Now;
string coinName = minerProcess.MinerConfiguration.CoinName;
double priceAtStart = 0;
string coinSymbol = String.Empty;
//coin may not be in Coin API
if (minerProcess.CoinInformation != null)
{
coinSymbol = minerProcess.CoinInformation.Symbol;
priceAtStart = minerProcess.CoinInformation.Price;
}
double priceAtEnd = priceAtStart;
//can't use Single here - coin info may be gone now and we crash
CoinInformation coinInfo = null;
if (coinInformation != null) //null if no internet connection
{
coinInfo = coinInformation.SingleOrDefault(c => c.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
}
if (coinInfo != null)
{
priceAtEnd = coinInfo.Price;
}
//get a copy using ToList() so we can change the list in the event handler without
//affecting relaunching processes
List <DeviceDescriptor> deviceDescriptors = minerProcess.MinerConfiguration.DeviceDescriptors.ToList();
LogProcessCloseArgs args = new LogProcessCloseArgs
{
StartDate = startDate,
EndDate = endDate,
CoinName = coinName,
CoinSymbol = coinSymbol,
StartPrice = priceAtStart,
EndPrice = priceAtEnd,
DeviceDescriptors = deviceDescriptors,
MinerConfiguration = minerProcess.MinerConfiguration,
AcceptedShares = minerProcess.AcceptedShares
};
LogProcessClose(this, args);
}
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 void setupProcessStartInfo(MinerProcess minerProcess)
{
string coinName = minerProcess.MinerConfiguration.CoinName;
string coinSymbol = engineConfiguration.CoinConfigurations.Single(c => c.Coin.Name.Equals(coinName, StringComparison.OrdinalIgnoreCase)).Coin.Symbol;
CoinInformation processCoinInfo = coinInformation.SingleOrDefault(c => c.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
//coin may not be in CoinChoose.com
if (coinInformation != null)
{
minerProcess.CoinInformation = processCoinInfo;
}
minerProcess.StartDate = DateTime.Now;
}
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);
}
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 void setupProcessStartInfo(MinerProcess minerProcess)
{
string coinName = minerProcess.MinerConfiguration.CoinName;
string coinSymbol = engineConfiguration.CoinConfigurations.Single(c => c.CryptoCoin.Name.Equals(coinName, StringComparison.OrdinalIgnoreCase)).CryptoCoin.Symbol;
CoinInformation processCoinInfo = null;
if (coinInformation != null) //null if no network connection
{
processCoinInfo = coinInformation.SingleOrDefault(c => c.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
}
//coin may not be in Coin API
if (processCoinInfo != null)
{
minerProcess.CoinInformation = processCoinInfo;
}
minerProcess.StartDate = DateTime.Now;
}
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)
Xgminer.Data.Configuration.Miner 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 void FlagSuspiciousMiner(MinerProcess minerProcess, DeviceInformation deviceInformation)
{
if (deviceInformation.Status.ToLower().Contains("sick"))
minerProcess.HasSickDevice = true;
if (deviceInformation.Status.ToLower().Contains("dead"))
minerProcess.HasDeadDevice = true;
if (deviceInformation.CurrentHashrate == 0)
minerProcess.HasZeroHashrateDevice = true;
//only check GPUs for subpar hashrate
//ASICs spike too much for this to be reliable there
//don't check average hashrate if using dynamic intensity
if (deviceInformation.Kind.Equals("GPU", StringComparison.OrdinalIgnoreCase) &&
!engineConfiguration.XgminerConfiguration.DesktopMode)
{
//avoid div by 0
if (deviceInformation.AverageHashrate > 0)
{
double performanceRatio = deviceInformation.CurrentHashrate / deviceInformation.AverageHashrate;
if (performanceRatio <= 0.50)
minerProcess.HasPoorPerformingDevice = true;
}
}
if (miningCoinConfigurations == null)
//started mining but haven't yet assigned mining members
//cannot check the following yet
return;
//Work Utility not returned by legacy API miners
if (!minerProcess.Miner.LegacyApi)
{
double effectiveHashrate = WorkUtilityToHashrate(deviceInformation.WorkUtility);
//avoid div by 0
if (deviceInformation.AverageHashrate > 0)
{
double performanceRatio = effectiveHashrate / deviceInformation.AverageHashrate;
if (performanceRatio <= 0.25)
minerProcess.StoppedAcceptingShares = true;
}
}
}
private void CheckAndNotifyFoundBlocks(MinerProcess minerProcess, long foundBlocks)
{
//started mining but haven't yet assigned mining members
if (miningCoinConfigurations == null)
return;
string coinName = minerProcess.MinerConfiguration.CoinName;
//reference miningCoinConfigurations so that we get access to the mining coins
Engine.Data.Configuration.Coin configuration = miningCoinConfigurations.SingleOrDefault(c => c.CryptoCoin.Name.Equals(coinName, StringComparison.OrdinalIgnoreCase));
if (configuration == null)
return;
if (configuration.NotifyOnBlockFound2 && (foundBlocks > minerProcess.FoundBlocks))
{
minerProcess.FoundBlocks = foundBlocks;
string notificationReason = String.Format("Block(s) found for {0} (block {1})",
coinName, minerProcess.FoundBlocks);
PostNotification(notificationReason, notificationReason, () =>
{
}, ToolTipIcon.Info, "");
}
}
private void FlagSuspiciousMiner(MinerProcess minerProcess, DeviceInformation deviceInformation)
{
if (deviceInformation.Status.ToLower().Contains("sick"))
minerProcess.HasSickDevice = true;
if (deviceInformation.Status.ToLower().Contains("dead"))
minerProcess.HasDeadDevice = true;
if (deviceInformation.CurrentHashrate == 0)
minerProcess.HasZeroHashrateDevice = true;
//only check GPUs for subpar hashrate
//ASICs spike too much for this to be reliable there
//don't check average hashrate if using dynamic intensity
if (deviceInformation.Kind.Equals("GPU", StringComparison.OrdinalIgnoreCase) &&
!engineConfiguration.XgminerConfiguration.DesktopMode)
{
//avoid div by 0
if (deviceInformation.AverageHashrate > 0)
{
double performanceRatio = deviceInformation.CurrentHashrate / deviceInformation.AverageHashrate;
if (performanceRatio <= 0.50)
minerProcess.HasPoorPerformingDevice = true;
}
}
double effectiveHashrate = WorkUtilityToHashrate(deviceInformation.WorkUtility);
//avoid div by 0
if (deviceInformation.AverageHashrate > 0)
{
double performanceRatio = effectiveHashrate / deviceInformation.AverageHashrate;
if (performanceRatio <= 0.25)
minerProcess.StoppedAcceptingShares = true;
}
}
private void CheckAndNotifyAcceptedShares(MinerProcess minerProcess, long acceptedShares)
{
string coinName = minerProcess.MinerConfiguration.CoinName;
//reference miningCoinConfigurations so that we get access to the mining coins
CoinConfiguration configuration = miningCoinConfigurations.Single(c => c.Coin.Name.Equals(coinName, StringComparison.OrdinalIgnoreCase));
if (configuration == null)
return;
if (configuration.NotifyOnShareAccepted && (acceptedShares > minerProcess.AcceptedShares))
{
minerProcess.AcceptedShares = acceptedShares;
string notificationReason = String.Format("Share(s) accepted for {0} (share {1})",
coinName, minerProcess.AcceptedShares);
notificationsControl.AddNotification(notificationReason, notificationReason, () =>
{
}, "");
}
}
private List<DeviceDetailsResponse> GetProcessDevices(MinerProcess minerProcess, List<DeviceInformationResponse> deviceInformationList)
{
List<DeviceDetailsResponse> processDevices = null;
if (processDeviceDetails.ContainsKey(minerProcess))
{
processDevices = processDeviceDetails[minerProcess];
foreach (DeviceInformationResponse deviceInformation in deviceInformationList)
{
DeviceDetailsResponse deviceDetails = processDevices.SingleOrDefault(d => d.Name.Equals(deviceInformation.Name, StringComparison.OrdinalIgnoreCase)
&& (d.ID == deviceInformation.ID));
if (deviceDetails == null)
{
//devs API returned a device not in the previous DEVDETAILS response
//need to clear our previous response and get a new one
processDevices = null;
break;
}
}
}
if (processDevices == null)
{
processDevices = GetDeviceDetailsFromProcess(minerProcess);
processDeviceDetails[minerProcess] = processDevices;
}
return processDevices;
}
private List<DeviceInformationResponse> GetDeviceInfoFromProcess(MinerProcess minerProcess)
{
Xgminer.Api.ApiContext apiContext = minerProcess.ApiContext;
//setup logging
apiContext.LogEvent -= LogApiEvent;
apiContext.LogEvent += LogApiEvent;
List<DeviceInformationResponse> deviceInformationList = null;
try
{
try
{
deviceInformationList = apiContext.GetDeviceInformation().Where(d => d.Enabled).ToList();
}
catch (IOException ex)
{
//don't fail and crash out due to any issues communicating via the API
deviceInformationList = null;
}
}
catch (SocketException ex)
{
//won't be able to connect for the first 5s or so
deviceInformationList = null;
}
return deviceInformationList;
}
private static void FlagSuspiciousProxy(MinerProcess minerProcess, List<DeviceInformation> deviceInformationList)
{
double currentProxyHashrate = deviceInformationList
.Where(device => device.Name.Equals("PXY", StringComparison.OrdinalIgnoreCase))
.Sum(device => device.CurrentHashrate);
double averageProxyHashrate = deviceInformationList
.Where(device => device.Name.Equals("PXY", StringComparison.OrdinalIgnoreCase))
.Sum(device => device.AverageHashrate);
//proxy is 0 hashrate and used to have a positive hashrate
if ((averageProxyHashrate > 0) && (currentProxyHashrate == 0))
{
minerProcess.HasZeroHashrateDevice = true;
}
}
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 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;
}
private void logProcessClose(MinerProcess minerProcess)
{
if (this.LogProcessClose == null)
return;
DateTime startDate = minerProcess.StartDate;
DateTime endDate = DateTime.Now;
string coinName = minerProcess.MinerConfiguration.CoinName;
double priceAtStart = 0;
string coinSymbol = String.Empty;
//coin may not be in Coin API
if (minerProcess.CoinInformation != null)
{
coinSymbol = minerProcess.CoinInformation.Symbol;
priceAtStart = minerProcess.CoinInformation.Price;
}
double priceAtEnd = priceAtStart;
//can't use Single here - coin info may be gone now and we crash
CoinInformation coinInfo = null;
if (coinInformation != null) //null if no internet connection
coinInfo = coinInformation.SingleOrDefault(c => c.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
if (coinInfo != null)
priceAtEnd = coinInfo.Price;
//get a copy using ToList() so we can change the list in the event handler without
//affecting relaunching processes
List<DeviceDescriptor> deviceDescriptors = minerProcess.MinerConfiguration.DeviceDescriptors.ToList();
LogProcessCloseArgs args = new LogProcessCloseArgs();
args.StartDate = startDate;
args.EndDate = endDate;
args.CoinName = coinName;
args.CoinSymbol = coinSymbol;
args.StartPrice = priceAtStart;
args.EndPrice = priceAtEnd;
args.DeviceDescriptors = deviceDescriptors;
args.MinerConfiguration = minerProcess.MinerConfiguration;
args.AcceptedShares = minerProcess.AcceptedShares;
this.LogProcessClose(this, args);
}
private void setupProcessStartInfo(MinerProcess minerProcess)
{
string coinName = minerProcess.MinerConfiguration.CoinName;
string coinSymbol = engineConfiguration.CoinConfigurations.Single(c => c.CryptoCoin.Name.Equals(coinName, StringComparison.OrdinalIgnoreCase)).CryptoCoin.Symbol;
CoinInformation processCoinInfo = null;
if (coinInformation != null) //null if no network connection
processCoinInfo = coinInformation.SingleOrDefault(c => c.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
//coin may not be in Coin API
if (processCoinInfo != null)
minerProcess.CoinInformation = processCoinInfo;
minerProcess.StartDate = DateTime.Now;
}
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)
{
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 RebaseGpuDeviceIndexes(MinerProcess minerProcess, List<int> deviceIndexes)
{
//we need to rebase GPUs here so that they match the rebasing done in CreateMinerConfiguration()
if (minerProcess.MinerConfiguration.Algorithm == CoinAlgorithm.Scrypt)
{
int firstGpuIndex = GetIndexOfFirstGpu();
for (int i = 0; i < deviceIndexes.Count; i++)
deviceIndexes[i] += firstGpuIndex;
}
}
private void logProcessClose(MinerProcess minerProcess)
{
DateTime startDate = minerProcess.StartDate;
DateTime endDate = DateTime.Now;
string coinName = minerProcess.MinerConfiguration.CoinName;
double priceAtStart = 0;
string coinSymbol = String.Empty;
//coin may not be in CoinChoose.com
if (minerProcess.CoinInformation != null)
{
coinSymbol = minerProcess.CoinInformation.Symbol;
priceAtStart = minerProcess.CoinInformation.Price;
}
double priceAtEnd = priceAtStart;
//can't use Single here - coin info may be gone now and we crash
CoinInformation coinInfo = null;
if (coinInformation != null) //null if no internet connection
coinInfo = coinInformation.SingleOrDefault(c => c.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
if (coinInfo != null)
priceAtEnd = coinInfo.Price;
//get a copy using ToList() so we can change the list in the event handler without
//affecting relaunching processes
List<int> deviceIndexes = minerProcess.MinerConfiguration.DeviceIndexes.ToList();
logProcessClose(startDate, endDate, coinName, coinSymbol, priceAtStart, priceAtEnd, deviceIndexes, minerProcess.MinerConfiguration);
}
private int GetDeviceIndexForDeviceDetails(DeviceDetails deviceDetails, MinerProcess minerProcess)
{
int result = devices
.FindIndex((device) => {
return device.Driver.Equals(deviceDetails.Driver, StringComparison.OrdinalIgnoreCase)
&&
(
//serial == serial && path == path (serial may not be unique)
(!String.IsNullOrEmpty(device.Serial) && device.Serial.Equals(deviceDetails.Serial, StringComparison.OrdinalIgnoreCase)
&& !String.IsNullOrEmpty(device.Path) && device.Path.Equals(deviceDetails.DevicePath, StringComparison.OrdinalIgnoreCase))
//serial == serial && path == String.Empty - WinUSB/LibUSB has no path, but has a serial #
|| (!String.IsNullOrEmpty(device.Serial) && device.Serial.Equals(deviceDetails.Serial, StringComparison.OrdinalIgnoreCase)
&& String.IsNullOrEmpty(device.Path) && String.IsNullOrEmpty(deviceDetails.DevicePath))
//path == path
|| (!String.IsNullOrEmpty(device.Path) && device.Path.Equals(deviceDetails.DevicePath, StringComparison.OrdinalIgnoreCase))
//proxy == proxy && ID = RelativeIndex
|| (device.Driver.Equals("proxy", StringComparison.OrdinalIgnoreCase) && (minerProcess.MinerConfiguration.DeviceDescriptors.Contains(device)))
//opencl = opencl && ID = RelativeIndex
|| (device.Driver.Equals("opencl", StringComparison.OrdinalIgnoreCase) && (device.RelativeIndex == deviceDetails.ID))
//cpu = cpu && ID = RelativeIndex
|| (device.Driver.Equals("cpu", StringComparison.OrdinalIgnoreCase) && (device.RelativeIndex == deviceDetails.ID))
);
});
return result;
}
private List<PoolInformation> GetPoolInfoFromProcess(MinerProcess minerProcess)
{
Xgminer.Api.ApiContext apiContext = minerProcess.ApiContext;
//setup logging
apiContext.LogEvent -= LogApiEvent;
apiContext.LogEvent += LogApiEvent;
List<PoolInformation> poolInformation = null;
try
{
try
{
poolInformation = apiContext.GetPoolInformation();
}
catch (IOException)
{
//don't fail and crash out due to any issues communicating via the API
poolInformation = null;
}
}
catch (SocketException)
{
//won't be able to connect for the first 5s or so
poolInformation = null;
}
return poolInformation;
}
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 FlagSuspiciousMiner(MinerProcess minerProcess, DeviceInformationResponse deviceInformation)
{
if (deviceInformation.Status.ToLower().Contains("sick"))
minerProcess.HasSickDevice = true;
if (deviceInformation.Status.ToLower().Contains("dead"))
minerProcess.HasDeadDevice = true;
if (deviceInformation.CurrentHashrate == 0)
minerProcess.HasZeroHashrateDevice = true;
//don't check average hashrate if using dynamic intensity and its a GPU
if (!engineConfiguration.XgminerConfiguration.DesktopMode ||
(!deviceInformation.Kind.Equals("GPU", StringComparison.OrdinalIgnoreCase)))
{
//avoid div by 0
if (deviceInformation.AverageHashrate > 0)
{
double performanceRatio = deviceInformation.CurrentHashrate / deviceInformation.AverageHashrate;
if (performanceRatio <= 0.50)
minerProcess.HasPoorPerformingDevice = true;
}
}
}
private void logProcessClose(MinerProcess minerProcess)
{
DateTime startDate = minerProcess.StartDate;
DateTime endDate = DateTime.Now;
string coinName = minerProcess.MinerConfiguration.CoinName;
double priceAtStart = 0;
string coinSymbol = String.Empty;
//coin may not be in CoinChoose.com
if (minerProcess.CoinInformation != null)
{
coinSymbol = minerProcess.CoinInformation.Symbol;
priceAtStart = minerProcess.CoinInformation.Price;
}
double priceAtEnd = priceAtStart;
//can't use Single here - coin info may be gone now and we crash
CoinInformation coinInfo = coinInformation.SingleOrDefault(c => c.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
if (coinInfo != null)
priceAtEnd = coinInfo.Price;
List<int> deviceIndexes = minerProcess.MinerConfiguration.DeviceIndexes;
logProcessClose(startDate, endDate, coinName, coinSymbol, priceAtStart, priceAtEnd, deviceIndexes);
}
private static void ClearSuspectProcessFlags(MinerProcess minerProcess)
{
minerProcess.HasDeadDevice = false;
minerProcess.HasSickDevice = false;
minerProcess.HasZeroHashrateDevice = false;
minerProcess.MinerIsFrozen = false;
minerProcess.HasPoorPerformingDevice = false;
}
private void CheckAndNotifyAcceptedShares(MinerProcess minerProcess, long acceptedShares)
{
//started mining but haven't yet assigned mining members
if (miningCoinConfigurations == null)
return;
string coinName = minerProcess.MinerConfiguration.CoinName;
//reference miningCoinConfigurations so that we get access to the mining coins
Coin configuration = miningCoinConfigurations.SingleOrDefault(c => c.PoolGroup.Name.Equals(coinName, StringComparison.OrdinalIgnoreCase));
if (configuration == null)
return;
if (configuration.NotifyOnShareAccepted2 && (acceptedShares > minerProcess.AcceptedShares))
{
minerProcess.AcceptedShares = acceptedShares;
PostNotification(String.Format("Share(s) accepted for {0} (share {1})",
coinName, minerProcess.AcceptedShares), NotificationKind.Information);
}
}
private SummaryInformationResponse GetSummaryInfoFromProcess(MinerProcess minerProcess)
{
Xgminer.Api.ApiContext apiContext = minerProcess.ApiContext;
//setup logging
apiContext.LogEvent -= LogApiEvent;
apiContext.LogEvent += LogApiEvent;
SummaryInformationResponse summaryInformation = null;
try
{
try
{
summaryInformation = apiContext.GetSummaryInformation();
}
catch (IOException ex)
{
//don't fail and crash out due to any issues communicating via the API
summaryInformation = null;
}
}
catch (SocketException ex)
{
//won't be able to connect for the first 5s or so
summaryInformation = null;
}
return summaryInformation;
}
private List<DeviceDetails> GetDeviceDetailsFromProcess(MinerProcess minerProcess)
{
ApiContext apiContext = minerProcess.ApiContext;
//setup logging
apiContext.LogEvent -= LogApiEvent;
apiContext.LogEvent += LogApiEvent;
List<DeviceDetails> deviceDetailsList;
try
{
try
{
deviceDetailsList = apiContext.GetDeviceDetails().ToList();
}
catch (IOException)
{
//don't fail and crash out due to any issues communicating via the API
deviceDetailsList = null;
}
}
catch (SocketException)
{
//won't be able to connect for the first 5s or so
deviceDetailsList = null;
}
return deviceDetailsList;
}
private void CheckAndNotifyFoundBlocks(MinerProcess minerProcess, long foundBlocks)
{
string coinName = minerProcess.MinerConfiguration.CoinName;
//reference miningCoinConfigurations so that we get access to the mining coins
CoinConfiguration configuration = miningCoinConfigurations.Single(c => c.Coin.Name.Equals(coinName, StringComparison.OrdinalIgnoreCase));
if (configuration == null)
return;
if (configuration.NotifyOnBlockFound && (foundBlocks > minerProcess.FoundBlocks))
{
minerProcess.FoundBlocks = foundBlocks;
string notificationReason = String.Format("Block(s) found for {0} (block {1})",
coinName, minerProcess.FoundBlocks);
notificationsControl.AddNotification(notificationReason, notificationReason, () =>
{
}, "");
}
}
private void RefreshProcessDeviceStats(MinerProcess minerProcess)
{
ClearSuspectProcessFlags(minerProcess);
List<DeviceInformation> deviceInformationList = GetDeviceInfoFromProcess(minerProcess);
if (deviceInformationList == null) //handled failure getting API info
{
minerProcess.MinerIsFrozen = true;
return;
}
//starting with bfgminer 3.7 we need the DEVDETAILS response to tie things from DEVS up with -d? details
List<DeviceDetails> processDevices = GetProcessDeviceDetails(minerProcess, deviceInformationList);
if (processDevices == null) //handled failure getting API info
{
minerProcess.MinerIsFrozen = true;
return;
}
//clear accepted shares as we'll be summing that as well
minerProcess.AcceptedShares = 0;
foreach (DeviceInformation deviceInformation in deviceInformationList)
{
//don't consider a standalone miner suspect - restarting the proxy doesn't help and often hurts
if (!deviceInformation.Name.Equals("PXY", StringComparison.OrdinalIgnoreCase))
FlagSuspiciousMiner(minerProcess, deviceInformation);
DeviceDetails deviceDetails = processDevices.SingleOrDefault(d => d.Name.Equals(deviceInformation.Name, StringComparison.OrdinalIgnoreCase)
&& (d.ID == deviceInformation.ID));
int deviceIndex = GetDeviceIndexForDeviceDetails(deviceDetails, minerProcess);
if (deviceIndex >= 0)
{
minerProcess.AcceptedShares += deviceInformation.AcceptedShares;
Device device = Devices[deviceIndex];
Coin coinConfiguration = CoinConfigurationForDevice(device);
if (minerProcess.Miner.LegacyApi && (coinConfiguration != null))
deviceInformation.WorkUtility = AdjustWorkUtilityForPoolMultipliers(deviceInformation.WorkUtility, coinConfiguration.PoolGroup.Algorithm);
DeviceViewModel deviceViewModel = LocalViewModel.ApplyDeviceInformationResponseModel(device, deviceInformation);
DeviceDetailsMapping[deviceViewModel] = deviceDetails;
if (coinConfiguration != null)
{
string poolName = GetPoolNameByIndex(coinConfiguration, deviceViewModel.PoolIndex);
//may be blank if donating
if (!String.IsNullOrEmpty(poolName))
{
deviceViewModel.Pool = poolName;
lastDevicePoolMapping[deviceViewModel] = poolName;
}
else
{
if (lastDevicePoolMapping.ContainsKey(deviceViewModel))
deviceViewModel.Pool = lastDevicePoolMapping[deviceViewModel];
}
if (!String.IsNullOrEmpty(deviceViewModel.Pool))
CheckAndSetNetworkDifficulty(minerProcess.ApiContext.IpAddress, minerProcess.ApiContext.Port, deviceViewModel.Pool);
}
}
}
FlagSuspiciousProxy(minerProcess, deviceInformationList);
LocalViewModel.ApplyDeviceDetailsResponseModels(minerProcess.MinerConfiguration.DeviceDescriptors, processDevices);
}