int test_init(void)
{
kaa_error_t error = kaa_log_create(&logger,
KAA_MAX_LOG_MESSAGE_LENGTH,
KAA_MAX_LOG_LEVEL,
NULL);
if (error || !logger) {
return error;
}
kaa_context.logger = logger;
error = kaa_status_create(&status);
if (error || !status) {
return error;
}
error = kaa_channel_manager_create(&channel_manager, &kaa_context);
if (error || !channel_manager) {
return error;
}
/* Add channel will fail due to absent access point, but it is expected */
kaa_channel_manager_add_transport_channel(channel_manager, &channel, NULL);
error = kaa_profile_manager_create(&profile_manager,
status, channel_manager, logger);
if (error || !profile_manager) {
return error;
}
return 0;
}
kaa_error_t kaa_client_init_operations_channel(kaa_client_t *kaa_client)
{
KAA_RETURN_IF_NIL(kaa_client, KAA_ERR_BADPARAM);
kaa_error_t error_code = KAA_ERR_NONE;
KAA_LOG_TRACE(kaa_client->kaa_context->logger, KAA_ERR_NONE, "Start operations channel initialization");
error_code = kaa_tcp_channel_create(&kaa_client->operations_channel
, kaa_client->kaa_context->logger
, OPERATIONS_SERVICES
, OPERATIONS_SERVICES_COUNT);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code, "Operations channel initialization failed");
return error_code;
}
KAA_LOG_TRACE(kaa_client->kaa_context->logger, KAA_ERR_NONE, "Initializing Kaa SDK Operations channel added to transport channel manager");
error_code = kaa_channel_manager_add_transport_channel(kaa_client->kaa_context->channel_manager
, &kaa_client->operations_channel
, &kaa_client->operations_channel_id);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code, "Error during Kaa operations channel setting as transport");
return error_code;
}
KAA_LOG_INFO(kaa_client->kaa_context->logger, KAA_ERR_NONE, "Operations channel initialized successfully");
print_mem_stat(kaa_client);
return error_code;
}
kaa_error_t kaa_client_init_channel(kaa_client_t *kaa_client, kaa_client_channel_type_t channel_type)
{
KAA_RETURN_IF_NIL(kaa_client, KAA_ERR_BADPARAM);
kaa_error_t error_code = KAA_ERR_NONE;
KAA_LOG_TRACE(kaa_client->kaa_context->logger, KAA_ERR_NONE, "Initializing channel....");
switch (channel_type) {
case KAA_CLIENT_CHANNEL_TYPE_BOOTSTRAP:
error_code = kaa_tcp_channel_create(&kaa_client->channel,
kaa_client->kaa_context->logger,
BOOTSTRAP_SERVICE, BOOTSTRAP_SERVICE_COUNT);
break;
case KAA_CLIENT_CHANNEL_TYPE_OPERATIONS:
error_code = kaa_tcp_channel_create(&kaa_client->channel
, kaa_client->kaa_context->logger
, OPERATIONS_SERVICES
, OPERATIONS_SERVICES_COUNT);
break;
}
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code, "Error initializing channel %d", channel_type);
return error_code;
}
error_code = kaa_tcp_channel_set_keepalive_timeout(&kaa_client->channel, 120);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code, "Error set keepalive");
}
error_code = kaa_channel_manager_add_transport_channel(kaa_client->kaa_context->channel_manager,
&kaa_client->channel,
&kaa_client->channel_id);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code, "Error register channel %d as transport", channel_type);
return error_code;
}
KAA_LOG_INFO(kaa_client->kaa_context->logger, KAA_ERR_NONE, "Channel(type=%d,id=%08X) initialized successfully"
, channel_type, kaa_client->channel_id);
char *hostname = NULL;
size_t hostname_size = 0;
uint16_t port = 0;
error_code = kaa_tcp_channel_get_access_point(&kaa_client->channel, &hostname, &hostname_size, &port);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code, "Kaa tcp channel get access point failed");
} else if (hostname_size > 0){
char *n_hostname = strndup(hostname, hostname_size);
KAA_LOG_INFO(kaa_client->kaa_context->logger, KAA_ERR_NONE,
"Channel(type=%d,id=%08X) destination %s:%d", channel_type
, kaa_client->channel_id, n_hostname, port);
free(n_hostname);
}
return error_code;
}
/*
* Initializes Kaa SDK.
*/
kaa_error_t kaa_sdk_init()
{
kaa_error_t error_code = kaa_init(&kaa_context_);
if (error_code) {
printf("Error during kaa context creation %d", error_code);
return error_code;
}
error_code = kaa_log_collector_init();
if (error_code) {
KAA_LOG_ERROR(kaa_context_->logger, error_code, "Failed to init Kaa log collector %d", error_code);
return error_code;
}
KAA_LOG_TRACE(kaa_context_->logger, KAA_ERR_NONE, "Adding transport channels");
error_code = kaa_tcp_channel_create(&operations_channel
, kaa_context_->logger
, OPERATIONS_SERVICES
, OPERATIONS_SERVICES_COUNT);
KAA_RETURN_IF_ERR(error_code);
error_code = kaa_tcp_channel_create(&bootstrap_channel
, kaa_context_->logger
, BOOTSTRAP_SERVICE
, BOOTSTRAP_SERVICE_COUNT);
KAA_RETURN_IF_ERR(error_code);
error_code = kaa_channel_manager_add_transport_channel(kaa_context_->channel_manager
, &bootstrap_channel
, NULL);
KAA_RETURN_IF_ERR(error_code);
error_code = kaa_channel_manager_add_transport_channel(kaa_context_->channel_manager
, &operations_channel
, NULL);
KAA_RETURN_IF_ERR(error_code);
KAA_LOG_TRACE(kaa_context_->logger, KAA_ERR_NONE, "Kaa SDK started");
return KAA_ERR_NONE;
}
kaa_error_t kaa_client_init_channel(kaa_client_t *kaa_client, kaa_client_channel_type_t channel_type)
{
KAA_RETURN_IF_NIL(kaa_client, KAA_ERR_BADPARAM);
kaa_error_t error_code = KAA_ERR_NONE;
KAA_LOG_TRACE(kaa_client->context->logger, KAA_ERR_NONE, "Initializing channel....");
switch (channel_type) {
case KAA_CLIENT_CHANNEL_TYPE_BOOTSTRAP:
error_code = kaa_tcp_channel_create(&kaa_client->channel
, kaa_client->context->logger
, BOOTSTRAP_SERVICE
, BOOTSTRAP_SERVICE_COUNT);
break;
case KAA_CLIENT_CHANNEL_TYPE_OPERATIONS:
error_code = kaa_tcp_channel_create(&kaa_client->channel
, kaa_client->context->logger
, OPERATIONS_SERVICES
, OPERATIONS_SERVICES_COUNT);
break;
}
if (error_code) {
KAA_LOG_ERROR(kaa_client->context->logger, error_code, "Failed to create transport channel, type %d", channel_type);
return error_code;
}
error_code = kaa_tcp_channel_set_socket_events_callback(&kaa_client->channel, &on_kaa_tcp_channel_event, kaa_client);
if (error_code) {
KAA_LOG_ERROR(kaa_client->context->logger, error_code,
"Failed to set socket events callback, channel type %d", channel_type);
return error_code;
}
error_code = kaa_channel_manager_add_transport_channel(kaa_client->context->channel_manager
, &kaa_client->channel
, &kaa_client->channel_id);
if (error_code) {
KAA_LOG_ERROR(kaa_client->context->logger, error_code, "Failed to add transport channel, type %d", channel_type);
return error_code;
}
KAA_LOG_INFO(kaa_client->context->logger, KAA_ERR_NONE, "Channel [0x%08X] initialized successfully (type %d)"
, kaa_client->channel_id, channel_type);
return error_code;
}
kaa_error_t kaa_client_start(kaa_client_t *kaa_client
, external_process_fn external_process
, void *external_process_context
, kaa_time_t max_delay)
{
KAA_RETURN_IF_NIL(kaa_client, KAA_ERR_BADPARAM);
KAA_LOG_TRACE(kaa_client->kaa_context->logger, KAA_ERR_NONE, "Kaa client starting ...");
print_mem_stat(kaa_client);
kaa_error_t error_code = KAA_ERR_NONE;
error_code = kaa_tcp_channel_create(&kaa_client->bootstrap_channel
, kaa_client->kaa_context->logger
, BOOTSTRAP_SERVICE
, BOOTSTRAP_SERVICE_COUNT);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code, "Error during Kaa bootstrap channel creation");
return error_code;
}
error_code = kaa_tcp_channel_set_socket_events_callback(&kaa_client->bootstrap_channel,
on_kaa_tcp_channel_event, (void*)kaa_client);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code, "Error setting callback bootstrap channel");
return error_code;
}
KAA_LOG_TRACE(kaa_client->kaa_context->logger, KAA_ERR_NONE, "Kaa client - bootstrap channel initialized");
print_mem_stat(kaa_client);
error_code = kaa_channel_manager_add_transport_channel(kaa_client->kaa_context->channel_manager
, &kaa_client->bootstrap_channel
, &kaa_client->bootstrap_channel_id);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code, "Error setting bootstrap channel setting as transport");
return error_code;
}
//Push running thread
sndc_sem_post(&kaa_client->start_semophore);
KAA_LOG_INFO(kaa_client->kaa_context->logger, KAA_ERR_NONE, "Kaa client started");
return KAA_ERR_NONE;
}
void test_create_request(void **state)
{
(void)state;
kaa_user_log_record_t *test_log_record = kaa_test_log_record_create();
test_log_record->data = kaa_string_copy_create(TEST_LOG_BUFFER);
size_t test_log_record_size = test_log_record->get_size(test_log_record);
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector, status,
channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
strategy.decision = NOOP;
strategy.max_parallel_uploads = UINT32_MAX;
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 2 * test_log_record_size,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, create_mock_storage(), &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t expected_size = 0;
error_code = kaa_logging_request_get_size(log_collector, &expected_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
uint8_t buffer[expected_size];
kaa_platform_message_writer_t *writer = NULL;
error_code = kaa_platform_message_writer_create(&writer, buffer, expected_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(writer);
error_code = kaa_logging_request_serialize(log_collector, writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_platform_message_writer_destroy(writer);
uint8_t *buf_cursor = buffer;
ASSERT_EQUAL(KAA_EXTENSION_LOGGING, KAA_HTONS(*(uint16_t *)buf_cursor));
buf_cursor += sizeof(uint16_t);
uint8_t options[] = { 0x00, 0x01 };
ASSERT_EQUAL(memcmp(buf_cursor, options, 2), 0);
buf_cursor += 2;
ASSERT_EQUAL(*(uint32_t *) buf_cursor, KAA_HTONL(20));
buf_cursor += sizeof(uint32_t);
uint8_t request_id_records_count[] = { 0x00, 0x01, 0x00, 0x01 };
ASSERT_EQUAL(memcmp(buf_cursor, request_id_records_count, 4), 0);
buf_cursor += 4;
uint8_t record_buf[test_log_record_size];
avro_writer_t avro_writer = avro_writer_memory((char *)record_buf, test_log_record_size);
test_log_record->serialize(avro_writer, test_log_record);
avro_writer_free(avro_writer);
ASSERT_EQUAL(*(uint32_t *) buf_cursor, KAA_HTONL(test_log_record_size));
buf_cursor += sizeof(uint32_t);
ASSERT_EQUAL(memcmp(buf_cursor, record_buf, test_log_record_size), 0);
kaa_log_collector_destroy(log_collector);
test_log_record->destroy(test_log_record);
}
void test_response(void **state)
{
(void)state;
srand(time(NULL));
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector, status, channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
mock_storage_context_t *storage = create_mock_storage();
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 1024,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, storage, &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
uint32_t response_count = 2;
size_t response_buffer_size = sizeof(uint32_t) + sizeof(uint32_t) * response_count;
uint8_t response_buffer[response_buffer_size];
uint8_t *response = response_buffer;
*((uint32_t *)response) = KAA_HTONL(response_count);
response += sizeof(uint32_t);
/* First response */
*((uint16_t *)response) = KAA_HTONS(rand());
response += sizeof(uint16_t);
*((uint8_t *)response) = 0x0; // SUCCESS
response += sizeof(uint8_t);
*((uint8_t *)response) = 0;
response += sizeof(uint8_t);
/* Second response */
*((uint16_t *)response) = KAA_HTONS(rand());
response += sizeof(uint16_t);
*((uint8_t *)response) = 0x1; // FAILURE
response += sizeof(uint8_t);
*((uint8_t *)response) = rand() % 4;
response += sizeof(uint8_t);
kaa_platform_message_reader_t *reader = NULL;
error_code = kaa_platform_message_reader_create(&reader, response_buffer, response_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(reader);
error_code = kaa_logging_handle_server_sync(log_collector, reader, 0, response_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_TRUE(strategy.on_failure_count);
ASSERT_TRUE(storage->on_remove_by_id_count);
ASSERT_TRUE(storage->on_unmark_by_id_count);
kaa_platform_message_reader_destroy(reader);
kaa_log_collector_destroy(log_collector);
}
void test_timeout(void **state)
{
(void)state;
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector,
status, channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_user_log_record_t *test_log_record = kaa_test_log_record_create();
test_log_record->data = kaa_string_copy_create(TEST_LOG_BUFFER);
size_t test_log_record_size = test_log_record->get_size(test_log_record);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
strategy.timeout = TEST_TIMEOUT;
strategy.decision = NOOP;
strategy.max_parallel_uploads = UINT32_MAX;
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 2 * test_log_record_size,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, create_mock_storage(), &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t request_buffer_size = 256;
uint8_t request_buffer[request_buffer_size];
kaa_platform_message_writer_t *writer = NULL;
error_code = kaa_platform_message_writer_create(&writer, request_buffer, request_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_request_serialize(log_collector, writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
sleep(TEST_TIMEOUT + 1);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_TRUE(strategy.on_timeout_count);
test_log_record->destroy(test_log_record);
kaa_platform_message_writer_destroy(writer);
kaa_log_collector_destroy(log_collector);
}
void test_decline_timeout(void **state)
{
(void)state;
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector, status, channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_user_log_record_t *test_log_record = kaa_test_log_record_create();
test_log_record->data = kaa_string_copy_create(TEST_LOG_BUFFER);
size_t test_log_record_size = test_log_record->get_size(test_log_record);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
strategy.timeout = TEST_TIMEOUT;
strategy.decision = NOOP;
strategy.max_parallel_uploads = UINT32_MAX;
mock_storage_context_t *storage = create_mock_storage();
ASSERT_NOT_NULL(storage);
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 2 * test_log_record_size,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, storage, &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t request_buffer_size = 256;
uint8_t request_buffer[request_buffer_size];
kaa_platform_message_writer_t *writer = NULL;
error_code = kaa_platform_message_writer_create(&writer, request_buffer, request_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_request_serialize(log_collector, writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
sleep(TEST_TIMEOUT + 1);
uint16_t bucket_id = *((uint16_t *)(request_buffer + KAA_EXTENSION_HEADER_SIZE));
bucket_id = KAA_NTOHS(bucket_id);
uint32_t response_count = 1;
size_t response_buffer_size = sizeof(uint32_t) + sizeof(uint32_t) * response_count;
uint8_t response_buffer[response_buffer_size];
uint8_t *response = response_buffer;
*((uint32_t *)response) = KAA_HTONL(response_count);
response += sizeof(uint32_t);
/* First response */
*((uint16_t *)response) = KAA_HTONS(bucket_id);
response += sizeof(uint16_t);
*((uint8_t *)response) = 0x0; // SUCCESS
response += sizeof(uint8_t);
*((uint8_t *)response) = 0;
response += sizeof(uint8_t);
kaa_platform_message_reader_t *reader = NULL;
error_code = kaa_platform_message_reader_create(&reader, response_buffer, response_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(reader);
error_code = kaa_logging_handle_server_sync(log_collector, reader, 0, response_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_TRUE(storage->on_remove_by_id_count);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_FALSE(strategy.on_timeout_count);
test_log_record->destroy(test_log_record);
kaa_platform_message_writer_destroy(writer);
kaa_platform_message_reader_destroy(reader);
kaa_log_collector_destroy(log_collector);
}
void test_max_parallel_uploads_with_log_sync(void **state)
{
(void)state;
uint32_t channel_id = 0;
kaa_transport_channel_interface_t transport_context;
test_kaa_channel_create(&transport_context);
kaa_channel_manager_add_transport_channel(channel_manager, &transport_context, &channel_id);
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector, status, channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_user_log_record_t *test_log_record = kaa_test_log_record_create();
test_log_record->data = kaa_string_copy_create(TEST_LOG_BUFFER);
size_t test_log_size = test_log_record->get_size(test_log_record);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
strategy.timeout = INT16_MAX;
strategy.decision = UPLOAD;
mock_storage_context_t *storage = create_mock_storage();
ASSERT_NOT_NULL(storage);
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 2 * test_log_size,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, storage, &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
/*
* Ensure the log delivery is forbidden at all.
*/
strategy.max_parallel_uploads = 0;
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(((mock_transport_channel_context_t *)transport_context.context)->on_sync_count, 0);
/*
* Ensure the first request is allowed.
*/
strategy.max_parallel_uploads = 1;
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(((mock_transport_channel_context_t *)transport_context.context)->on_sync_count, 1);
/*
* Do the first request to remember the delivery timeout of the log batch.
*/
size_t request_buffer_size = 256;
uint8_t request_buffer[request_buffer_size];
kaa_platform_message_writer_t *writer = NULL;
error_code = kaa_platform_message_writer_create(&writer, request_buffer, request_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_request_serialize(log_collector, writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
/*
* Ensure the second request is forbidden.
*/
ASSERT_EQUAL(((mock_transport_channel_context_t *)transport_context.context)->on_sync_count, 1);
/*
* Clean up.
*/
error_code = kaa_channel_manager_remove_transport_channel(channel_manager, channel_id);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
test_log_record->destroy(test_log_record);
kaa_log_collector_destroy(log_collector);
}
void test_max_parallel_uploads_with_sync_all(void **state)
{
(void)state;
uint32_t channel_id = 0;
kaa_transport_channel_interface_t transport_context;
test_kaa_channel_create(&transport_context);
kaa_channel_manager_add_transport_channel(channel_manager, &transport_context, &channel_id);
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector,
status, channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_user_log_record_t *test_log_record = kaa_test_log_record_create();
test_log_record->data = kaa_string_copy_create(TEST_LOG_BUFFER);
size_t test_log_size = test_log_record->get_size(test_log_record);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
strategy.timeout = INT16_MAX;
strategy.decision = UPLOAD;
mock_storage_context_t *storage = create_mock_storage();
ASSERT_NOT_NULL(storage);
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 2 * test_log_size,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, storage, &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
/*
* Ensure the log delivery is forbidden at all.
*/
strategy.max_parallel_uploads = 0;
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t expected_size = 0;
error_code = kaa_logging_request_get_size(log_collector, &expected_size);
assert_int_equal(KAA_ERR_NONE, error_code);
ASSERT_FALSE(expected_size);
/*
* Ensure the first request is allowed.
*/
strategy.max_parallel_uploads = 1;
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
/*
* Do the first request to remember the delivery timeout of the log batch.
*/
error_code = kaa_logging_request_get_size(log_collector, &expected_size);
assert_int_equal(KAA_ERR_NONE, error_code);
ASSERT_TRUE(expected_size);
size_t request_buffer_size = 256;
uint8_t request_buffer[request_buffer_size];
kaa_platform_message_writer_t *writer = NULL;
error_code = kaa_platform_message_writer_create(&writer, request_buffer, request_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_request_serialize(log_collector, writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
/*
* Ensure the second request is forbidden.
*/
error_code = kaa_logging_request_get_size(log_collector, &expected_size);
assert_int_equal(KAA_ERR_NONE, error_code);
ASSERT_FALSE(expected_size);
/*
* Clean up.
*/
error_code = kaa_channel_manager_remove_transport_channel(channel_manager, channel_id);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
test_log_record->destroy(test_log_record);
kaa_log_collector_destroy(log_collector);
}
/* ---------------------------------------------------------------------------*/
/* Log delivery tests */
/* ---------------------------------------------------------------------------*/
/* Server chunk, managed by a corresponding reader object.
* Perfectly packed. Packed attribute is intentionally avoided. */
struct response_chunk {
uint8_t bucket_id[2]; /* 16 bits for bucket ID */
uint8_t resp_code; /* 8 bits for response code. 0 == SUCCESS, 1 == FAILURE */
// cppcheck-suppress unusedStructMember
uint8_t reserved; /* Should be 0 */
};
struct response_packet {
uint8_t resp_cnt[4]; /* 32 bits for amount of responces in buffer */
struct response_chunk resps[]; /* Responses itself */
};
#define RESP_PACKETS 2 /* Amount of response packets */
#define RESP_SUCCESS_IDX 0 /* Index of successfull response */
#define RESP_FAILURE_IDX 1 /* Index of failed response */
#define TEST_BUFFER_SIZE 1024
#define TEST_EXT_OP 0 /* Simple stub */
static mock_strategy_context_t test_strategy1;
static mock_strategy_context_t test_strategy2;
static mock_storage_context_t *test_storage1;
static mock_storage_context_t *test_storage2;
static kaa_log_collector_t *log_collector;
static size_t test_log_record_size = TEST_BUFFER_SIZE;
/* Will contain response_packet. Thus required to be aligned. */
static uint32_t test_reader_buffer[TEST_BUFFER_SIZE / 4];
static uint32_t test_writer_buffer[TEST_BUFFER_SIZE / 4];
/* Portion of the test buffer filled with valid data */
static size_t test_filled_size;
static kaa_platform_message_reader_t *test_reader;
static kaa_platform_message_writer_t *test_writer;
static kaa_user_log_record_t *test_log_record;
/* Values to be checked inside mock event function */
static void *expected_ctx;
static int check_bucket;
static uint16_t expected_bucked_id;
/* Required to trace generic mock function calls */
static int call_is_expected;
static int call_completed;
/* Required to trace on fail mock function calls */
static int failed_call_is_expected;
static int failed_call_completed;
/* Required to trace on success mock function calls */
static int success_call_is_expected;
static int success_call_completed;
/* Required to trace on timeout mock function calls */
static int timeout_call_is_expected;
static int timeout_call_completed;
/* Mock event functions */
static void mock_log_event_generic_fn(void *ctx, const kaa_log_bucket_info_t *bucket)
{
ASSERT_TRUE(call_is_expected);
ASSERT_NOT_NULL(bucket); /* Shouldn't be NULL no matter what */
if (check_bucket) {
ASSERT_EQUAL(expected_bucked_id, bucket->bucket_id);
}
ASSERT_EQUAL(expected_ctx, ctx);
call_completed++;
}
