Skip to content

Commit

Permalink
baish mircohttpd integration
Browse files Browse the repository at this point in the history
  • Loading branch information
fireice-uk committed Jan 15, 2017
1 parent 3025fe1 commit 2033ed3
Show file tree
Hide file tree
Showing 7 changed files with 3,118 additions and 42 deletions.
7 changes: 7 additions & 0 deletions cli-miner.cpp
Expand Up @@ -18,6 +18,7 @@
#include "jconf.h"
#include "console.h"
#include "donate-level.h"
#include "httpd.h"

#include <stdlib.h>
#include <stdio.h>
Expand Down Expand Up @@ -69,6 +70,12 @@ int main(int argc, char *argv[])
return 0;
}

if (!httpd::inst()->start_daemon())
{
win_exit();
return 0;
}

printer::inst()->print_str("-------------------------------------------------------------------\n");
printer::inst()->print_str("XMR-Stak-CPU mining software, CPU Version.\n");
printer::inst()->print_str("Based on CPU mining code by wolf9466 (heavily optimized by myself).\n");
Expand Down
133 changes: 95 additions & 38 deletions executor.cpp
Expand Up @@ -414,19 +414,19 @@ void executor::ex_main()
break;

case EV_USR_HASHRATE:
hashrate_report();
break;

case EV_USR_RESULTS:
result_report();
case EV_USR_CONNSTAT:
print_report(ev.iName);
break;

case EV_USR_CONNSTAT:
connection_report();
case EV_HTML_HASHRATE:
case EV_HTML_RESULTS:
case EV_HTML_CONNSTAT:
http_report(ev.iName);
break;

case EV_HASHRATE_LOOP:
hashrate_report();
print_report(EV_USR_HASHRATE);
push_timed_event(ex_event(EV_HASHRATE_LOOP), jconf::inst()->GetAutohashTime());
break;

Expand All @@ -451,23 +451,22 @@ inline const char* hps_format(double h, char* buf, size_t l)
return " (na)";
}

void executor::hashrate_report()
void executor::hashrate_report(std::string& out)
{
std::string output;
char num[32];
size_t nthd = pvThreads->size();

output.reserve(256 + nthd * 64);
out.reserve(256 + nthd * 64);

double fTotal[3] = { 0.0, 0.0, 0.0};
size_t i;

output.append("HASHRATE REPORT\n");
output.append("| ID | 2.5s | 60s | 15m |");
out.append("HASHRATE REPORT\n");
out.append("| ID | 2.5s | 60s | 15m |");
if(nthd != 1)
output.append(" ID | 2.5s | 60s | 15m |\n");
out.append(" ID | 2.5s | 60s | 15m |\n");
else
output.append(1, '\n');
out.append(1, '\n');

for (i = 0; i < nthd; i++)
{
Expand All @@ -478,36 +477,34 @@ void executor::hashrate_report()
fHps[2] = telem->calc_telemetry_data(900000, i);

snprintf(num, sizeof(num), "| %2u |", (unsigned int)i);
output.append(num);
output.append(hps_format(fHps[0], num, sizeof(num))).append(" |");
output.append(hps_format(fHps[1], num, sizeof(num))).append(" |");
output.append(hps_format(fHps[2], num, sizeof(num))).append(1, ' ');
out.append(num);
out.append(hps_format(fHps[0], num, sizeof(num))).append(" |");
out.append(hps_format(fHps[1], num, sizeof(num))).append(" |");
out.append(hps_format(fHps[2], num, sizeof(num))).append(1, ' ');

fTotal[0] += fHps[0];
fTotal[1] += fHps[1];
fTotal[2] += fHps[2];

if((i & 0x1) == 1) //Odd i's
output.append("|\n");
out.append("|\n");
}

if((i & 0x1) == 1) //We had odd number of threads
output.append("|\n");
out.append("|\n");

if(nthd != 1)
output.append("-----------------------------------------------------\n");
out.append("-----------------------------------------------------\n");
else
output.append("---------------------------\n");

output.append("Totals: ");
output.append(hps_format(fTotal[0], num, sizeof(num)));
output.append(hps_format(fTotal[1], num, sizeof(num)));
output.append(hps_format(fTotal[2], num, sizeof(num)));
output.append(" H/s\nHighest: ");
output.append(hps_format(fHighestHps, num, sizeof(num)));
output.append(" H/s\n");

printer::inst()->print_str(output.c_str());
out.append("---------------------------\n");

out.append("Totals: ");
out.append(hps_format(fTotal[0], num, sizeof(num)));
out.append(hps_format(fTotal[1], num, sizeof(num)));
out.append(hps_format(fTotal[2], num, sizeof(num)));
out.append(" H/s\nHighest: ");
out.append(hps_format(fHighestHps, num, sizeof(num)));
out.append(" H/s\n");
}

