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; }
int srand_from_pubnub_time(pubnub_t *pbp) { pubnub_res rslt = pubnub_time(pbp); if (rslt != PNR_STARTED) { return -1; } rslt = pubnub_await(pbp); if (rslt != PNR_OK) { return -1; } char const* pbtime = pubnub_get(pbp); if (0 == pbtime) { return -1; } size_t length_of_time = strlen(pbtime); if (0 == length_of_time) { return -1; } char const *s = pbtime + length_of_time - 1; unsigned int val_for_srand = 0; for (int i = 0; (i < 10) && (s > pbtime); ++i, --s) { val_for_srand = val_for_srand * 10 + *s - '0'; } srand(val_for_srand); return 0; }
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 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; }
void pnc_ops_parse_response(const char *method_name, enum pubnub_res res, pubnub_t *pn) { const char *msg; if (res != PNR_STARTED) { printf("%s returned error %d: %s\n", method_name, res, pubnub_res_2_string(res)); return; } res = pubnub_await(pn); if (res == PNR_HTTP_ERROR) { printf("%s HTTP error / code: %d\n", method_name, pubnub_last_http_code(pn)); return; } if (res == PNR_STARTED) { printf("%s returned unexpected: PNR_STARTED(%d)\n", method_name, res); return; } if (PNR_OK == res) { puts("\n****************************************"); printf("Result for %s: success!\n", method_name); puts("****************************************"); for (;;) { msg = pubnub_get(pn); if (NULL == msg) { break; } puts(msg); } puts("****************************************"); } else { printf("%s failed! error code %d: %s\n", method_name, res, pubnub_res_2_string(res)); } }
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() { /* 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; }