dlog_logger: add a function for resizing log_compressed_storage

Change-Id: I1a2631ac944ef7d1384245464c9a194e3eab535f

diff --git a/src/logger/log_compressed_storage.c b/src/logger/log_compressed_storage.c
index 2050c3a..2f69410 100644 (file)
--- a/src/logger/log_compressed_storage.c
+++ b/src/logger/log_compressed_storage.c
@@ -413,3 +413,13 @@ const struct log_compressed_storage *log_compressed_storage_reader_get_storage(c
        assert(reader);
        return reader->storage;
 }
+
+void log_compressed_storage_resize(log_compressed_storage *storage, unsigned int capacity)
+{
+       assert(capacity != 0);
+
+       /* in case of shrinking the storage size drop excess logs */
+       while (storage->counter_end - storage->counter_begin > capacity)
+               log_compressed_storage_remove_the_earliest_log(storage);
+       storage->capacity = capacity;
+}

diff --git a/src/logger/log_compressed_storage.h b/src/logger/log_compressed_storage.h
index 3f4712a..6f5d616 100644 (file)
--- a/src/logger/log_compressed_storage.h
+++ b/src/logger/log_compressed_storage.h
@@ -183,6 +183,15 @@ const char *log_compressed_storage_get_name(const log_compressed_storage *storag
  */
 struct compression_algo *get_algo_from_storage(const struct log_compressed_storage *storage);
 
+/**
+ * @brief This function resizes storage to new, specified capacity.
+ * @param[in] storage The storage that will be resized.
+ * @param[in] capacity New capacity to which the storage will be resized to.
+ * @note When new capacity is smaller than the current one, this function
+ *       will be removing earliest logs until they stop surpassing new max capacity.
+ */
+void log_compressed_storage_resize(log_compressed_storage *storage, unsigned int capacity);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/src/tests/test_logger_compressed_storage.c b/src/tests/test_logger_compressed_storage.c
index 514261e..c027512 100644 (file)
--- a/src/tests/test_logger_compressed_storage.c
+++ b/src/tests/test_logger_compressed_storage.c
@@ -68,6 +68,12 @@ void callback_count_inc(const struct compression_entry *ce, void *user_data)
        callback_count++;
 }
 
+static int dropped_logs_counter = 0;
+void callback_dropped_log_increment(const struct compression_entry *ce, void *user_data)
+{
+       dropped_logs_counter++;
+}
+
 
 char good_compressible_input[4096] = {0, };
 char weak_compressible_input[4096];
@@ -458,6 +464,153 @@ void test_naming()
        log_compressed_storage_free(s1);
 }
 
