public void PoolDataReceived(byte[] data, PoolClient poolClient)
{
Log.Information("Pool {0} sent: {1}", poolClient.poolEndPoint, data.GetString());
lock (_minerManager.MinerManagerLock)
{
foreach (Miner m in _minerManager.GetMinerList())
{
if (m.connection != null)
{
SendToMiner(data, m.connection);
}
}
}
}
private void StartPoolStats()
{
statsTimer = new Timer(poolInstance.poolStatsIntervalInMs);
statsTimer.AutoReset = true;
statsTimer.Elapsed += delegate
{
if (IsPoolConnectionRequired() == false)
{
return;
}
string hashPrint = minerManager.GetCurrentHashrateReadable();
if (hashPrint.Length > 0)
{
hashPrint = "Hashrate: " + hashPrint;
}
TimeSpan time = poolInstance.poolConnectedTime - DateTime.Now;
Log.Information("[{0}] {1} Miners: {2} Shares: {3}/{4}/{5} {6}",
this.poolWorkerName, time.ToString("hh\\:mm"), minerManager.ConnectedMiners,
poolInstance.submittedSharesCount, poolInstance.acceptedSharesCount,
poolInstance.rejectedSharesCount, hashPrint);
lock (minerManager.MinerManagerLock)
{
//Serilog.Log.Information(string.Format("{0, -10} {1, 6} {2, 6} {3, 6} {4, -15}", "MINER", "SUBMIT", "ACCEPT", "REJECT", "HASHRATE"));
//Serilog.Log.Information(string.Format("{0, -10} {1, 6} {2, 6} {3, 6} {4, -15}", "-----", "------", "------", "------", "--------"));
minerManager.GetMinerList().ForEach <Miner>(m => m.PrintShares(poolWorkerName));
}
poolHandler.DoSendHashrate(this);
};
statsTimer.Start();
}
public void PoolDataReceived(byte[] data, PoolClient poolClient)
{
Log.Verbose("Pool {0} sent: {1}", poolClient.poolEndPoint, data.GetString());
string work;
string poolData = data.GetString();
if (poolData.Length <= 1)
{
return;
}
dynamic dyn = JsonConvert.DeserializeObject(poolData.TrimNewLine());
if (Helpers.JsonHelper.DoesJsonObjectExist(dyn.id))
{
switch ((int)dyn.id)
{
case 1:
if (Helpers.JsonHelper.DoesJsonObjectExist(dyn.method))
{
string jsonMethod = dyn.method;
switch (jsonMethod.ToLower())
{
case "job":
work = [email protected] + [email protected]_id + [email protected] + [email protected];
if (_pool.currentPoolTarget != work)
{
Log.Debug("[{0}] sent new target", poolClient.poolWorkerName);
lock (_minerManager.MinerManagerLock)
{
foreach (Miner m in _minerManager.GetMinerList())
{
if (m.connection != null)
{
Log.Debug("Modifying work target ID {0} to ID {1}", (int)dyn.id, m.minerID);
dyn.id = m.minerID;
SendToMiner(JsonConvert.SerializeObject(dyn), m.connection);
}
}
}
_pool.currentPoolTarget = work;
_pool.currentPoolWork = poolData;
}
return;
default:
return;
}
}
else
{
work = dyn.result.job.blob + dyn.result.job.job_id + dyn.result.job.target + dyn.result.job.id;
if (_pool.currentPoolTarget != work)
{
Log.Debug("[{0}] sent new target2", poolClient.poolWorkerName);
lock (_minerManager.MinerManagerLock)
{
foreach (Miner m in _minerManager.GetMinerList())
{
if (m.connection != null)
{
Log.Debug("Modifying work target ID {0} to ID {1}", (int)dyn.id, m.minerID);
dyn.id = m.minerID;
_minerServer.SendToMiner(JsonConvert.SerializeObject(dyn), m.connection);
}
}
}
_pool.currentPoolTarget = work;
_pool.currentPoolWork = poolData;
return;
}
}
break;
default:
Log.Debug("switch defaulted");
break;
}
Log.Verbose("exit3");
if (Helpers.JsonHelper.DoesJsonObjectExist(dyn.result.status))
{
string status = dyn.result.status;
switch (status.ToUpper())
{
case "OK":
Log.Debug("[{0}] returned OK", poolClient.poolWorkerName);
bool result = true;
//result = dyn.result.status == "OK";
Miner miner = _minerManager.GetNextShare(result);
if (miner != null)
{
_minerServer.SendToMiner(poolData, miner.connection);
if (result)
{
_pool.acceptedSharesCount++;
}
else
{
_pool.rejectedSharesCount++;
}
Log.Information("[{0}] {1}'s share was {2}! ({3})", _pool.poolWorkerName, miner.workerIdentifier, result ? "accepted" : "rejected", _minerManager.ResetMinerShareSubmittedTime(miner));
if (!result)
{
Log.Debug("Pool: " + poolData);
}
}
break;
default:
Log.Verbose("result default");
break;
}
}
}
}
public void PoolDataReceived(byte[] data, PoolClient poolClient)
{
//Log.Debug("Pool {0} sent: {1}", poolClient.poolEndPoint, data.GetString());
string work;
string poolData = data.GetString();
dynamic dyn = JsonConvert.DeserializeObject(poolData.TrimNewLine());
if (Helpers.JsonHelper.DoesJsonObjectExist(dyn.id))
{
//This still needs to be converted to dyn.method
switch ((int)dyn.id)
{
case 0:
//new target
try
{
work = dyn.result[0] + dyn.result[1] + dyn.result[2] + dyn.result[3];
}
catch
{
work = dyn.result[0] + dyn.result[1] + dyn.result[2];
}
if (_pool.currentPoolTarget != work)
{
Log.Debug("[{0}] sent new target", poolClient.poolWorkerName);
lock (_minerManager.MinerManagerLock)
{
foreach (Miner m in _minerManager.GetMinerList())
{
//Log.Debug("Modifying getWork ID {0} to ID {1}", (int)dyn.id, m.minerID);
dyn.id = m.minerID;
_minerServer.SendToMiner(JsonConvert.SerializeObject(dyn), m.connection);
}
}
_pool.currentPoolTarget = work;
}
//_minerServer.BroadcastToMiners();
break;
case 1:
case 2:
if (JsonHelper.DoesJsonObjectExist(dyn.error) && !JsonHelper.DoesJsonObjectExist(dyn.result))
{
Log.Fatal("Server error for {0}: {1} {2}", poolClient.poolEndPoint, Convert.ToString(dyn.error.code), Convert.ToString(dyn.error.message));
_pool.Stop();
_minerServer.StopListening();
return;
}
else if (JsonHelper.DoesJsonObjectExist(dyn.result))
{
if (dyn.result == false)
{
Log.Fatal("Server error2 for {0}: {1} {2}", poolClient.poolEndPoint, Convert.ToString(dyn.error.code), Convert.ToString(dyn.error.message));
_pool.Stop();
_minerServer.StopListening();
return;
}
}
Log.Information("[{0}] authorized with {1}!", _pool.poolWorkerName, poolClient.poolEndPoint);
break;
case 5:
case 3:
//Log.Debug("{0} sent new work.", _pool.poolEndPoint);
if (JsonHelper.DoesJsonObjectExist(dyn.error))
{
Log.Fatal("Server error3 for {0}: {1} {2}", poolClient.poolEndPoint, Convert.ToString(dyn.error.code), Convert.ToString(dyn.error.message));
return;
}
try
{
work = dyn.result[0] + dyn.result[1] + dyn.result[2] + dyn.result[3];
}
catch
{
work = dyn.result[0] + dyn.result[1] + dyn.result[2];
}
if (_pool.currentPoolWork != work)
{
Log.Debug("[{0}] sent new work", poolClient.poolWorkerName);
_pool.ClearSubmittedSharesHistory();
lock (_minerManager.MinerManagerLock)
{
foreach (Miner m in _minerManager.GetMinerList())
{
//Log.Debug("Modifying getWork ID {0} to ID {1} for {3}", (int)dyn.id, m.minerID, m.workerIdentifier);
dyn.id = m.minerID;
_minerServer.SendToMiner(JsonConvert.SerializeObject(dyn), m.connection);
}
}
_pool.currentPoolWork = work;
_pool.currentPoolWorkDynamic = dyn;
}
break;
case int i when(i >= 7 && i != 999):
case 4:
bool result = false;
if (JsonHelper.DoesJsonObjectExist(dyn.result))
{
result = dyn.result;
}
Miner miner = _minerManager.GetNextShare(result);
if (miner != null)
{
_minerServer.SendToMiner(poolData, miner.connection);
if (result)
{
_pool.acceptedSharesCount++;
}
else
{
_pool.rejectedSharesCount++;
}
Log.Information("[{0}] {1}'s share was {2}! ({3})", _pool.poolWorkerName, miner.workerIdentifier, result ? "accepted" : "rejected", _minerManager.ResetMinerShareSubmittedTime(miner));
if (!result)
{
Log.Debug("Pool: " + poolData);
}
}
break;
case 6:
Log.Verbose("Hashrate accepted by {0}", poolClient.poolEndPoint);
//_minerServer.BroadcastToMiners(s);
break;
case 999:
if (JsonHelper.DoesJsonObjectExist(dyn.error) && !JsonHelper.DoesJsonObjectExist(dyn.result))
{
Log.Fatal("Server error for {0}: {1}", poolClient.poolEndPoint, Convert.ToString(dyn.error));
_pool.Stop();
_minerServer.StopListening();
return;
}
else if (JsonHelper.DoesJsonObjectExist(dyn.result))
{
if (dyn.result == false) //no dyn.error.code
{
Log.Fatal("Server error2 for {0}: {1}", poolClient.poolEndPoint, Convert.ToString(dyn.error));
_pool.Stop();
_minerServer.StopListening();
return;
}
}
break;
default:
Log.Warning("EthPoolHandler Unhandled: {0}", poolData);
break;
}
} /* else if (dyn.error != null && dyn.result == null)
* {
* Log.Error("Server sent Error: " + dyn.error.code + ": " + dyn.error.message);
* }
*/
}
