static public async Task Start(string address, CancellationToken token)
{
var random = new Random();
_address = address;
NHLog.Info("NHWebSocket-WD", "Starting nhmws watchdog");
NHSmaData.InitializeIfNeeded();
// TODO use this or just use the application exit source
while (!token.IsCancellationRequested)
{
try
{
await NewConnection(token);
}
catch (Exception e)
{
NHLog.Error("NHWebSocket-WD", $"Error occured: {e.Message}");
}
// if we didn't initialize the restart delay reconnect
if (!_isNhmwsRestart && !token.IsCancellationRequested)
{
// delays re-connect 10 to 30 seconds
var delaySeconds = 10 + random.Next(0, 20);
NHLog.Info("NHWebSocket-WD", $"Attempting reconnect in {delaySeconds} seconds");
await Task.Delay(delaySeconds * 1000, token);
}
else if (_isNhmwsRestart && !token.IsCancellationRequested)
{
NHLog.Info("NHWebSocket-WD", $"Restarting nhmws SESSION");
}
}
NHLog.Info("NHWebSocket-WD", "Ending nhmws watchdog");
}
// TODO this has nothing to do with Mian_Form
private async void IdleCheck(object sender, IdleChangedEventArgs e)
{
if (!ConfigManager.GeneralConfig.StartMiningWhenIdle || _isManuallyStarted)
{
return;
}
// TODO set is mining here
if (MiningState.Instance.IsCurrentlyMining)
{
if (!e.IsIdle)
{
await ApplicationStateManager.StopAllDevice();
Logger.Info("NICEHASH", "Resumed from idling");
}
}
else if (ApplicationStateManager.CurrentForm == ApplicationStateManager.CurrentFormState.Main && e.IsIdle)
{
Logger.Info("NICEHASH", "Entering idling state");
if (StartMining(false) != StartMiningReturnType.StartMining)
{
await ApplicationStateManager.StopAllDevice();
}
}
}
// TODO copy pasted crap from NiceHashStats
#region NonRpcMessages
#region SMA
private static void SetAlgorithmRates(JArray data)
{
try
{
var payingDict = new Dictionary <AlgorithmType, double>();
if (data != null)
{
foreach (var algo in data)
{
var algoKey = (AlgorithmType)algo[0].Value <int>();
payingDict[algoKey] = algo[1].Value <double>();
}
}
NHSmaData.UpdateSmaPaying(payingDict);
// TODO new check crap
foreach (var dev in AvailableDevices.Devices)
{
dev.UpdateEstimatePaying(payingDict);
}
}
catch (Exception e)
{
NHLog.Error("NHWebSocket", $"SetAlgorithmRates error: {e.Message}");
}
}
private static Task SetExchangeRates(string origdata)
{
try
{
dynamic message = JsonConvert.DeserializeObject(origdata);
string data = message.data.Value;
var exchange = JsonConvert.DeserializeObject <ExchangeRateJson>(data);
if (exchange?.exchanges_fiat == null || exchange.exchanges == null)
{
return(Task.CompletedTask);
}
double usdBtcRate = -1;
foreach (var exchangePair in exchange.exchanges)
{
if (!exchangePair.TryGetValue("coin", out var coin) || coin != "BTC" ||
!exchangePair.TryGetValue("USD", out var usd) ||
!double.TryParse(usd, NumberStyles.Float, CultureInfo.InvariantCulture, out var usdD))
{
continue;
}
usdBtcRate = usdD;
break;
}
BalanceAndExchangeRates.Instance.UpdateExchangesFiat(usdBtcRate, exchange.exchanges_fiat);
}
catch (Exception e)
{
NHLog.Error("NHWebSocket", $"SetExchangeRates error: {e.Message}");
}
return(Task.CompletedTask);
}
private static Task HandleMarkets(string data)
{
try
{
}
catch (Exception e)
{
NHLog.Error("NHWebSocket", $"HandleMarkets error: {e.Message}");
}
return(Task.CompletedTask);
}
private static Task HandleBurn(string data)
{
try
{
dynamic message = JsonConvert.DeserializeObject(data);
ApplicationStateManager.Burn(message.message.Value);
}
catch (Exception e)
{
NHLog.Error("NHWebSocket", $"SetBalance error: {e.Message}");
}
return(Task.Delay(0));
}
private void UpdateExchange(object sender, EventArgs e)
{
FormHelpers.SafeInvoke(this, () =>
{
var br = ExchangeRateApi.GetUsdExchangeRate();
var currencyRate = Tr("N/A");
if (br > 0)
{
currencyRate = ExchangeRateApi.ConvertToActiveCurrency(br).ToString("F2");
}
toolTip1.SetToolTip(statusStrip1, $"1 BTC = {currencyRate} {ExchangeRateApi.ActiveDisplayCurrency}");
Logger.Info("NICEHASH", $"Current Bitcoin rate: {br.ToString("F2", CultureInfo.InvariantCulture)}");
});
}
private static Task SetBalance(string data)
{
try
{
dynamic message = JsonConvert.DeserializeObject(data);
string balance = message.value.Value;
if (double.TryParse(balance, NumberStyles.Float, CultureInfo.InvariantCulture, out var bal))
{
ApplicationStateManager.OnBalanceUpdate(bal);
}
}
catch (Exception e)
{
NHLog.Error("NHWebSocket", $"SetBalance error: {e.Message}");
}
return(Task.Delay(0));
}
private static Task SetBalance(string data)
{
try
{
dynamic message = JsonConvert.DeserializeObject(data);
string balance = message.value.Value;
if (double.TryParse(balance, NumberStyles.Float, CultureInfo.InvariantCulture, out var btcBalance))
{
BalanceAndExchangeRates.Instance.BtcBalance = btcBalance;
}
}
catch (Exception e)
{
NHLog.Error("NHWebSocket", $"SetBalance error: {e.Message}");
}
return(Task.CompletedTask);
}
static public async Task Start(string address, CancellationToken token)
{
try
{
var random = new Random();
_address = address;
NHLog.Info("NHWebSocket-WD", "Starting nhmws watchdog");
// TODO use this or just use the application exit source
while (!token.IsCancellationRequested)
{
try
{
await NewConnection(token);
// after each connection is completed check if we should re-connect or exit the watchdog
// if we didn't initialize the restart delay reconnect
if (!_isNhmwsRestart && !token.IsCancellationRequested)
{
// delays re-connect 10 to 30 seconds
var delaySeconds = 10 + random.Next(0, 20);
NHLog.Info("NHWebSocket-WD", $"Attempting reconnect in {delaySeconds} seconds");
await TaskHelpers.TryDelay(TimeSpan.FromSeconds(delaySeconds), token);
}
else if (_isNhmwsRestart && !token.IsCancellationRequested)
{
NHLog.Info("NHWebSocket-WD", $"Restarting nhmws SESSION");
}
}
catch (TaskCanceledException e)
{
NHLog.Debug("NHWebSocket-WD", $"TaskCanceledException {e.Message}");
return;
}
catch (Exception e)
{
NHLog.Error("NHWebSocket-WD", $"Error occured: {e.Message}");
}
}
}
finally
{
NHLog.Info("NHWebSocket-WD", "Ending nhmws watchdog");
}
}
private static Task HandleMarkets(string data)
{
try
{
var markets = JsonConvert.DeserializeObject <MarketsMessage>(data);
#if !DEBUG_MARKETS
StratumService.Instance.SetEnabledMarkets(markets.data);
#else
changeDebugMarkets();
StratumService.Instance.SetEnabledMarkets(debugEU, debugUSA);
#endif
}
catch (Exception e)
{
NHLog.Error("NHWebSocket", $"HandleMarkets error: {e.Message}");
}
return(Task.CompletedTask);
}
private static Task HandleMarkets(string data)
{
try
{
var markets = JsonConvert.DeserializeObject <MarketsMessage>(data);
var hasEU = markets.data.Contains("EU");
var hasUSA = markets.data.Contains("USA");
#if !DEBUG_MARKETS
StratumService.SetEnabled(hasEU, hasUSA);
#else
changeDebugMarkets();
StratumService.SetEnabled(debugEU, debugUSA);
#endif
}
catch (Exception e)
{
NHLog.Error("NHWebSocket", $"HandleMarkets error: {e.Message}");
}
return(Task.Delay(0));
}
static private void Login(object sender, EventArgs e)
{
NHLog.Info("NHWebSocket", "Connected");
try
{
// always send login
var loginJson = JsonConvert.SerializeObject(_login);
var sendMessages = new List <NHSendMessage> {
new NHSendMessage(MessageType.SEND_MESSAGE, loginJson)
};
if (CredentialValidators.ValidateBitcoinAddress(_login.btc))
{
var minerStatusJsonStr = CreateMinerStatusMessage(true);
sendMessages.Add(new NHSendMessage(MessageType.SEND_MESSAGE_STATUS, minerStatusJsonStr));
}
_sendQueue.Enqueue(sendMessages);
}
catch (Exception er)
{
NHLog.Info("NHWebSocket", er.Message);
}
}
static private async Task HandleMessage(MessageEventArgs e)
{
try
{
if (e.IsText)
{
NHLog.Info("NHWebSocket", $"Received: {e.Data}");
var method = GetMethod(e.Data);
if (IsRpcMethod(method))
{
await HandleRpcMessage(method, e.Data);
}
else
{
await HandleNonRpcMessage(method, e.Data);
}
}
}
catch (Exception ex)
{
NHLog.Error("NHWebSocket", $"HandleMessage {ex.Message}");
}
}
private static Task SetExchangeRates(string origdata)
{
var completed = Task.Delay(0);
try
{
dynamic message = JsonConvert.DeserializeObject(origdata);
string data = message.data.Value;
var exchange = JsonConvert.DeserializeObject <ExchangeRateJson>(data);
if (exchange?.exchanges_fiat == null || exchange.exchanges == null)
{
return(completed);
}
foreach (var exchangePair in exchange.exchanges)
{
if (!exchangePair.TryGetValue("coin", out var coin) || coin != "BTC" ||
!exchangePair.TryGetValue("USD", out var usd) ||
!double.TryParse(usd, NumberStyles.Float, CultureInfo.InvariantCulture, out var usdD))
{
continue;
}
ExchangeRateApi.UsdBtcRate = usdD;
break;
}
ExchangeRateApi.UpdateExchangesFiat(exchange.exchanges_fiat);
// TODO check where and why we have this
ApplicationStateManager.OnExchangeUpdated();
}
catch (Exception e)
{
NHLog.Error("NHWebSocket", $"SetExchangeRates error: {e.Message}");
}
return(completed);
}
// TODO this thing needs to be completely removed
// TODO this will be moved outside of GUI code, replace textBoxBTCAddress.Text with ConfigManager.GeneralConfig.BitcoinAddress
private StartMiningReturnType StartMining(bool showWarnings)
{
//if (ConfigManager.GeneralConfig.BitcoinAddress.Equals(""))
//{
// if (showWarnings)
// {
// var result = MessageBox.Show(Tr("You have not entered a bitcoin address. {0} will start mining in DEMO mode. In the DEMO mode, you can test run the miner and be able see how much you can earn using your computer. Would you like to continue in DEMO mode?\n\nDISCLAIMER: YOU WILL NOT EARN ANYTHING DURING DEMO MODE!"),
// Tr("Start mining in DEMO mode?"),
// MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
// if (result == DialogResult.Yes)
// {
// _demoMode = true;
// //labelDemoMode.Visible = true;
// }
// else
// {
// return StartMiningReturnType.IgnoreMsg;
// }
// }
// else
// {
// return StartMiningReturnType.IgnoreMsg;
// }
//}
////else if (!VerifyMiningAddress(true)) return StartMiningReturnType.IgnoreMsg; // TODO this whole shitty thing
var hasData = NHSmaData.HasData;
if (!showWarnings)
{
for (var i = 0; i < 10; i++)
{
if (hasData)
{
break;
}
Thread.Sleep(1000);
hasData = NHSmaData.HasData;
Logger.Info("NICEHASH", $"After {i}s has data: {hasData}");
}
}
if (!hasData)
{
Logger.Debug("NICEHASH", "No data received within timeout");
if (showWarnings)
{
MessageBox.Show(Tr("Unable to get NiceHash profitability data. If you are connected to internet, try again later."),
Tr("Error!"),
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(StartMiningReturnType.IgnoreMsg);
}
var isMining = true;
ApplicationStateManager.StartAllAvailableDevices();
return(isMining ? StartMiningReturnType.StartMining : StartMiningReturnType.ShowNoMining);
}
static private async Task HandleRpcMessage(string method, string data)
{
string btc = null;
string worker = null;
string group = null;
int rpcId = -1;
bool executed = false;
bool loginNeeded = false;
ExecutedCall executedCall = null;
try
{
_isInRPC.Value = true;
dynamic message = JsonConvert.DeserializeObject(data);
int? rpcIdOption = (int?)message.id;
rpcId = rpcIdOption ?? -1;
ThrowIfWeCannotHanldeRPC();
switch (method)
{
case "mining.set.username":
btc = (string)message.username;
executed = await miningSetUsername(btc);
loginNeeded = executed;
break;
case "mining.set.worker":
worker = (string)message.worker;
executed = miningSetWorker(worker);
loginNeeded = executed;
break;
case "mining.set.group":
group = (string)message.group;
executed = miningSetGroup(group);
loginNeeded = executed;
break;
case "mining.enable":
executed = await SetDevicesEnabled((string)message.device, true);
break;
case "mining.disable":
executed = await SetDevicesEnabled((string)message.device, false);
break;
case "mining.start":
executed = await StartMining((string)message.device);
break;
case "mining.stop":
executed = await StopMining((string)message.device);
break;
case "mining.set.power_mode":
// TODO not supported atm
SetPowerMode((string)message.device, (TDPSimpleType)message.power_mode);
break;
case "miner.reset":
MinerReset((string)message.level);
break;
default:
throw new RpcException($"RpcMessage operation not supported for method '{method}'", ErrorCode.UnableToHandleRpc);
}
executedCall = new ExecutedCall(rpcId, 0, null);
}
catch (RpcException rpcEx)
{
executedCall = new ExecutedCall(rpcId, rpcEx.Code, rpcEx.Message);
}
catch (Exception e)
{
NHLog.Error("NHWebSocket", $"Non RpcException - error: {e.Message}");
// intenral nhm error
if (executedCall == null)
{
executedCall = new ExecutedCall(rpcId, 1, "Internal NiceHash Miner Error");
}
}
finally
{
_isInRPC.Value = false;
if (executedCall != null)
{
// send miner status and send executed
var minerStatusMsg = CreateMinerStatusMessage();
Send(minerStatusMsg);
_lastSendMinerStatusTimestamp.Value = DateTime.UtcNow;
// Then executed
var rpcMessage = executedCall.Serialize();
Send(rpcMessage);
// Login if we have to
if (loginNeeded)
{
SetCredentials(btc, worker, group);
}
}
}
}
// TODO add cancelation token
static private async Task NewConnection(CancellationToken stop)
{
NHLog.Info("NHWebSocket", "STARTING nhmws SESSION");
try
{
// TODO if we fill the Queue before this we should start fresh afterwards
// TODO think if we might want to dump prev data????
// on each new connection clear the ConcurrentQueues,
_recieveQueue = new ConcurrentQueue <MessageEventArgs>();
_sendQueue = new ConcurrentQueue <IEnumerable <NHSendMessage> >();
_isNhmwsRestart = false;
_notifyMinerStatusAfter.Value = null;
NHLog.Info("NHWebSocket", "Creating socket");
using (_webSocket = new WebSocket(_address, true))
{
//stop.Register(() => _webSocket.Close(CloseStatusCode.Normal, "Closing CancellationToken"));
_webSocket.OnOpen += Login;
_webSocket.OnMessage += (s, eMsg) => _recieveQueue.Enqueue(eMsg);
_webSocket.OnError += (s, e) => NHLog.Info("NHWebSocket", $"Error occured: {e.Message}");
_webSocket.OnClose += (s, e) => NHLog.Info("NHWebSocket", $"Connection closed code {e.Code}: {e.Reason}");;
_webSocket.Log.Level = LogLevel.Debug;
_webSocket.Log.Output = (data, s) => NHLog.Info("NHWebSocket", data.ToString());
_webSocket.EnableRedirection = true;
NHLog.Info("NHWebSocket", "Connecting");
_webSocket.Connect();
const int minerStatusTickSeconds = 45;
var checkWaitTime = TimeSpan.FromMilliseconds(50);
var skipMinerStatus = !CredentialValidators.ValidateBitcoinAddress(_login.btc);
NHLog.Info("NHWebSocket", "Starting Loop");
while (IsWsAlive && !stop.IsCancellationRequested)
{
if (IsWsAlive)
{
HandleSendMessage();
}
if (IsWsAlive)
{
await HandleReceiveMessage();
}
// TODO add here the last miner status send check
if (IsWsAlive)
{
await Task.Delay(checkWaitTime); // TODO add cancelation token here
}
if (skipMinerStatus)
{
continue;
}
var elapsedTime = DateTime.UtcNow - _lastSendMinerStatusTimestamp.Value;
if (elapsedTime.TotalSeconds > minerStatusTickSeconds)
{
var minerStatusJsonStr = CreateMinerStatusMessage();
var minerStatus = new NHSendMessage(MessageType.SEND_MESSAGE_STATUS, minerStatusJsonStr);
_sendQueue.Enqueue(new NHSendMessage[1] {
minerStatus
});
}
if (_notifyMinerStatusAfter.Value.HasValue && DateTime.UtcNow >= _notifyMinerStatusAfter.Value.Value)
{
_notifyMinerStatusAfter.Value = null;
var minerStatusJsonStr = CreateMinerStatusMessage();
var minerStatus = new NHSendMessage(MessageType.SEND_MESSAGE_STATUS, minerStatusJsonStr);
_sendQueue.Enqueue(new NHSendMessage[1] {
minerStatus
});
}
}
// Ws closed
NHLog.Info("NHWebSocket", "Exited Loop");
}
}
finally
{
NHLog.Info("NHWebSocket", "ENDING nhmws SESSION");
}
}
private static void Send(string data)
{
NHLog.Info("NHWebSocket", $"Sending data: {data}");
_webSocket?.Send(data);
}
private static string CreateMinerStatusMessage(bool sendDeviceNames = false)
{
var devices = AvailableDevices.Devices;
var rigStatus = ApplicationStateManager.CalcRigStatusString();
var paramList = new List <JToken>
{
rigStatus
};
var deviceList = new JArray();
foreach (var device in devices)
{
try
{
var array = new JArray
{
sendDeviceNames?device.Name : "",
device.B64Uuid // TODO
};
var status = DeviceReportStatus(device.DeviceType, device.State);
array.Add(status);
array.Add((int)Math.Round(device.Load));
var speedsJson = new JArray();
var speeds = MiningStats.GetSpeedForDevice(device.Uuid);
if (speeds != null && device.State == DeviceState.Mining)
{
foreach (var kvp in speeds)
{
speedsJson.Add(new JArray((int)kvp.type, kvp.speed));
}
}
array.Add(speedsJson);
// Hardware monitoring
array.Add((int)Math.Round(device.Temp));
array.Add(device.FanSpeed);
array.Add((int)Math.Round(device.PowerUsage));
// Power mode
array.Add((int)device.TDPSimple);
// Intensity mode
array.Add(0);
deviceList.Add(array);
}
catch (Exception e)
{
NHLog.Error("NHWebSocket", e.Message);
}
}
paramList.Add(deviceList);
var data = new MinerStatusMessage
{
param = paramList
};
var sendData = JsonConvert.SerializeObject(data);
return(sendData);
}
