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; }
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); }
static int collabclient_sessionJoin_processmsg_foreach_fn( kvmsg_t* msg, void *argument ) { cloneclient_t* cc = (cloneclient_t*)argument; printf("processmsg_foreach() seq:%ld\n", kvmsg_sequence (msg) ); int create = 1; zeromq_subscriber_process_update( cc, msg, create ); return 0; }
/** * We call this function for each key-value pair in our hash table */ static int s_send_single (const char *key, void *data, void *args) { kvroute_t *kvroute = (kvroute_t *) args; kvmsg_t *kvmsg = (kvmsg_t *) data; DEBUG ("I: s_send_single %"PRId64" type:%s", kvmsg_sequence(kvmsg), kvmsg_get_prop (kvmsg, "type") ); if (strlen (kvroute->subtree) <= strlen (kvmsg_key (kvmsg)) && memcmp (kvroute->subtree, kvmsg_key (kvmsg), strlen (kvroute->subtree)) == 0) { zframe_send (&kvroute->identity, // Choose recipient kvroute->socket, ZFRAME_MORE + ZFRAME_REUSE); kvmsg_send (kvmsg, kvroute->socket); } 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; } } }
/** * Process the given kvmsg from the server. If create is set and we do * not have any charview for a changed glyph then we first create a * charview for it. This allows the updates from a server to be * processed at startup time, getting us up to speed with any glyphs * that have changed. * * This function is mainly called in response to an update which is * published from the server. However, in sessionJoin() we also call * here to handle the incremental updates to glyphs that have occurred * after the SFD was sent to the server. */ static void zeromq_subscriber_process_update( cloneclient_t* cc, kvmsg_t *kvmsg, int create ) { cc->sequence = kvmsg_sequence (kvmsg); if( cc->sequence >= cc->roundTripTimerWaitingSeq ) cc->roundTripTimerWaitingSeq = 0; char* uuid = kvmsg_get_prop (kvmsg, "uuid" ); byte* data = kvmsg_body (kvmsg); size_t data_size = kvmsg_size (kvmsg); printf("cc process_update() uuid:%s\n", uuid ); FontView* fv = FontViewFind( FontViewFind_byXUIDConnected, uuid ); printf("fv:%p\n", fv ); if( fv ) { if( !data_size ) { printf("WARNING: zero length message!\n" ); return; } SplineFont *sf = fv->b.sf; if( !sf ) { printf("ERROR: font view does not have the splinefont set!\n" ); return; } char* pos = kvmsg_get_prop (kvmsg, "pos" ); char* name = kvmsg_get_prop (kvmsg, "name" ); printf("pos:%s\n", pos ); // SplineChar *sc = sf->glyphs[ atoi(pos) ]; SplineChar* sc = SFGetOrMakeChar( sf, -1, name ); printf("sc:%p\n", sc ); if( !sc ) { printf("WARNING: font view does not have a glyph for pos:%s\n", pos ); printf("WARNING: font view does not have a glyph for name:%s\n", name ); return; } printf("sc.name:%s\n", sc->name ); printf("data.size:%ld\n", data_size ); if( DEBUG_SHOW_SFD_CHUNKS ) printf("data:%s\n", data ); int current_layer = 0; if( !sc->views && create ) { int show = 0; CharView* cv = CharViewCreateExtended( sc, fv, -1, show ); printf("created charview:%p\n", cv ); } for( CharViewBase* cv = sc->views; cv; cv = cv->next ) { printf("have charview:%p\n", cv ); char filename[PATH_MAX]; snprintf(filename, PATH_MAX, "%s/fontforge-collab-inx-%d.sfd", getTempDir(), getpid() ); GFileWriteAll( filename, (char*)data); FILE* file = fopen( filename, "rb" ); Undoes* undo = SFDGetUndo( sf, file, sc, "UndoOperation", "EndUndoOperation", current_layer ); fclose(file); if( !undo ) { printf("***** ERROR ****** reading back undo instance!\n"); printf("data: %s\n\n", data ); } if( undo ) { // NOT HANDLED! if( undo->undotype == ut_statehint ) { printf("*** warning ut_statehint not handled\n"); break; } printf("________________________ READ undo.layer: %d dm:%d layer_sz:%d\n", undo->layer, cv->drawmode, cv->sc->layer_cnt ); int selectedlayer = cv->drawmode; if( undo->layer != UNDO_LAYER_UNKNOWN ) selectedlayer = undo->layer; // use oldlayer to store current setting and switch to the // selected layer for this block. int oldlayer = cv->drawmode; cv->drawmode = selectedlayer; undo->next = 0; undo->next = cv->layerheads[selectedlayer]->redoes; cv->layerheads[selectedlayer]->redoes = undo; CVDoRedo( cv ); char* isLocalUndo = kvmsg_get_prop (kvmsg, "isLocalUndo" ); if( isLocalUndo ) { if( isLocalUndo[0] == '1' ) { Undoes* undo = cv->layerheads[selectedlayer]->undoes; if( undo ) { cv->layerheads[selectedlayer]->undoes = undo->next; undo->next = cv->layerheads[selectedlayer]->redoes; cv->layerheads[selectedlayer]->redoes = undo; } } } if( cv->drawmode != oldlayer ) { cv->drawmode = oldlayer; CVCharChangedUpdate( cv ); } } break; } } printf ("I: processed update=%d\n", (int) cc->sequence); }
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; }
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; }