static bool
s_can_connect (void *server, void *client)
{
// We'll do each test on a new port number since otherwise we have to
// destroy and recreate the sockets each time.
static int port_nbr = 9000;
int rc = zsocket_bind (server, "tcp://*:%d", port_nbr);
assert (rc == port_nbr);
rc = zsocket_connect (client, "tcp://localhost:%d", port_nbr);
assert (rc == 0);
zpoller_t *poller = zpoller_new (client, NULL);
zstr_send (server, "Hello, World");
// Need up to half a second if running under Valgrind
bool success = zpoller_wait (poller, 500) == client;
if (success)
free (zstr_recv (client));
zpoller_destroy (&poller);
rc = zsocket_unbind (server, "tcp://*:%d", port_nbr);
assert (rc != -1);
rc = zsocket_disconnect (client, "tcp://localhost:%d", port_nbr);
assert (rc != -1);
port_nbr++;
return success;
}
void
prob_disconnect(prob_client_t pc)
{
if (zsocket_disconnect(pc->zocket, "%s", pc->file) != 0) Warning(info, "Could not disconnect from zocket %s", pc->file);
zsocket_destroy(pc->ctx, pc->zocket);
zctx_destroy(&(pc->ctx));
}
int zero_native_disconnect(mq_socket_t *socket, const char *format, ...)
{
va_list args;
int err;
va_start(args, format);
err = zsocket_disconnect(socket->arg, format, args);
va_end(args);
return(err);
}
static int
s_agent_handle_control (agent_t *self)
{
// Get the whole message off the control socket in one go
zmsg_t *request = zmsg_recv (self->control);
char *command = zmsg_popstr (request);
if (!command)
return -1; // Interrupted
if (streq (command, "SET")) {
char *name = zmsg_popstr (request);
char *value = zmsg_popstr (request);
curve_codec_set_metadata (self->codec, name, value);
free (name);
free (value);
}
else
if (streq (command, "CONNECT")) {
assert (!self->endpoint);
self->endpoint = zmsg_popstr (request);
int rc = zsocket_connect (self->dealer, "%s", self->endpoint);
assert (rc != -1);
zframe_t *server_key = zmsg_pop (request);
zframe_t *output = curve_codec_execute (self->codec, &server_key);
zframe_send (&output, self->dealer, 0);
self->state = connecting;
}
else
if (streq (command, "DISCONNECT")) {
if (self->endpoint) {
int rc = zsocket_disconnect (self->dealer, "%s", self->endpoint);
assert (rc != -1);
free (self->endpoint);
}
}
else
if (streq (command, "VERBOSE")) {
char *verbose = zmsg_popstr (request);
curve_codec_set_verbose (self->codec, *verbose == '1');
free (verbose);
}
else
if (streq (command, "TERMINATE")) {
self->state = terminated;
zstr_send (self->control, "OK");
}
else {
puts ("E: invalid command from API");
assert (false);
}
free (command);
zmsg_destroy (&request);
return 0;
}
static void ReConnectSignals() {
int err = 0;
const proto::ServerInfo& sinfo = gServerInfo;
err |= zsocket_disconnect(gSignals, "tcp://%s:%d", sinfo.host().c_str(), sinfo.pub());
err |= zsocket_connect(gSignals, "tcp://%s:%d", sinfo.host().c_str(), sinfo.pub());
const char one[2] = {1, 0};
zsocket_set_subscribe(gSignals, one);
if(err){
printf("ReConnectSignals(): FAIL\n");
}
}
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;
}
