コード例 #1
0
    } 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
コード例 #2
0
    } 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
コード例 #3
0
    } 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
コード例 #4
0
ファイル: example-libevent-sub.c プロジェクト: VPLus/c
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;
}
コード例 #5
0
    } 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
コード例 #6
0
    } 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
コード例 #7
0
    } 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
コード例 #8
0
ファイル: pubnub.cpp プロジェクト: Ashar786/c
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;
}
コード例 #9
0
    } 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
コード例 #10
0
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;
}
コード例 #11
0
ファイル: pubnubcpptest.cpp プロジェクト: Ashar786/c
TEST_F(PubNubCppTest, PubNubAutoDone) {
	pubnub *p = pubnub_init("demo", "demo", &cb, NULL);
	{
		PubNub pn(p, true);
		EXPECT_FALSE(initCalled);
	}
	EXPECT_TRUE(doneCalled);
}
コード例 #12
0
    } 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
コード例 #13
0
ファイル: pubnubcpptest.cpp プロジェクト: Ashar786/c
TEST_F(PubNubCppTest, PubNubNotAutoDone) {
	pubnub *p = pubnub_init("demo", "demo", &cb, NULL);
	{
		PubNub pn(p);
		EXPECT_FALSE(initCalled);
	}
	ASSERT_FALSE(doneCalled);
	pubnub_done(p);
}
コード例 #14
0
ファイル: pubnub_fntest_runner.c プロジェクト: sveljko/c-core
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);
    }
}
コード例 #15
0
ファイル: pubnub_at.c プロジェクト: jhofstee/siwi2way
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;
}
コード例 #16
0
ファイル: main.c プロジェクト: jhofstee/siwi2way
// 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);
}
コード例 #17
0
    } 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
コード例 #18
0
ファイル: main.c プロジェクト: jhofstee/siwi2way
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;
}
コード例 #20
0
ファイル: pubnub_sync_recieve.c プロジェクト: mkhare/tunnelpi
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;
}
コード例 #21
0
ファイル: pubnubcpptest.cpp プロジェクト: Ashar786/c
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());
}
コード例 #22
0
    } 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
コード例 #23
0
ファイル: main.c プロジェクト: shyampurk/iot-for-utilities
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;
}
コード例 #24
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
コード例 #25
0
ファイル: pubnubtest.cpp プロジェクト: Ashar786/c
	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;
		}
	}
コード例 #26
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;
}
コード例 #27
0
ファイル: pubnub_sync_sample.c プロジェクト: ramshenai/c-core
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;
}
コード例 #28
0
ファイル: pubnubcpptest.cpp プロジェクト: Ashar786/c
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);
}
コード例 #29
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;
}
コード例 #30
0
ファイル: pubnub_console.c プロジェクト: pubnub/c-core
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;
}