+void test_storage_resize_extend_no_logs()
+{
+       log_compressed_storage *storage = log_compressed_storage_create(123, "storydzus", g_algo);
+       assert(log_compressed_storage_get_capacity(storage) == 123);
+
+       log_compressed_storage_resize(storage, 456);
+       assert(log_compressed_storage_get_capacity(storage) == 456);
+
+       log_compressed_storage_free(storage);
+}
+
+void test_storage_resize_extend_then_shrink()
+{
+       unsigned int storage_capacity = 1;
+       log_compressed_storage *storage = log_compressed_storage_create(storage_capacity, "storydzus", g_algo);
+       assert(log_compressed_storage_get_capacity(storage) == storage_capacity);
+
+       /* try adding a log above the storage's capacity */
+       char log[] = "log and some extra characters";
+       /* min legal log_len to compress for fastlz is 16, miniz accepts any len */
+       size_t log_len = strlen(log);
+
+       log_compressed_storage_reader *reader = log_compressed_storage_new_reader(storage, false, false, callback_dropped_log_increment, NULL);
+       assert(log_compressed_storage_reader_is_new_entry_available(reader) == false);
+
+       dropped_logs_counter = 0;
+       assert(log_compressed_storage_add_new_entry(storage, log, log_len) == true);
+       assert(dropped_logs_counter == 1);
+       assert(log_compressed_storage_reader_is_new_entry_available(reader) == false);
+
+       /* resize the storage fit the log */
+       log_compressed_storage_resize(storage, storage_capacity + log_len);
+       dropped_logs_counter = 0;
+       assert(log_compressed_storage_add_new_entry(storage, log, log_len) == true);
+       assert(dropped_logs_counter == 0);
+       assert(log_compressed_storage_reader_is_new_entry_available(reader) == true);
+
+       /* check if storage shrinks */
+       dropped_logs_counter = 0;
+       log_compressed_storage_resize(storage, 1);
+       assert(dropped_logs_counter == 1);
+       assert(log_compressed_storage_reader_is_new_entry_available(reader) == false);
+
+       log_compressed_storage_free(storage);
+}
+
+void test_storage_resize_partial_shrink()
+{
+       char log[] = "some random text";
+       size_t log_len = strlen(log);
+
+       size_t log_num_to_add = 5;
+       unsigned int storage_capacity = log_num_to_add * log_len;
+       log_compressed_storage *storage = log_compressed_storage_create(storage_capacity, "storydzus", g_algo);
+       assert(log_compressed_storage_get_capacity(storage) == storage_capacity);
+
+       log_compressed_storage_reader *reader = log_compressed_storage_new_reader(storage, false, false, callback_dropped_log_increment, NULL);
+       assert(log_compressed_storage_reader_is_new_entry_available(reader) == false);
+       dropped_logs_counter = 0;
+
+       size_t log_size_after_comp;
+       /* add some logs */
+       for (int i = 0; i < log_num_to_add; i++) {
+               assert(log_compressed_storage_add_new_entry(storage, log, log_len) == true);
+               assert(log_compressed_storage_reader_is_new_entry_available(reader) == true);
+               /* determine log size after applying compression, every log has the same contents */
+               if (i == 0)
+                       log_size_after_comp = log_compressed_storage_get_usage(storage);
+       }
+       assert(dropped_logs_counter == 0);
+
+       /* shrink the storage */
+       size_t new_log_num = 3;
+       unsigned int new_storage_capacity = new_log_num * log_size_after_comp;
+       log_compressed_storage_resize(storage, new_storage_capacity);
+       assert(log_compressed_storage_get_capacity(storage) == new_storage_capacity);
+
+       assert(dropped_logs_counter == 2);
+
+       log_compressed_storage_free(storage);
+}
+
+void test_storage_resize_extend_with_logs()
+{
+       char log[] = "some random text";
+       size_t log_len = strlen(log);
+
+       size_t log_num_to_add = 5;
+       unsigned int storage_capacity = log_num_to_add * log_len;
+       log_compressed_storage *storage = log_compressed_storage_create(storage_capacity, "storydzus", g_algo);
+       assert(log_compressed_storage_get_capacity(storage) == storage_capacity);
+
+       log_compressed_storage_reader *reader = log_compressed_storage_new_reader(storage, false, false, callback_dropped_log_increment, NULL);
+       assert(log_compressed_storage_reader_is_new_entry_available(reader) == false);
+       dropped_logs_counter = 0;
+
+       /* add some logs */
+       for (int i = 0; i < log_num_to_add; i++) {
+               assert(log_compressed_storage_add_new_entry(storage, log, log_len) == true);
+               assert(log_compressed_storage_reader_is_new_entry_available(reader) == true);
+       }
+       assert(dropped_logs_counter == 0);
+
+       /* extend the storage */
+       size_t new_max_log_num = 8;
+       unsigned int new_storage_capacity = new_max_log_num * log_len;
+       log_compressed_storage_resize(storage, new_storage_capacity);
+       assert(log_compressed_storage_get_capacity(storage) == new_storage_capacity);
+
+       assert(dropped_logs_counter == 0);
+
+       log_compressed_storage_free(storage);
+}
+
+void test_storage_resize_large_buffer()
+{
+       unsigned int storage_capacity = 333333;
+       log_compressed_storage *storage = log_compressed_storage_create(storage_capacity, "storydzus", g_algo);
+       assert(log_compressed_storage_get_capacity(storage) == storage_capacity);
+
+       /* some extra characters to meet fastlz min buffer length limit to compress */
+       char log[] = "foobarbazsomeextra";
+       while (log_compressed_storage_get_usage(storage) < 300000)
+               log_compressed_storage_add_new_entry(storage, log, strlen(log));
+
+       log_compressed_storage_new_reader(storage, false, false, callback_dropped_log_increment, NULL);
+       dropped_logs_counter = 0;
+
+       unsigned int resize_capacity = 222222;
+       log_compressed_storage_resize(storage, resize_capacity);
+       assert(dropped_logs_counter > 0);
+       assert(log_compressed_storage_get_usage(storage) <= resize_capacity);
+
+       log_compressed_storage_free(storage);
+}
+
+void test_storage_resize_shrink_with_no_logs()
+{
+       log_compressed_storage *storage = log_compressed_storage_create(2, "storydzus", g_algo);
+       assert(log_compressed_storage_get_capacity(storage) == 2);
+
+       log_compressed_storage_resize(storage, 1);
+       assert(log_compressed_storage_get_capacity(storage) == 1);
+
+       log_compressed_storage_free(storage);
+}
+
 static size_t get_good_size_fastlz() {
        char buffer [FASTLZ_NEEDED_OUTPUT_SIZE(sizeof good_compressible_input)];
        return fastlz_compress(good_compressible_input, sizeof good_compressible_input, buffer);
@@ -498,6 +651,12 @@ int main(void)
                test_get_usage();
                test_monitor();
                test_naming();
+               test_storage_resize_extend_no_logs();
+               test_storage_resize_extend_then_shrink();
+               test_storage_resize_partial_shrink();
+               test_storage_resize_extend_with_logs();
+               test_storage_resize_large_buffer();
+               test_storage_resize_shrink_with_no_logs();
        }
 
        return 0;