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