public FrequentPatternGUI()
{
InitializeComponent();
_managerDataMining = new MiningManager();
_rules = new List <AssociationRule>();
_actualMap = new Map();
}
private static async Task SetBTC(string btc)
{
// change in memory and save changes to file
CredentialsSettings.Instance.BitcoinAddress = btc;
ConfigManager.GeneralConfigFileCommit();
await MiningManager.ChangeUsername(CreateUsername(btc, RigID()));
}
private static void RestartMinersIfMining()
{
// if mining update the mining manager
if (MiningState.Instance.IsCurrentlyMining)
{
MiningManager.RestartMiners(GetUsername());
}
}
public void Initialize()
{
Instance = this;
titleText.SetActive(true);
foreach (var mine in resourceMines)
{
mine.OnResourceMined += AddItemToInventory;
mine.Initialize();
}
}
public void Awake()
{
inventoryManager = this.GetComponent <PlayerInventoryManager>();
miningManager = this.GetComponent <MiningManager>();
if (_instance != null)
{
Debug.LogError("Multiple PlayerManager instances found! Overriding existing instance.");
}
_instance = this;
}
private static async Task <bool> StopMining()
{
await MiningManager.StopAllMiners();
StopComputeDevicesCheckTimer();
StopInternetCheckTimer();
DisplayNoInternetConnection(false); // hide warning
DisplayMiningProfitable(true); // hide warning
return(true);
}
private static void StartMinerStatsCheckTimer()
{
if (_minerStatsCheck?.IsActive ?? false)
{
return;
}
_minerStatsCheck = new AppTimer(async(object sender, ElapsedEventArgs e) =>
{
await MiningManager.MinerStatsCheck();
},
ConfigManager.GeneralConfig.MinerAPIQueryInterval * 1000);
_minerStatsCheck.Start();
}
//public static bool StartDemoMining()
//{
// StopMinerStatsCheckTimer();
// return false;
//}
private static bool StopMining(bool headless)
{
MiningManager.StopAllMiners();
PInvoke.PInvokeHelpers.AllowMonitorPowerdownAndSleep();
StopMinerStatsCheckTimer();
StopComputeDevicesCheckTimer();
StopPreventSleepTimer();
StopInternetCheckTimer();
DisplayNoInternetConnection(false); // hide warning
DisplayMiningProfitable(true); // hide warning
return(true);
}
private static void UpdateDevicesToMine()
{
var allDevs = AvailableDevices.Devices;
var devicesToMine = allDevs.Where(dev => dev.State == DeviceState.Mining).ToList();
if (devicesToMine.Count > 0)
{
StartMining();
MiningManager.UpdateMiningSession(devicesToMine, GetUsername());
}
else
{
StopMining(false);
}
}
internal static async Task <(bool stopped, string failReason)> StopDeviceTask(ComputeDevice device)
{
device.StartState = false;
// we can only stop a device it is mining or benchmarking
switch (device.State)
{
case DeviceState.Stopped:
return(false, $"Device {device.Uuid} already stopped");
case DeviceState.Mining:
case DeviceState.Benchmarking:
await MiningManager.StopDevice(device);
return(true, "");
default:
return(false, $"Cannot handle state {device.State} for device {device.Uuid}");
}
}
private void Start_button_Click(object sender, EventArgs e)
{
Extract_label.Text = "Extracting frequent patterns...";
Extract_label.Refresh();
InitializeConfiguration();
Start_button.Enabled = false;
_managerDataMining.AlgorithmManager.MiningAlgorithms[combo_algoritmo.SelectedIndex].SetMinSup(_managerDataMining.AlgorithmManager.Minsupp);
List <ItemSet> result = _managerDataMining.AlgorithmManager.MiningAlgorithms[combo_algoritmo.SelectedIndex].ExtractFrequentPattern(_transazioniItemset);
_rules.Clear();
_rules = _managerDataMining.GenerateAssociationRuleBase(result, this._transazioniItemset.Count);
_managerDataMining = new MiningManager();
GC.Collect();
GC.WaitForPendingFinalizers();
Show_button.Enabled = true;
this._transazioniItemset = null;
Extract_label.Text = "Patterns extracted";
Extract_label.Refresh();
}
internal static async Task <(bool started, string failReason)> StartDeviceTask(ComputeDevice device)
{
device.StartState = true;
// we can only start a device it is already stopped
if (device.State == DeviceState.Disabled)
{
return(false, "Device is disabled");
}
if (device.State != DeviceState.Stopped && device.State != DeviceState.Error)
{
return(false, "Device already started");
}
var started = true;
var failReason = "";
var allAlgorithmsDisabled = !device.AnyAlgorithmEnabled();
var isAllZeroPayingState = device.AllEnabledAlgorithmsZeroPaying();
// check if device has any benchmakrs
var needBenchmarkOrRebench = device.AnyEnabledAlgorithmsNeedBenchmarking();
if (allAlgorithmsDisabled)
{
device.State = DeviceState.Error;
started = false;
failReason = "Cannot start a device with all disabled algoirhtms";
}
else if (isAllZeroPayingState && !needBenchmarkOrRebench)
{
device.State = DeviceState.Error;
started = false;
failReason = "No enabled algorithm is profitable";
}
else
{
await MiningManager.StartDevice(device);
}
return(started, failReason);
}
private static void DeviceStatus_Tick(object state)
{
var devices = AvailableDevices.Devices;
var deviceList = new List <JArray>();
var activeIDs = MiningManager.GetActiveMinersIndexes();
foreach (var device in devices)
{
try
{
var array = new JArray
{
device.Index,
device.Name
};
var status = Convert.ToInt32(activeIDs.Contains(device.Index)) + ((int)device.DeviceType + 1) * 2;
array.Add(status);
array.Add((int)Math.Round(device.Load));
array.Add((int)Math.Round(device.Temp));
array.Add(device.FanSpeed);
deviceList.Add(array);
}
catch (Exception e) {
NiceHashMinerLegacy.Common.Logger.Error("SOCKET", e.ToString());
}
}
var data = new DeviceStatusMessage
{
devices = deviceList
};
var sendData = JsonConvert.SerializeObject(data);
// This function is run every minute and sends data every run which has two auxiliary effects
// Keeps connection alive and attempts reconnection if internet was dropped
_socket?.SendData(sendData);
}
private async Task Benchmark()
{
bool showFailed = false;
bool startMining = false;
_stopBenchmark = CancellationTokenSource.CreateLinkedTokenSource(ApplicationStateManager.ExitApplication.Token);
try
{
foreach (var a in _algorithms)
{
a.SetBenchmarkPending();
}
var benchAlgos = new Queue <AlgorithmContainer>(_algorithms);
//BenchmarkingHandlers.TryAdd(Device, this);
// whole benchmark scope
var commandTask = GetCommand(_stopBenchmark.Token);
// Until container is not empty
while (benchAlgos.Any() && !_stopBenchmark.IsCancellationRequested)
{
// per algo benchmark scope
bool?benchmarkSuccess = null;
_stopCurrentAlgorithmBenchmark = CancellationTokenSource.CreateLinkedTokenSource(_stopBenchmark.Token);
try
{
var nextAlgo = benchAlgos.Dequeue();
var benchmark = BenchmarkAlgorithm(nextAlgo, _stopCurrentAlgorithmBenchmark.Token);
var firstFinished = await Task.WhenAny(new Task <object>[] { commandTask, benchmark });
var ret = await firstFinished;
if (ret is IReadOnlyList <AlgorithmContainer> updatedAlgorithms)
{
commandTask = GetCommand(_stopBenchmark.Token);
var stop = _algorithms.Except(updatedAlgorithms).Any(algo => algo == nextAlgo);
var restAlgorithms = updatedAlgorithms.Where(algo => algo != nextAlgo).ToArray();
// update Algorithms
_algorithms = restAlgorithms;
foreach (var a in _algorithms)
{
a.SetBenchmarkPending();
}
// updated
benchAlgos = new Queue <AlgorithmContainer>(_algorithms);
if (stop)
{
// THIS Throws
_stopCurrentAlgorithmBenchmark.Cancel();
}
else
{
// wait for the current benchmark to finish
ret = await benchmark;
}
}
if (ret is bool success)
{
benchmarkSuccess = success;
}
// this will drain the container
await Task.Delay(MiningSettings.Instance.MinerRestartDelayMS, _stopCurrentAlgorithmBenchmark.Token);
}
catch (TaskCanceledException e)
{
Logger.Debug("BenchmarkingDevice", $"TaskCanceledException occurred in benchmark task: {e.Message}");
}
catch (Exception e)
{
Logger.Error("BenchmarkingDevice", $"Exception occurred in benchmark task: {e.Message}");
}
finally
{
_stopCurrentAlgorithmBenchmark.Dispose();
if (!_stopCurrentAlgorithmBenchmark.IsCancellationRequested && benchmarkSuccess.HasValue && !benchmarkSuccess.Value)
{
showFailed = true;
}
}
}
startMining = !_stopBenchmark.IsCancellationRequested;
// clear what we didn't benchmark
while (benchAlgos.Any())
{
var nextAlgo = benchAlgos.Dequeue();
nextAlgo.ClearBenchmarkPending();
}
if (showFailed)
{
AvailableNotifications.CreateFailedBenchmarksInfo(Device);
}
}
catch (Exception ex)
{
Logger.Error("BenchmarkingDevice2", $"Exception occurred in benchmark task: {ex.Message}");
}
finally
{
_stopBenchmark.Dispose();
if (startMining)
{
_ = MiningManager.StartDevice(Device); // important do not await
}
else
{
Device.State = DeviceState.Stopped;
}
}
}
public TransactionsController(IRepository <SignedTransaction> transactionsRepository, IHashLibrary hashLibrary, MiningManager miningManager)
{
this.transactionsRepository = transactionsRepository;
this.hashLibrary = hashLibrary;
this.miningManager = miningManager;
}