char* time_format(char* buf, size_t len, std::chrono::system_clock::time_point time)
Expand All @@ -531,12 +528,11 @@ char* time_format(char* buf, size_t len, std::chrono::system_clock::time_point t
return buf;
}

void executor::result_report()
void executor::result_report(std::string& out)
{
char num[128];
char date[32];

std::string out;
out.reserve(1024);

size_t iGoodRes = vMineResults[0].count, iTotalRes = iGoodRes;
Expand Down Expand Up @@ -594,16 +590,13 @@ void executor::result_report()
}
else
out.append("Yay! No errors.\n");

printer::inst()->print_str(out.c_str());
}

void executor::connection_report()
void executor::connection_report(std::string& out)
{
char num[128];
char date[32];

std::string out;
out.reserve(512);

jpsock* pool = pick_pool_by_id(dev_pool_id + 1);
Expand Down Expand Up @@ -638,6 +631,70 @@ void executor::connection_report()
}
else
out.append("Yay! No errors.\n");
}

void executor::print_report(ex_event_name ev)
{
std::string out;
switch(ev)
{
case EV_USR_HASHRATE:
hashrate_report(out);
break;

case EV_USR_RESULTS:
result_report(out);
break;

case EV_USR_CONNSTAT:
connection_report(out);
break;
default:
assert(false);
break;
}

printer::inst()->print_str(out.c_str());
}

void executor::http_report(ex_event_name ev)
{
assert(pHttpString != nullptr);

switch(ev)
{
case EV_HTML_HASHRATE:
hashrate_report(*pHttpString);
break;

case EV_HTML_RESULTS:
result_report(*pHttpString);
break;

case EV_HTML_CONNSTAT:
connection_report(*pHttpString);
break;
default:
assert(false);
break;
}

httpReady.set_value();
}

void executor::get_http_report(ex_event_name ev_id, std::string& data)
{
std::lock_guard<std::mutex> lck(httpMutex);

assert(pHttpString == nullptr);
assert(ev_id == EV_HTML_HASHRATE || ev_id == EV_HTML_RESULTS || ev_id == EV_HTML_CONNSTAT);

pHttpString = &data;
httpReady = std::promise<void>();
std::future<void> ready = httpReady.get_future();

push_event(ex_event(ev_id));

ready.wait();
pHttpString = nullptr;
}
16 changes: 13 additions & 3 deletions executor.h
Expand Up @@ -4,6 +4,7 @@
#include <atomic>
#include <array>
#include <list>
#include <future>

class jpsock;
class minethd;
Expand All @@ -21,6 +22,8 @@ class executor
void ex_start() { my_thd = new std::thread(&executor::ex_main, this); }
void ex_main();

void get_http_report(ex_event_name ev_id, std::string& data);

inline void push_event(ex_event&& ev) { oEventQ.push(std::move(ev)); }
void push_timed_event(ex_event&& ev, size_t sec);

Expand Down Expand Up @@ -69,9 +72,16 @@ class executor
void ex_clock_thd();
void pool_connect(jpsock* pool);

