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_;
};
