static int
s_subscriber (zloop_t *loop, zmq_pollitem_t *poller, void *args)
{
clonesrv_t *self = (clonesrv_t *) args;
// Get state snapshot if necessary
if (self->kvmap == NULL) {
self->kvmap = zhash_new ();
void *snapshot = zsocket_new (self->ctx, ZMQ_DEALER);
zsocket_connect (snapshot, "tcp://localhost:%d", self->peer);
zclock_log ("I: asking for snapshot from: tcp://localhost:%d",
self->peer);
zstr_sendm (snapshot, "ICANHAZ?");
zstr_send (snapshot, ""); // blank subtree to get all
while (true) {
kvmsg_t *kvmsg = kvmsg_recv (snapshot);
if (!kvmsg)
break; // Interrupted
if (streq (kvmsg_key (kvmsg), "KTHXBAI")) {
self->sequence = kvmsg_sequence (kvmsg);
kvmsg_destroy (&kvmsg);
break; // Done
}
kvmsg_store (&kvmsg, self->kvmap);
}
zclock_log ("I: received snapshot=%d", (int) self->sequence);
zsocket_destroy (self->ctx, snapshot);
}
// Find and remove update off pending list
kvmsg_t *kvmsg = kvmsg_recv (poller->socket);
if (!kvmsg)
return 0;
if (strneq (kvmsg_key (kvmsg), "HUGZ")) {
if (!s_was_pending (self, kvmsg)) {
// If active update came before client update, flip it
// around, store active update (with sequence) on pending
// list and use to clear client update when it comes later
zlist_append (self->pending, kvmsg_dup (kvmsg));
}
// If update is more recent than our kvmap, apply it
if (kvmsg_sequence (kvmsg) > self->sequence) {
self->sequence = kvmsg_sequence (kvmsg);
kvmsg_store (&kvmsg, self->kvmap);
zclock_log ("I: received update=%d", (int) self->sequence);
}
else
kvmsg_destroy (&kvmsg);
}
else
kvmsg_destroy (&kvmsg);
return 0;
}
int main (void)
{
// Prepare our context and publisher socket
zctx_t *ctx = zctx_new ();
void *publisher = zsocket_new (ctx, ZMQ_PUB);
zsocket_set_hwm (publisher, 0);
zsocket_bind (publisher, "tcp://*:5556");
zclock_sleep (200);
zhash_t *kvmap = zhash_new ();
int64_t sequence = 0;
srandom ((unsigned) time (NULL));
while (!zctx_interrupted) {
// Distribute as key-value message
kvmsg_t *kvmsg = kvmsg_new (++sequence);
kvmsg_fmt_key (kvmsg, "%d", randof (10000));
kvmsg_fmt_body (kvmsg, "%d", randof (1000000));
kvmsg_send (kvmsg, publisher);
kvmsg_store (&kvmsg, kvmap);
}
printf (" Interrupted\n%d messages out\n", (int) sequence);
zhash_destroy (&kvmap);
zctx_destroy (&ctx);
return 0;
}
static int
s_collector (zloop_t *loop, zmq_pollitem_t *poller, void *args)
{
clonesrv_t *self = (clonesrv_t *) args;
kvmsg_t *kvmsg = kvmsg_recv (poller->socket);
if (kvmsg) {
if (self->active) {
kvmsg_set_sequence (kvmsg, ++self->sequence);
kvmsg_send (kvmsg, self->publisher);
int ttl = atoi (kvmsg_get_prop (kvmsg, "ttl"));
if (ttl)
kvmsg_set_prop (kvmsg, "ttl",
"%" PRId64, zclock_time () + ttl * 1000);
kvmsg_store (&kvmsg, self->kvmap);
zclock_log ("I: publishing update=%d", (int) self->sequence);
}
else {
// If we already got message from active, drop it, else
// hold on pending list
if (s_was_pending (self, kvmsg))
kvmsg_destroy (&kvmsg);
else
zlist_append (self->pending, kvmsg);
}
}
return 0;
}
static void
state_manager (void *args, zctx_t *ctx, void *pipe)
{
zhash_t *kvmap = zhash_new ();
zstr_send (pipe, "READY");
void *snapshot = zsocket_new (ctx, ZMQ_ROUTER);
zsocket_bind (snapshot, "tcp://*:5556");
zmq_pollitem_t items [] = {
{ pipe, 0, ZMQ_POLLIN, 0 },
{ snapshot, 0, ZMQ_POLLIN, 0 }
};
int64_t sequence = 0; // Current snapshot version number
while (!zctx_interrupted) {
int rc = zmq_poll (items, 2, -1);
if (rc == -1 && errno == ETERM)
break; // Context has been shut down
// Apply state update from main thread
if (items [0].revents & ZMQ_POLLIN) {
kvmsg_t *kvmsg = kvmsg_recv (pipe);
if (!kvmsg)
break; // Interrupted
sequence = kvmsg_sequence (kvmsg);
kvmsg_store (&kvmsg, kvmap);
}
// Execute state snapshot request
if (items [1].revents & ZMQ_POLLIN) {
zframe_t *identity = zframe_recv (snapshot);
if (!identity)
break; // Interrupted
// Request is in second frame of message
char *request = zstr_recv (snapshot);
if (streq (request, "ICANHAZ?"))
free (request);
else {
printf ("E: bad request, aborting\n");
break;
}
// Send state snapshot to client
kvroute_t routing = { snapshot, identity };
// For each entry in kvmap, send kvmsg to client
zhash_foreach (kvmap, s_send_single, &routing);
// Now send END message with sequence number
printf ("Sending state shapshot=%d\n", (int) sequence);
zframe_send (&identity, snapshot, ZFRAME_MORE);
kvmsg_t *kvmsg = kvmsg_new (sequence);
kvmsg_set_key (kvmsg, "KTHXBAI");
kvmsg_set_body (kvmsg, (byte *) "", 0);
kvmsg_send (kvmsg, snapshot);
kvmsg_destroy (&kvmsg);
}
}
zhash_destroy (&kvmap);
}
// If key-value pair has expired, delete it and publish the
// fact to listening clients.
static int
s_flush_single (char *key, void *data, void *args)
{
clonesrv_t *self = (clonesrv_t *) args;
kvmsg_t *kvmsg = (kvmsg_t *) data;
int64_t ttl;
sscanf (kvmsg_get_prop (kvmsg, "ttl"), "%" PRId64, &ttl);
if (ttl && zclock_time () >= ttl) {
kvmsg_set_sequence (kvmsg, ++self->sequence);
kvmsg_set_body (kvmsg, (byte *) "", 0);
kvmsg_send (kvmsg, self->publisher);
kvmsg_store (&kvmsg, self->kvmap);
zclock_log ("I: publishing delete=%d", (int) self->sequence);
}
return 0;
}
static int
s_collector (zloop_t *loop, zmq_pollitem_t *poller, void *args)
{
clonesrv_t *self = (clonesrv_t *) args;
kvmsg_t *kvmsg = kvmsg_recv (poller->socket);
if (kvmsg) {
kvmsg_set_sequence (kvmsg, ++self->sequence);
kvmsg_send (kvmsg, self->publisher);
int ttl = atoi (kvmsg_get_prop (kvmsg, "ttl"));
if (ttl)
kvmsg_set_prop (kvmsg, "ttl",
"%" PRId64, zclock_time () + ttl * 1000);
kvmsg_store (&kvmsg, self->kvmap);
zclock_log ("I: publishing update=%d", (int) self->sequence);
}
return 0;
}
static int
s_new_master (zloop_t *loop, zmq_pollitem_t *unused, void *args)
{
clonesrv_t *self = (clonesrv_t *) args;
self->master = TRUE;
self->slave = FALSE;
zmq_pollitem_t poller = { self->subscriber, 0, ZMQ_POLLIN };
zloop_poller_end (bstar_zloop (self->bstar), &poller);
// Apply pending list to own hash table
while (zlist_size (self->pending)) {
kvmsg_t *kvmsg = (kvmsg_t *) zlist_pop (self->pending);
kvmsg_set_sequence (kvmsg, ++self->sequence);
kvmsg_send (kvmsg, self->publisher);
kvmsg_store (&kvmsg, self->kvmap);
zclock_log ("I: publishing pending=%d", (int) self->sequence);
}
return 0;
}
/**
* A callback function that should be invoked when there is input in
* the zeromq fd zeromq_fd. The collabclient is taken as the user data
* pointer.
*
* Add this callback using GDrawAddReadFD()
*/
static void zeromq_subscriber_fd_callback(int zeromq_fd, void* datas )
{
cloneclient_t* cc = (cloneclient_t*)datas;
// printf("zeromq_subscriber_fd_callback(1)\n");
int opt = 0;
size_t optsz = sizeof(int);
zmq_getsockopt( cc->subscriber, ZMQ_EVENTS, &opt, &optsz );
if( opt & ZMQ_POLLIN )
{
printf("zeromq_subscriber_fd_callback() have message! cc:%p\n",cc);
while( 1 )
{
kvmsg_t *kvmsg = kvmsg_recv_full (cc->subscriber, ZMQ_DONTWAIT);
if (kvmsg)
{
int64_t msgseq = kvmsg_sequence (kvmsg);
// Discard out-of-sequence kvmsgs, incl. heartbeats
if ( msgseq > cc->sequence)
{
int create = 1;
zeromq_subscriber_process_update( cc, kvmsg, create );
kvmsg_store (&kvmsg, cc->kvmap);
printf ("I: received update=%d\n", (int) cc->sequence);
}
else
{
kvmsg_destroy (&kvmsg);
}
}
else
break;
}
}
}
int main (void)
{
// Prepare our context and subscriber
zctx_t *ctx = zctx_new ();
void *snapshot = zsocket_new (ctx, ZMQ_DEALER);
zsocket_connect (snapshot, "tcp://localhost:5556");
void *subscriber = zsocket_new (ctx, ZMQ_SUB);
zsockopt_set_subscribe (subscriber, "");
zsocket_connect (subscriber, "tcp://localhost:5557");
void *publisher = zsocket_new (ctx, ZMQ_PUSH);
zsocket_connect (publisher, "tcp://localhost:5558");
zhash_t *kvmap = zhash_new ();
srandom ((unsigned) time (NULL));
// Get state snapshot
int64_t sequence = 0;
zstr_send (snapshot, "ICANHAZ?");
while (TRUE) {
kvmsg_t *kvmsg = kvmsg_recv (snapshot);
if (!kvmsg)
break; // Interrupted
if (streq (kvmsg_key (kvmsg), "KTHXBAI")) {
sequence = kvmsg_sequence (kvmsg);
printf ("I: received snapshot=%d\n", (int) sequence);
kvmsg_destroy (&kvmsg);
break; // Done
}
kvmsg_store (&kvmsg, kvmap);
}
int64_t alarm = zclock_time () + 1000;
while (!zctx_interrupted) {
zmq_pollitem_t items [] = { { subscriber, 0, ZMQ_POLLIN, 0 } };
int tickless = (int) ((alarm - zclock_time ()));
if (tickless < 0)
tickless = 0;
int rc = zmq_poll (items, 1, tickless * ZMQ_POLL_MSEC);
if (rc == -1)
break; // Context has been shut down
if (items [0].revents & ZMQ_POLLIN) {
kvmsg_t *kvmsg = kvmsg_recv (subscriber);
if (!kvmsg)
break; // Interrupted
// Discard out-of-sequence kvmsgs, incl. heartbeats
if (kvmsg_sequence (kvmsg) > sequence) {
sequence = kvmsg_sequence (kvmsg);
kvmsg_store (&kvmsg, kvmap);
printf ("I: received update=%d\n", (int) sequence);
}
else
kvmsg_destroy (&kvmsg);
}
// If we timed-out, generate a random kvmsg
if (zclock_time () >= alarm) {
kvmsg_t *kvmsg = kvmsg_new (0);
kvmsg_fmt_key (kvmsg, "%d", randof (10000));
kvmsg_fmt_body (kvmsg, "%d", randof (1000000));
kvmsg_send (kvmsg, publisher);
kvmsg_destroy (&kvmsg);
alarm = zclock_time () + 1000;
}
}
printf (" Interrupted\n%d messages in\n", (int) sequence);
zhash_destroy (&kvmap);
zctx_destroy (&ctx);
return 0;
}
int main (void)
{
// Prepare our context and subscriber
void *context = zmq_init (1);
void *subscriber = zmq_socket (context, ZMQ_SUB);
zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE, "", 0);
zmq_connect (subscriber, "tcp://localhost:5556");
void *snapshot = zmq_socket (context, ZMQ_XREQ);
zmq_connect (snapshot, "tcp://localhost:5557");
void *updates = zmq_socket (context, ZMQ_PUSH);
zmq_connect (updates, "tcp://localhost:5558");
s_catch_signals ();
zhash_t *kvmap = zhash_new ();
srandom ((unsigned) time (NULL));
// Get state snapshot
int64_t sequence = 0;
s_send (snapshot, "I can haz state?");
while (!s_interrupted) {
kvmsg_t *kvmsg = kvmsg_recv (snapshot);
if (!kvmsg)
break; // Interrupted
if (streq (kvmsg_key (kvmsg), "KTHXBAI")) {
sequence = kvmsg_sequence (kvmsg);
kvmsg_destroy (&kvmsg);
break; // Done
}
kvmsg_store (&kvmsg, kvmap);
}
printf ("I: received snapshot=%" PRId64 "\n", sequence);
int zero = 0;
zmq_setsockopt (snapshot, ZMQ_LINGER, &zero, sizeof (zero));
zmq_close (snapshot);
int64_t alarm = s_clock () + 1000;
while (!s_interrupted) {
zmq_pollitem_t items [] = { { subscriber, 0, ZMQ_POLLIN, 0 } };
int tickless = (int) ((alarm - s_clock ()));
if (tickless < 0)
tickless = 0;
int rc = zmq_poll (items, 1, tickless * 1000);
if (rc == -1)
break; // Context has been shut down
if (items [0].revents & ZMQ_POLLIN) {
kvmsg_t *kvmsg = kvmsg_recv (subscriber);
if (!kvmsg)
break; // Interrupted
// Discard out-of-sequence kvmsgs, incl. heartbeats
if (kvmsg_sequence (kvmsg) > sequence) {
sequence = kvmsg_sequence (kvmsg);
kvmsg_store (&kvmsg, kvmap);
printf ("I: received update=%" PRId64 "\n", sequence);
}
else
kvmsg_destroy (&kvmsg);
}
// If we timed-out, generate a random kvmsg
if (s_clock () >= alarm) {
kvmsg_t *kvmsg = kvmsg_new (0);
kvmsg_fmt_key (kvmsg, "%d", randof (10000));
kvmsg_fmt_body (kvmsg, "%d", randof (1000000));
kvmsg_send (kvmsg, updates);
kvmsg_destroy (&kvmsg);
alarm = s_clock () + 1000;
}
}
zhash_destroy (&kvmap);
printf (" Interrupted\n%" PRId64 " messages in\n", sequence);
zmq_setsockopt (updates, ZMQ_LINGER, &zero, sizeof (zero));
zmq_close (updates);
zmq_close (subscriber);
zmq_term (context);
return 0;
}
int main (void)
{
// Prepare our context and sockets
zctx_t *ctx = zctx_new ();
void *snapshot = zsocket_new (ctx, ZMQ_ROUTER);
zsocket_bind (snapshot, "tcp://*:5556");
void *publisher = zsocket_new (ctx, ZMQ_PUB);
zsocket_bind (publisher, "tcp://*:5557");
void *collector = zsocket_new (ctx, ZMQ_PULL);
zsocket_bind (collector, "tcp://*:5558");
// .split body of main task
// The body of the main task collects updates from clients and
// publishes them back out to clients:
int64_t sequence = 0;
zhash_t *kvmap = zhash_new ();
zmq_pollitem_t items [] = {
{ collector, 0, ZMQ_POLLIN, 0 },
{ snapshot, 0, ZMQ_POLLIN, 0 }
};
while (!zctx_interrupted) {
int rc = zmq_poll (items, 2, 1000 * ZMQ_POLL_MSEC);
// Apply state update sent from client
if (items [0].revents & ZMQ_POLLIN) {
kvmsg_t *kvmsg = kvmsg_recv (collector);
if (!kvmsg)
break; // Interrupted
kvmsg_set_sequence (kvmsg, ++sequence);
kvmsg_send (kvmsg, publisher);
kvmsg_store (&kvmsg, kvmap);
printf ("I: publishing update %5d\n", (int) sequence);
}
// Execute state snapshot request
if (items [1].revents & ZMQ_POLLIN) {
zframe_t *identity = zframe_recv (snapshot);
if (!identity)
break; // Interrupted
// Request is in second frame of message
char *request = zstr_recv (snapshot);
if (streq (request, "ICANHAZ?"))
free (request);
else {
printf ("E: bad request, aborting\n");
break;
}
// Send state snapshot to client
kvroute_t routing = { snapshot, identity };
// For each entry in kvmap, send kvmsg to client
zhash_foreach (kvmap, s_send_single, &routing);
// Now send END message with sequence number
printf ("I: sending shapshot=%d\n", (int) sequence);
zframe_send (&identity, snapshot, ZFRAME_MORE);
kvmsg_t *kvmsg = kvmsg_new (sequence);
kvmsg_set_key (kvmsg, "KTHXBAI");
kvmsg_set_body (kvmsg, (byte *) "", 0);
kvmsg_send (kvmsg, snapshot);
kvmsg_destroy (&kvmsg);
}
}
printf (" Interrupted\n%d messages handled\n", (int) sequence);
zhash_destroy (&kvmap);
zctx_destroy (&ctx);
return 0;
}
FontViewBase* collabclient_sessionJoin( void* ccvp, FontView *fv )
{
FontViewBase* ret = 0;
#ifdef BUILD_COLLAB
cloneclient_t* cc = (cloneclient_t*)ccvp;
printf("collabclient_sessionJoin(top)\n");
// Get state snapshot
cc->sequence = 0;
zstr_sendm (cc->snapshot, "ICANHAZ?");
zstr_send (cc->snapshot, SUBTREE);
// if we wait for timeoutMS millisec then we assume failure
// timeWaitedMS is used to keep track of how long we have waited
kvmsg_t* lastSFD = 0;
int timeWaitedMS = 0;
int timeoutMS = pref_collab_sessionJoinTimeoutMS;
while (true)
{
printf("timeoutMS:%d timeWaitedMS:%d\n", timeoutMS, timeWaitedMS );
if( timeWaitedMS >= timeoutMS )
{
char* addrport = collabclient_makeAddressString( cc->address, cc->port );
gwwv_post_error(_("FontForge Collaboration"),
_("Failed to connect to server session at %s"),
addrport );
return 0;
}
kvmsg_t *kvmsg = kvmsg_recv_full( cc->snapshot, ZMQ_DONTWAIT );
if (!kvmsg)
{
int msToWait = 50;
g_usleep( msToWait * 1000 );
timeWaitedMS += msToWait;
continue;
}
/* kvmsg_t *kvmsg = kvmsg_recv (cc->snapshot); */
/* if (!kvmsg) */
/* break; // Interrupted */
if (streq (kvmsg_key (kvmsg), "KTHXBAI")) {
cc->sequence = kvmsg_sequence (kvmsg);
printf ("I: received snapshot=%d\n", (int) cc->sequence);
kvmsg_destroy (&kvmsg);
// Done
break;
}
printf ("I: storing seq=%ld ", kvmsg_sequence (kvmsg));
if( kvmsg_get_prop (kvmsg, "type") )
printf(" type:%s", kvmsg_get_prop (kvmsg, "type") );
printf ("\n");
if( !strcmp(kvmsg_get_prop (kvmsg, "type"), MSG_TYPE_SFD ))
{
if( !lastSFD ||
kvmsg_sequence (kvmsg) > kvmsg_sequence (lastSFD))
{
lastSFD = kvmsg;
}
size_t data_size = kvmsg_size(lastSFD);
printf("data_size:%ld\n", data_size );
}
kvmsg_store (&kvmsg, cc->kvmap);
}
printf("collabclient_sessionJoin(done with netio getting snapshot)\n");
printf("collabclient_sessionJoin() lastSFD:%p\n", lastSFD );
// int rc = 0;
// void* out = 0;
// rc = zhash_foreach ( cc->kvmap, collabclient_sessionJoin_findSFD_foreach_fn, &out );
// printf("collabclient_sessionJoin() last sfd:%p\n", out );
if( !lastSFD )
{
gwwv_post_error(_("FontForge Collaboration"), _("No Font Snapshot received from the server"));
return 0;
}
if( lastSFD )
{
int openflags = 0;
char filename[PATH_MAX];
snprintf(filename, PATH_MAX, "%s/fontforge-collab-import-%d.sfd",getTempDir(),getpid());
GFileWriteAll( filename, kvmsg_body (lastSFD) );
/*
* Since we are creating a new fontview window for the collab session
* we "hand over" the collabClient from the current fontview used to join
* the session to the fontview which owns the sfd from the wire.
*/
FontViewBase* newfv = ViewPostScriptFont( filename, openflags );
newfv->collabClient = cc;
fv->b.collabClient = 0;
newfv->collabState = cs_client;
FVTitleUpdate( newfv );
collabclient_notifySessionJoining( cc, newfv );
ret = newfv;
/* cloneclient_t* newc = collabclient_new( cc->address, cc->port ); */
/* collabclient_sessionJoin( newc, fv ); */
}
printf("applying updates from server that were performed after the SFD snapshot was done...\n");
kvmap_visit( cc->kvmap, kvmsg_sequence (lastSFD),
collabclient_sessionJoin_processmsg_foreach_fn, cc );
/* struct collabclient_sessionJoin_processUpdates_foreach_args args; */
/* args.cc = cc; */
/* args.lastSFD = lastSFD; */
/* rc = zhash_foreach ( cc->kvmap, collabclient_sessionJoin_processUpdates_foreach_fn, &args ); */
printf("collabclient_sessionJoin(complete)\n");
#endif
return ret;
}
/**
* COllect Updates
*
* We store each update with a new sequence number, and if necessary, a
* time-to-live. We publish updates immediately on our publisher socket:
*/
static int
s_collector (zloop_t *loop, zmq_pollitem_t *poller, void *args)
{
clonesrv_t *self = (clonesrv_t *) args;
DEBUG("I: s_collector");
kvmsg_t *kvmsg = kvmsg_recv (poller->socket);
if (kvmsg) {
kvmsg_set_sequence (kvmsg, ++self->sequence);
kvmsg_fmt_key(kvmsg, "%s%d", SUBTREE, self->sequence-1 );
if( !strcmp(MSG_TYPE_SFD, kvmsg_get_prop (kvmsg, "type")))
{
// setup the beacon
// Broadcast on the zyre port
beacon_announce_t ba;
memset( &ba, 0, sizeof(ba));
strcpy( ba.protocol, "fontforge-collab" );
ba.version = 2;
char* uuid = kvmsg_get_prop (kvmsg, "collab_uuid" );
if( uuid ) {
strcpy( ba.uuid, uuid );
} else {
ff_uuid_generate( ba.uuid );
}
strncpy( ba.username, GetAuthor(), beacon_announce_username_sz );
ff_gethostname( ba.machinename, beacon_announce_machinename_sz );
ba.port = htons( self->port );
strcpy( ba.fontname, "" );
DEBUG("I: adding beacon, payloadsz:%zu user:%s machine:%s",
sizeof(beacon_announce_t), ba.username, ba.machinename );
char* fontname = kvmsg_get_prop (kvmsg, "fontname" );
if( fontname )
{
strcpy( ba.fontname, fontname );
}
service_beacon = zbeacon_new( self->ctx, 5670 );
zbeacon_set_interval (service_beacon, 300 );
zbeacon_publish (service_beacon, (byte*)&ba, sizeof(ba));
}
kvmsg_send (kvmsg, self->publisher);
// int ttl = atoi (kvmsg_get_prop (kvmsg, "ttl"));
// if (ttl)
// kvmsg_set_prop (kvmsg, "ttl",
// "%" PRId64, zclock_time () + ttl * 1000);
DEBUG ("I: publishing update=%d type:%s", (int) self->sequence,kvmsg_get_prop (kvmsg, "type"));
DEBUG("I:x hash size:%ld", zhash_size(self->kvmap));
kvmsg_store( &kvmsg, self->kvmap );
}
return 0;
}