void hashrate_report();
void result_report();
void connection_report();
void hashrate_report(std::string& out);
void result_report(std::string& out);
void connection_report(std::string& out);

void http_report(ex_event_name ev);
void print_report(ex_event_name ev);

std::string* pHttpString = nullptr;
std::promise<void> httpReady;
std::mutex httpMutex;

struct sck_error_log
{
Expand Down
96 changes: 96 additions & 0 deletions httpd.cpp
@@ -0,0 +1,96 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <string>

#include "msgstruct.h"
#include "httpd.h"
#include "console.h"
#include "executor.h"

#ifdef _WIN32
#include "libmicrohttpd/microhttpd.h"
#define strcasecmp _stricmp
#else
#include <microhttpd.h>
#endif // _WIN32

httpd* httpd::oInst = nullptr;

httpd::httpd()
{

}

int httpd::req_handler(void * cls,
MHD_Connection* connection,
const char* url,
const char* method,
const char* version,
const char* upload_data,
size_t* upload_data_size,
void ** ptr)
{
struct MHD_Response * rsp;

if (strcmp(method, "GET") != 0)
return MHD_NO;

*ptr = nullptr;

std::string str;
if(strcasecmp(url, "/h") == 0 || strcasecmp(url, "/hashrate") == 0)
{
str.append("<html><head><title>Hashrate Report</title></head><body><pre>");
executor::inst()->get_http_report(EV_HTML_HASHRATE, str);
str.append("</pre></body></html>");

rsp = MHD_create_response_from_buffer(str.size(), (void*)str.c_str(), MHD_RESPMEM_MUST_COPY);
}
else if(strcasecmp(url, "/c") == 0 || strcasecmp(url, "/connection") == 0)
{
str.append("<html><head><title>Connection Report</title></head><body><pre>");
executor::inst()->get_http_report(EV_HTML_CONNSTAT, str);
str.append("</pre></body></html>");

rsp = MHD_create_response_from_buffer(str.size(), (void*)str.c_str(), MHD_RESPMEM_MUST_COPY);
}
else if(strcasecmp(url, "/r") == 0 || strcasecmp(url, "/results") == 0)
{
str.append("<html><head><title>Results Report</title></head><body><pre>");
executor::inst()->get_http_report(EV_HTML_RESULTS, str);
str.append("</pre></body></html>");

rsp = MHD_create_response_from_buffer(str.size(), (void*)str.c_str(), MHD_RESPMEM_MUST_COPY);
}
else
{
char buffer[1024];
snprintf(buffer, sizeof(buffer), "<html><head><title>Error</title></head><body>"
"<pre>Unkown url %s - please use /h, /r or /c as url</pre></body></html>", url);

rsp = MHD_create_response_from_buffer(strlen(buffer),
(void*)buffer, MHD_RESPMEM_MUST_COPY);
}

int ret = MHD_queue_response(connection, MHD_HTTP_OK, rsp);
MHD_destroy_response(rsp);
return ret;
}

bool httpd::start_daemon()
{
d = MHD_start_daemon(MHD_USE_THREAD_PER_CONNECTION,
8100, NULL, NULL,
&httpd::req_handler,
NULL, MHD_OPTION_END);

if(d == nullptr)
{
printer::inst()->print_str("HTTP Daemon failed to start.");
return false;
}

return true;
}

31 changes: 31 additions & 0 deletions httpd.h
@@ -0,0 +1,31 @@
#pragma once

struct MHD_Daemon;
struct MHD_Connection;

class httpd
{
public:
static httpd* inst()
{
if (oInst == nullptr) oInst = new httpd;
return oInst;
};

bool start_daemon();

private:
httpd();
static httpd* oInst;

static int req_handler(void * cls,
MHD_Connection* connection,
const char* url,
const char* method,
const char* version,
const char* upload_data,
size_t* upload_data_size,
void ** ptr);

MHD_Daemon *d;
};

0 comments on commit 2033ed3

Please sign in to comment.