static MiningManager()
{
ApplicationStateManager.OnInternetCheck += OnInternetCheck;
_switchingManager = new AlgorithmSwitchingManager();
_switchingManager.SmaCheck += SwichMostProfitableGroupUpMethod;
}
public MiningSession(List <ComputeDevice> devices,
IMainFormRatesComunication mainFormRatesComunication,
string miningLocation, string worker, string btcAdress)
{
// init fixed
_mainFormRatesComunication = mainFormRatesComunication;
_miningLocation = miningLocation;
_switchingManager = new AlgorithmSwitchingManager();
_switchingManager.SmaCheck += SwichMostProfitableGroupUpMethod;
_btcAdress = btcAdress;
_worker = worker;
// initial settup
_miningDevices = GroupSetupUtils.GetMiningDevices(devices, true);
if (_miningDevices.Count > 0)
{
GroupSetupUtils.AvarageSpeeds(_miningDevices);
}
// init timer stuff
_preventSleepTimer = new Timer();
_preventSleepTimer.Elapsed += PreventSleepTimer_Tick;
// sleep time is minimal 1 minute
_preventSleepTimer.Interval = 20 * 1000; // leave this interval, it works
// set internet checking
_internetCheckTimer = new Timer();
_internetCheckTimer.Elapsed += InternetCheckTimer_Tick;
_internetCheckTimer.Interval = 1 * 1000 * 60; // every minute
// assume profitable
_isProfitable = true;
// assume we have internet
_isConnectedToInternet = true;
if (IsMiningEnabled)
{
_preventSleepTimer.Start();
_internetCheckTimer.Start();
}
_switchingManager.Start();
_isMiningRegardlesOfProfit = ConfigManager.GeneralConfig.MinimumProfit == 0;
}
private static async Task MiningManagerCommandQueueLoop(CancellationToken stop)
{
var switchingManager = new AlgorithmSwitchingManager();
try
{
switchingManager.SmaCheck += SwichMostProfitableGroupUpMethod;
switchingManager.ForceUpdate();
var checkWaitTime = TimeSpan.FromMilliseconds(50);
Func <bool> isActive = () => !stop.IsCancellationRequested;
Logger.Info(Tag, "Starting MiningManagerCommandQueueLoop");
while (isActive())
{
if (isActive())
{
await TaskHelpers.TryDelay(checkWaitTime, stop);
}
// command handling
if (isActive() && _commandQueue.TryDequeue(out var command))
{
await HandleCommand(command);
}
}
}
catch (TaskCanceledException e)
{
Logger.Debug(Tag, $"MiningManagerCommandQueueLoop TaskCanceledException: {e.Message}");
}
finally
{
Logger.Info(Tag, "Exiting MiningManagerCommandQueueLoop run cleanup");
// cleanup
switchingManager.SmaCheck -= SwichMostProfitableGroupUpMethod;
switchingManager.Stop();
foreach (var groupMiner in _runningMiners.Values)
{
await groupMiner.StopTask();
}
_runningMiners.Clear();
_miningDevices.Clear();
EthlargementIntegratedPlugin.Instance.Stop();
}
}
public void SwitchingManager_ShouldReportNewProfitAfterTicks()
{
var higherPayings = new Dictionary <AlgorithmType, double>();
foreach (var key in StartPaying.Keys)
{
higherPayings[key] = StartPaying[key] + 0.000001;
}
var manager = new AlgorithmSwitchingManager();
manager.SmaCheckTimerOnElapsed(null, null);
NHSmaData.UpdateSmaPaying(higherPayings);
for (var i = 1; i <= AlgorithmSwitchingManager.MaxHistory + 5; i++)
{
manager.SmaCheckTimerOnElapsed(null, null);
foreach (var algo in higherPayings.Keys)
{
var paying = manager.LastPayingForAlgo(algo);
Assert.AreEqual(NHSmaData.IsAlgorithmStable(algo), TestStables.Contains(algo));
var range = NHSmaData.IsAlgorithmStable(algo)
? AlgorithmSwitchingManager.StableRange
: AlgorithmSwitchingManager.UnstableRange;
if (i < range.Lower)
{
// We are below the interval for this algo to have updated
Assert.AreEqual(StartPaying[algo], paying);
}
else if (i >= range.Upper)
{
// We are above the max ticks for this algo to be updated
Assert.AreEqual(higherPayings[algo], paying);
}
}
}
}
public void SwitchingManager_ShouldAlwaysReportLowerProfit()
{
var manager = new AlgorithmSwitchingManager();
manager.SmaCheckTimerOnElapsed(null, null);
var currentPaying = new Dictionary <AlgorithmType, double>();
for (var i = 0; i < AlgorithmSwitchingManager.MaxHistory + 10; i++)
{
foreach (var algo in StartPaying.Keys)
{
currentPaying[algo] = manager.LastPayingForAlgo(algo);
// Randomly add or subtract
NHSmaData.UpdatePayingForAlgo(algo, StartPaying[algo] + (R.NextDouble() - 0.5));
}
manager.SmaCheckTimerOnElapsed(null, null);
// Iterate again to check
foreach (var algo in StartPaying.Keys)
{
Assert.IsTrue(NHSmaData.TryGetPaying(algo, out var paying));
if (paying <= currentPaying[algo])
{
// New value was less/same, so normalized value should be that
Assert.AreEqual(paying, manager.LastPayingForAlgo(algo));
}
else
{
// New value was more, so normalized should be equal or greater (depending on ticks)
Assert.IsTrue(manager.LastPayingForAlgo(algo) >= currentPaying[algo]);
}
}
}
}
private static async Task MiningManagerCommandQueueLoop(CancellationToken stop)
{
var switchingManager = new AlgorithmSwitchingManager();
var lastDeferredCommandTime = DateTime.UtcNow;
Func <bool> handleDeferredCommands = () => (DateTime.UtcNow - lastDeferredCommandTime).TotalSeconds >= 0.5;
var deferredCommands = new List <DeferredDeviceCommand>();
try
{
switchingManager.SmaCheck += SwichMostProfitableGroupUpMethod;
switchingManager.ForceUpdate();
var checkWaitTime = TimeSpan.FromMilliseconds(50);
Func <bool> isActive = () => !stop.IsCancellationRequested;
Logger.Info(Tag, "Starting MiningManagerCommandQueueLoop");
while (isActive())
{
if (isActive())
{
await TaskHelpers.TryDelay(checkWaitTime, stop);
}
if (handleDeferredCommands() && deferredCommands.Any())
{
await HandleDeferredCommands(deferredCommands);
deferredCommands.Clear();
}
// command handling
var(command, hasTimedout, exceptionString) = await _commandQueue.ReadAsync(checkWaitTime, stop);
if (command == null)
{
if (exceptionString != null)
{
Logger.Error(Tag, $"Channel.ReadAsync error: {exceptionString}");
}
continue;
}
if (command is DeferredDeviceCommand deferredCommand)
{
deferredCommand.device.IsPendingChange = true; // TODO check if we can be without this one
deferredCommand.device.State = DeviceState.Pending;
lastDeferredCommandTime = DateTime.UtcNow;
deferredCommands.Add(deferredCommand);
continue;
}
if (command is MainCommand mainCommand)
{
await HandleCommand(mainCommand);
}
}
}
catch (TaskCanceledException e)
{
Logger.Debug(Tag, $"MiningManagerCommandQueueLoop TaskCanceledException: {e.Message}");
}
finally
{
Logger.Info(Tag, "Exiting MiningManagerCommandQueueLoop run cleanup");
// cleanup
switchingManager.SmaCheck -= SwichMostProfitableGroupUpMethod;
switchingManager.Stop();
foreach (var groupMiner in _runningMiners.Values)
{
await groupMiner.StopTask();
}
_runningMiners.Clear();
_miningDevices.Clear();
}
}
