/**
* Poll the socket, fail after timeout and log
* @param messageHash
* @return
*/
bool BoomStick::CheckForMessagePending(const std::string& messageHash, const unsigned int msToWait, std::string& reply) {
if (0 == mUtilizedThread) {
mUtilizedThread = pthread_self();
} else {
CHECK(pthread_self() == mUtilizedThread);
}
if (!mChamber) {
LOG(WARNING) << "Invalid socket";
return false;
}
if (!zsocket_poll(mChamber, msToWait)) {
reply = "socket timed out";
return false;
}
return true;
}
int
zsocket_test (Bool verbose)
{
printf (" * zsocket: ");
// @selftest
zctx_t *ctx = zctx_new ();
assert (ctx);
// Create a detached thread, let it run
char *interf = "*";
char *domain = "localhost";
int service = 5560;
void *writer = zsocket_new (ctx, ZMQ_PUSH);
assert (writer);
void *reader = zsocket_new (ctx, ZMQ_PULL);
assert (reader);
assert (streq (zsocket_type_str (writer), "PUSH"));
assert (streq (zsocket_type_str (reader), "PULL"));
int rc = zsocket_bind (writer, "tcp://%s:%d", interf, service);
assert (rc == service);
rc = zsocket_connect (reader, "tcp://%s:%d", domain, service);
assert (rc == 0);
zstr_send (writer, "HELLO");
char *message = zstr_recv (reader);
assert (message);
assert (streq (message, "HELLO"));
free (message);
int port = zsocket_bind (writer, "tcp://%s:*", interf);
assert (port >= ZSOCKET_DYNFROM && port <= ZSOCKET_DYNTO);
assert (zsocket_poll (writer, 100) == FALSE);
rc = zsocket_connect (reader, "txp://%s:%d", domain, service);
assert (rc == -1);
zsocket_destroy (ctx, writer);
zctx_destroy (&ctx);
// @end
printf ("OK\n");
return 0;
}
int rrsvr_recv(rrsvr_t *self, void *buf, size_t len)
{
int nbytes = 0;
if (zsocket_poll(self->socket, self->timeout)) {
zmsg_t *msg = zmsg_recv(self->socket);
if (self->mode == ASYNC_MODE) { //** Retrieves envelope
free(self->cli_identity);
self->cli_identity = zmsg_popstr(msg);
}
nbytes = zmsg_content_size(msg);
size_t to_copy = (size_t)nbytes < len ? (size_t)nbytes : len;
zframe_t *frame = zmsg_pop(msg);
memcpy (buf, zframe_data(frame), to_copy);
zframe_destroy(&frame);
zmsg_destroy(&msg);
}
return nbytes;
}
/**
* Blocking call that returns when the alien has been shot.
* @return
*/
void Alien::GetShot(const unsigned int timeout, std::vector<std::string>& bullets) {
bullets.clear();
if (!mBody) {
LOG(WARNING) << "Alien attempted to GetShot but is not properly initialized";
return;
}
if (zsocket_poll(mBody, timeout)) {
zmsg_t* msg = zmsg_recv(mBody);
if (msg && zmsg_size(msg) >= 2) {
zframe_t* data = zmsg_pop(msg);
if (data) {
//remove the first frame
zframe_destroy(&data);
}
int msgSize = zmsg_size(msg);
for (int i = 0; i < msgSize; i++) {
data = zmsg_pop(msg);
if (data) {
std::string bullet;
bullet.assign(reinterpret_cast<char*> (zframe_data(data)), zframe_size(data));
bullets.push_back(bullet);
zframe_destroy(&data);
}
}
} else {
if (msg) {
LOG(WARNING) << "Got Invalid bullet of size: " << zmsg_size(msg);
}
}
if (msg) {
zmsg_destroy(&msg);
}
}
}
void
zsocket_test (bool verbose)
{
printf (" * zsocket (deprecated): ");
// @selftest
zctx_t *ctx = zctx_new ();
assert (ctx);
// Create a detached thread, let it run
char *interf = "127.0.0.1";
char *domain = "localhost";
int service = 5560;
void *writer = zsocket_new (ctx, ZMQ_PUSH);
assert (writer);
void *reader = zsocket_new (ctx, ZMQ_PULL);
assert (reader);
assert (streq (zsocket_type_str (writer), "PUSH"));
assert (streq (zsocket_type_str (reader), "PULL"));
int rc = zsocket_bind (writer, "tcp://%s:%d", interf, service);
assert (rc == service);
#if (ZMQ_VERSION >= ZMQ_MAKE_VERSION (3, 2, 0))
// Check unbind
rc = zsocket_unbind (writer, "tcp://%s:%d", interf, service);
assert (rc == 0);
// In some cases and especially when running under Valgrind, doing
// a bind immediately after an unbind causes an EADDRINUSE error.
// Even a short sleep allows the OS to release the port for reuse.
zclock_sleep (100);
// Bind again
rc = zsocket_bind (writer, "tcp://%s:%d", interf, service);
assert (rc == service);
#endif
rc = zsocket_connect (reader, "tcp://%s:%d", domain, service);
assert (rc == 0);
zstr_send (writer, "HELLO");
char *message = zstr_recv (reader);
assert (message);
assert (streq (message, "HELLO"));
free (message);
// Test binding to ports
int port = zsocket_bind (writer, "tcp://%s:*", interf);
assert (port >= ZSOCKET_DYNFROM && port <= ZSOCKET_DYNTO);
assert (zsocket_poll (writer, 100) == false);
// Test error state when connecting to an invalid socket type
// ('txp://' instead of 'tcp://', typo intentional)
rc = zsocket_connect (reader, "txp://%s:%d", domain, service);
assert (rc == -1);
// Test sending frames to socket
rc = zsocket_sendmem (writer, "ABC", 3, ZFRAME_MORE);
assert (rc == 0);
rc = zsocket_sendmem (writer, "DEFG", 4, 0);
assert (rc == 0);
zframe_t *frame = zframe_recv (reader);
assert (frame);
assert (zframe_streq (frame, "ABC"));
assert (zframe_more (frame));
zframe_destroy (&frame);
frame = zframe_recv (reader);
assert (frame);
assert (zframe_streq (frame, "DEFG"));
assert (!zframe_more (frame));
zframe_destroy (&frame);
rc = zsocket_signal (writer);
assert (rc == 0);
rc = zsocket_wait (reader);
assert (rc == 0);
zsocket_destroy (ctx, reader);
zsocket_destroy (ctx, writer);
zctx_destroy (&ctx);
// @end
printf ("OK\n");
}
int
zsocket_test (bool verbose)
{
printf (" * zsocket: ");
// @selftest
zctx_t *ctx = zctx_new ();
assert (ctx);
// Create a detached thread, let it run
char *interf = "*";
char *domain = "localhost";
int service = 5560;
void *writer = zsocket_new (ctx, ZMQ_PUSH);
assert (writer);
void *reader = zsocket_new (ctx, ZMQ_PULL);
assert (reader);
assert (streq (zsocket_type_str (writer), "PUSH"));
assert (streq (zsocket_type_str (reader), "PULL"));
int rc = zsocket_bind (writer, "tcp://%s:%d", interf, service);
assert (rc == service);
rc = zsocket_connect (reader, "tcp://%s:%d", domain, service);
assert (rc == 0);
zstr_send (writer, "HELLO");
char *message = zstr_recv (reader);
assert (message);
assert (streq (message, "HELLO"));
free (message);
// Test binding to ports
int port = zsocket_bind (writer, "tcp://%s:*", interf);
assert (port >= ZSOCKET_DYNFROM && port <= ZSOCKET_DYNTO);
assert (zsocket_poll (writer, 100) == false);
rc = zsocket_connect (reader, "txp://%s:%d", domain, service);
assert (rc == -1);
// Test sending frames to socket
rc = zsocket_sendmem (writer,"ABC", 3, ZFRAME_MORE);
assert (rc == 0);
rc = zsocket_sendmem (writer, "DEFG", 4, 0);
assert (rc == 0);
zframe_t *frame = zframe_recv (reader);
assert (frame);
assert (zframe_streq (frame, "ABC"));
assert (zframe_more (frame));
zframe_destroy (&frame);
frame = zframe_recv (reader);
assert (frame);
assert (zframe_streq (frame, "DEFG"));
assert (!zframe_more (frame));
zframe_destroy (&frame);
// Test zframe_sendmem_zero_copy
rc = zsocket_sendmem_zero_copy (writer, strdup ("ABC"), 3,
s_test_free_str_cb, NULL, ZFRAME_MORE);
assert (rc == 0);
rc = zsocket_sendmem_zero_copy (writer, strdup ("DEFG"), 4,
s_test_free_str_cb, NULL, 0);
assert (rc == 0);
frame = zframe_recv (reader);
assert (frame);
assert (zframe_streq (frame, "ABC"));
assert (zframe_more (frame));
zframe_destroy (&frame);
frame = zframe_recv (reader);
assert (frame);
assert (zframe_streq (frame, "DEFG"));
assert (!zframe_more (frame));
zframe_destroy (&frame);
zsocket_destroy (ctx, writer);
zctx_destroy (&ctx);
// @end
printf ("OK\n");
return 0;
}
int main(void) {
gBlock.set_height(0);
gClientName = sysinfo::GetClientName();
gClientID = sysinfo::GetClientID();
gInstanceID = gClientID * (unsigned)time(0);
srand(gInstanceID);
std::string frontHost;
unsigned frontPort;
Configuration* cfg = Configuration::create();
try{
cfg->parse("config.txt");
frontHost = cfg->lookupString("", "server", "localhost");
frontPort = cfg->lookupInt("", "port", 6666);
gAddr = cfg->lookupString("", "address", "");
gClientName = cfg->lookupString("", "name", gClientName.c_str());
}catch(const ConfigurationException& ex){
printf("ERROR: %s\n", ex.c_str());
printf("hit return to exit...\n");
std::string line;
std::getline(std::cin, line);
exit(EXIT_FAILURE);
}
if(!gClientName.size())
gClientName = sysinfo::GetClientName();
printf("madPrimeMiner-v%d.%d\n", gClientVersion/10, gClientVersion%10);
printf("ClientName = '%s' ClientID = %u InstanceID = %u\n", gClientName.c_str(), gClientID, gInstanceID);
printf("Address = '%s'\n", gAddr.c_str());
if(!gAddr.size()){
printf("ERROR: address not specified in config.txt\n");
printf("hit return to exit...\n");
std::string line;
std::getline(std::cin, line);
exit(EXIT_FAILURE);
}
gCtx = zctx_new();
gWorkers = zsocket_new(gCtx, ZMQ_PULL);
zsocket_bind(gWorkers, "inproc://shares");
gClient = new XPMClient(gCtx);
gExit = !gClient->Initialize(cfg);
while(!gExit){
printf("Connecting to frontend: %s:%d ...\n", frontHost.c_str(), frontPort);
gBlock.Clear();
proto::Reply rep;
gExit = true;
while(gExit){
zsocket_destroy(gCtx, gFrontend);
gFrontend = zsocket_new(gCtx, ZMQ_DEALER);
int err = zsocket_connect(gFrontend, "tcp://%s:%d", frontHost.c_str(), frontPort);
if(err){
printf("ERROR: invalid hostname and/or port.\n");
exit(EXIT_FAILURE);
}
proto::Request req;
req.set_type(proto::Request::CONNECT);
req.set_reqid(++gNextReqID);
req.set_version(gClientVersion);
req.set_height(0);
GetNewReqNonce(req);
Send(req, gFrontend);
bool ready = zsocket_poll(gFrontend, 3*1000);
if(zctx_interrupted)
break;
if(!ready)
continue;
Receive(rep, gFrontend);
if(rep.error() != proto::Reply::NONE){
printf("ERROR: %s\n", proto::Reply::ErrType_Name(rep.error()).c_str());
if(rep.has_errstr())
printf("Message from server: %s\n", rep.errstr().c_str());
}
if(!rep.has_sinfo())
break;
gServerInfo = rep.sinfo();
bool ret = false;
ret |= !ConnectBitcoin();
ret |= !ConnectSignals();
if(ret)
break;
gExit = false;
}
zsocket_disconnect(gFrontend, "tcp://%s:%d", frontHost.c_str(), frontPort);
if(gExit)
break;
zloop_t* wloop = zloop_new();
zmq_pollitem_t item_server = {gServer, 0, ZMQ_POLLIN, 0};
int err = zloop_poller(wloop, &item_server, &HandleReply, 0);
assert(!err);
zmq_pollitem_t item_signals = {gSignals, 0, ZMQ_POLLIN, 0};
err = zloop_poller(wloop, &item_signals, &HandleSignal, 0);
assert(!err);
zmq_pollitem_t item_workers = {gWorkers, 0, ZMQ_POLLIN, 0};
err = zloop_poller(wloop, &item_workers, &HandleWorkers, 0);
assert(!err);
err = zloop_timer(wloop, 60*1000, 0, &HandleTimer, 0);
assert(err >= 0);
gHeartBeat = true;
gExit = true;
if(rep.has_block())
HandleNewBlock(rep.block());
else
RequestWork();
gClient->Toggle();
zloop_start(wloop);
gClient->Toggle();
zloop_destroy(&wloop);
zsocket_destroy(gCtx, gServer);
zsocket_destroy(gCtx, gSignals);
gServer = 0;
gSignals = 0;
}
delete gClient;
zsocket_destroy(gCtx, gWorkers);
zsocket_destroy(gCtx, gFrontend);
zctx_destroy(&gCtx);
return EXIT_SUCCESS;
}
