void test_empty_log_collector_extension_count(void)
{
kaa_service_t service = KAA_SERVICE_LOGGING;
info = (kaa_serialize_info_t *) KAA_MALLOC(sizeof(kaa_serialize_info_t));
info->services = &service;
info->services_count = 1;
info->allocator = &allocator;
info->allocator_context = mock;
void *log_storage_context = NULL;
void *log_upload_strategy_context = NULL;
kaa_error_t error_code = ext_unlimited_log_storage_create(&log_storage_context, kaa_context->logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_upload_strategy_create(kaa_context
, &log_upload_strategy_context
, KAA_LOG_UPLOAD_VOLUME_STRATEGY);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_init(kaa_context->log_collector, log_storage_context, log_upload_strategy_context);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_protocol_serialize_client_sync(kaa_context->platform_protocol, info, &buffer, &buffer_size);
KAA_FREE(info);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
char count_of_extensions = *(buffer + 7);
KAA_LOG_DEBUG(kaa_context->logger, KAA_ERR_NONE, "count of extensions is %d, expected 1", count_of_extensions);
ASSERT_EQUAL(count_of_extensions, 1);
}
/*
* Initializes Kaa log collector.
*/
kaa_error_t kaa_log_collector_init()
{
kaa_error_t error_code = ext_unlimited_log_storage_create(&log_storage_context, kaa_context_->logger);
if (error_code) {
KAA_LOG_ERROR(kaa_context_->logger, error_code, "Failed to create log storage");
return error_code;
}
error_code = ext_log_upload_strategy_by_volume_create(&log_upload_strategy_context
, kaa_context_->channel_manager
, kaa_context_->bootstrap_manager);
if (error_code) {
KAA_LOG_ERROR(kaa_context_->logger, error_code, "Failed to create log upload strategy");
return error_code;
}
error_code = ext_log_upload_strategy_by_volume_set_threshold_count(log_upload_strategy_context
, KAA_DEMO_UPLOAD_COUNT_THRESHOLD);
error_code = kaa_logging_init(kaa_context_->log_collector
, log_storage_context
, log_upload_strategy_context);
return error_code;
}
void test_add_log_record(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
void *storage;
error_code = ext_unlimited_log_storage_create(&storage, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t record_count = 0;
const char *data = "DATA";
size_t data_size = strlen("DATA");
error_code = add_log_record(storage, data, data_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
++record_count;
ASSERT_EQUAL(ext_log_storage_get_records_count(storage), record_count);
error_code = add_log_record(storage, data, data_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
++record_count;
ASSERT_EQUAL(ext_log_storage_get_records_count(storage), record_count);
ASSERT_EQUAL(ext_log_storage_get_total_size(storage), record_count * data_size);
ext_log_storage_destroy(storage);
KAA_TRACE_OUT(logger);
}
void test_allocate_log_record_buffer(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
void *storage;
error_code = ext_unlimited_log_storage_create(&storage, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_storage_allocate_log_record_buffer(storage, NULL);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
kaa_log_record_t record1 = { NULL, 0 };
error_code = ext_log_storage_allocate_log_record_buffer(storage, &record1);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NULL(record1.data);
kaa_log_record_t record2 = { NULL, 256 };
error_code = ext_log_storage_allocate_log_record_buffer(storage, &record2);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(record2.data);
ext_log_storage_deallocate_log_record_buffer(storage, &record2);
ext_log_storage_destroy(storage);
KAA_TRACE_OUT(logger);
}
int main(/*int argc, char *argv[]*/)
{
printf("Cassandra data analytics demo started\n");
if (wiringPiSetup() == -1) {
printf("Failed to initialize Pi wiring\n");
exit(1);
}
kaa_client_t *kaa_client = NULL;
void *log_storage_context = NULL;
void *log_upload_strategy_context = NULL;
/**
* Initialize Kaa client.
*/
kaa_error_t error_code = kaa_client_create(&kaa_client, NULL);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed create Kaa client");
/**
* Configure Kaa data collection module.
*/
error_code = ext_unlimited_log_storage_create(&log_storage_context, kaa_client_get_context(kaa_client)->logger);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed to create unlimited log storage");
error_code = ext_log_upload_strategy_create(kaa_client_get_context(kaa_client), &log_upload_strategy_context, KAA_LOG_UPLOAD_VOLUME_STRATEGY);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed to create log upload strategy");
error_code = ext_log_upload_strategy_set_threshold_count(log_upload_strategy_context, KAA_DEMO_UPLOAD_COUNT_THRESHOLD);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed to set threshold log record count");
kaa_log_bucket_constraints_t bucket_sizes = {
.max_bucket_size = MAX_LOG_BUCKET_SIZE,
.max_bucket_log_count = MAX_LOG_COUNT,
};
error_code = kaa_logging_init(kaa_client_get_context(kaa_client)->log_collector
, log_storage_context
, log_upload_strategy_context
, &bucket_sizes);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed to init Kaa log collector");
/**
* Start Kaa client main loop.
*/
error_code = kaa_client_start(kaa_client, &kaa_demo_add_log_record, (void *)kaa_client, KAA_DEMO_LOG_GENERATION_FREQUENCY);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed to start Kaa main loop");
/**
* Destroy Kaa client.
*/
kaa_client_destroy(kaa_client);
printf("Cassandra data analytics demo stopped\n");
return error_code;
}
/*
* Initializes Kaa log collector.
*/
kaa_error_t kaa_log_collector_init(kaa_client_t *kaa_client)
{
KAA_RETURN_IF_NIL(kaa_client, KAA_ERR_BADPARAM)
kaa_error_t error_code = ext_unlimited_log_storage_create(&kaa_client->log_storage_context
, kaa_client->kaa_context->logger);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code, "Failed to create log storage");
return error_code;
}
error_code = ext_log_upload_strategy_create(kaa_client->kaa_context
,&kaa_client->log_upload_strategy_context
, KAA_LOG_UPLOAD_VOLUME_STRATEGY);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code, "Failed to create log upload strategy");
return error_code;
}
// Due to unknown problems with networking via ESP8266, some server responses are lost.
// It leads to log delivery timeouts.
error_code = ext_log_upload_strategy_set_upload_timeout(kaa_client->log_upload_strategy_context
, KAA_DEMO_TWO_DAYS_UPLOAD_TIMEOUT);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger,
error_code,
"Failed to create log upload strategy by volume set upload timeout to %d",
KAA_DEMO_TWO_DAYS_UPLOAD_TIMEOUT);
return error_code;
}
error_code = ext_log_upload_strategy_et_threshold_count(kaa_client->log_upload_strategy_context
, KAA_DEMO_UPLOAD_COUNT_THRESHOLD);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger,
error_code,
"Failed to create log upload strategy by volume set threshold count to %d",
KAA_DEMO_UPLOAD_COUNT_THRESHOLD);
return error_code;
}
error_code = kaa_logging_init(kaa_client->kaa_context->log_collector
, kaa_client->log_storage_context
, kaa_client->log_upload_strategy_context);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, error_code,"Failed to logging init");
return error_code;
}
KAA_LOG_INFO(kaa_client->kaa_context->logger, KAA_ERR_NONE, "Log collector init complete");
return error_code;
}
/*
* Initializes Kaa log collector.
*/
kaa_error_t kaa_log_collector_init(kaa_client_t *kaa_client)
{
KAA_RETURN_IF_NIL(kaa_client, KAA_ERR_BADPARAM);
kaa_error_t error_code = ext_unlimited_log_storage_create(
&kaa_client->log_storage_context,
kaa_client->kaa_context->logger);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger,
error_code,
"Failed to create log storage");
return error_code;
}
error_code = ext_log_upload_strategy_create(kaa_client->kaa_context
,&kaa_client->log_upload_strategy_context
, KAA_LOG_UPLOAD_VOLUME_STRATEGY);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger,
error_code,
"Failed to create log upload strategy");
return error_code;
}
error_code = ext_log_upload_strategy_set_threshold_count(kaa_client->log_upload_strategy_context
, KAA_DEMO_UPLOAD_COUNT_THRESHOLD);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger,
error_code,
"Failed to create log upload strategy by volume set threshold count to %d",
KAA_DEMO_UPLOAD_COUNT_THRESHOLD);
return error_code;
}
error_code = kaa_logging_init(kaa_client->kaa_context->log_collector
, kaa_client->log_storage_context
, kaa_client->log_upload_strategy_context);
if (error_code) {
KAA_LOG_ERROR(kaa_client->kaa_context->logger,
error_code,
"Failed to logging init");
return error_code;
}
KAA_LOG_INFO(kaa_client->kaa_context->logger,
KAA_ERR_NONE,
"Log collector init complete");
return error_code;
}
void test_create_unlimited_storage(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
void *storage;
error_code = ext_unlimited_log_storage_create(NULL, NULL);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_unlimited_log_storage_create(&storage, NULL);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_unlimited_log_storage_create(NULL, logger);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_unlimited_log_storage_create(&storage, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ext_log_storage_destroy(storage);
KAA_TRACE_OUT(logger);
}
int main(/*int argc, char *argv[]*/)
{
printf("Data collection demo started\n");
/**
* Initialize Kaa client.
*/
kaa_error_t error_code = kaa_client_create(&kaa_client, NULL);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed create Kaa client");
error_code = ext_unlimited_log_storage_create(&log_storage_context, kaa_client_get_context(kaa_client)->logger);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed to create unlimited log storage");
error_code = ext_log_upload_strategy_by_volume_create(&log_upload_strategy_context
, kaa_client_get_context(kaa_client)->channel_manager
, kaa_client_get_context(kaa_client)->bootstrap_manager);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed to create log upload strategy");
error_code = ext_log_upload_strategy_by_volume_set_threshold_count(log_upload_strategy_context
, KAA_DEMO_UPLOAD_COUNT_THRESHOLD);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed to set threshold log record count");
error_code = kaa_logging_init(kaa_client_get_context(kaa_client)->log_collector
, log_storage_context
, log_upload_strategy_context);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed to init Kaa log collector");
/**
* Start Kaa client main loop.
*/
error_code = kaa_client_start(kaa_client, &kaa_demo_add_log_record, (void *)kaa_client, KAA_DEMO_LOG_GENERATION_FREQUENCY);
KAA_DEMO_RETURN_IF_ERROR(error_code, "Failed to start Kaa main loop");
/**
* Destroy Kaa client.
*/
kaa_client_destroy(kaa_client);
printf("Data collection demo stopped\n");
return error_code;
}
void test_unmark_by_bucket_id(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
void *storage;
error_code = ext_unlimited_log_storage_create(&storage, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t record_len = 0;
size_t TEST_RECORD_COUNT = 10;
size_t record_count = 0;
const char *data = "DATA";
size_t data_size = strlen("DATA");
while (record_count < TEST_RECORD_COUNT) {
error_code = add_log_record(storage, data, data_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
++record_count;
}
size_t buffer_size = data_size;
char buffer[buffer_size];
size_t bucket_id_1 = 1;
size_t i;
for (i = 0; i < record_count / 2; ++i) {
error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_1, &record_len);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
}
size_t bucket_id_2 = 2;
for (i = 0; i < record_count / 2; ++i) {
error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_2, &record_len);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
}
size_t bucket_id_3 = 3;
error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_3, &record_len);
ASSERT_EQUAL(error_code, KAA_ERR_NOT_FOUND);
error_code = ext_log_storage_remove_by_bucket_id(storage, bucket_id_2);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_3, &record_len);
ASSERT_EQUAL(error_code, KAA_ERR_NOT_FOUND);
error_code = ext_log_storage_unmark_by_bucket_id(storage, bucket_id_1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t bucket_id_4 = 4;
for (i = 0; i < record_count / 2; ++i) {
error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_4, &record_len);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
}
error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_3, &record_len);
ASSERT_EQUAL(error_code, KAA_ERR_NOT_FOUND);
error_code = ext_log_storage_remove_by_bucket_id(storage, bucket_id_4);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(ext_log_storage_get_records_count(storage), 0);
ASSERT_EQUAL(ext_log_storage_get_total_size(storage), 0);
ext_log_storage_destroy(storage);
KAA_TRACE_OUT(logger);
}
void test_write_next_log_record(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
void *storage;
error_code = ext_unlimited_log_storage_create(&storage, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t bucket_id = 0;
size_t record_len = 0;
error_code = ext_log_storage_write_next_record(storage, NULL, 0, 0, NULL);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_storage_write_next_record(storage, NULL, 33, 0, NULL);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_storage_write_next_record(storage, NULL, 33, bucket_id, NULL);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_storage_write_next_record(storage, NULL, 33, bucket_id, &record_len);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
size_t record_count = 0;
const char *data = "DATA";
size_t data_size = strlen("DATA");
error_code = add_log_record(storage, data, data_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
++record_count;
error_code = add_log_record(storage, data, data_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
++record_count;
size_t buffer_size = (record_count + 1) * data_size;
char buffer[buffer_size];
bucket_id = 1;
error_code = ext_log_storage_write_next_record(storage, buffer, 1, bucket_id, &record_len);
ASSERT_EQUAL(error_code, KAA_ERR_INSUFFICIENT_BUFFER);
error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id, &record_len);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(record_len, data_size);
error_code = ext_log_storage_write_next_record(storage, buffer + record_len, buffer_size - record_len, bucket_id, &record_len);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(record_len, data_size);
error_code = ext_log_storage_write_next_record(storage, buffer + 2 * record_len, buffer_size - 2 * record_len, bucket_id, &record_len);
ASSERT_EQUAL(error_code, KAA_ERR_NOT_FOUND);
int res = memcmp(buffer, data, data_size);
ASSERT_EQUAL(res, 0);
res = memcmp(buffer + data_size, data, data_size);
ASSERT_EQUAL(res, 0);
ext_log_storage_destroy(storage);
KAA_TRACE_OUT(logger);
}
