void zyre_peer_test (bool verbose) { printf (" * zyre_peer: "); zsock_t *mailbox = zsock_new_dealer ("@tcp://127.0.0.1:5551"); zhash_t *peers = zhash_new (); zuuid_t *you = zuuid_new (); zuuid_t *me = zuuid_new (); zyre_peer_t *peer = zyre_peer_new (peers, you); assert (!zyre_peer_connected (peer)); zyre_peer_connect (peer, me, "tcp://127.0.0.1:5551"); assert (zyre_peer_connected (peer)); zyre_peer_set_name (peer, "peer"); assert (streq (zyre_peer_name (peer), "peer")); zre_msg_t *msg = zre_msg_new (ZRE_MSG_HELLO); zre_msg_set_endpoint (msg, "tcp://127.0.0.1:5552"); int rc = zyre_peer_send (peer, &msg); assert (rc == 0); msg = zre_msg_recv (mailbox); assert (msg); if (verbose) zre_msg_print (msg); zre_msg_destroy (&msg); // Destroying container destroys all peers it contains zhash_destroy (&peers); zuuid_destroy (&me); zuuid_destroy (&you); zsock_destroy (&mailbox); printf ("OK\n"); }
JNIEXPORT jlong JNICALL Java_org_zeromq_czmq_Zsock__1_1newDealer (JNIEnv *env, jclass c, jstring endpoint) { char *endpoint_ = (char *) (*env)->GetStringUTFChars (env, endpoint, NULL); jlong new_dealer_ = (jlong) (intptr_t) zsock_new_dealer (endpoint_); (*env)->ReleaseStringUTFChars (env, endpoint, endpoint_); return new_dealer_; }
static zsock_t * s_worker_socket () { zsock_t *worker = zsock_new_dealer("tcp://localhost:5556"); // Tell queue we're ready for work printf ("I: worker ready\n"); zframe_t *frame = zframe_new (PPP_READY, 1); zframe_send (&frame, worker, 0); return worker; }
/** * @brief Connects to the 0mq socket on path. * * Connects to the 0mq socket located on the file path passed in, then stores that socket in the global display struct * upon success. * * @returns Whether the connection succeeded. * * @param path The path to the 0mq socket in the filesystem. */ __PUBLIC bool mux_connect(const char *path) { display->zmq.path = path; display->zmq.socket = zsock_new_dealer(display->zmq.path); zsys_handler_set(mux_handler); if (display->zmq.socket == NULL) { mux_printf_error("0mq socket creation failed"); return false; } display->zmq.poller = zpoller_new(display->zmq.socket, NULL); if (display->zmq.poller == NULL) { mux_printf_error("Could not initialize socket poller"); return false; } mux_printf("Bound to %s", path); return true; }
void zeb_broker_test (bool verbose) { printf (" * zeb_broker: "); if (verbose) printf ("\n"); // @selftest zactor_t *server = zactor_new (zeb_broker, "broker"); if (verbose) zstr_send (server, "VERBOSE"); zstr_sendx (server, "BIND", "tcp://127.0.0.1:9999", NULL); zsock_t* client = zsock_new_dealer (">tcp://127.0.0.1:9999"); zsock_t* worker = zsock_new_dealer (">tcp://127.0.0.1:9999"); assert (client); assert (worker); xrap_traffic_t *traffic = xrap_traffic_new (); // Invalid Command xrap_traffic_set_id (traffic, XRAP_TRAFFIC_XRAP_OFFER); xrap_traffic_send (traffic, client); xrap_traffic_recv (traffic, client); assert (xrap_traffic_id (traffic) == XRAP_TRAFFIC_ERROR); assert (xrap_traffic_status_code (traffic) == XRAP_TRAFFIC_COMMAND_INVALID); // Open Connections for client & worker xrap_traffic_set_id (traffic, XRAP_TRAFFIC_CONNECTION_OPEN); xrap_traffic_send (traffic, client); xrap_traffic_recv (traffic, client); assert (xrap_traffic_id (traffic) == XRAP_TRAFFIC_OK); xrap_traffic_set_id (traffic, XRAP_TRAFFIC_CONNECTION_OPEN); xrap_traffic_send (traffic, worker); xrap_traffic_recv (traffic, worker); assert (xrap_traffic_id (traffic) == XRAP_TRAFFIC_OK); // Provide Rubish Offering xrap_traffic_set_id (traffic, XRAP_TRAFFIC_XRAP_OFFER); xrap_traffic_set_route (traffic, "///"); xrap_traffic_set_method (traffic, "GET"); xrap_traffic_send (traffic, worker); xrap_traffic_recv (traffic, worker); assert (xrap_traffic_id (traffic) == XRAP_TRAFFIC_FAIL); assert (xrap_traffic_status_code (traffic) == XRAP_TRAFFIC_CONFLICT); // Provide Offering xrap_traffic_set_id (traffic, XRAP_TRAFFIC_XRAP_OFFER); xrap_traffic_set_route (traffic, "/foo/{[^/]}"); xrap_traffic_set_method (traffic, "GET"); xrap_traffic_send (traffic, worker); xrap_traffic_recv (traffic, worker); assert (xrap_traffic_id (traffic) == XRAP_TRAFFIC_OK); // Send Request xrap_msg_t *xmsg = xrap_msg_new (XRAP_MSG_GET); xrap_msg_set_resource (xmsg, "%s", "/foo/bar"); zmsg_t *msg = xrap_msg_encode (&xmsg); xrap_traffic_set_id (traffic, XRAP_TRAFFIC_XRAP_SEND); xrap_traffic_set_content (traffic, &msg); xrap_traffic_send (traffic, client); xrap_traffic_recv (traffic, client); assert (xrap_traffic_id (traffic) == XRAP_TRAFFIC_OK); // Receive Request xrap_traffic_recv (traffic, worker); assert (xrap_traffic_id (traffic) == XRAP_TRAFFIC_XRAP_DELIVER); msg = zmsg_dup (xrap_traffic_content (traffic)); xmsg = xrap_msg_decode (&msg); assert (xrap_msg_id (xmsg) == XRAP_MSG_GET); assert (streq ("/foo/bar", xrap_msg_resource (xmsg))); xrap_msg_destroy (&xmsg); // Send Response xmsg = xrap_msg_new (XRAP_MSG_GET_OK); xrap_msg_set_status_code (xmsg, 200); xrap_msg_set_content_type (xmsg, "text/hello"); xrap_msg_set_content_body (xmsg, "Hello World!"); msg = xrap_msg_encode (&xmsg); xrap_traffic_set_id (traffic, XRAP_TRAFFIC_XRAP_DELIVER); xrap_traffic_set_content (traffic, &msg); xrap_traffic_send (traffic, worker); // Receive Response xrap_traffic_recv (traffic, client); assert (xrap_traffic_id (traffic) == XRAP_TRAFFIC_XRAP_DELIVER); msg = zmsg_dup (xrap_traffic_content (traffic)); xmsg = xrap_msg_decode (&msg); assert (xrap_msg_id (xmsg) == XRAP_MSG_GET_OK); assert (xrap_msg_status_code (xmsg) == 200); assert (streq ("text/hello", xrap_msg_content_type (xmsg))); assert (streq ("Hello World!", xrap_msg_content_body (xmsg))); xrap_msg_destroy (&xmsg); // Send Request 2 xmsg = xrap_msg_new (XRAP_MSG_GET); xrap_msg_set_resource (xmsg, "%s", "/fou/baz"); msg = xrap_msg_encode (&xmsg); xrap_traffic_set_id (traffic, XRAP_TRAFFIC_XRAP_SEND); xrap_traffic_set_content (traffic, &msg); xrap_traffic_send (traffic, client); xrap_traffic_recv (traffic, client); assert (xrap_traffic_id (traffic) == XRAP_TRAFFIC_FAIL); assert (xrap_traffic_status_code (traffic) == XRAP_TRAFFIC_NOT_FOUND); xrap_traffic_destroy (&traffic); // Finished, we can clean up zsock_destroy (&client); zsock_destroy (&worker); zactor_destroy (&server); // @end printf ("OK\n"); }
/// // Create a DEALER socket. Default action is connect. QZsock* QZsock::newDealer (const QString &endpoint, QObject *qObjParent) { return new QZsock (zsock_new_dealer (endpoint.toUtf8().data()), qObjParent); }
void zpipes_server_test (bool verbose) { printf (" * zpipes_server: \n"); if (verbose) printf ("\n"); // @selftest // Prepare test cases const char *endpoint = "ipc://@/zpipes/local"; zactor_t *server = zactor_new (zpipes_server, NULL); if (verbose) zstr_send (server, "VERBOSE"); zstr_sendx (server, "BIND", endpoint, NULL); zsock_t *writer = zsock_new_dealer (endpoint); assert (writer); zsock_t *writer2 = zsock_new_dealer (endpoint); assert (writer2); zsock_t *reader = zsock_new_dealer (endpoint); assert (reader); zsock_t *reader2 = zsock_new_dealer (endpoint); assert (reader2); zchunk_t *chunk = zchunk_new ("Hello, World", 12); int32_t timeout = 100; // -------------------------------------------------------------------- // Basic tests // Open writer on pipe zpipes_msg_send_output (writer, "test pipe"); if (s_expect_reply (writer, ZPIPES_MSG_OUTPUT_OK)) assert (false); // Write will timeout if there's no reader zpipes_msg_send_write (writer, chunk, timeout); if (s_expect_reply (writer, ZPIPES_MSG_WRITE_TIMEOUT)) assert (false); // Now open reader on pipe zpipes_msg_send_input (reader, "test pipe"); if (s_expect_reply (reader, ZPIPES_MSG_INPUT_OK)) assert (false); // Read will timeout if there's no data zpipes_msg_send_read (reader, 12, timeout); if (s_expect_reply (reader, ZPIPES_MSG_READ_TIMEOUT)) assert (false); // Write should now be successful zpipes_msg_send_write (writer, chunk, 0); if (s_expect_reply (writer, ZPIPES_MSG_WRITE_OK)) assert (false); // Read should now be successful zpipes_msg_send_read (reader, 12, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_OK)) assert (false); // Zero read request returns "end of pipe" zpipes_msg_send_read (reader, 0, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_END)) assert (false); // Close writer zpipes_msg_send_close (writer); if (s_expect_reply (writer, ZPIPES_MSG_CLOSE_OK)) assert (false); // Any read request returns "end of pipe" zpipes_msg_send_read (reader, 12, timeout); if (s_expect_reply (reader, ZPIPES_MSG_READ_END)) assert (false); // Close reader zpipes_msg_send_close (reader); if (s_expect_reply (reader, ZPIPES_MSG_CLOSE_OK)) assert (false); // -------------------------------------------------------------------- // Test pipelining (request queuing & filtering) // Open reader on pipe zpipes_msg_send_input (reader, "test pipe"); if (s_expect_reply (reader, ZPIPES_MSG_INPUT_OK)) assert (false); // Open writer on pipe zpipes_msg_send_output (writer, "test pipe"); if (s_expect_reply (writer, ZPIPES_MSG_OUTPUT_OK)) assert (false); // Pipeline three read requests zpipes_msg_send_read (reader, 12, timeout); zpipes_msg_send_read (reader, 12, timeout); zpipes_msg_send_read (reader, 12, timeout); // First read will return with a timeout if (s_expect_reply (reader, ZPIPES_MSG_READ_TIMEOUT)) assert (false); // Write chunk to pipe zpipes_msg_send_write (writer, chunk, 0); if (s_expect_reply (writer, ZPIPES_MSG_WRITE_OK)) assert (false); // Second read will succeed if (s_expect_reply (reader, ZPIPES_MSG_READ_OK)) assert (false); // Send PING, expect PING-OK back zpipes_msg_send_ping (reader); if (s_expect_reply (reader, ZPIPES_MSG_PING_OK)) assert (false); // Close writer zpipes_msg_send_close (writer); if (s_expect_reply (writer, ZPIPES_MSG_CLOSE_OK)) assert (false); // Third read will report end of pipe if (s_expect_reply (reader, ZPIPES_MSG_READ_END)) assert (false); // Close reader zpipes_msg_send_close (reader); if (s_expect_reply (reader, ZPIPES_MSG_CLOSE_OK)) assert (false); // Read now fails as pipe is closed zpipes_msg_send_read (reader, 12, timeout); if (s_expect_reply (reader, ZPIPES_MSG_INVALID)) assert (false); // Closing an already closed pipe is an error zpipes_msg_send_close (reader); if (s_expect_reply (reader, ZPIPES_MSG_INVALID)) assert (false); // -------------------------------------------------------------------- // Test read/close pipelining // Open reader on pipe zpipes_msg_send_input (reader, "test pipe"); if (s_expect_reply (reader, ZPIPES_MSG_INPUT_OK)) assert (false); // Open writer on pipe zpipes_msg_send_output (writer, "test pipe"); if (s_expect_reply (writer, ZPIPES_MSG_OUTPUT_OK)) assert (false); // Pipeline two read requests zpipes_msg_send_read (reader, 12, timeout); zpipes_msg_send_read (reader, 12, timeout); // Send PING, expect PING-OK back zpipes_msg_send_ping (reader); if (s_expect_reply (reader, ZPIPES_MSG_PING_OK)) assert (false); // Close reader zpipes_msg_send_close (reader); // First read now fails if (s_expect_reply (reader, ZPIPES_MSG_READ_FAILED)) assert (false); if (s_expect_reply (reader, ZPIPES_MSG_CLOSE_OK)) assert (false); // Second read is now invalid if (s_expect_reply (reader, ZPIPES_MSG_INVALID)) assert (false); // Close writer zpipes_msg_send_close (writer); if (s_expect_reply (writer, ZPIPES_MSG_CLOSE_OK)) assert (false); // -------------------------------------------------------------------- // Test reads and writes of different sizes // Open reader on pipe zpipes_msg_send_input (reader, "test pipe"); if (s_expect_reply (reader, ZPIPES_MSG_INPUT_OK)) assert (false); // Open writer on pipe zpipes_msg_send_output (writer, "test pipe"); if (s_expect_reply (writer, ZPIPES_MSG_OUTPUT_OK)) assert (false); // Write chunk to pipe zpipes_msg_send_write (writer, chunk, 0); if (s_expect_reply (writer, ZPIPES_MSG_WRITE_OK)) assert (false); // Close writer zpipes_msg_send_close (writer); if (s_expect_reply (writer, ZPIPES_MSG_CLOSE_OK)) assert (false); // Read back in several steps zpipes_msg_send_read (reader, 1, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_OK)) assert (false); zpipes_msg_send_read (reader, 2, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_OK)) assert (false); zpipes_msg_send_read (reader, 3, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_OK)) assert (false); zpipes_msg_send_read (reader, 3, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_OK)) assert (false); // We get a short read (3 bytes) zpipes_msg_send_read (reader, 100, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_OK)) assert (false); // Pipe is now empty zpipes_msg_send_read (reader, 100, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_END)) assert (false); // Close reader zpipes_msg_send_close (reader); if (s_expect_reply (reader, ZPIPES_MSG_CLOSE_OK)) assert (false); // -------------------------------------------------------------------- // Test connection expiry // Set connection timeout to 200 msecs zstr_sendx (server, "SET", "server/timeout", "200", NULL); // Open reader on pipe zpipes_msg_send_input (reader, "test pipe"); if (s_expect_reply (reader, ZPIPES_MSG_INPUT_OK)) assert (false); // Read will expire, we don't expect any response for this command zpipes_msg_send_read (reader, 12, 0); // Do nothing for long enough for the timeout to hit zclock_sleep (300); // Try again, server should now treat the client as disconnected zpipes_msg_send_read (reader, 12, 0); if (s_expect_reply (reader, ZPIPES_MSG_INVALID)) assert (false); // Now check that disconnection erases pipe contents // Open reader on pipe zpipes_msg_send_input (reader, "test pipe"); if (s_expect_reply (reader, ZPIPES_MSG_INPUT_OK)) assert (false); // Open writer on pipe zpipes_msg_send_output (writer, "test pipe"); if (s_expect_reply (writer, ZPIPES_MSG_OUTPUT_OK)) assert (false); // Write chunk to pipe zpipes_msg_send_write (writer, chunk, 0); if (s_expect_reply (writer, ZPIPES_MSG_WRITE_OK)) assert (false); // Do nothing for long enough for the timeout to hit // Both writer and reader should be disconnected zclock_sleep (300); // Open reader on pipe zpipes_msg_send_input (reader, "test pipe"); if (s_expect_reply (reader, ZPIPES_MSG_INPUT_OK)) assert (false); // Open writer on pipe zpipes_msg_send_output (writer, "test pipe"); if (s_expect_reply (writer, ZPIPES_MSG_OUTPUT_OK)) assert (false); // This read should timeout, as pipe is empty zpipes_msg_send_read (reader, 12, timeout); if (s_expect_reply (reader, ZPIPES_MSG_READ_TIMEOUT)) assert (false); // Close writer zpipes_msg_send_close (writer); if (s_expect_reply (writer, ZPIPES_MSG_CLOSE_OK)) assert (false); // Close reader zpipes_msg_send_close (reader); if (s_expect_reply (reader, ZPIPES_MSG_CLOSE_OK)) assert (false); // -------------------------------------------------------------------- // Test writer closing while reader still active // Open writer on pipe zpipes_msg_send_output (writer, "test pipe"); if (s_expect_reply (writer, ZPIPES_MSG_OUTPUT_OK)) assert (false); // Open reader on pipe zpipes_msg_send_input (reader, "test pipe"); if (s_expect_reply (reader, ZPIPES_MSG_INPUT_OK)) assert (false); // Write one chunk to pipe zpipes_msg_send_write (writer, chunk, 0); if (s_expect_reply (writer, ZPIPES_MSG_WRITE_OK)) assert (false); // Close writer, before reader has read data zpipes_msg_send_close (writer); if (s_expect_reply (writer, ZPIPES_MSG_CLOSE_OK)) assert (false); // Open writer on same pipe name zpipes_msg_send_output (writer, "test pipe"); if (s_expect_reply (writer, ZPIPES_MSG_OUTPUT_OK)) assert (false); // Read should still be successful zpipes_msg_send_read (reader, 12, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_OK)) assert (false); // Create second reader and open pipe for input zpipes_msg_send_input (reader2, "test pipe"); if (s_expect_reply (reader2, ZPIPES_MSG_INPUT_OK)) assert (false); // Write one chunk to pipe, will go to second instance zpipes_msg_send_write (writer, chunk, 0); if (s_expect_reply (writer, ZPIPES_MSG_WRITE_OK)) assert (false); // Pipe is terminated and empty zpipes_msg_send_read (reader, 0, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_END)) assert (false); // Reader2 should be successful zpipes_msg_send_read (reader2, 12, 0); if (s_expect_reply (reader2, ZPIPES_MSG_READ_OK)) assert (false); // Close reader zpipes_msg_send_close (reader); if (s_expect_reply (reader, ZPIPES_MSG_CLOSE_OK)) assert (false); // Close writer zpipes_msg_send_close (writer); if (s_expect_reply (writer, ZPIPES_MSG_CLOSE_OK)) assert (false); // Pipe is terminated and empty zpipes_msg_send_read (reader2, 0, 0); if (s_expect_reply (reader2, ZPIPES_MSG_READ_END)) assert (false); // Do that again to be sure it wasn't a coincidence :) zpipes_msg_send_read (reader2, 0, 0); if (s_expect_reply (reader2, ZPIPES_MSG_READ_END)) assert (false); // Close reader2 zpipes_msg_send_close (reader2); if (s_expect_reply (reader2, ZPIPES_MSG_CLOSE_OK)) assert (false); // -------------------------------------------------------------------- // Test reader closing while writer still active // Open writer on pipe zpipes_msg_send_output (writer, "test pipe"); if (s_expect_reply (writer, ZPIPES_MSG_OUTPUT_OK)) assert (false); // Open reader on pipe zpipes_msg_send_input (reader, "test pipe"); if (s_expect_reply (reader, ZPIPES_MSG_INPUT_OK)) assert (false); // Write one chunk to pipe zpipes_msg_send_write (writer, chunk, 0); if (s_expect_reply (writer, ZPIPES_MSG_WRITE_OK)) assert (false); // Read should be successful zpipes_msg_send_read (reader, 12, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_OK)) assert (false); // Close reader zpipes_msg_send_close (reader); if (s_expect_reply (reader, ZPIPES_MSG_CLOSE_OK)) assert (false); // Write should fail zpipes_msg_send_write (writer, chunk, 0); if (s_expect_reply (writer, ZPIPES_MSG_WRITE_FAILED)) assert (false); // Close writer zpipes_msg_send_close (writer); if (s_expect_reply (writer, ZPIPES_MSG_CLOSE_OK)) assert (false); // -------------------------------------------------------------------- // Two readers or writers on same pipe are not allowed // Open writer on pipe zpipes_msg_send_output (writer, "test pipe"); if (s_expect_reply (writer, ZPIPES_MSG_OUTPUT_OK)) assert (false); // Open second writer on pipe zpipes_msg_send_output (writer2, "test pipe"); if (s_expect_reply (writer2, ZPIPES_MSG_OUTPUT_FAILED)) assert (false); // Open reader on pipe zpipes_msg_send_input (reader, "test pipe"); if (s_expect_reply (reader, ZPIPES_MSG_INPUT_OK)) assert (false); // Open second reader on pipe zpipes_msg_send_input (reader2, "test pipe"); if (s_expect_reply (reader2, ZPIPES_MSG_INPUT_FAILED)) assert (false); // Close reader zpipes_msg_send_close (reader); if (s_expect_reply (reader, ZPIPES_MSG_CLOSE_OK)) assert (false); // Close writer zpipes_msg_send_close (writer); if (s_expect_reply (writer, ZPIPES_MSG_CLOSE_OK)) assert (false); // -------------------------------------------------------------------- // Test short read when writer closes // Open writer on pipe zpipes_msg_send_output (writer, "test pipe"); if (s_expect_reply (writer, ZPIPES_MSG_OUTPUT_OK)) assert (false); // Open reader on pipe zpipes_msg_send_input (reader, "test pipe"); if (s_expect_reply (reader, ZPIPES_MSG_INPUT_OK)) assert (false); // Write one chunk to pipe zpipes_msg_send_write (writer, chunk, 0); if (s_expect_reply (writer, ZPIPES_MSG_WRITE_OK)) assert (false); // Try to read large amount of data, will block zpipes_msg_send_read (reader, 1000, 0); // Close writer zpipes_msg_send_close (writer); if (s_expect_reply (writer, ZPIPES_MSG_CLOSE_OK)) assert (false); // Reader should now return short read if (s_expect_reply (reader, ZPIPES_MSG_READ_OK)) assert (false); // Pipe is terminated and empty zpipes_msg_send_read (reader, 0, 0); if (s_expect_reply (reader, ZPIPES_MSG_READ_END)) assert (false); // Close reader zpipes_msg_send_close (reader); if (s_expect_reply (reader, ZPIPES_MSG_CLOSE_OK)) assert (false); // -------------------------------------------------------------------- zchunk_destroy (&chunk); zactor_destroy (&server); zsock_destroy (&reader); zsock_destroy (&writer); zsock_destroy (&reader2); zsock_destroy (&writer2); // @end printf ("OK\n"); }
Z K1(zsocknewdealer){R ptr(zsock_new_dealer(xs));}
/// // Create a DEALER socket. Default action is connect. QmlZsock *QmlZsockAttached::constructDealer (const QString &endpoint) { QmlZsock *qmlSelf = new QmlZsock (); qmlSelf->self = zsock_new_dealer (endpoint.toUtf8().data()); return qmlSelf; };
/// // Create a DEALER socket. Default action is connect. QmlZsock *QmlZsockAttached::newDealer (const QString &endpoint) { QmlZsock *retQ_ = new QmlZsock (); retQ_->self = zsock_new_dealer (endpoint.toUtf8().data()); return retQ_; };