void RPCMinerClient::Run(const std::string &url, const std::string &user, const std::string &password, const int threadcount)
{
m_running=true;
m_done=false;
m_url=url;
m_user=user;
m_password=password;
m_threadcount=threadcount;
int64 lastrequestedwork=GetTimeMillis()-5000;
int64 laststats=GetTimeMillis()-25000;
m_lasttarget=0;
m_lasthashdisplay=GetTimeMillis();
int64 timenowmillis;
static unsigned int counter=0u;
std::cout << "Client will start " << m_threadcount << " miner threads" << std::endl;
std::cout << "Work will be refreshed every " << m_workrefreshms << " ms" << std::endl;
while(Done()==false && HasError() == false)
{
if(m_minerthreads.RunningThreadCount()<m_threadcount)
{
int nextDeviceIndex = m_minerthreads.LastDeviceIndex() + 1;
m_minerthreads.Start(new threadtype(nextDeviceIndex));
}
/* if(lastrequestedwork<=GetTimeMillis()-m_workrefreshms)
{
SendWorkRequest();
lastrequestedwork=GetTimeMillis();
}
*/
if(m_serverstatsurl!="" && laststats<=GetTimeMillis()-60000)
{
json_spirit::Object statsobj;
if(GetServerStats(statsobj))
{
PrintServerStats(statsobj);
}
laststats=GetTimeMillis();
}
if(m_minerthreads.HaveFoundHash())
{
std::cout << GetTimeStr(time(0)) << " Found Hash!" << std::endl;
foundhash fhash;
m_minerthreads.GetFoundHash(fhash);
++counter;
std::cout<<"Hashs found: "<<counter<<std::endl;
SendFoundHash(fhash.m_blockid,fhash.m_nonce);
SendWorkRequest();
lastrequestedwork=GetTimeMillis();
}
CleanupOldBlocks();
if(lastrequestedwork<=GetTimeMillis()-m_workrefreshms)
{
SendWorkRequest();
lastrequestedwork=GetTimeMillis();
}
timenowmillis=GetTimeMillis();
if(m_hashraterefresh>0 && (m_lasthashdisplay+m_hashraterefresh)<=timenowmillis)
{
int64 hr=GetHashRate(true);
if(m_blocklookup.size()>0)
{
std::cout << hr << " khash/s" << std::endl;
}
else
{
if(m_startuptime+30000<timenowmillis)
{
std::cout << "No blocks are being hashed right now. This can happen if the application is" << std::endl;
std::cout << "still starting up, you supplied incorrect parameters, or there is a" << std::endl;
std::cout << "communications error connecting to the RPC server." << std::endl;
m_minerthreads.ClearWork();
}
}
}
Sleep(10);
}
m_running=false;
}
void RemoteMinerClient::Run(const std::string &server, const std::string &port, const std::string &password, const std::string &address, const int threadcount)
{
int64 lastrequestedwork=GetTimeMillis();
//debug
int64 starttime=0;
int64 hashcount=0;
int64 lastdisplay=0;
std::cout << "Client will start " << threadcount << " miner threads" << std::endl;
while(true)
{
if(IsConnected()==false)
{
m_minerthreads.Stop();
std::cout << "Attempting to connect to " << server << ":" << port << std::endl;
Sleep(1000);
if(Connect(server,port))
{
m_minerthreads.Start(new threadtype);
m_gotserverhello=false;
std::cout << "Connected to " << server << ":" << port << std::endl;
SendClientHello(password,address);
lastrequestedwork=GetTimeMillis();
//debug
starttime=GetTimeMillis();
}
}
else
{
Update();
while(MessageReady() && !ProtocolError())
{
RemoteMinerMessage message;
if(ReceiveMessage(message))
{
if(message.GetValue().type()==json_spirit::obj_type)
{
HandleMessage(message);
}
else
{
std::cout << "Unexpected json type sent by server. Disconnecting." << std::endl;
Disconnect();
}
}
}
if(ProtocolError())
{
std::cout << "Protocol error. Disconnecting." << std::endl;
Disconnect();
}
if(m_minerthreads.RunningThreadCount()<threadcount)
{
m_minerthreads.Start(new threadtype);
}
if(m_minerthreads.HaveFoundHash())
{
std::cout << "Found Hash!" << std::endl;
RemoteMinerThread::foundhash fhash;
m_minerthreads.GetFoundHash(fhash);
SendFoundHash(fhash.m_blockid,fhash.m_nonce);
SendWorkRequest();
}
while(m_minerthreads.HaveHashResult())
{
RemoteMinerThread::hashresult hresult;
m_minerthreads.GetHashResult(hresult);
SendMetaHash(hresult.m_blockid,hresult.m_metahashstartnonce,hresult.m_metahashdigest,hresult.m_besthash,hresult.m_besthashnonce);
//debug
//std::cout << "sent result " << hresult.m_blockid << " " << hresult.m_metahashstartnonce << " " << hresult.m_besthashnonce << std::endl;
hashcount+=m_metahashsize;
if(hresult.m_metahashstartnonce>4000000000 && (lastrequestedwork+5000)<GetTimeMillis())
{
std::cout << "Requesting a new block " << GetTimeMillis() << std::endl;
SendWorkRequest();
lastrequestedwork=GetTimeMillis();
}
}
if(m_minerthreads.NeedWork())
{
if((lastrequestedwork+6000)<GetTimeMillis())
{
std::cout << "Requesting a new block " << GetTimeMillis() << std::endl;
SendWorkRequest();
lastrequestedwork=GetTimeMillis();
}
}
//debug
if(lastdisplay+10000<=GetTimeMillis())
{
if(((GetTimeMillis()-starttime)/1000)>0)
{
//std::cout << hashcount/((GetTimeMillis()-starttime)/1000) << std::endl;
//std::cout << "sendsize=" << m_sendbuffer.size() << std::endl;
lastdisplay=GetTimeMillis();
}
}
}
}
}
