void test_profile_handle_sync(void)
{
KAA_TRACE_IN(logger);
bool need_resync = false;
kaa_error_t error_code = KAA_ERR_NONE;
uint16_t extension_options = 0x1; /* Need resync */
const size_t buffer_size = 6;
char buffer[buffer_size];
kaa_platform_message_reader_t *reader;
error_code = kaa_platform_message_reader_create(&reader, buffer, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_profile_handle_server_sync(profile_manager, reader, extension_options, 0);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_profile_need_profile_resync(profile_manager, &need_resync);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_TRUE(need_resync);
extension_options = 0x0; /* Need resync */
error_code = kaa_profile_handle_server_sync(profile_manager, reader, extension_options, 0);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_profile_need_profile_resync(profile_manager, &need_resync);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_FALSE(need_resync);
kaa_platform_message_reader_destroy(reader);
KAA_TRACE_OUT(logger);
}
void test_profile_update(void)
{
KAA_TRACE_IN(logger);
kaa_profile_t *profile1 = kaa_profile_basic_endpoint_profile_test_create();
profile1->profile_body = kaa_string_copy_create("dummy");
kaa_error_t error = kaa_profile_manager_update_profile(profile_manager, profile1);
ASSERT_EQUAL(error, KAA_ERR_NONE);
bool need_resync = false;
error = kaa_profile_need_profile_resync(profile_manager, &need_resync);
ASSERT_EQUAL(error, KAA_ERR_NONE);
ASSERT_TRUE(need_resync);
error = kaa_profile_manager_update_profile(profile_manager, profile1);
ASSERT_EQUAL(error, KAA_ERR_NONE);
error = kaa_profile_need_profile_resync(profile_manager, &need_resync);
ASSERT_EQUAL(error, KAA_ERR_NONE);
ASSERT_FALSE(need_resync);
profile1->destroy(profile1);
kaa_profile_t *profile2 = kaa_profile_basic_endpoint_profile_test_create();
profile2->profile_body = kaa_string_copy_create("new_dummy");
error = kaa_profile_manager_update_profile(profile_manager, profile2);
ASSERT_EQUAL(error, KAA_ERR_NONE);
error = kaa_profile_need_profile_resync(profile_manager, &need_resync);
ASSERT_EQUAL(error, KAA_ERR_NONE);
ASSERT_TRUE(need_resync);
profile2->destroy(profile2);
KAA_TRACE_OUT(logger);
}
void test_profile_sync_serialize(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
kaa_platform_message_writer_t *manual_writer;
kaa_platform_message_writer_t *auto_writer;
const char *access_token = "access token";
const size_t access_token_size = strlen(access_token);
kaa_profile_t *profile = kaa_profile_basic_endpoint_profile_test_create();
profile->profile_body = kaa_string_copy_create("dummy");
size_t serialized_profile_size = profile->get_size(profile);
char *serialized_profile = (char *) KAA_MALLOC(serialized_profile_size * sizeof(char));
avro_writer_t avro_writer = avro_writer_memory(serialized_profile, serialized_profile_size);
profile->serialize(avro_writer, profile);
error_code = kaa_profile_manager_update_profile(profile_manager, profile);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
status->is_registered = false;
error_code = kaa_profile_manager_set_endpoint_access_token(profile_manager, access_token);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t profile_sync_size;
error_code = kaa_profile_request_get_size(profile_manager, &profile_sync_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
char buffer[profile_sync_size];
error_code = kaa_platform_message_writer_create(&manual_writer, buffer, profile_sync_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
uint32_t network_order_32;
error_code = kaa_platform_message_write_extension_header(manual_writer
, KAA_PROFILE_EXTENSION_TYPE
, 0
, profile_sync_size - KAA_EXTENSION_HEADER_SIZE);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
bool need_resync = true;
ASSERT_EQUAL(kaa_profile_need_profile_resync(profile_manager, &need_resync), KAA_ERR_NONE);
network_order_32 = KAA_HTONL(0);
if (need_resync)
network_order_32 = KAA_HTONL(serialized_profile_size);
error_code = kaa_platform_message_write(manual_writer, &network_order_32, sizeof(uint32_t));
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
if (need_resync) {
error_code = kaa_platform_message_write_aligned(manual_writer, serialized_profile, serialized_profile_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
}
network_order_32 = KAA_HTONS(TEST_PUB_KEY_SIZE) << 16 | PUB_KEY_VALUE;
error_code = kaa_platform_message_write(manual_writer, &network_order_32, sizeof(uint32_t));
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_write_aligned(manual_writer, test_ep_key, TEST_PUB_KEY_SIZE);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
network_order_32 = KAA_HTONS(access_token_size) << 16 | ACCESS_TOKEN_VALUE;
error_code = kaa_platform_message_write(manual_writer, &network_order_32, sizeof(uint32_t));
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_write_aligned(manual_writer, access_token, access_token_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
char buffer2[profile_sync_size];
error_code = kaa_platform_message_writer_create(&auto_writer, buffer2, profile_sync_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_profile_request_serialize(profile_manager, auto_writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = (memcmp(buffer, buffer2, profile_sync_size) == 0 ? KAA_ERR_NONE : KAA_ERR_BADDATA);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
KAA_FREE(serialized_profile);
avro_writer_free(avro_writer);
profile->destroy(profile);
kaa_platform_message_writer_destroy(auto_writer);
kaa_platform_message_writer_destroy(manual_writer);
KAA_TRACE_OUT(logger);
}
static kaa_error_t kaa_client_sync_serialize(kaa_platform_protocol_t *self
, const kaa_service_t services[]
, size_t services_count
, char* buffer
, size_t *size)
{
kaa_platform_message_writer_t *writer = NULL;
kaa_error_t error_code = kaa_platform_message_writer_create(&writer, buffer, *size);
KAA_RETURN_IF_ERR(error_code);
uint16_t total_services_count = services_count + 1 /* Meta extension */;
error_code = kaa_platform_message_header_write(writer, KAA_PLATFORM_PROTOCOL_ID, KAA_PLATFORM_PROTOCOL_VERSION);
if (error_code) {
KAA_LOG_ERROR(self->logger, error_code, "Failed to write the client sync header");
return error_code;
}
char *extension_count_p = writer->current;
writer->current += KAA_PROTOCOL_EXTENSIONS_COUNT_SIZE;
error_code = kaa_meta_data_request_serialize(self->status, writer, self->request_id);
while (!error_code && services_count--) {
switch (services[services_count]) {
case KAA_SERVICE_BOOTSTRAP: {
error_code = kaa_channel_manager_bootstrap_request_serialize(self->kaa_context->channel_manager
, writer);
if (error_code)
KAA_LOG_ERROR(self->logger, error_code, "Failed to serialize the bootstrap extension");
break;
}
case KAA_SERVICE_PROFILE: {
bool need_resync = false;
error_code = kaa_profile_need_profile_resync(self->kaa_context->profile_manager
, &need_resync);
if (!error_code) {
if (need_resync) {
error_code = kaa_profile_request_serialize(self->kaa_context->profile_manager, writer);
if (error_code)
KAA_LOG_ERROR(self->logger, error_code, "Failed to serialize the profile extension");
} else {
--total_services_count;
}
} else {
KAA_LOG_ERROR(self->logger, error_code, "Failed to read profile's 'need_resync' flag");
}
break;
}
case KAA_SERVICE_USER: {
error_code = kaa_user_request_serialize(self->kaa_context->user_manager, writer);
if (error_code)
KAA_LOG_ERROR(self->logger, error_code, "Failed to serialize the user extension");
break;
}
case KAA_SERVICE_EVENT: {
#ifndef KAA_DISABLE_FEATURE_EVENTS
error_code = kaa_event_request_serialize(self->kaa_context->event_manager, self->request_id, writer);
if (error_code)
KAA_LOG_ERROR(self->logger, error_code, "Failed to serialize the event extension");
#else
--total_services_count;
#endif
break;
}
case KAA_SERVICE_LOGGING: {
#ifndef KAA_DISABLE_FEATURE_LOGGING
bool need_resync = false;
error_code = kaa_logging_need_logging_resync(self->kaa_context->log_collector, &need_resync);
if (!error_code) {
if (need_resync) {
error_code = kaa_logging_request_serialize(self->kaa_context->log_collector, writer);
if (error_code)
KAA_LOG_ERROR(self->logger, error_code, "Failed to serialize the logging extension");
} else {
--total_services_count;
}
} else {
KAA_LOG_ERROR(self->logger, error_code, "Failed to read logging's 'need_resync' flag");
}
#else
--total_services_count;
#endif
break;
}
case KAA_SERVICE_CONFIGURATION: {
#ifndef KAA_DISABLE_FEATURE_CONFIGURATION
error_code = kaa_configuration_manager_request_serialize(self->kaa_context->configuration_manager, writer);
if (error_code)
KAA_LOG_ERROR(self->logger, error_code, "Failed to serialize the configuration extension");
#else
--total_services_count;
#endif
break;
}
case KAA_SERVICE_NOTIFICATION: {
#ifndef KAA_DISABLE_FEATURE_NOTIFICATION
error_code = kaa_notification_manager_request_serialize(self->kaa_context->notification_manager, writer);
if (error_code)
KAA_LOG_ERROR(self->logger, error_code, "Failed to serialize the configuration extension");
#else
--total_services_count;
#endif
break;
}
default:
break;
}
}
*(uint16_t *) extension_count_p = KAA_HTONS(total_services_count);
*size = writer->current - writer->begin;
kaa_platform_message_writer_destroy(writer);
return error_code;
}
static kaa_error_t kaa_client_sync_get_size(kaa_platform_protocol_t *self
, const kaa_service_t services[]
, size_t services_count
, size_t *expected_size)
{
KAA_RETURN_IF_NIL4(self, services, services_count, expected_size, KAA_ERR_BADPARAM)
*expected_size = KAA_PROTOCOL_MESSAGE_HEADER_SIZE;
size_t extension_size = 0;
kaa_error_t err_code = kaa_meta_data_request_get_size(&extension_size);
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to query size for meta extension");
return err_code;
}
*expected_size += extension_size;
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated meta extension size %u", extension_size);
while (!err_code && services_count--) {
switch (services[services_count]) {
case KAA_SERVICE_BOOTSTRAP: {
err_code = kaa_channel_manager_bootstrap_request_get_size(self->kaa_context->channel_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated bootstrap extension size %u", extension_size);
break;
}
case KAA_SERVICE_PROFILE: {
bool need_resync = false;
err_code = kaa_profile_need_profile_resync(self->kaa_context->profile_manager
, &need_resync);
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to read 'need_resync' flag");
}
if (!err_code && need_resync) {
err_code = kaa_profile_request_get_size(self->kaa_context->profile_manager
, &extension_size);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated profile extension size %u", extension_size);
}
break;
}
case KAA_SERVICE_USER: {
err_code = kaa_user_request_get_size(self->kaa_context->user_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated user extension size %u", extension_size);
break;
}
#ifndef KAA_DISABLE_FEATURE_EVENTS
case KAA_SERVICE_EVENT: {
err_code = kaa_event_request_get_size(self->kaa_context->event_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated event extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_LOGGING
case KAA_SERVICE_LOGGING: {
err_code = kaa_logging_request_get_size(self->kaa_context->log_collector
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated logging extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_CONFIGURATION
case KAA_SERVICE_CONFIGURATION: {
err_code = kaa_configuration_manager_get_size(self->kaa_context->configuration_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated configuration extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_NOTIFICATION
case KAA_SERVICE_NOTIFICATION: {
err_code = kaa_notification_manager_get_size(self->kaa_context->notification_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated notification extension size %u", extension_size);
break;
}
#endif
default:
extension_size = 0;
break;
}
*expected_size += extension_size;
}
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to query extension size in %u service"
, services[services_count]);
}
return err_code;
}
