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