C++ (Cpp) cometd_conn_take_advice Examples

Example #1

File: check_cometd.c Project: foobarfighter/c-cometd-client

END_TEST

START_TEST (test_cometd_should_retry_recv)
{
    cometd_advice* handshake_advice = cometd_advice_new();
    handshake_advice->reconnect = COMETD_RECONNECT_HANDSHAKE;

    cometd_advice* retry_advice = cometd_advice_new();
    retry_advice->reconnect = COMETD_RECONNECT_RETRY;

    cometd_conn* conn = g_instance->conn;

    cometd_conn_set_state(conn, COMETD_DISCONNECTED);
    fail_if(cometd_should_retry_recv(g_instance));

    cometd_conn_set_state(conn, COMETD_UNCONNECTED);
    cometd_conn_take_advice(conn, handshake_advice);
    fail_if(cometd_should_retry_recv(g_instance));

    cometd_conn_set_state(conn, COMETD_UNCONNECTED);
    cometd_conn_take_advice(conn, NULL);
    fail_if(cometd_should_retry_recv(g_instance));

    cometd_conn_set_state(conn, COMETD_UNCONNECTED);
    cometd_conn_take_advice(conn, retry_advice);
    fail_unless(cometd_should_retry_recv(g_instance));
}

Example #2

File: cometd.c Project: GhostGumm/CarbonComet

int
cometd_process_connect(const cometd* h, JsonNode* msg)
{
  cometd_advice* advice;
  cometd_conn* conn = h->conn;

  // If we are trying to disconnect cleanly then we should not
  // reset the connected/connecting status on response.
  if (cometd_conn_is_state(conn, COMETD_DISCONNECTING | COMETD_DISCONNECTED))
    return COMETD_SUCCESS;

  // Always set advice if it is offered and reuse old advice if new advice DNE
  advice = cometd_msg_advice(msg);
  if (advice)
    cometd_conn_take_advice(conn, advice);

  if (!cometd_msg_is_successful(msg))
  {
    cometd_conn_set_state(conn, COMETD_UNCONNECTED);
    cometd_handle_advice(h, advice);
  }
  else
    cometd_conn_set_state(conn, COMETD_CONNECTED);

  return COMETD_SUCCESS;
}

Example #3

File: check_cometd.c Project: foobarfighter/c-cometd-client

END_TEST

START_TEST(test_cometd_should_handshake)
{
    cometd_conn_set_state(g_instance->conn, COMETD_HANDSHAKE_SUCCESS);
    fail_if(cometd_should_handshake(g_instance));

    cometd_conn_set_state(g_instance->conn, COMETD_CONNECTED);
    fail_if(cometd_should_handshake(g_instance));

    cometd_conn_set_state(g_instance->conn, COMETD_UNCONNECTED);
    cometd_advice* advice = cometd_advice_new();
    advice->reconnect = COMETD_RECONNECT_HANDSHAKE;
    cometd_conn_take_advice(g_instance->conn, advice);

    fail_unless(cometd_should_handshake(g_instance));

    cometd_conn_take_advice(g_instance->conn, NULL);
}

Example #4

File: check_cometd.c Project: foobarfighter/c-cometd-client

END_TEST

START_TEST (test_cometd_get_backoff)
{
    cometd_conn* conn = g_instance->conn;
    cometd_config* config = g_instance->config;

    cometd_configure(g_instance, COMETDOPT_BACKOFF_INCREMENT, 10);

    // test incremental backoff when no advice
    cometd_conn_take_advice(conn, NULL);
    ck_assert_int_eq(0, cometd_get_backoff(g_instance, 0));
    ck_assert_int_eq(10, cometd_get_backoff(g_instance, 1));
    ck_assert_int_eq(20, cometd_get_backoff(g_instance, 2));

    // test when advice is hanshake
    cometd_advice* handshake_advice = cometd_advice_new();
    handshake_advice->reconnect = COMETD_RECONNECT_HANDSHAKE;
    handshake_advice->interval = 10;
    cometd_conn_take_advice(conn, handshake_advice);
    ck_assert_int_eq(10, cometd_get_backoff(g_instance, 20));

    // test when advice is retry
    cometd_advice* retry_advice = cometd_advice_new();
    retry_advice->reconnect = COMETD_RECONNECT_RETRY;
    retry_advice->interval = 10;
    cometd_conn_take_advice(conn, retry_advice);
    ck_assert_int_eq(10, cometd_get_backoff(g_instance, 20));

    // test when advice is none
    cometd_advice* none_advice = cometd_advice_new();
    none_advice->reconnect = COMETD_RECONNECT_NONE;
    none_advice->interval = 10;
    cometd_conn_take_advice(conn, none_advice);
    ck_assert_int_eq(-1, cometd_get_backoff(g_instance, 20));

    // test when interval is 0 and the attempt is > 1, use backoff increment
    cometd_advice* zero_interval = cometd_advice_new();
    zero_interval->reconnect = COMETD_RECONNECT_RETRY;
    zero_interval->interval = 0;
    cometd_conn_take_advice(conn, zero_interval);
    ck_assert_int_eq(0, cometd_get_backoff(g_instance, 1));
    ck_assert_int_eq(10, cometd_get_backoff(g_instance, 2));
    ck_assert_int_eq(20, cometd_get_backoff(g_instance, 3));

    cometd_conn_take_advice(conn, NULL);
}

Example #5

File: cometd.c Project: GhostGumm/CarbonComet

int	cometd_process_handshake(const cometd* h, JsonNode* msg)
{
  cometd_conn* conn = h->conn;
  cometd_config* config = h->config;

  cometd_transport* t = cometd_transport_negotiate(config->transports, msg);

  int code = COMETD_SUCCESS;
  
  if (t) {
    gchar* client_id = cometd_msg_client_id(msg);
    cometd_conn_set_transport(conn, t);
    cometd_conn_set_client_id(conn, client_id);
    cometd_conn_set_state(conn, COMETD_HANDSHAKE_SUCCESS);
    g_free(client_id);
  } else {
    code = ECOMETD_NO_TRANSPORT;
  }
  cometd_conn_take_advice(conn, cometd_msg_advice(msg));

  return code;
}