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