} TEST_ENDDEF TEST_DEF(broken_connection_test_group_multichannel_out) { static pubnub_t *pbp; pbp = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp); pubnub_init(pbp, "demo", "demo"); expect_pnr(pubnub_remove_channel_group(pbp, "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_add_channel_to_group(pbp, "three", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); TEST_SLEEP_FOR(CHANNEL_REGISTRY_PROPAGATION_DELAY); expect_pnr(pubnub_subscribe(pbp, "ch,two", "gr"), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "ch", "\"Test 3\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "two", "\"Test 4\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "three", "\"Test 5\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_subscribe(pbp, "ch,two", "gr"), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test 3\"", "\"Test 4\"", "\"Test 5\"", NULL)); expect_pnr(pubnub_publish(pbp, "ch", "\"Test 3 - 2\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "two", "\"Test 4 - 2\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "three", "\"Test 5 - 2\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); printf("Please disconnect from Internet. Press Enter when done."); await_console(); expect_pnr(pubnub_subscribe(pbp, "ch,two", "gr"), PNR_STARTED); await_timed(6*SECONDS, PNR_ADDR_RESOLUTION_FAILED, pbp); printf("Please reconnect to Internet. Press Enter when done."); await_console(); expect_pnr(pubnub_subscribe(pbp, "ch,two", "gr"), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test 3 - 2\"", "\"Test 4 - 2\"", "\"Test 5 - 2\"", NULL)); expect_pnr(pubnub_publish(pbp, "ch", "\"Test 3 - 4\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "two", "\"Test 4 - 4\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "three", "\"Test 5 - 4\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_subscribe(pbp, "ch,two", "gr"), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test 3 - 4\"", "\"Test 4 - 4\"", "\"Test 5 - 4\"", NULL)); expect_pnr(pubnub_remove_channel_from_group(pbp, "three", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); TEST_POP_DEFERRED; } TEST_ENDDEF
void pnc_ops_subscribe(pubnub_t *pn_sub) { int i; enum pubnub_res res; char channels_string[PNC_SUBSCRIBE_CHANNELS_LIMIT * PNC_CHANNEL_NAME_SIZE]; char groups_string[PNC_SUBSCRIBE_CHANNELS_LIMIT * PNC_CHANNEL_NAME_SIZE]; puts("Subscribe will show the first message and return to select operation loop."); pnc_subscribe_list_channels(channels_string, sizeof channels_string); pnc_subscribe_list_channel_groups(groups_string, sizeof groups_string); for (i = 0; i < 2; i++) { puts("Subscribe loop..."); if (strlen(channels_string) == 0 && strlen(groups_string) == 0) { puts("You need to add some channels or channel groups first. Ignoring"); return; } else if (strlen(groups_string) == 0) { res = pubnub_subscribe(pn_sub, channels_string, NULL); } else if (strlen(channels_string) == 0) { res = pubnub_subscribe(pn_sub, NULL, groups_string); } else { res = pubnub_subscribe(pn_sub, channels_string, groups_string); } pnc_ops_parse_response("pubnub_subscribe()", res, pn_sub); } }
} TEST_ENDDEF TEST_DEF(wrong_api_usage) { static pubnub_t *pbp; pbp = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp); pubnub_init(pbp, g_pubkey, g_keysub); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "ch", "\"Test \""), PNR_STARTED); expect_pnr(pubnub_publish(pbp, "ch", "\"Test - 2\""), PNR_IN_PROGRESS); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_IN_PROGRESS); await_timed(5*SECONDS, PNR_OK, pbp); pubnub_set_non_blocking_io(pbp); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_IN_PROGRESS); expect_pnr(pubnub_publish(pbp, "ch", "\"Test - 2\""), PNR_IN_PROGRESS); pubnub_cancel(pbp); await_timed(5*SECONDS, PNR_CANCELLED, pbp); expect_pnr(pubnub_subscribe(pbp, NULL, NULL), PNR_INVALID_CHANNEL); TEST_POP_DEFERRED; } TEST_ENDDEF
} TEST_ENDDEF TEST_DEF(connect_disconnect_and_connect_again) { static pubnub_t *pbp; pbp = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp); pubnub_init(pbp, g_pubkey, g_keysub); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "ch", "\"Test M4\""), PNR_STARTED); pubnub_cancel(pbp); await_timed(5*SECONDS, PNR_CANCELLED, pbp); expect_pnr(pubnub_publish(pbp, "ch", "\"Test M4 - 2\""), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test M4 - 2\"", NULL)); pubnub_set_non_blocking_io(pbp); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); pubnub_cancel(pbp); await_timed(5*SECONDS, PNR_CANCELLED, pbp); expect_pnr(pubnub_publish(pbp, "ch", "\"Test M4 - 3\""), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test M4 - 3\"", NULL)); TEST_POP_DEFERRED; } TEST_ENDDEF
} TEST_ENDDEF TEST_DEF(connect_and_send_over_several_channels_simultaneously) { static pubnub_t *pbp; pbp = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp); pubnub_init(pbp, "demo", "demo"); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "ch", "\"Test M1\""), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "two", "\"Test M1\""), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test M1\"", NULL)); expect_pnr(pubnub_subscribe(pbp, "two", NULL), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test M1\"", NULL)); TEST_POP_DEFERRED; } TEST_ENDDEF
} TEST_ENDDEF TEST_DEF(simple_connect_and_receiver_over_single_channel) { static pubnub_t *pbp; static pubnub_t *pbp_2; pbp = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp); pubnub_init(pbp, "demo", "demo"); pbp_2 = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp_2); pubnub_init(pbp_2, "demo", "demo"); expect_pnr(pubnub_subscribe(pbp_2, "ch", NULL), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp_2); pubnub_set_non_blocking_io(pbp_2); expect_pnr(pubnub_subscribe(pbp_2, "ch", NULL), PNR_STARTED); expect_pnr(pubnub_publish(pbp, "ch", "\"Test 2\""), PNR_STARTED); await_timed_2(5*SECONDS, PNR_OK, pbp, PNR_OK, pbp_2); expect(pnfntst_got_messages(pbp_2, "\"Test 2\"", NULL)); expect_pnr(pubnub_publish(pbp, "ch", "\"Test 2 - 2\""), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_subscribe(pbp_2, "ch", NULL), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp_2); expect(pnfntst_got_messages(pbp_2, "\"Test 2 - 2\"", NULL)); TEST_POP_DEFERRED; TEST_POP_DEFERRED; } TEST_ENDDEF
} TEST_ENDDEF TEST_DEF(connect_disconnect_and_connect_again_combo) { static pubnub_t *pbp; static pubnub_t *pbp_2; pbp = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp); pubnub_init(pbp, g_pubkey, g_keysub); pbp_2 = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp_2); pubnub_init(pbp_2, g_pubkey, g_keysub); expect_pnr(pubnub_remove_channel_group(pbp, "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_add_channel_to_group(pbp, "ch", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); TEST_SLEEP_FOR(CHANNEL_REGISTRY_PROPAGATION_DELAY); expect_pnr(pubnub_subscribe(pbp, NULL, "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "ch", "\"Test M4\""), PNR_STARTED); pubnub_cancel(pbp); expect_pnr(pubnub_publish(pbp_2, "two", "\"Test M5\""), PNR_STARTED); pubnub_cancel(pbp_2); await_timed_2(5*SECONDS, PNR_CANCELLED, pbp, PNR_CANCELLED, pbp_2); expect_pnr(pubnub_publish(pbp, "ch", "\"Test M4 - 2\""), PNR_STARTED); expect_pnr(pubnub_publish(pbp_2, "two", "\"Test M5 - 2\""), PNR_STARTED); await_timed_2(5*SECONDS, PNR_OK, pbp, PNR_OK, pbp_2); expect_pnr(pubnub_subscribe(pbp, "two", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test M4 - 2\"", "\"Test M5 - 2\"", NULL)); pubnub_set_non_blocking_io(pbp); expect_pnr(pubnub_subscribe(pbp, "two", "gr"), PNR_STARTED); pubnub_cancel(pbp); await_timed(5*SECONDS, PNR_CANCELLED, pbp); expect_pnr(pubnub_publish(pbp, "ch", "\"Test M4 - 3\""), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "two", "\"Test M5 - 3\""), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_subscribe(pbp, "two", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test M4 - 3\"", "\"Test M5 - 3\"", NULL)); expect_pnr(pubnub_remove_channel_from_group(pbp, "ch", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); TEST_POP_DEFERRED; TEST_POP_DEFERRED; } TEST_ENDDEF
PUBNUB_API void PubNub::subscribe(const std::string &channel, long timeout, PubNub_subscribe_cb cb, void *cb_data) { if (cb) { subscribe_pair *cb_info = new subscribe_pair(std::pair<PubNub_subscribe_cb, PubNub *>(cb, this), cb_data); pubnub_subscribe(p, channel.c_str(), timeout, pubnub_cpp_subscribe_cb, cb_info); } else { pubnub_subscribe(p, channel.c_str(), timeout, NULL, NULL); } }
int main() { enum pubnub_res pbresult; pubnub_t *ctx = pubnub_alloc(); if (NULL == ctx) { puts("Couldn't allocate a Pubnub context"); return -1; } char pubkey[] = "pub-c-9e002851-755d-4197-9037-cfe897af871d"; char subkey[] = "sub-c-82c22366-19a3-11e6-9a17-0619f8945a4f"; char chnlname[] = "hello_world"; printf("pubnub info\npubkey %s\nsubkey %s\nchnlname %s\n",pubkey, subkey, chnlname); fflush(stdout); pubnub_init(ctx, pubkey, subkey); pubnub_subscribe(ctx, chnlname, NULL); pbresult = pubnub_await(ctx); if (pbresult != PNR_OK) { printf("Failed to subscribe, error %d\n", pbresult); pubnub_free(ctx); return -1; } while (1) { fflush(stdout); pubnub_subscribe(ctx, chnlname, NULL); pbresult = pubnub_await(ctx); if (pbresult != PNR_OK) { printf("Failed to subscribe, error %d\n", pbresult); pubnub_free(ctx); return -1; } else { char const *msg = pubnub_get(ctx); while (msg != NULL) { // printf("Got message: %s\n", msg); put_data_buf(msg); msg = pubnub_get(ctx); // printf("Got message2: %s\n", msg); } } } pubnub_free(ctx); return 0; }
static void read_stdin(int fd, short kind, void *userp) { struct pubnub *p = userp; char letter; int n = read(0, &letter, 1); if (n < 0) { perror("read"); exit(EXIT_FAILURE); } else if (n == 0) { // eof exit(EXIT_SUCCESS); } if (letter < 'a' || letter > 'z') { printf("Unknown input '%c'. Please press a letter 'a' to 'z'.\n", letter); return; } int i = letter - 'a'; subscribed[i] = !subscribed[i]; const char chname_buf[2] = { letter, 0 }; const char *chname = chname_buf; if (subscribed[i]) { printf("Subscribed to channel '%c'\n", letter); pubnub_subscribe(p, /* channel name */ chname, -1, subscribe_received, NULL); } else { printf("Unsubscribed from channel '%c'\n", letter); pubnub_unsubscribe(p, /* channel names */ &chname, 1, -1, NULL, NULL); } }
static void subscribe_received(struct pubnub *p, enum pubnub_res result, char **channels, struct json_object *msg, void *ctx_data, void *call_data) { /* ctx_data is (struct pubnub_libevent *) */ /* call_data is NULL as that's what we passed to pubnub_subscribe_multi() */ if (result == PNR_CANCELLED) { free(channels); return; } if (result != PNR_OK) /* This must be something fatal, we retry on recoverable * errors. */ exit(EXIT_FAILURE); if (json_object_array_length(msg) == 0) { printf("pubnub subscribe ok, no news\n"); } else { for (int i = 0; i < json_object_array_length(msg); i++) { json_object *msg1 = json_object_array_get_idx(msg, i); printf("pubnub subscribe [%s]: %s\n", channels[i], json_object_get_string(msg1)); free(channels[i]); } } free(channels); /* Loop. */ pubnub_subscribe(p, NULL, -1, subscribe_received, NULL); }
} TEST_ENDDEF TEST_DEF(connect_and_send_over_several_channels_in_group_simultaneously) { static pubnub_t *pbp; pbp = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp); pubnub_init(pbp, "demo", "demo"); expect_pnr(pubnub_remove_channel_group(pbp, "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_add_channel_to_group(pbp, "ch,two", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); TEST_SLEEP_FOR(CHANNEL_REGISTRY_PROPAGATION_DELAY); expect_pnr(pubnub_subscribe(pbp, NULL, "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "ch", "\"Test M1\""), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "two", "\"Test M2\""), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect(pnfntst_subscribe_and_check(pbp, NULL, "gr", 5*SECONDS, "\"Test M1\"", "ch", "\"Test M2\"", "two", NULL)); expect_pnr(pubnub_remove_channel_from_group(pbp, "ch,two", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); TEST_POP_DEFERRED; } TEST_ENDDEF
} TEST_ENDDEF TEST_DEF(broken_connection_test) { static pubnub_t *pbp; pbp = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp); pubnub_init(pbp, "demo", "demo"); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp, "ch", "\"Test 3\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test 3\"", NULL)); expect_pnr(pubnub_publish(pbp, "ch", "\"Test 3 - 2\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); printf("Please disconnect from Internet. Press Enter when done."); await_console(); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); await_timed(6*SECONDS, PNR_ADDR_RESOLUTION_FAILED, pbp); printf("Please reconnect to Internet. Press Enter when done."); await_console(); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test 3 - 2\"", NULL)); printf("Please disconnect from Internet. Press Enter when done."); await_console(); expect_pnr(pubnub_publish(pbp, "ch", "\"Test 3 - 3\""), PNR_STARTED); await_timed(6*SECONDS, PNR_ADDR_RESOLUTION_FAILED, pbp); printf("Please reconnect to Internet. Press Enter when done."); await_console(); expect_pnr(pubnub_publish(pbp, "ch", "\"Test 3 - 4\""), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_subscribe(pbp, "ch", NULL), PNR_STARTED); await_timed(6*SECONDS, PNR_OK, pbp); expect(pnfntst_got_messages(pbp, "\"Test 3 - 4\"", NULL)); TEST_POP_DEFERRED; } TEST_ENDDEF
} TEST_ENDDEF TEST_DEF(simple_connect_and_receiver_over_single_channel_in_group) { static pubnub_t *pbp; static pubnub_t *pbp_2; pbp = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp); pubnub_init(pbp, "demo", "demo"); pbp_2 = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp_2); pubnub_init(pbp_2, "demo", "demo"); expect_pnr(pubnub_remove_channel_group(pbp_2, "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp_2); expect_pnr(pubnub_add_channel_to_group(pbp_2, "ch", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp_2); TEST_SLEEP_FOR(CHANNEL_REGISTRY_PROPAGATION_DELAY); expect_pnr(pubnub_subscribe(pbp_2, NULL, "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp_2); pubnub_set_non_blocking_io(pbp_2); expect_pnr(pubnub_subscribe(pbp_2, NULL, "gr"), PNR_STARTED); expect_pnr(pubnub_publish(pbp, "ch", "\"Test 2\""), PNR_STARTED); await_timed_2(5*SECONDS, PNR_OK, pbp, PNR_OK, pbp_2); expect(pnfntst_got_messages(pbp_2, "\"Test 2\"", NULL)); expect_pnr(pubnub_publish(pbp, "ch", "\"Test 2 - 2\""), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_subscribe(pbp_2, NULL, "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp_2); expect(pnfntst_got_messages(pbp_2, "\"Test 2 - 2\"", NULL)); expect_pnr(pubnub_remove_channel_from_group(pbp, "ch", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); TEST_POP_DEFERRED; TEST_POP_DEFERRED; } TEST_ENDDEF
} TEST_ENDDEF TEST_DEF(complex_send_and_receive_over_channel_plus_group_simultaneously) { static pubnub_t *pbp; static pubnub_t *pbp_2; pbp = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp); pubnub_init(pbp, g_pubkey, g_keysub); pbp_2 = pubnub_alloc(); TEST_DEFER(pubnub_free, pbp_2); pubnub_init(pbp_2, g_pubkey, g_keysub); expect_pnr(pubnub_remove_channel_group(pbp, "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_add_channel_to_group(pbp, "two,three", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); TEST_SLEEP_FOR(CHANNEL_REGISTRY_PROPAGATION_DELAY); expect_pnr(pubnub_subscribe(pbp, NULL, "gr"), PNR_STARTED); expect_pnr(pubnub_subscribe(pbp_2, "ch", NULL), PNR_STARTED); await_timed_2(5*SECONDS, PNR_OK, pbp, PNR_OK, pbp_2); expect_pnr(pubnub_publish(pbp, "two", "\"Test M3\""), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); expect_pnr(pubnub_publish(pbp_2, "ch", "\"Test M3\""), PNR_STARTED); expect_pnr(pubnub_publish(pbp, "three", "\"Test M3 - 1\""), PNR_STARTED); await_timed_2(5*SECONDS, PNR_OK, pbp, PNR_OK, pbp_2); expect_pnr(pubnub_subscribe(pbp, NULL, "gr"), PNR_STARTED); expect_pnr(pubnub_subscribe(pbp_2, "ch", NULL), PNR_STARTED); await_timed_2(5*SECONDS, PNR_OK, pbp, PNR_OK, pbp_2); expect(pnfntst_got_messages(pbp, "\"Test M3\"", "\"Test M3 - 1\"", NULL)); expect(pnfntst_got_messages(pbp_2, "\"Test M3\"", NULL)); expect_pnr(pubnub_remove_channel_from_group(pbp, "two,three", "gr"), PNR_STARTED); await_timed(5*SECONDS, PNR_OK, pbp); TEST_POP_DEFERRED; TEST_POP_DEFERRED; } TEST_ENDDEF
void print_nub(struct PubnubRequest* nubreq, NubEv ev, char const* buf, int buf_len, void *ctx) { switch(ev) { case NUB_DATA: ve_qtracen("chat:", buf, buf_len); break; case NUB_ERROR: break; case NUB_DONE: ve_qtrace("nub done"); pubnub_subscribe(nubreq, nubreq->nub->timeToken, print_nub); break; } }
int main() { char const *msg; enum pubnub_res res; struct UserData user_data; struct UserData user_data_2; char const *chan = "hello_world"; pubnub_t *pbp = pubnub_alloc(); pubnub_t *pbp_2 = pubnub_alloc(); if (NULL == pbp) { printf("Failed to allocate Pubnub context!\n"); return -1; } if (NULL == pbp_2) { printf("Failed to allocate Pubnub context!\n"); return -1; } InitUserData(&user_data, pbp); InitUserData(&user_data_2, pbp_2); pubnub_init(pbp, "demo", "demo"); pubnub_register_callback(pbp, sample_callback, &user_data); pubnub_init(pbp_2, "demo", "demo"); pubnub_register_callback(pbp_2, sample_callback, &user_data_2); puts("-----------------------"); puts("Subscribing..."); puts("-----------------------"); /* First subscribe, to get the time token */ res = pubnub_subscribe(pbp, chan, NULL); if (res != PNR_STARTED) { printf("pubnub_subscribe() returned unexpected: %d\n", res); pubnub_free(pbp); pubnub_free(pbp_2); return -1; } puts("Await subscribe"); res = await(&user_data); if (res == PNR_STARTED) { printf("await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); pubnub_free(pbp_2); return -1; } if (PNR_OK == res) { puts("Subscribed!"); } else { printf("Subscribing failed with code: %d\n", res); } /* The "real" subscribe, with the just acquired time token */ res = pubnub_subscribe(pbp, chan, NULL); if (res != PNR_STARTED) { printf("pubnub_subscribe() returned unexpected: %d\n", res); pubnub_free(pbp); pubnub_free(pbp_2); return -1; } /* Don't do "full" await here, because we didn't publish anything yet! */ start_await(&user_data); puts("-----------------------"); puts("Publishing..."); puts("-----------------------"); /* Since the subscribe is ongoing in the `pbp` context, we can't publish on it, so we use a different context to publish */ res = pubnub_publish(pbp_2, chan, "\"Hello world from subscribe-publish callback sample!\""); if (res != PNR_STARTED) { printf("pubnub_publish() returned unexpected: %d\n", res); pubnub_free(pbp); pubnub_free(pbp_2); return -1; } puts("Await publish"); res = await(&user_data_2); if (res == PNR_STARTED) { printf("await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); pubnub_free(pbp_2); return -1; } if (PNR_OK == res) { printf("Published! Response from Pubnub: %s\n", pubnub_last_publish_result(pbp_2)); } else if (PNR_PUBLISH_FAILED == res) { printf("Published failed on Pubnub, description: %s\n", pubnub_last_publish_result(pbp_2)); } else { printf("Publishing failed with code: %d\n", res); } /* Don't need `pbp_2` no more */ if (pubnub_free(pbp_2) != 0) { printf("Failed to free the Pubnub context `pbp_2`\n"); } /* Now we await the subscribe on `pbp` */ puts("Await subscribe"); res = end_await(&user_data); if (res == PNR_STARTED) { printf("await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { puts("Subscribed! Got messages:"); for (;;) { msg = pubnub_get(pbp); if (NULL == msg) { break; } puts(msg); } } else { printf("Subscribing failed with code: %d\n", res); } /* We're done */ if (pubnub_free(pbp) != 0) { printf("Failed to free the Pubnub context `pbp`\n"); } puts("Pubnub subscribe-publish callback demo over."); return 0; }
int main() { /* This is a widely use channel, something should happen there from time to time */ char const *chan = "hello_world"; pubnub_t *pbp = pubnub_alloc(); if (NULL == pbp) { printf("Failed to allocate Pubnub context!\n"); return -1; } pubnub_init(pbp, "demo", "demo"); srand(time(NULL)); /* This is essential, as otherwise waiting for incoming data will block! Since we're doing this, be sure to not enable verbose debugging, as you won't see a thing except endless lines of some tracing. */ pubnub_set_non_blocking_io(pbp); puts("--------------------------"); puts("Subscribe loop starting..."); puts("--------------------------"); for (;;) { time_t t = time(NULL); bool stop = false; enum pubnub_res res = pubnub_subscribe(pbp, chan, NULL); if (res != PNR_STARTED) { printf("pubnub_subscribe() returned unexpected: %d\n", res); break;; } /* Don't await here, 'cause it will loop until done */ while (!stop) { res = pubnub_last_result(pbp); if (res == PNR_STARTED) { /* Here we simulate the "get out of subscribe loop" external signal with a random number. Basically, this has a 4% chance of stopping the wait every second. */ if (time(NULL) != t) { stop = (rand() % 25) == 3; t = time(NULL); } } else { if (PNR_OK == res) { puts("Subscribed! Got messages:"); for (;;) { char const *msg = pubnub_get(pbp); if (NULL == msg) { break; } puts(msg); } } else { printf("Subscribing failed with code: %d\n", res); } break; } } if (stop) { puts("---------------------------"); puts("Cancelling the Subscribe..."); puts("---------------------------"); pubnub_cancel(pbp); /* Now it's OK to await, since we don't have anything else to do */ pubnub_await(pbp); break; } } /* We're done */ if (pubnub_free(pbp) != 0) { printf("Failed to free the Pubnub context `pbp`\n"); } puts("Pubnub callback demo over."); return 0; }
/* wait for commands when idle */ void pubnub_atSubscribe(struct PubnubAt* nubat) { if (nubat->nub.httpc.reqQueue || nubat->atCmdPending) return; pubnub_subscribe(&nubat->subReq, nubat->nub.timeToken, subscribe_callback); }
int main() { char const *msg; enum pubnub_res res; char const *chan = "hello_world"; pubnub_t *pbp = pubnub_alloc(); if (NULL == pbp) { printf("Failed to allocate Pubnub context!\n"); return -1; } pubnub_init(pbp, "demo", "demo"); pubnub_set_transaction_timeout(pbp, PUBNUB_DEFAULT_NON_SUBSCRIBE_TIMEOUT); /* Leave this commented out to use the default - which is blocking I/O on most platforms. Uncomment to use non- blocking I/O. */ // pubnub_set_non_blocking_io(pbp); generate_uuid(pbp); pubnub_set_auth(pbp, "danaske"); puts("Publishing..."); res = pubnub_publish(pbp, chan, "\"Hello world from sync!\""); if (res != PNR_STARTED) { printf("pubnub_publish() returned unexpected: %d\n", res); pubnub_free(pbp); return -1; } res = pubnub_await(pbp); if (res == PNR_STARTED) { printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { printf("Published! Response from Pubnub: %s\n", pubnub_last_publish_result(pbp)); } else if (PNR_PUBLISH_FAILED == res) { printf("Published failed on Pubnub, description: %s\n", pubnub_last_publish_result(pbp)); } else { printf("Publishing failed with code: %d\n", res); } puts("Subscribing..."); res = pubnub_subscribe(pbp, chan, NULL); if (res != PNR_STARTED) { printf("pubnub_subscribe() returned unexpected: %d\n", res); pubnub_free(pbp); return -1; } res = pubnub_await(pbp); if (res == PNR_STARTED) { printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { puts("Subscribed!"); } else { printf("Subscribing failed with code: %d\n", res); } res = pubnub_subscribe(pbp, chan, NULL); if (res != PNR_STARTED) { printf("pubnub_subscribe() returned unexpected: %d\n", res); pubnub_free(pbp); return -1; } res = pubnub_await(pbp); if (res == PNR_STARTED) { printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { puts("Subscribed! Got messages:"); for (;;) { msg = pubnub_get(pbp); if (NULL == msg) { break; } puts(msg); } } else { printf("Subscribing failed with code: %d\n", res); } puts("Getting time..."); res = pubnub_time(pbp); if (res != PNR_STARTED) { printf("pubnub_time() returned unexpected: %d\n", res); pubnub_free(pbp); return -1; } res = pubnub_await(pbp); if (res == PNR_STARTED) { printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { printf("Gotten time: %s; last time token=%s\n", pubnub_get(pbp), pubnub_last_time_token(pbp)); } else { printf("Getting time failed with code: %d\n", res); } puts("Getting history with include_token..."); res = pubnub_history(pbp, chan, 10, true); if (res != PNR_STARTED) { printf("pubnub_history() returned unexpected: %d\n", res); pubnub_free(pbp); return -1; } res = pubnub_await(pbp); if (res == PNR_STARTED) { printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { puts("Got history! Elements:"); for (;;) { msg = pubnub_get(pbp); if (NULL == msg) { break; } puts(msg); } } else { printf("Getting history v2 with include_token failed with code: %d\n", res); } puts("Getting here_now presence..."); res = pubnub_here_now(pbp, chan, NULL); if (res != PNR_STARTED) { printf("pubnub_here_now() returned unexpected: %d\n", res); pubnub_free(pbp); return -1; } res = pubnub_await(pbp); if (res == PNR_STARTED) { printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { puts("Got here now presence!"); for (;;) { msg = pubnub_get(pbp); if (NULL == msg) { break; } puts(msg); } } else { printf("Getting here-now presence failed with code: %d\n", res); } /** Global here_now presence for "demo" subscribe key is _very_ long, but we have it here to show that we can handle very long response if the PUBNUB_DYNAMIC_REPLY_BUFFER is "on". */ if (PUBNUB_DYNAMIC_REPLY_BUFFER) { puts("Getting global here_now presence..."); res = pubnub_global_here_now(pbp); if (res != PNR_STARTED) { printf("pubnub_global_here_now() returned unexpected: %d\n", res); pubnub_free(pbp); return -1; } res = pubnub_await(pbp); if (res == PNR_STARTED) { printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { puts("Got global here now presence!"); for (;;) { msg = pubnub_get(pbp); if (NULL == msg) { break; } puts(msg); } } else { printf("Getting global here-now presence failed with code: %d\n", res); } } puts("Getting where_now presence..."); res = pubnub_where_now(pbp, pubnub_uuid_get(pbp)); if (res != PNR_STARTED) { printf("pubnub_where_now() returned unexpected: %d\n", res); pubnub_free(pbp); return -1; } res = pubnub_await(pbp); if (res == PNR_STARTED) { printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { puts("Got where now presence!"); for (;;) { msg = pubnub_get(pbp); if (NULL == msg) { break; } puts(msg); } } else { printf("Getting where-now presence failed with code: %d\n", res); } puts("Setting state..."); res = pubnub_set_state(pbp, chan, NULL, pubnub_uuid_get(pbp), "{\"x\":5}"); if (res != PNR_STARTED) { printf("pubnub_set_state() returned unexpected: %d\n", res); pubnub_free(pbp); return -1; } res = pubnub_await(pbp); if (res == PNR_STARTED) { printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { puts("Got set state response!"); for (;;) { msg = pubnub_get(pbp); if (NULL == msg) { break; } puts(msg); } } else { printf("Setting state failed with code: %d\n", res); } puts("Getting state..."); res = pubnub_state_get(pbp, chan, NULL, pubnub_uuid_get(pbp)); if (res != PNR_STARTED) { printf("pubnub_state_get() returned unexpected: %d\n", res); pubnub_free(pbp); return -1; } res = pubnub_await(pbp); if (res == PNR_STARTED) { printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { puts("Got state!"); for (;;) { msg = pubnub_get(pbp); if (NULL == msg) { break; } puts(msg); } } else { printf("Getting state failed with code: %d\n", res); } puts("List channel group..."); res = pubnub_list_channel_group(pbp, "channel-group"); if (res != PNR_STARTED) { printf("pubnub_state_get() returned unexpected: %d\n", res); pubnub_free(pbp); return -1; } res = pubnub_await(pbp); if (res == PNR_STARTED) { printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res); pubnub_free(pbp); return -1; } if (PNR_OK == res) { puts("Got channel group list!"); for (;;) { msg = pubnub_get_channel(pbp); if (NULL == msg) { break; } puts(msg); } } else { printf("Getting channel group list failed with code: %d ('%s')\n", res, pubnub_res_2_string(res)); } /* We're done */ if (pubnub_free(pbp) != 0) { printf("Failed to free the Pubnub context\n"); } puts("Pubnub sync demo over."); return 0; }
static #if defined _WIN32 void #else void* #endif pnc_ops_subscribe_thr(void *pn_sub_addr) { pubnub_t *pn_sub = (pubnub_t *)pn_sub_addr; enum pubnub_res res; char channels_string[PNC_SUBSCRIBE_CHANNELS_LIMIT * PNC_CHANNEL_NAME_SIZE]; char channel_groups_string[PNC_SUBSCRIBE_CHANNELS_LIMIT * PNC_CHANNEL_NAME_SIZE]; puts("\nSubscribe thread created"); pubnub_mutex_lock(m_loop_enabled_mutex); m_loop_enabled = true; pubnub_mutex_unlock(m_loop_enabled_mutex); for (;;) { bool loop_enabled; pubnub_mutex_lock(m_loop_enabled_mutex); loop_enabled = m_loop_enabled; pubnub_mutex_unlock(m_loop_enabled_mutex); if (!loop_enabled) { break; } puts("Subscribe loop..."); pnc_subscribe_list_channels(channels_string, sizeof channels_string); pnc_subscribe_list_channel_groups(channel_groups_string, sizeof channel_groups_string); if (strlen(channels_string) == 0 && strlen(channel_groups_string) == 0) { puts("You need add some channels or channel groups first. Ignoring"); break; } else if (strlen(channel_groups_string) == 0) { res = pubnub_subscribe(pn_sub, channels_string, NULL); } else if (strlen(channels_string) == 0) { res = pubnub_subscribe(pn_sub, NULL, channel_groups_string); } else { res = pubnub_subscribe(pn_sub, channels_string, channel_groups_string); } if (res != PNR_STARTED) { printf("pubnub_subscribe() returned unexpected %d: %s\n", res, pubnub_res_2_string(res)); break; } await(&m_user_data_sub); } #if !defined _WIN32 return NULL; #endif }
bool pnfntst_subscribe_and_check(pubnub_t *p, char const *channel, char const*chgroup, unsigned ms, ...) { char const *aMsgs[16]; char const *aChan[16]; uint16_t missing; size_t count = 0; pnfntst_timer_t *tmr; va_list vl; PUBNUB_ASSERT(pb_valid_ctx_ptr(p)); va_start(vl, ms); while (count < 16) { char const *msg = va_arg(vl, char*); if (NULL == msg) { break; } aMsgs[count] = msg; msg = va_arg(vl, char*); if (NULL == msg) { return false; } aChan[count] = msg; ++count; } va_end(vl); if ((0 == count) || (count > 16)) { return false; } missing = (0x01 << count) - 1; tmr = pnfntst_alloc_timer(); if (NULL == tmr) { puts("subscribe and check: timer alloc failed"); return false; } pnfntst_start_timer(tmr, ms); while (pnfntst_timer_is_running(tmr) && missing) { enum pubnub_res pbres; if (PNR_STARTED != pubnub_subscribe(p, channel, chgroup)) { puts("subscribe and check: subscribe failed"); break; } while (pnfntst_timer_is_running(tmr)) { pbres = pubnub_last_result(p); if (pbres != PNR_STARTED) { break; } } if (pbres != PNR_OK) { printf("subscribe and check: subscribe error %d\n", pbres); break; } do { size_t i; char const *msg = pubnub_get(p); char const *chan = pubnub_get_channel(p); if ((NULL == msg) || (NULL == chan)) { break; } for (i = 0; i < count; ++i) { if ((missing & (0x01 << i)) && (strcmp(msg, aMsgs[i]) == 0) && (strcmp(chan, aChan[i]) == 0) ) { missing &= ~(0x01 << i); break; } } } while (missing); } pnfntst_free_timer(tmr); return !missing; }