} TEST_ENDDEF
TEST_DEF(connect_and_receive_over_several_channels_simultaneously) {
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,two", NULL), PNR_STARTED);
await_timed(5*SECONDS, PNR_OK, pbp_2);
expect_pnr(pubnub_publish(pbp, "ch", "\"Test M2\""), PNR_STARTED);
await_timed(5*SECONDS, PNR_OK, pbp);
expect_pnr(pubnub_publish(pbp, "two", "\"Test M2-2\""), PNR_STARTED);
await_timed(5*SECONDS, PNR_OK, pbp);
expect_pnr(pubnub_subscribe(pbp_2, "ch,two", NULL), PNR_STARTED);
await_timed(5*SECONDS, PNR_OK, pbp_2);
expect(pnfntst_got_messages(pbp_2, "\"Test M2\"", "\"Test M2-2\"", NULL));
TEST_POP_DEFERRED;
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
int
main(void)
{
/* Set up the libevent library. */
event_init();
/* Set up the PubNub library, with a single shared context,
* using the libevent backend for event handling. */
struct pubnub *p = pubnub_init("demo", "demo", &pubnub_libevent_callbacks, pubnub_libevent_init());
/* Set the terminal interaction handlers. */
terminal_interactive();
atexit(terminal_cooked);
struct event ev;
event_set(&ev, 0 /*stdin*/, EV_READ | EV_PERSIST, read_stdin, p);
event_add(&ev, NULL);
/* Start the event loop. */
event_dispatch();
/* We should never reach here. */
pubnub_done(p);
return EXIT_SUCCESS;
}
} 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_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_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
PUBNUB_API
PubNub::PubNub(const std::string &publish_key, const std::string &subscribe_key,
const struct pubnub_callbacks *cb, void *cb_data)
{
p = pubnub_init(publish_key.c_str(), subscribe_key.c_str(), cb, cb_data);
p_autodestroy = true;
}
} 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
int
main(void)
{
/* Set up the libevent library. */
event_init();
/* Set up the PubNub library, with a single shared context,
* using the libevent backend for event handling. */
struct pubnub *p = pubnub_init("demo", "demo", &pubnub_libevent_callbacks, pubnub_libevent_init());
/* Set the clock update timer. */
evtimer_set(&clock_update_timer, clock_update, NULL);
clock_update(-1, EV_TIMEOUT, NULL);
/* First step in the PubNub call sequence is publishing a message. */
publish(p);
/* Here, we could start any other asynchronous operations as needed,
* launch a GUI or whatever. */
/* Start the event loop. */
event_dispatch();
/* We should never reach here. */
pubnub_done(p);
return EXIT_SUCCESS;
}
TEST_F(PubNubCppTest, PubNubAutoDone) {
pubnub *p = pubnub_init("demo", "demo", &cb, NULL);
{
PubNub pn(p, true);
EXPECT_FALSE(initCalled);
}
EXPECT_TRUE(doneCalled);
}
} 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_F(PubNubCppTest, PubNubNotAutoDone) {
pubnub *p = pubnub_init("demo", "demo", &cb, NULL);
{
PubNub pn(p);
EXPECT_FALSE(initCalled);
}
ASSERT_FALSE(doneCalled);
pubnub_done(p);
}
static void srand_from_pubnub(char const* pubkey, char const* keysub)
{
pubnub_t* pbp = pubnub_alloc();
if (pbp != NULL) {
pubnub_init(pbp, pubkey, keysub);
srand_from_pubnub_time(pbp);
pubnub_free(pbp);
}
}
int pubnub_atInit(struct PubnubAt* nubat, char const* channel, const char* publishKey,
const char* subscribeKey, const char* secretKey, const char* host, u16 port)
{
pubnub_init(&nubat->nub, channel, publishKey, subscribeKey, secretKey, host, port, nubat);
pubnub_req_init(&nubat->nub, &nubat->subReq, 512, 512);
nubat->atCmdPending = veFalse;
nubat->g = NULL;
return RET_OK;
}
// see www.pubnub.com/blog/build-real-time-web-apps-easy
void pubnub_demo_chat(void)
{
static struct Pubnub nub;
static struct PubnubRequest nubreq;
/* The underlying tcp connection, should reconnect in case of failure.. */
pubnub_init(&nub, "chat", "demo", "demo", "0", "pubsub.pubnub.com", 80, NULL);
pubnub_req_init(&nub, &nubreq, 512, 512);
pubnub_publish(&nubreq, "\"Hello World From c\"", print_nub);
}
} 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 pubnub_account(void)
{
static struct Pubnub nub;
static struct PubnubRequest nubreq;
/* The underlying tcp connection, should reconnect in case of failure.. */
pubnub_init(&nub, "6356800465306", dev_regs.pubnubPublishKey, dev_regs.pubnubSubscribeKey,
"0", "pubsub.pubnub.com", 80, NULL);
pubnub_req_init(&nub, &nubreq, 512, 512);
pubnub_publish(&nubreq, "\"Hello World From c\"", print_nub);
}
int pubnub_send(char *p_data)
{
enum pubnub_res l_response;
char const *l_responseChannel = "parkingdevice-resp";
struct Pubnub_UUID uuid;
struct Pubnub_UUID_String str_uuid;
pubnub_t *l_publish = pubnub_alloc();
if (NULL == l_publish)
{
printf("Failed to allocate Pubnub context!\n");
return -1;
}
pubnub_init(l_publish, pub_key, sub_key);
if (0 != pubnub_generate_uuid_v4_random(&uuid))
{
pubnub_set_uuid(l_publish, "zeka-peka-iz-jendeka");
}
else
{
str_uuid = pubnub_uuid_to_string(&uuid);
pubnub_set_uuid(l_publish, str_uuid.uuid);
printf("Generated UUID: %s\n", str_uuid.uuid);
}
pubnub_set_auth(l_publish, "danaske");
puts("Publishing...");
l_response = pubnub_publish(l_publish, l_responseChannel, p_data);
if(l_response != PNR_STARTED)
{
printf("pubnub_publish() returned unexpected: %d\n", l_response);
pubnub_free(l_publish);
return -1;
}
l_response = pubnub_await(l_publish);
if (l_response == PNR_STARTED)
{
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", l_response);
pubnub_free(l_publish);
return -1;
}
if (PNR_OK == l_response) {
printf("Published! Response from Pubnub: %s\n", pubnub_last_publish_result(l_publish));
return 0;
}
else if (PNR_PUBLISH_FAILED == l_response) {
printf("Published failed on Pubnub, description: %s\n", pubnub_last_publish_result(l_publish));
}
else {
printf("Publishing failed with code: %d\n", l_response);
}
pubnub_free(l_publish);
return 0;
}
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;
}
TEST_F(PubNubCppTest, PubNubSettersGetters) {
pubnub *p = pubnub_init("demo", "demo", &cb, NULL);
PubNub pn(p, true);
const char *sk = "secret_key";
pn.set_secret_key(sk);
EXPECT_STREQ(sk, p->secret_key);
const char *ck = "cipher_key";
pn.set_cipher_key(ck);
EXPECT_STREQ(ck, p->cipher_key);
const char *org = "origin";
pn.set_origin(org);
EXPECT_STREQ(org, p->origin);
const char *uuid = "uuid";
pn.set_uuid(uuid);
EXPECT_STREQ(uuid, pn.current_uuid().c_str());
}
} 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
int pubnub_publishStatus(char *p_data){
enum pubnub_res res;
char const *chan = "sensorStatus-resp";
pubnub_t *pbp = pubnub_alloc();
if (NULL == pbp) {
printf("Failed to allocate Pubnub context!\n");
return -1;
}
pubnub_init(pbp, g_pub_key,g_sub_key);
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");
res = pubnub_publish(pbp, chan, p_data);
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);
}
return 0;
}
} TEST_ENDDEF
TEST_DEF(handling_errors_from_pubnub) {
static pubnub_t *pbp;
pbp = pubnub_alloc();
TEST_DEFER(pubnub_free, pbp);
pubnub_init(pbp, g_pubkey, g_keysub);
expect_pnr(pubnub_publish(pbp, "ch", "\"Test "), PNR_STARTED);
await_timed(5*SECONDS, PNR_PUBLISH_FAILED, pbp);
expect(400 == pubnub_last_http_code(pbp));
expect(pubnub_parse_publish_result(pubnub_last_publish_result(pbp)) == PNPUB_INVALID_JSON);
expect_pnr(pubnub_publish(pbp, ",", "\"Test \""), PNR_STARTED);
await_timed(5*SECONDS, PNR_PUBLISH_FAILED, pbp);
expect(400 == pubnub_last_http_code(pbp));
expect(pubnub_parse_publish_result(pubnub_last_publish_result(pbp)) == PNPUB_INVALID_CHAR_IN_CHAN_NAME);
TEST_POP_DEFERRED;
} TEST_ENDDEF
virtual void SetUp() {
memset(&cb, 0, sizeof(cb));
cb.add_socket = pubnub_test_add_socket;
cb.rem_socket = pubnub_test_rem_socket;
cb.timeout = pubnub_test_timeout;
cb.wait = pubnub_test_wait;
cb.stop_wait = pubnub_test_stop_wait;
waitCalled = 0;
curlInit = false;
curlRequests.clear();
_err_pipe[0] = 0;
_err_pipe[1] = 0;
_old_err = 0;
_err.clear();
#ifdef _MSC_VER
if (_pipe(_err_pipe, 65536, O_BINARY) != -1) {
#define READ_PIPE(hnd, buf, size) (eof(hnd) ? 0 : read(hnd, buf, size))
#else
if (pipe2(_err_pipe, O_NONBLOCK) != -1) {
#define READ_PIPE(hnd, buf, size) read(hnd, buf, size)
#endif
_old_err = dup(fileno(stderr));
fflush(stderr);
dup2(_err_pipe[1], fileno(stderr));
}
p = pubnub_init("publish_key", "subscribe_key", &cb, NULL);
addSock = remSock = 0;
addSockMode = 0;
cbCalled = false;
}
virtual void TearDown() {
if (_old_err > 0) {
dup2(_old_err, fileno(stderr));
close(_old_err);
}
if (_err_pipe[0] > 0) {
close(_err_pipe[0]);
}
if (_err_pipe[1] > 0) {
close(_err_pipe[1]);
}
pubnub_done(p);
}
void GetErr() {
fflush(stderr);
if (_old_err > 0) {
dup2(_old_err, fileno(stderr));
close(_old_err);
_old_err = 0;
}
std::string buf;
const int bufSize = 1024;
buf.resize(bufSize);
int bytesRead = READ_PIPE(_err_pipe[0], &(*buf.begin()), bufSize);
while(bytesRead == bufSize) {
_err += buf;
bytesRead = READ_PIPE(_err_pipe[0], &(*buf.begin()), bufSize);
}
if (bytesRead > 0) {
buf.resize(bytesRead);
_err += buf;
}
}
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()
{
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;
}
struct pubnub *test_pubnub_init(const char *publish_key, const char *subscribe_key,
const struct pubnub_callbacks *cb, void *cb_data)
{
PubNubCppTest::initCalled = true;
return pubnub_init(publish_key, subscribe_key, cb, cb_data);
}
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;
}
int main()
{
int option;
char opt_string[4];
char channel[PNC_CHANNEL_NAME_SIZE];
char channel_group[PNC_CHANNEL_NAME_SIZE];
char auth_key[PNC_AUTH_KEY_SIZE];
char uuid[PNC_UUID_SIZE + 1];
char state[2048];
pubnub_t *pn = pubnub_alloc();
pubnub_t *pn_sub = pubnub_alloc();
if (NULL == pn || NULL == pn_sub) {
printf("Failed to allocate pubnub context");
return -1;
}
pubnub_init(pn, pubkey, pubkey);
pubnub_init(pn_sub, pubkey, pubkey);
pubnub_set_uuid(pn, PNC_DEFAULT_UUID);
pubnub_set_uuid(pn, PNC_DEFAULT_SUBSCRIBE_UUID);
pnc_ops_init(pn, pn_sub);
displayMenuOptions(pn);
option = 0;
while (option != MENU_EXIT) {
fgets(opt_string, sizeof(opt_string), stdin);
opt_string[strlen(opt_string) - 1] = '\0';
option = atoi(opt_string);
printf("You entered %d(%s)\n", option, opt_string);
switch (option) {
case MENU_DISPLAY:
break;
case MENU_PUBLISH:
{
char message[PNC_READ_STRING_SIZE];
bool store = false;
// TODO: add json built string
pnc_read_string_from_console("Channel Name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_read_bool_from_console_optional("Store", &store, true);
puts("Enter the message for publish. To exit loop enter Q");
while (fgets(message, PNC_READ_STRING_SIZE, stdin) != NULL && strcmp(message, "Q\n")) {
if (strlen(message) == 1) {
puts("Invalid input");
continue;
}
message[strlen(message) - 1] = '\0';
if (message[0] == '{' && message[strlen(message) - 1] == '}') {
pnc_ops_parse_response("pubnub_publish()",
pubnub_publish(pn, channel, message), pn);
}
else {
char encoded[PNC_READ_STRING_SIZE];
snprintf(encoded, sizeof encoded, "\"%s\"", message);
pnc_ops_parse_response("pubnub_publish()",
pubnub_publish(pn, channel, encoded), pn);
}
puts("Enter the message for publish. To exit loop enter Q.");
}
break;
}
case MENU_HISTORY:
{
int count = 100;
bool include_token = false;
pnc_read_int_from_console_optional("Count", &count, true);
if (count <= 0) {
count = 100;
puts("Count value cannot be less than 1. Default value(100) was applied.");
}
pnc_read_string_from_console("Channel Name",
channel, PNC_CHANNEL_NAME_SIZE);
// WARNING: Default buffer can be not big enough to get 100-items
// history response with timetokens
pnc_read_bool_from_console("Include timetokens", &include_token);
pnc_ops_parse_response("pubnub_history()",
pubnub_history(pn, channel, count, include_token), pn);
break;
}
case MENU_HERE_NOW:
pnc_read_string_from_console("Channel Name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_ops_parse_response("pubnub_here_now()",
pubnub_here_now(pn, channel, NULL), pn);
break;
case MENU_TIME:
pnc_ops_parse_response("pubnub_time()", pubnub_time(pn), pn);
break;
case MENU_AUTH:
pnc_read_string_from_console("Auth key", auth_key, PNC_AUTH_KEY_SIZE);
pubnub_set_auth(pn, auth_key);
break;
case MENU_UUID:
pnc_read_string_from_console("UUID", uuid, PNC_UUID_SIZE);
pubnub_set_uuid(pn, uuid);
break;
case MENU_STATE_GET:
pnc_read_string_from_console("Channel Name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_read_string_from_console_optional("UUID",
uuid, PNC_UUID_SIZE, true);
if (strlen(uuid) == 0) {
strcpy(uuid, pubnub_uuid_get(pn));
}
pnc_ops_parse_response("pubnub_get_state()",
pubnub_state_get(pn, channel, NULL, uuid), pn);
break;
case MENU_SET_STATE:
// Set State
pnc_read_string_from_console("Channel Name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_read_string_from_console("JSON state without escaping",
state, PNC_READ_STRING_SIZE);
pnc_ops_parse_response("pubnub_set_state()",
pubnub_set_state(pn, channel, NULL, pubnub_uuid_get(pn), state), pn);
break;
case MENU_WHERE_NOW:
pnc_read_string_from_console_optional("UUID", uuid, PNC_UUID_SIZE, true);
if (strlen(uuid) == 0) {
puts("Using current UUID");
strcpy(uuid, PNC_DEFAULT_UUID);
}
pnc_ops_parse_response("pubnub_where_now()",
pubnub_where_now(pn, uuid), pn);
break;
case MENU_ADD_PRESENCE_CHANNEL:
{
char presence_channel[PNC_CHANNEL_NAME_SIZE + sizeof(PNC_PRESENCE_SUFFIX)];
pnc_read_string_from_console("Channel name", channel, PNC_CHANNEL_NAME_SIZE);
strcpy(presence_channel, channel);
strcat(presence_channel, PNC_PRESENCE_SUFFIX);
pnc_subscribe_add_channel(presence_channel);
break;
}
case MENU_SUBSCRIBE:
pnc_ops_subscribe(pn_sub);
break;
case MENU_UNSUBSCRIBE:
pnc_ops_unsubscribe(pn_sub);
break;
case MENU_SUBSCRIPTION_ADD_CHANNEL:
pnc_read_string_from_console("Enter Channel name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_subscribe_add_channel(channel);
break;
case MENU_SUBSCRIPTION_ADD_GROUP:
pnc_read_string_from_console("Enter Group name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_subscribe_add_channel_group(channel);
break;
case MENU_SUBSCRIPTION_REMOVE_CHANNEL:
pnc_read_string_from_console("Enter Channel name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_subscribe_remove_channel(channel);
break;
case MENU_SUBSCRIPTION_REMOVE_GROUP:
pnc_read_string_from_console("Enter Group name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_subscribe_remove_channel_group(channel);
break;
case MENU_GROUP_ADD_CHANNEL:
pnc_read_string_from_console("Group name",
channel_group, PNC_CHANNEL_NAME_SIZE);
pnc_read_string_from_console("Channel to add",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_ops_parse_response("pubnub_add_channel_to_group()",
pubnub_add_channel_to_group(pn, channel, channel_group), pn);
break;
case MENU_GROUP_REMOVE_CHANNEL:
pnc_read_string_from_console("Group name",
channel_group, PNC_CHANNEL_NAME_SIZE);
pnc_read_string_from_console("Channel to remove",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_ops_parse_response("pubnub_remove_channel_from_group()",
pubnub_remove_channel_from_group(pn, channel, channel_group), pn);
break;
case MENU_GROUP_LIST_CHANNELS:
pnc_read_string_from_console("Group to list",
channel_group, PNC_CHANNEL_NAME_SIZE);
pnc_ops_parse_response("pubnub_list_channel_group()",
pubnub_list_channel_group(pn, channel_group), pn);
break;
case MENU_GROUP_REMOVE_GROUP:
pnc_read_string_from_console("Group to remove",
channel, PNC_CHANNEL_NAME_SIZE);
pubnub_remove_channel_group(pn, channel);
break;
default:
printf("Invalid input: %d\n", option);
break;
}
printf("\n================================\n\n");
displayMenuOptions(pn);
}
puts("Exiting");
if (pubnub_free(pn) != 0) {
puts("Failed to free the Pubnub context");
}
return 0;
}