/**
* Called by Java's Socket::monitor(String addr, int events).
*/
JNIEXPORT jboolean JNICALL Java_org_zeromq_ZMQ_00024Socket_monitor (JNIEnv *env,
jobject obj,
jstring addr,
jint events)
{
void *s = get_socket (env, obj);
if (addr == NULL) {
raise_exception (env, EINVAL);
return false;
}
const char *c_addr = env->GetStringUTFChars (addr, NULL);
if (c_addr == NULL) {
raise_exception (env, EINVAL);
return false;
}
int rc = 0;
if (c_addr && strlen(c_addr))
rc = zmq_socket_monitor(s, c_addr, events);
else
rc = zmq_socket_monitor(s, 0, 0);
int err = zmq_errno();
env->ReleaseStringUTFChars (addr, c_addr);
if (rc != 0) {
raise_exception (env, err);
return false;
}
return true;
}
inline void init_monitor(const char *addr_, int events)
{
int rc = zmq_socket_monitor(ptr, addr_, events);
if (rc != 0)
throw error_t ();
monaddr = std::string(addr_);
}
static int luazmq_skt_monitor (lua_State *L) {
zsocket *skt = luazmq_getsocket(L);
char endpoint[128];
const char *bind;
int ret, events;
if(
(lua_gettop(L) == 1) || /* s:monitor() */
(lua_type(L, 2) == LUA_TNUMBER) /* s:monitor(EVENT_ALL) */
){
#ifdef _MSC_VER
sprintf_s(endpoint, sizeof(endpoint), "inproc://lzmq.monitor.%p", skt->skt);
#else
sprintf(endpoint, "inproc://lzmq.monitor.%p", skt->skt);
#endif
bind = endpoint;
events = luaL_optint(L, 2, ZMQ_EVENT_ALL);
}
else{
bind = luaL_checkstring(L, 2);
events = luaL_optint(L, 3, ZMQ_EVENT_ALL);
}
ret = zmq_socket_monitor (skt->skt, bind, events);
if(-1 == ret){
return luazmq_fail(L, skt);
}
lua_pushstring(L, bind);
return 1;
}
zmonitor_t *
zmonitor_new (zctx_t *ctx, void *socket, int events)
{
zmonitor_t *self = (zmonitor_t *) zmalloc (sizeof (zmonitor_t));
assert (self);
// Start background agent to connect to the inproc monitor socket
assert (ctx);
self->pipe = zthread_fork (ctx, s_agent_task, NULL);
if (self->pipe) {
self->socket = socket;
// Register a monitor endpoint on the socket
char *monitor_endpoint = (char *) zmalloc (100);
sprintf (monitor_endpoint, "inproc://zmonitor-%p", self->socket);
int rc = zmq_socket_monitor (self->socket, monitor_endpoint, events);
assert (rc == 0);
// Configure backend agent with monitor endpoint
zstr_sendf (self->pipe, "%s", monitor_endpoint);
free (monitor_endpoint);
char *status = zstr_recv (self->pipe);
if (strneq (status, "OK"))
zmonitor_destroy (&self);
zstr_free (&status);
}
else {
free (self);
self = NULL;
}
return self;
}
static int luazmq_skt_reset_monitor (lua_State *L) {
zsocket *skt = luazmq_getsocket(L);
int ret = zmq_socket_monitor (skt->skt, NULL, 0);
if(-1 == ret){
return luazmq_fail(L, skt);
}
return luazmq_pass(L);
}
void Van::init() {
scheduler_ = parseNode(FLAGS_scheduler);
myNode_ = parseNode(FLAGS_my_node);
LOG(INFO) << "I'm \n[" << myNode_.DebugString() << "]";
context_ = zmq_ctx_new();
CHECK(context_ != nullptr) << "Create 0mq context failed";
zmq_ctx_set(context_, ZMQ_MAX_SOCKETS, 65536);
bind();
connect(scheduler_);
if (isScheduler()) {
CHECK(!zmq_socket_monitor(receiver_, "inproc://monitor", ZMQ_EVENT_ALL));
} else {
CHECK(!zmq_socket_monitor(senders_[scheduler_.id()], "inproc://monitor",
ZMQ_EVENT_ALL));
}
monitorThread_ = new std::thread(&Van::monitor, this);
monitorThread_->detach();
}
Bool CZmq::StartMonitor(UInt32 iEvents, const AString& sAddr)
{
if (m_pHandle)
{
Long lMonitorId = (Long)m_pHandle;
Char sMonitorAddr[DEFAULT_SIZE] = {0};
if (sAddr.size())
sprintf(sMonitorAddr, "%s", sAddr.c_str());
else
sprintf(sMonitorAddr, "inproc://project-monitor-%ld", lMonitorId);
if (zmq_socket_monitor(m_pHandle, sMonitorAddr, (Int32)iEvents) == UTIL_ERROR)
return false;
if (!sAddr.size())
{
if (m_pMonitor)
{
zmq_close(m_pMonitor);
m_pMonitor = 0;
}
m_pMonitor = zmq_socket(g_ZmqManager->GetZmqCtx(), HZMQ_PAIR);
if (!m_pMonitor)
{
FillErr();
return false;
}
Int32 iLinger = 0;
zmq_setsockopt (m_pMonitor, ZMQ_LINGER, &iLinger, sizeof(iLinger));
Int32 iTimeout = HZMQ_TIMEOUT;
zmq_setsockopt (m_pMonitor, ZMQ_RCVTIMEO, &iTimeout, sizeof(iTimeout));
zmq_setsockopt (m_pMonitor, ZMQ_SNDTIMEO, &iTimeout, sizeof(iTimeout));
Int32 iRet = zmq_connect(m_pMonitor, sMonitorAddr);
if (iRet == UTIL_ERROR)
{
FillErr();
return false;
}
}
return true;
}
return false;
}
static void
s_self_destroy (self_t **self_p)
{
assert (self_p);
if (*self_p) {
self_t *self = *self_p;
#if defined (ZMQ_EVENT_ALL)
zmq_socket_monitor (self->monitored, NULL, 0);
#endif
zpoller_destroy (&self->poller);
zsock_destroy (&self->sink);
free (self);
*self_p = NULL;
}
}
void
zmonitor_destroy (zmonitor_t **self_p)
{
assert (self_p);
if (*self_p) {
zmonitor_t *self = *self_p;
// Deregister monitor endpoint
zmq_socket_monitor (self->socket, NULL, 0);
zstr_send (self->pipe, "TERMINATE");
char *reply = zstr_recv (self->pipe);
zstr_free (&reply);
free (self);
*self_p = NULL;
}
}
Bool CZmq::StopMonitor()
{
if (m_pHandle)
{
if (m_pMonitor)
{
zmq_close(m_pMonitor);
m_pMonitor = 0;
}
if (zmq_socket_monitor(m_pHandle, 0, 0) == UTIL_ERROR)
return false;
return true;
}
return false;
}
static void
s_self_start (self_t *self)
{
assert (!self->sink);
char *endpoint = zsys_sprintf ("inproc://zmonitor-%p", self->monitored);
int rc;
#if defined (ZMQ_EVENT_ALL)
rc = zmq_socket_monitor (self->monitored, endpoint, self->events);
assert (rc == 0);
#endif
self->sink = zsock_new (ZMQ_PAIR);
assert (self->sink);
rc = zsock_connect (self->sink, "%s", endpoint);
assert (rc == 0);
zpoller_add (self->poller, self->sink);
free (endpoint);
}
static void prep_server_socket (int set_heartbeats_,
int is_curve_,
void **server_out_,
void **mon_out_,
char *endpoint_,
size_t ep_length_,
int socket_type_)
{
// We'll be using this socket in raw mode
void *server = test_context_socket (socket_type_);
int value = 0;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (server, ZMQ_LINGER, &value, sizeof (value)));
if (set_heartbeats_) {
value = 50;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (server, ZMQ_HEARTBEAT_IVL, &value, sizeof (value)));
}
if (is_curve_)
setup_curve (server, 1);
bind_loopback_ipv4 (server, endpoint_, ep_length_);
// Create and connect a socket for collecting monitor events on dealer
void *server_mon = test_context_socket (ZMQ_PAIR);
TEST_ASSERT_SUCCESS_ERRNO (zmq_socket_monitor (
server, "inproc://monitor-dealer",
ZMQ_EVENT_CONNECTED | ZMQ_EVENT_DISCONNECTED | ZMQ_EVENT_ACCEPTED));
// Connect to the inproc endpoint so we'll get events
TEST_ASSERT_SUCCESS_ERRNO (
zmq_connect (server_mon, "inproc://monitor-dealer"));
*server_out_ = server;
*mon_out_ = server_mon;
}
static void
prep_server_socket(void * ctx, int set_heartbeats, int is_curve, void ** server_out, void ** mon_out)
{
int rc;
// We'll be using this socket in raw mode
void *server = zmq_socket (ctx, ZMQ_ROUTER);
assert (server);
int value = 0;
rc = zmq_setsockopt (server, ZMQ_LINGER, &value, sizeof (value));
assert (rc == 0);
if(set_heartbeats) {
value = 50;
rc = zmq_setsockopt (server, ZMQ_HEARTBEAT_IVL, &value, sizeof(value));
assert (rc == 0);
}
if(is_curve)
setup_curve(server, 1);
rc = zmq_bind (server, "tcp://127.0.0.1:5556");
assert (rc == 0);
// Create and connect a socket for collecting monitor events on dealer
void *server_mon = zmq_socket (ctx, ZMQ_PAIR);
assert (server_mon);
rc = zmq_socket_monitor (server, "inproc://monitor-dealer",
ZMQ_EVENT_CONNECTED | ZMQ_EVENT_DISCONNECTED | ZMQ_EVENT_ACCEPTED);
assert (rc == 0);
// Connect to the inproc endpoint so we'll get events
rc = zmq_connect (server_mon, "inproc://monitor-dealer");
assert (rc == 0);
*server_out = server;
*mon_out = server_mon;
}
JNIEXPORT jboolean JNICALL Java_org_zeromq_ZMQ_00024Socket_monitor (JNIEnv *env,
jobject obj,
jstring addr,
jint events)
{
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3,2,0)
void *socket = get_socket (env, obj);
const char *c_addr = addr ? env->GetStringUTFChars (addr, NULL) : NULL;
int rc = zmq_socket_monitor(socket , c_addr, events);
int err = rc < 0 ? zmq_errno() : 0;
env->ReleaseStringUTFChars (addr, c_addr);
if (rc < 0) {
raise_exception (env, err);
return JNI_FALSE;
}
return JNI_TRUE;
#else
return JNI_FALSE;
#endif
}
int main (void)
{
setup_test_environment();
void *ctx = zmq_ctx_new ();
assert (ctx);
// We'll monitor these two sockets
void *client = zmq_socket (ctx, ZMQ_DEALER);
assert (client);
void *server = zmq_socket (ctx, ZMQ_DEALER);
assert (server);
// Socket monitoring only works over inproc://
int rc = zmq_socket_monitor (client, "tcp://127.0.0.1:9999", 0);
assert (rc == -1);
assert (zmq_errno () == EPROTONOSUPPORT);
// Monitor all events on client and server sockets
rc = zmq_socket_monitor (client, "inproc://monitor-client", ZMQ_EVENT_ALL);
assert (rc == 0);
rc = zmq_socket_monitor (server, "inproc://monitor-server", ZMQ_EVENT_ALL);
assert (rc == 0);
// Create two sockets for collecting monitor events
void *client_mon = zmq_socket (ctx, ZMQ_PAIR);
assert (client_mon);
void *server_mon = zmq_socket (ctx, ZMQ_PAIR);
assert (server_mon);
// Connect these to the inproc endpoints so they'll get events
rc = zmq_connect (client_mon, "inproc://monitor-client");
assert (rc == 0);
rc = zmq_connect (server_mon, "inproc://monitor-server");
assert (rc == 0);
// Now do a basic ping test
rc = zmq_bind (server, "tcp://127.0.0.1:9998");
assert (rc == 0);
rc = zmq_connect (client, "tcp://127.0.0.1:9998");
assert (rc == 0);
bounce (client, server);
// Close client and server
close_zero_linger (client);
close_zero_linger (server);
// Now collect and check events from both sockets
int event = get_monitor_event (client_mon, NULL, NULL);
if (event == ZMQ_EVENT_CONNECT_DELAYED)
event = get_monitor_event (client_mon, NULL, NULL);
assert (event == ZMQ_EVENT_CONNECTED);
event = get_monitor_event (client_mon, NULL, NULL);
assert (event == ZMQ_EVENT_MONITOR_STOPPED);
// This is the flow of server events
event = get_monitor_event (server_mon, NULL, NULL);
assert (event == ZMQ_EVENT_LISTENING);
event = get_monitor_event (server_mon, NULL, NULL);
assert (event == ZMQ_EVENT_ACCEPTED);
event = get_monitor_event (server_mon, NULL, NULL);
assert (event == ZMQ_EVENT_CLOSED);
event = get_monitor_event (server_mon, NULL, NULL);
assert (event == ZMQ_EVENT_MONITOR_STOPPED);
// Close down the sockets
close_zero_linger (client_mon);
close_zero_linger (server_mon);
zmq_ctx_term (ctx);
return 0 ;
}
int main (void)
{
setup_test_environment();
int rc;
void *req;
void *req2;
void *rep;
void* threads [3];
addr = "tcp://127.0.0.1:5560";
// Create the infrastructure
void *ctx = zmq_ctx_new ();
assert (ctx);
// REP socket
rep = zmq_socket (ctx, ZMQ_REP);
assert (rep);
// Assert supported protocols
rc = zmq_socket_monitor (rep, addr.c_str(), 0);
assert (rc == -1);
assert (zmq_errno() == EPROTONOSUPPORT);
// Deregister monitor
rc = zmq_socket_monitor (rep, NULL, 0);
assert (rc == 0);
// REP socket monitor, all events
rc = zmq_socket_monitor (rep, "inproc://monitor.rep", ZMQ_EVENT_ALL);
assert (rc == 0);
threads [0] = zmq_threadstart(&rep_socket_monitor, ctx);
// REQ socket
req = zmq_socket (ctx, ZMQ_REQ);
assert (req);
// REQ socket monitor, all events
rc = zmq_socket_monitor (req, "inproc://monitor.req", ZMQ_EVENT_ALL);
assert (rc == 0);
threads [1] = zmq_threadstart(&req_socket_monitor, ctx);
zmq_sleep(1);
// Bind REQ and REP
rc = zmq_bind (rep, addr.c_str());
assert (rc == 0);
rc = zmq_connect (req, addr.c_str());
assert (rc == 0);
bounce (rep, req);
// 2nd REQ socket
req2 = zmq_socket (ctx, ZMQ_REQ);
assert (req2);
// 2nd REQ socket monitor, connected event only
rc = zmq_socket_monitor (req2, "inproc://monitor.req2", ZMQ_EVENT_CONNECTED);
assert (rc == 0);
threads [2] = zmq_threadstart(&req2_socket_monitor, ctx);
rc = zmq_connect (req2, addr.c_str());
assert (rc == 0);
// Close the REP socket
rc = zmq_close (rep);
assert (rc == 0);
// Allow some time for detecting error states
zmq_sleep(1);
// Close the REQ socket
rc = zmq_close (req);
assert (rc == 0);
// Close the 2nd REQ socket
rc = zmq_close (req2);
assert (rc == 0);
zmq_ctx_term (ctx);
// Expected REP socket events
assert (rep_socket_events & ZMQ_EVENT_LISTENING);
assert (rep_socket_events & ZMQ_EVENT_ACCEPTED);
assert (rep_socket_events & ZMQ_EVENT_CLOSED);
// Expected REQ socket events
assert (req_socket_events & ZMQ_EVENT_CONNECTED);
assert (req_socket_events & ZMQ_EVENT_DISCONNECTED);
assert (req_socket_events & ZMQ_EVENT_CLOSED);
// Expected 2nd REQ socket events
assert (req2_socket_events & ZMQ_EVENT_CONNECTED);
assert (!(req2_socket_events & ZMQ_EVENT_CLOSED));
for (unsigned int i = 0; i < 3; ++i)
zmq_threadclose(threads [i]);
return 0 ;
}
int main (void)
{
setup_test_environment ();
size_t len = MAX_SOCKET_STRING;
char my_endpoint[MAX_SOCKET_STRING];
void *ctx = zmq_ctx_new ();
assert (ctx);
// We'll monitor these two sockets
void *client = zmq_socket (ctx, ZMQ_DEALER);
assert (client);
void *server = zmq_socket (ctx, ZMQ_DEALER);
assert (server);
// Socket monitoring only works over inproc://
int rc = zmq_socket_monitor (client, "tcp://127.0.0.1:*", 0);
assert (rc == -1);
assert (zmq_errno () == EPROTONOSUPPORT);
// Monitor all events on client and server sockets
rc = zmq_socket_monitor (client, "inproc://monitor-client", ZMQ_EVENT_ALL);
assert (rc == 0);
rc = zmq_socket_monitor (server, "inproc://monitor-server", ZMQ_EVENT_ALL);
assert (rc == 0);
// Create two sockets for collecting monitor events
void *client_mon = zmq_socket (ctx, ZMQ_PAIR);
assert (client_mon);
void *server_mon = zmq_socket (ctx, ZMQ_PAIR);
assert (server_mon);
// Connect these to the inproc endpoints so they'll get events
rc = zmq_connect (client_mon, "inproc://monitor-client");
assert (rc == 0);
rc = zmq_connect (server_mon, "inproc://monitor-server");
assert (rc == 0);
// Now do a basic ping test
rc = zmq_bind (server, "tcp://127.0.0.1:*");
assert (rc == 0);
rc = zmq_getsockopt (server, ZMQ_LAST_ENDPOINT, my_endpoint, &len);
assert (rc == 0);
rc = zmq_connect (client, my_endpoint);
assert (rc == 0);
bounce (server, client);
// Close client and server
close_zero_linger (client);
close_zero_linger (server);
// Now collect and check events from both sockets
int event = get_monitor_event (client_mon, NULL, NULL);
if (event == ZMQ_EVENT_CONNECT_DELAYED)
event = get_monitor_event (client_mon, NULL, NULL);
assert (event == ZMQ_EVENT_CONNECTED);
#ifdef ZMQ_BUILD_DRAFT_API
expect_monitor_event (client_mon, ZMQ_EVENT_HANDSHAKE_SUCCEEDED);
#endif
expect_monitor_event (client_mon, ZMQ_EVENT_MONITOR_STOPPED);
// This is the flow of server events
expect_monitor_event (server_mon, ZMQ_EVENT_LISTENING);
expect_monitor_event (server_mon, ZMQ_EVENT_ACCEPTED);
#ifdef ZMQ_BUILD_DRAFT_API
expect_monitor_event (server_mon, ZMQ_EVENT_HANDSHAKE_SUCCEEDED);
#endif
event = get_monitor_event (server_mon, NULL, NULL);
// Sometimes the server sees the client closing before it gets closed.
if (event != ZMQ_EVENT_DISCONNECTED) {
assert (event == ZMQ_EVENT_CLOSED);
event = get_monitor_event (server_mon, NULL, NULL);
}
if (event != ZMQ_EVENT_DISCONNECTED) {
assert (event == ZMQ_EVENT_MONITOR_STOPPED);
}
// Close down the sockets
close_zero_linger (client_mon);
close_zero_linger (server_mon);
zmq_ctx_term (ctx);
return 0;
}
int zero_native_monitor(mq_socket_t *socket, char *address, int events)
{
return(zmq_socket_monitor(socket->arg, address, events));
}
// TODO: read/write external should use buffer->valid_db_size instead of passing in additional
// parameters
void *DiskIOThread::run_thread(void *_thr_info){
DiskIOThread *diskio = (DiskIOThread *) _thr_info;
int ret = zmq_socket_monitor(diskio->sock, "inproc://monitor.router_sock", ZMQ_EVENT_CONNECTED | ZMQ_EVENT_ACCEPTED | ZMQ_EVENT_DISCONNECTED);
if(ret < 0){
diskio->status = -1;
return NULL;
}
zmq::socket_t monitor_sock(*diskio->zmq_ctx, ZMQ_PAIR);
try{
monitor_sock.connect("inproc://monitor.router_sock");
}catch(zmq::error_t &e){
std::cout << "monitor socket create failed" << std::endl;
return NULL;
}
zmq::pollitem_t pollitems[3];
pollitems[0].socket = diskio->sock;
pollitems[0].events = ZMQ_POLLIN;
pollitems[1].socket = monitor_sock;
pollitems[1].events = ZMQ_POLLIN;
pollitems[2].socket = diskio->cancel_sock;
pollitems[2].events = ZMQ_POLLIN;
while(true){
try {
zmq::poll(pollitems, 3);
}catch(...){
std::cout << "error from poll!" << std::endl;
return NULL;
}
if(pollitems[2].revents){
int32_t cid;
boost::shared_array<uint8_t> data;
int32_t len = recv_msg(diskio->cancel_sock, cid, data);
if(len < 0){
diskio->status = -1;
return NULL;
}
EMsgType type = *((EMsgType *) data.get());
int32_t extern_cid, sock_idx;
switch(type){
case DiskIOCancel:
extern_cid = zmq_rid_to_cid(cid);
sock_idx = cid_to_sock_idx(extern_cid);
diskio->client_valid[sock_idx] = false;
break;
case DiskIOEnable:
extern_cid = zmq_rid_to_cid(cid);
sock_idx = cid_to_sock_idx(extern_cid);
diskio->client_valid[sock_idx] = true;
break;
default:
assert(0);
diskio->status = -1;
return NULL;
}
continue;
}
if(pollitems[0].revents){
int32_t cid;
boost::shared_array<uint8_t> data;
int32_t len = recv_msg(diskio->sock, cid, data);
if(len < 0){
assert(0);
diskio->status = -1;
return NULL;
}
//std::cout << "received from cid = " << std::hex << cid << std::dec << std::endl;
EMsgType type = *((EMsgType *) data.get());
Buffer *buf;
std::string base; // for DiskIOExternal, base is actually fullpath
int32_t extern_cid;
int32_t sock_idx;
if(type == DiskIORead || type == DiskIOWrite || type == DiskIOReadExternal
|| type == DiskIOWriteExternal || type == DiskIOWriteRead){
len = recv_msg(diskio->sock, data);
if(len < 0){
assert(0);
diskio->status = -1;
return NULL;
}
buf = *((Buffer **) data.get());
len = recv_msg(diskio->sock, data);
if(len < 0){
assert(0);
diskio->status = -1;
return NULL;
}
base = std::string((char *) data.get());
}
//std::cout << "request type = " << type << std::endl;
block_id_t bid;
int32_t extern_size;
int32_t dbsize;
int64_t offset;
int32_t fidx;
int32_t suc;
std::string fname;
int32_t rsize;
int32_t wsuc;
int32_t rd_db_id;
EMsgType re_type;
switch(type){
case DiskIORead:
bid = buf->get_block_id();
dbsize = buf->get_db_size();
fidx = get_file_idx(bid, dbsize, offset);
fname = build_filename(diskio->datapath, base, fidx);
extern_cid = zmq_rid_to_cid(cid);
sock_idx = cid_to_sock_idx(extern_cid);
if(!diskio->client_valid[sock_idx]){
rsize = 0;
re_type = DiskIOReadNotDone;
}else{
// read data from specified file, with
rsize = dir_read(buf->get_db_ptr(), dbsize, fname.c_str(), offset);
re_type = DiskIOReadDone;
}
// finished reading send back message
suc = send_msg(diskio->sock, cid, (uint8_t *) &re_type, sizeof(Buffer *), ZMQ_SNDMORE);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
send_msg(diskio->sock, (uint8_t *) &buf, sizeof(Buffer *), ZMQ_SNDMORE);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
suc = send_msg(diskio->sock, (uint8_t *) &rsize, sizeof(int32_t), 0);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
break;
case DiskIOWrite:
bid = buf->get_block_id();
dbsize = buf->get_db_size();
fidx = get_file_idx(bid, dbsize, offset);
fname = build_filename(diskio->datapath, base, fidx);
// read data from specified file, with
wsuc = dir_write(buf->get_db_ptr(), dbsize, fname.c_str(), offset);
re_type = DiskIOWriteDone;
// finished reading send back message
suc = send_msg(diskio->sock, cid, (uint8_t *) &re_type, sizeof(Buffer *), ZMQ_SNDMORE);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
send_msg(diskio->sock, (uint8_t *) &buf, sizeof(Buffer *), ZMQ_SNDMORE);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
suc = send_msg(diskio->sock, (uint8_t *) &wsuc, sizeof(int32_t), 0);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
break;
case DiskIOWriteRead:
len = recv_msg(diskio->sock, data);
if(len < 0){
assert(0);
diskio->status = -1;
return NULL;
}
rd_db_id = *((int32_t *) data.get());
bid = buf->get_block_id();
dbsize = buf->get_db_size();
fidx = get_file_idx(bid, dbsize, offset);
fname = build_filename(diskio->datapath, base, fidx);
// write data to
wsuc = dir_write(buf->get_db_ptr(), dbsize, fname.c_str(), offset);
int32_t resp_val;
extern_cid = zmq_rid_to_cid(cid);
sock_idx = cid_to_sock_idx(extern_cid);
if(!diskio->client_valid[sock_idx]){
resp_val = 0;
re_type = DiskIOWriteReadWriteDone;
}else{
if(wsuc == 0){
fidx = get_file_idx(rd_db_id, dbsize, offset);
fname = build_filename(diskio->datapath, base, fidx);
rsize = dir_read(buf->get_db_ptr(), dbsize, fname.c_str(), offset);
}
if(wsuc < 0 || rsize < 0){
resp_val = -1;
}else{
resp_val = rsize;
}
re_type = DiskIOWriteReadDone;
}
// finished reading send back message
suc = send_msg(diskio->sock, cid, (uint8_t *) &re_type, sizeof(Buffer *), ZMQ_SNDMORE);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
send_msg(diskio->sock, (uint8_t *) &buf, sizeof(Buffer *), ZMQ_SNDMORE);
if(suc < 0){
diskio->status = -1;
return NULL;
}
suc = send_msg(diskio->sock, (uint8_t *) &resp_val, sizeof(int32_t), 0);
if(suc < 0){
diskio->status = -1;
return NULL;
}
break;
case DiskIOReadExternal:
len = recv_msg(diskio->sock, data);
if(len < 0){
assert(0);
diskio->status = -1;
return NULL;
}
offset = *((int64_t *) data.get());
len = recv_msg(diskio->sock, data);
if(len < 0){
assert(0);
diskio->status = -1;
return NULL;
}
extern_size = *((int32_t *) data.get());
//std::cout << "size to read = " << extern_size << std::endl;
extern_cid = zmq_rid_to_cid(cid);
sock_idx = cid_to_sock_idx(extern_cid);
if(!diskio->client_valid[sock_idx]){
rsize = 0;
re_type = DiskIOReadExternalNotDone;
}else{
//std::cout << "received request to read external data" << std::endl;
dbsize = buf->get_db_size();
if(extern_size > dbsize){
assert(0);
diskio->status = -1;
return NULL;
}
fname = std::string(base);
// read data from specified file, with
rsize = dir_read(buf->get_db_ptr(), extern_size, fname.c_str(), offset);
re_type = DiskIOReadExternalDone;
}
buf->set_valid_db_size(rsize);
// finished reading send back message
suc = send_msg(diskio->sock, cid, (uint8_t *) &re_type, sizeof(EMsgType),
ZMQ_SNDMORE);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
send_msg(diskio->sock, (uint8_t *) &buf, sizeof(Buffer *), ZMQ_SNDMORE);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
suc = send_msg(diskio->sock, (uint8_t *) &rsize, sizeof(int32_t), 0);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
break;
case DiskIOWriteExternal:
len = recv_msg(diskio->sock, data);
if(len < 0){
assert(0);
diskio->status = -1;
return NULL;
}
offset = *((int64_t *) data.get());
len = recv_msg(diskio->sock, data);
if(len < 0){
assert(0);
diskio->status = -1;
return NULL;
}
// if has been canceled, don't send response
extern_cid = zmq_rid_to_cid(cid);
sock_idx = cid_to_sock_idx(extern_cid);
if(diskio->client_sock[sock_idx] == NULL) continue;
extern_size = *((int32_t *) data.get());
dbsize = buf->get_db_size();
//std::cout << "extern_size = " << extern_size << " dbsize = " << dbsize << std::endl;
assert(extern_size <= dbsize);
fname = std::string(base);
// read data from specified file, with
rsize = reg_write(buf->get_db_ptr(), extern_size, fname.c_str(), offset);
re_type = DiskIOWriteExternalDone;
// finished reading send back message
suc = send_msg(diskio->sock, cid, (uint8_t *) &re_type, sizeof(Buffer *),
ZMQ_SNDMORE);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
send_msg(diskio->sock, (uint8_t *) &buf, sizeof(Buffer *), ZMQ_SNDMORE);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
suc = send_msg(diskio->sock, (uint8_t *) &rsize, sizeof(int32_t), 0);
if(suc < 0){
assert(0);
diskio->status = -1;
return NULL;
}
break;
case DiskIOShutDown:
std::cout << "diskio thread received shutdown message" << std::endl;
return NULL;
break;
case DiskIOConn:
break;
default:
std::cout << "!!!!!!!!!diskio thread msgtype = " << type << std::endl;
assert(0);
diskio->status = -1;
return NULL;
}
continue;
}
if(pollitems[1].revents){
zmq_event_t *event;
boost::shared_array<uint8_t> data;
int len;
len = recv_msg(monitor_sock, data);
if (len < 0){
assert(0);
diskio->status = -11;
return NULL;
}
assert(len == sizeof(zmq_event_t));
event = (zmq_event_t *) data.get();
switch (event->event){
case ZMQ_EVENT_CONNECTED:
std::cout << "established connection." << std::endl;
break;
case ZMQ_EVENT_ACCEPTED:
std::cout << "connection accepted" << std::endl;
break;
case ZMQ_EVENT_DISCONNECTED:
std::cout << "client disconnected" << std::endl;
break;
default:
std::cout << "unexpected event" << std::endl;
return NULL;
}
continue;
}
}
return NULL;
}
void zeromq_thread() {
{
void* objectContext = zmq_ctx_new();
void* objectSocket = zmq_socket(objectContext, ZMQ_PAIR);
{
char charZeromq[1024] = { };
sprintf(charZeromq, "tcp://localhost:%d", main_intZeromq);
if (zmq_connect(objectSocket, charZeromq) == -1) {
printf("zeromq: %s\n", zmq_strerror(zmq_errno()));
}
}
{
zeromq_objectSocket = objectSocket;
}
{
void* objectMonitor = zmq_socket(objectContext, ZMQ_PAIR);
{
if (zmq_socket_monitor(objectSocket, "inproc://minichess-zeromq-monitor", ZMQ_EVENT_ALL) == -1) {
printf("zeromq: %s\n", zmq_strerror(zmq_errno()));
}
if (zmq_connect(objectMonitor, "inproc://minichess-zeromq-monitor") == -1) {
printf("zeromq: %s\n", zmq_strerror(zmq_errno()));
}
}
{
do {
int intEventspecifier = 0;
int intEventvalue = 0;
char charEventaddress[256] = { };
#if (ZMQ_VERSION_MAJOR == 3)
{
zmq_msg_t objectMessage = { };
zmq_msg_init(&objectMessage);
if (zmq_recvmsg(objectMonitor, &objectMessage, 0) == -1) {
printf("zeromq: %s\n", zmq_strerror(zmq_errno()));
}
zmq_event_t objectEvent = { };
memcpy(&objectEvent, zmq_msg_data(&objectMessage), sizeof(objectEvent));
intEventspecifier = objectEvent.event;
intEventvalue = 0
charEventaddress[0] = '\0';
zmq_msg_close(&objectMessage);
}
#elif (ZMQ_VERSION_MAJOR == 4)
{
zmq_msg_t objectMessage = { };
zmq_msg_init(&objectMessage);
if (zmq_recvmsg(objectMonitor, &objectMessage, 0) == -1) {
printf("zeromq: %s\n", zmq_strerror(zmq_errno()));
}
uint8_t* intData = (uint8_t*) (zmq_msg_data(&objectMessage));
intEventspecifier = *(uint16_t*) (intData + 0);
intEventvalue = *(uint32_t*) (intData + 2);
zmq_msg_close(&objectMessage);
}
{
zmq_msg_t objectMessage = { };
zmq_msg_init(&objectMessage);
if (zmq_recvmsg(objectMonitor, &objectMessage, 0) == -1) {
printf("zeromq: %s\n", zmq_strerror(zmq_errno()));
}
charEventaddress[0] = '\0';
zmq_msg_close(&objectMessage);
}
#endif
{
if (intEventspecifier == ZMQ_EVENT_CONNECTED) {
{
zeromq_boolConnected = true;
webserver_broadcast("zeromq_status", NULL);
}
{
cJSON* objectOut = cJSON_CreateObject();
cJSON* objectIn = NULL;
{
cJSON_AddStringToObject(objectOut, "strFunction", "ping");
}
{
zeromq_send(objectOut);
objectIn = zeromq_recv();
}
{
strcpy(zeromq_charClient, cJSON_GetObjectItem(objectIn, "strOut")->valuestring);
webserver_broadcast("zeromq_name", NULL);
}
cJSON_Delete(objectOut);
cJSON_Delete(objectIn);
}
{
printf("zeromq: connected to %s\n", zeromq_charClient);
}
} else if (intEventspecifier == ZMQ_EVENT_DISCONNECTED) {
{
zeromq_boolConnected = false;
webserver_broadcast("zeromq_status", NULL);
}
{
printf("zeromq: disconnected from %s\n", zeromq_charClient);
}
}
}
{
if (intEventspecifier == ZMQ_EVENT_CONNECTED) {
int intTest = 0;
if (intTest > 0) {
setbuf(stdout, NULL);
}
if (intTest > 0) {
printf("test_board: ");
printf("%d\n", test_board());
}
if (intTest > 1) {
printf("test_winner: ");
printf("%d\n", test_winner());
}
if (intTest > 2) {
printf("test_isValid: ");
printf("%d\n", test_isValid());
}
if (intTest > 3) {
printf("test_isEnemy: ");
printf("%d\n", test_isEnemy());
}
if (intTest > 4) {
printf("test_isOwn: ");
printf("%d\n", test_isOwn());
}
if (intTest > 5) {
printf("test_isNothing: ");
printf("%d\n", test_isNothing());
}
if (intTest > 6) {
printf("test_eval: ");
printf("%d\n", test_eval());
}
if (intTest > 7) {
printf("test_moves: ");
printf("%d\n", test_moves());
}
if (intTest > 8) {
printf("test_move: ");
printf("%d\n", test_move());
}
if (intTest > 9) {
printf("test_undo: ");
printf("%d\n", test_undo());
}
if (intTest > 10) {
printf("test_movesShuffled: ");
printf("%d\n", test_movesShuffled());
}
if (intTest > 11) {
printf("test_movesEvaluated: ");
printf("%d\n", test_movesEvaluated());
}
if (intTest > 12) {
printf("test_moveRandom: ");
printf("%d\n", test_moveRandom());
}
if (intTest > 13) {
printf("test_moveGreedy: ");
printf("%d\n", test_moveGreedy());
}
if (intTest > 14) {
printf("test_moveNegamax: ");
printf("%d\n", test_moveNegamax());
}
if (intTest > 15) {
printf("test_moveAlphabeta: ");
printf("%d\n", test_moveAlphabeta());
}
}
}
} while (pthread_mutex_trylock(&zeromq_objectRunning) != 0);
pthread_mutex_unlock(&zeromq_objectRunning);
}
zmq_close(objectMonitor);
}
zmq_close(objectSocket);
zmq_ctx_destroy(objectContext);
}
}
static void
test_stream_handshake_timeout_accept (void)
{
int rc;
// Set up our context and sockets
void *ctx = zmq_ctx_new ();
assert (ctx);
// We use this socket in raw mode, to make a connection and send nothing
void *stream = zmq_socket (ctx, ZMQ_STREAM);
assert (stream);
int zero = 0;
rc = zmq_setsockopt (stream, ZMQ_LINGER, &zero, sizeof (zero));
assert (rc == 0);
rc = zmq_connect (stream, "tcp://localhost:5557");
assert (rc == 0);
// We'll be using this socket to test TCP stream handshake timeout
void *dealer = zmq_socket (ctx, ZMQ_DEALER);
assert (dealer);
rc = zmq_setsockopt (dealer, ZMQ_LINGER, &zero, sizeof (zero));
assert (rc == 0);
int val, tenth = 100;
size_t vsize = sizeof(val);
// check for the expected default handshake timeout value - 30 sec
rc = zmq_getsockopt (dealer, ZMQ_HANDSHAKE_IVL, &val, &vsize);
assert (rc == 0);
assert (vsize == sizeof(val));
assert (val == 30000);
// make handshake timeout faster - 1/10 sec
rc = zmq_setsockopt (dealer, ZMQ_HANDSHAKE_IVL, &tenth, sizeof (tenth));
assert (rc == 0);
vsize = sizeof(val);
// make sure zmq_setsockopt changed the value
rc = zmq_getsockopt (dealer, ZMQ_HANDSHAKE_IVL, &val, &vsize);
assert (rc == 0);
assert (vsize == sizeof(val));
assert (val == tenth);
// Create and connect a socket for collecting monitor events on dealer
void *dealer_mon = zmq_socket (ctx, ZMQ_PAIR);
assert (dealer_mon);
rc = zmq_socket_monitor (dealer, "inproc://monitor-dealer",
ZMQ_EVENT_CONNECTED | ZMQ_EVENT_DISCONNECTED | ZMQ_EVENT_ACCEPTED);
assert (rc == 0);
// Connect to the inproc endpoint so we'll get events
rc = zmq_connect (dealer_mon, "inproc://monitor-dealer");
assert (rc == 0);
// bind dealer socket to accept connection from non-sending stream socket
rc = zmq_bind (dealer, "tcp://127.0.0.1:5557");
assert (rc == 0);
// we should get ZMQ_EVENT_ACCEPTED and then ZMQ_EVENT_DISCONNECTED
int event = get_monitor_event (dealer_mon, NULL, NULL);
assert (event == ZMQ_EVENT_ACCEPTED);
event = get_monitor_event (dealer_mon, NULL, NULL);
assert (event == ZMQ_EVENT_DISCONNECTED);
rc = zmq_close (dealer);
assert (rc == 0);
rc = zmq_close (dealer_mon);
assert (rc == 0);
rc = zmq_close (stream);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
