@cryptotaxi247 / netdata-1 / commits / de88c30dc

Metadata event loop code cleanup (#19929)

* Remove query counter * Refactor metadata worker structure to use stack-allocated event loop and improve initialization checks Code cleanup * Refactor metadata_queue_load_host_context to remove unnecessary parameter

Stelios Fragkakis committed Mar 21, 2025 at 20:39 UTC de88c30dca8262dba4b32d7d8ddc8b203ca94b14

4 files changed +86 -138

src/database/rrdhost.c

+1 -2

@@ -459,8 +459,7 @@ RRDHOST *rrdhost_create(

459 rrdhost_flag_set(host, RRDHOST_FLAG_METADATA_INFO | RRDHOST_FLAG_METADATA_UPDATE);

460 if (is_localhost) {

461 BUFFER *buf = buffer_create(0, NULL);

462 - size_t query_counter = 0;

463 - store_host_info_and_metadata(host, buf, &query_counter);

462 + store_host_info_and_metadata(host, buf);

463 buffer_free(buf);

464 }

465 rrdhost_load_rrdcontext_data(host);

src/database/sqlite/sqlite_aclk.c

+1 -1

@@ -958,7 +958,7 @@ void sql_aclk_sync_init(void)

958

959 netdata_log_info("Created %d archived hosts", number_of_children);

960 // Trigger host context load for hosts that have been created

961 - metadata_queue_load_host_context(NULL);

961 + metadata_queue_load_host_context();

962

963 if (!number_of_children)

964 aclk_queue_node_info(localhost, true);

src/database/sqlite/sqlite_metadata.c

+82 -133

@@ -229,26 +229,25 @@ typedef enum {

229

230 struct metadata_wc {

231 uv_thread_t thread;

232 - uv_loop_t *loop;

232 + uv_loop_t loop;

233 uv_async_t async;

234 uv_timer_t timer_req;

235 time_t metadata_check_after;

236 Pvoid_t ae_DelJudyL;

237 METADATA_FLAG flags;

238 + bool initialized;

239 + SPINLOCK cmd_queue_lock;

240 struct completion start_stop_complete;

241 struct completion *scan_complete;

242 /* FIFO command queue */

241 - SPINLOCK cmd_queue_lock;

243 struct metadata_cmd *cmd_base;

244 ARAL *ar;

244 -};

245 +} metasync_worker;

246

247 #define metadata_flag_check(target_flags, flag) (__atomic_load_n(&((target_flags)->flags), __ATOMIC_SEQ_CST) & (flag))

248 #define metadata_flag_set(target_flags, flag) __atomic_or_fetch(&((target_flags)->flags), (flag), __ATOMIC_SEQ_CST)

249 #define metadata_flag_clear(target_flags, flag) __atomic_and_fetch(&((target_flags)->flags), ~(flag), __ATOMIC_SEQ_CST)

250

250 -struct metadata_wc metasync_worker = {.loop = NULL};

251 -

251 //

252 // For unittest

253 //

@@ -883,7 +882,7 @@ static int chart_label_store_to_sql_callback(const char *name, const char *value

882 return 1;

883 }

884

886 -static int check_and_update_chart_labels(RRDSET *st, BUFFER *work_buffer, size_t *query_counter)

885 +static int check_and_update_chart_labels(RRDSET *st, BUFFER *work_buffer)

886 {

887 size_t old_version = st->rrdlabels_last_saved_version;

888 size_t new_version = rrdlabels_version(st->rrdlabels);

@@ -896,10 +895,8 @@ static int check_and_update_chart_labels(RRDSET *st, BUFFER *work_buffer, size_t

895 rrdlabels_walkthrough_read(st->rrdlabels, chart_label_store_to_sql_callback, &tmp);

896 buffer_strcat(work_buffer, " ON CONFLICT (chart_id, label_key) DO UPDATE SET source_type = excluded.source_type, label_value=excluded.label_value, date_created=UNIXEPOCH()");

897 int rc = db_execute(db_meta, buffer_tostring(work_buffer));

899 - if (likely(!rc)) {

898 + if (likely(!rc))

899 st->rrdlabels_last_saved_version = new_version;

901 - (*query_counter)++;

902 - }

900

901 return rc;

902 }

@@ -1582,6 +1579,9 @@ static void metadata_free_cmd_queue(struct metadata_wc *wc)

1579

1580 static void metadata_enq_cmd(struct metadata_wc *wc, struct metadata_cmd *cmd)

1581 {

1582 + if(unlikely(!wc->initialized))

1583 + return;

1584 +

1585 if (cmd->opcode == METADATA_SYNC_SHUTDOWN) {

1586 metadata_flag_set(wc, METADATA_FLAG_SHUTDOWN);

1587 goto wakeup_event_loop;

@@ -1639,10 +1639,10 @@ static void timer_cb(uv_timer_t* handle)

1639 uv_update_time(handle->loop);

1640

1641 struct metadata_wc *wc = handle->data;

1642 - struct metadata_cmd cmd;

1643 - memset(&cmd, 0, sizeof(cmd));

1642

1643 if (wc->metadata_check_after < now_realtime_sec()) {

1644 + struct metadata_cmd cmd;

1645 + memset(&cmd, 0, sizeof(cmd));

1646 cmd.opcode = METADATA_SCAN_HOSTS;

1647 metadata_enq_cmd(wc, &cmd);

1648 }

@@ -2058,7 +2058,7 @@ static void after_metadata_hosts(uv_work_t *req, int status __maybe_unused)

2058 freez(data);

2059 }

2060

2061 -static void metadata_scan_host(RRDHOST *host, BUFFER *work_buffer, size_t *query_counter, bool shutting_down)

2061 +static void metadata_scan_host(RRDHOST *host, BUFFER *work_buffer, bool shutting_down)

2062 {

2063 static bool skip_models = false;

2064 RRDSET *st;

@@ -2074,18 +2074,15 @@ static void metadata_scan_host(RRDHOST *host, BUFFER *work_buffer, size_t *query

2074 rrdset_foreach_reentrant(st, host) {

2075

2076 if(rrdset_flag_check(st, RRDSET_FLAG_METADATA_UPDATE)) {

2077 - (*query_counter)++;

2077

2078 rrdset_flag_clear(st, RRDSET_FLAG_METADATA_UPDATE);

2079

2080 buffer_flush(work_buffer);

2081

2082 worker_is_busy(UV_EVENT_STORE_CHART);

2084 - rc = check_and_update_chart_labels(st, work_buffer, query_counter);

2083 + rc = check_and_update_chart_labels(st, work_buffer);

2084 if (unlikely(rc))

2085 error_report("METADATA: 'host:%s': Failed to update labels for chart %s", rrdhost_hostname(host), rrdset_name(st));

2087 - else

2088 - (*query_counter)++;

2086

2087 rc = store_chart_metadata(st, &store_chart);

2088 if (unlikely(rc)) {

@@ -2096,8 +2093,6 @@ static void metadata_scan_host(RRDHOST *host, BUFFER *work_buffer, size_t *query

2093 rrdhost_hostname(host),

2094 rrdset_name(st));

2095 }

2099 - else

2100 - (*query_counter)++;

2096 worker_is_idle();

2097 }

2098

@@ -2133,8 +2128,7 @@ static void metadata_scan_host(RRDHOST *host, BUFFER *work_buffer, size_t *query

2128 rrdhost_hostname(host),

2129 rrdset_name(st),

2130 rrddim_name(rd));

2136 - } else

2137 - (*query_counter)++;

2131 + }

2132

2133 worker_is_idle();

2134 }

@@ -2154,7 +2148,7 @@ static void metadata_scan_host(RRDHOST *host, BUFFER *work_buffer, size_t *query

2148 }

2149

2150

2157 -static void store_host_and_system_info(RRDHOST *host, size_t *query_counter)

2151 +static void store_host_and_system_info(RRDHOST *host)

2152 {

2153 rrdhost_flag_clear(host, RRDHOST_FLAG_METADATA_INFO);

2154

@@ -2162,19 +2156,11 @@ static void store_host_and_system_info(RRDHOST *host, size_t *query_counter)

2156 error_report("METADATA: 'host:%s': Failed to store host updated system information in the database", rrdhost_hostname(host));

2157 rrdhost_flag_set(host, RRDHOST_FLAG_METADATA_INFO | RRDHOST_FLAG_METADATA_UPDATE);

2158 }

2165 - else {

2166 - if (likely(query_counter))

2167 - (*query_counter)++;

2168 - }

2159

2160 if (unlikely(store_host_metadata(host))) {

2161 error_report("METADATA: 'host:%s': Failed to store host info in the database", rrdhost_hostname(host));

2162 rrdhost_flag_set(host, RRDHOST_FLAG_METADATA_INFO | RRDHOST_FLAG_METADATA_UPDATE);

2163 }

2174 - else {

2175 - if (likely(query_counter))

2176 - (*query_counter)++;

2177 - }

2164 }

2165

2166 struct judy_list_t {

@@ -2333,7 +2319,7 @@ static void store_sql_statements(struct judy_list_t *pending_sql_statement)

2319 worker_is_idle();

2320 }

2321

2336 -static void meta_store_host_labels(RRDHOST *host, BUFFER *work_buffer, size_t *query_counter)

2322 +static void meta_store_host_labels(RRDHOST *host, BUFFER *work_buffer)

2323 {

2324 rrdhost_flag_clear(host, RRDHOST_FLAG_METADATA_LABELS);

2325

@@ -2344,7 +2330,6 @@ static void meta_store_host_labels(RRDHOST *host, BUFFER *work_buffer, size_t *q

2330 return;

2331 }

2332

2347 - (*query_counter)++;

2333 buffer_flush(work_buffer);

2334

2335 struct query_build tmp = {.sql = work_buffer, .count = 0};

@@ -2358,11 +2343,10 @@ static void meta_store_host_labels(RRDHOST *host, BUFFER *work_buffer, size_t *q

2343 if (unlikely(rc)) {

2344 error_report("METADATA: 'host:%s': failed to update metadata host labels", rrdhost_hostname(host));

2345 rrdhost_flag_set(host, RRDHOST_FLAG_METADATA_LABELS | RRDHOST_FLAG_METADATA_UPDATE);

2361 - } else

2362 - (*query_counter)++;

2346 + }

2347 }

2348

2365 -static void store_host_claim_id(RRDHOST *host, size_t *query_counter)

2349 +static void store_host_claim_id(RRDHOST *host)

2350 {

2351 rrdhost_flag_clear(host, RRDHOST_FLAG_METADATA_CLAIMID);

2352 int rc;

@@ -2374,23 +2358,23 @@ static void store_host_claim_id(RRDHOST *host, size_t *query_counter)

2358

2359 if (unlikely(rc))

2360 rrdhost_flag_set(host, RRDHOST_FLAG_METADATA_CLAIMID | RRDHOST_FLAG_METADATA_UPDATE);

2377 - else

2378 - (*query_counter)++;

2361 }

2362

2381 -void store_host_info_and_metadata(RRDHOST *host, BUFFER *work_buffer, size_t *query_counter)

2363 +

2364 +

2365 +void store_host_info_and_metadata(RRDHOST *host, BUFFER *work_buffer)

2366 {

2367 // Store labels (if needed)

2368 if (unlikely(rrdhost_flag_check(host, RRDHOST_FLAG_METADATA_LABELS)))

2385 - meta_store_host_labels(host, work_buffer, query_counter);

2369 + meta_store_host_labels(host, work_buffer);

2370

2371 // Store claim id (if needed)

2372 if (unlikely(rrdhost_flag_check(host, RRDHOST_FLAG_METADATA_CLAIMID)))

2389 - store_host_claim_id(host, query_counter);

2373 + store_host_claim_id(host);

2374

2375 // Store host and system info (if needed);

2376 if (rrdhost_flag_check(host, RRDHOST_FLAG_METADATA_INFO))

2393 - store_host_and_system_info(host, query_counter);

2377 + store_host_and_system_info(host);

2378 }

2379

2380 // Worker thread to scan hosts for pending metadata to store

@@ -2419,26 +2403,17 @@ static void start_metadata_hosts(uv_work_t *req)

2403 continue;

2404

2405 usec_t started_ut = now_monotonic_usec();

2422 - size_t query_counter = 0;

2423 -

2406 rrdhost_flag_clear(host,RRDHOST_FLAG_METADATA_UPDATE);

2425 -

2407 worker_is_busy(UV_EVENT_STORE_HOST);

2408

2409 // store labels, claim_id, host and system info (if needed)

2429 - store_host_info_and_metadata(host, work_buffer, &query_counter);

2430 -

2410 + store_host_info_and_metadata(host, work_buffer);

2411 worker_is_idle();

2412

2433 - metadata_scan_host(host, work_buffer, &query_counter, shutting_down);

2413 + metadata_scan_host(host, work_buffer, shutting_down);

2414

2415 COMPUTE_DURATION(report_duration, "us", started_ut, now_monotonic_usec());

2436 - nd_log_daemon(

2437 - NDLP_DEBUG,

2438 - "Host %s saved metadata with %zu SQL statements, in %s",

2439 - rrdhost_hostname(host),

2440 - query_counter,

2441 - report_duration);

2416 + nd_log_daemon(NDLP_DEBUG, "Host %s saved metadata in %s", rrdhost_hostname(host), report_duration);

2417 }

2418 dfe_done(host);

2419

@@ -2463,9 +2438,16 @@ static void close_callback(uv_handle_t *handle, void *data __maybe_unused)

2438 uv_close(handle, NULL); // Automatically close and free the handle

2439 }

2440

2441 +#define EVENT_LOOP_NAME "METASYNC"

2442 +

2443 static void metadata_event_loop(void *arg)

2444 {

2468 - worker_register("METASYNC");

2445 + struct metadata_wc *config = arg;

2446 + uv_thread_set_name_np(EVENT_LOOP_NAME);

2447 + worker_register(EVENT_LOOP_NAME);

2448 +

2449 + config->ar = aral_by_size_acquire(sizeof(struct metadata_cmd));

2450 +

2451 worker_register_job_name(METADATA_DATABASE_NOOP, "noop");

2452 worker_register_job_name(METADATA_DEL_DIMENSION, "delete dimension");

2453 worker_register_job_name(METADATA_STORE_CLAIM_ID, "add claim id");

@@ -2476,48 +2458,25 @@ static void metadata_event_loop(void *arg)

2458 worker_register_job_name(METADATA_DEL_HOST_AE, "delete host alert entry");

2459 worker_register_job_name(METADATA_EXECUTE_STORE_STATEMENT, "add sql statement");

2460

2479 - int ret;

2461 unsigned cmd_batch_size;

2481 - struct metadata_wc *wc = arg;

2482 - enum metadata_opcode opcode;

2462

2484 - wc->ar = aral_by_size_acquire(sizeof(struct metadata_cmd));

2485 -

2486 - uv_thread_set_name_np("METASYNC");

2487 - uv_loop_t *loop = wc->loop = mallocz(sizeof(uv_loop_t));

2488 - ret = uv_loop_init(loop);

2489 - if (ret) {

2490 - netdata_log_error("uv_loop_init(): %s", uv_strerror(ret));

2491 - goto error_after_loop_init;

2492 - }

2493 -

2494 - loop->data = wc;

2495 -

2496 - ret = uv_async_init(wc->loop, &wc->async, async_cb);

2497 - if (ret) {

2498 - netdata_log_error("uv_async_init(): %s", uv_strerror(ret));

2499 - goto error_after_async_init;

2500 - }

2501 - wc->async.data = wc;

2502 -

2503 - ret = uv_timer_init(loop, &wc->timer_req);

2504 - if (ret) {

2505 - netdata_log_error("uv_timer_init(): %s", uv_strerror(ret));

2506 - goto error_after_timer_init;

2507 - }

2508 - wc->timer_req.data = wc;

2509 - fatal_assert(0 == uv_timer_start(&wc->timer_req, timer_cb, TIMER_INITIAL_PERIOD_MS, TIMER_REPEAT_PERIOD_MS));

2463 + uv_loop_t *loop = &config->loop;

2464 + fatal_assert(0 == uv_loop_init(loop));

2465 + fatal_assert(0 == uv_async_init(loop, &config->async, async_cb));

2466 + fatal_assert(0 == uv_timer_init(loop, &config->timer_req));

2467 + fatal_assert(0 == uv_timer_start(&config->timer_req, timer_cb, TIMER_INITIAL_PERIOD_MS, TIMER_REPEAT_PERIOD_MS));

2468 + loop->data = config;

2469 + config->async.data = config;

2470 + config->timer_req.data = config;

2471

2472 nd_log(NDLS_DAEMON, NDLP_DEBUG, "Starting metadata sync thread");

2473

2474 struct metadata_cmd cmd;

2475 memset(&cmd, 0, sizeof(cmd));

2515 - metadata_flag_clear(wc, METADATA_FLAG_PROCESSING);

2476 + metadata_flag_clear(config, METADATA_FLAG_PROCESSING);

2477 + config->metadata_check_after = now_realtime_sec() + METADATA_HOST_CHECK_FIRST_CHECK;

2478 + completion_mark_complete(&config->start_stop_complete);

2479

2517 - wc->metadata_check_after = now_realtime_sec() + METADATA_HOST_CHECK_FIRST_CHECK;

2518 -

2519 - int shutdown = 0;

2520 - completion_mark_complete(&wc->start_stop_complete);

2480 BUFFER *work_buffer = buffer_create(1024, &netdata_buffers_statistics.buffers_sqlite);

2481 struct scan_metadata_payload *data;

2482 Pvoid_t *Pvalue;

@@ -2526,11 +2485,14 @@ static void metadata_event_loop(void *arg)

2485 struct judy_list_t *pending_uuid_deletion = NULL;

2486 struct judy_list_t *pending_sql_statement = NULL;

2487

2529 - while (shutdown == 0 || (wc->flags & METADATA_FLAG_PROCESSING)) {

2488 + int shutdown = 0;

2489 + config->initialized = true;

2490 + while (shutdown == 0 || (config->flags & METADATA_FLAG_PROCESSING)) {

2491 nd_uuid_t *uuid;

2492 RRDHOST *host = NULL;

2493 ALARM_ENTRY *ae = NULL;

2494 sqlite3_stmt *stmt;

2495 + enum metadata_opcode opcode;

2496

2497 worker_is_idle();

2498 uv_run(loop, UV_RUN_DEFAULT);

@@ -2541,10 +2503,10 @@ static void metadata_event_loop(void *arg)

2503 if (unlikely(cmd_batch_size >= METADATA_MAX_BATCH_SIZE))

2504 break;

2505

2544 - cmd = metadata_deq_cmd(wc);

2506 + cmd = metadata_deq_cmd(config);

2507 opcode = cmd.opcode;

2508

2547 - if (unlikely(opcode == METADATA_DATABASE_NOOP && metadata_flag_check(wc, METADATA_FLAG_SHUTDOWN))) {

2509 + if (unlikely(opcode == METADATA_DATABASE_NOOP && metadata_flag_check(config, METADATA_FLAG_SHUTDOWN))) {

2510 shutdown = 1;

2511 continue;

2512 }

@@ -2593,7 +2555,7 @@ static void metadata_event_loop(void *arg)

2555 }

2556 break;

2557 case METADATA_SCAN_HOSTS:

2596 - if (unlikely(metadata_flag_check(wc, METADATA_FLAG_PROCESSING)))

2558 + if (unlikely(metadata_flag_check(config, METADATA_FLAG_PROCESSING)))

2559 break;

2560

2561 if (unittest_running)

@@ -2601,7 +2563,7 @@ static void metadata_event_loop(void *arg)

2563

2564 data = mallocz(sizeof(*data));

2565 data->request.data = data;

2604 - data->wc = wc;

2566 + data->wc = config;

2567 data->pending_alert_list = pending_ae_list;

2568 data->pending_ctx_cleanup_list = pending_ctx_cleanup_list;

2569 data->pending_uuid_deletion = pending_uuid_deletion;

@@ -2616,16 +2578,16 @@ static void metadata_event_loop(void *arg)

2578 if (unlikely(cmd.completion))

2579 cmd.completion = NULL; // Do not complete after launching worker (worker will do)

2580

2619 - metadata_flag_set(wc, METADATA_FLAG_PROCESSING);

2581 + metadata_flag_set(config, METADATA_FLAG_PROCESSING);

2582 if (uv_queue_work(loop, &data->request, start_metadata_hosts, after_metadata_hosts)) {

2583 // Failed to launch worker -- let the event loop handle completion

2622 - cmd.completion = wc->scan_complete;

2584 + cmd.completion = config->scan_complete;

2585 pending_ae_list = data->pending_alert_list;

2586 pending_ctx_cleanup_list = data->pending_ctx_cleanup_list;

2587 pending_uuid_deletion = data->pending_uuid_deletion;

2588 pending_sql_statement = data->pending_sql_statement;

2589 freez(data);

2628 - metadata_flag_clear(wc, METADATA_FLAG_PROCESSING);

2590 + metadata_flag_clear(config, METADATA_FLAG_PROCESSING);

2591 }

2592 break;

2593 case METADATA_LOAD_HOST_CONTEXT:

@@ -2634,7 +2596,7 @@ static void metadata_event_loop(void *arg)

2596

2597 data = callocz(1,sizeof(*data));

2598 data->request.data = data;

2637 - data->wc = wc;

2599 + data->wc = config;

2600 if (uv_queue_work(loop, &data->request, start_all_host_load_context, after_start_host_load_context)) {

2601 freez(data);

2602 }

@@ -2655,7 +2617,7 @@ static void metadata_event_loop(void *arg)

2617 *Pvalue = (void *)ae;

2618 break;

2619 case METADATA_DEL_HOST_AE:

2658 - (void) JudyLIns(&wc->ae_DelJudyL, (Word_t) (void *) cmd.param[0], PJE0);

2620 + (void) JudyLIns(&config->ae_DelJudyL, (Word_t) (void *) cmd.param[0], PJE0);

2621 break;

2622 case METADATA_EXECUTE_STORE_STATEMENT:

2623 stmt = (sqlite3_stmt *) cmd.param[0];

@@ -2679,6 +2641,7 @@ static void metadata_event_loop(void *arg)

2641 completion_mark_complete(cmd.completion);

2642 } while (opcode != METADATA_DATABASE_NOOP);

2643 }

2644 + config->initialized = false;

2645

2646 uv_walk(loop, (uv_walk_cb) close_callback, NULL);

2647 uv_run(loop, UV_RUN_NOWAIT);

@@ -2692,10 +2655,10 @@ static void metadata_event_loop(void *arg)

2655 worker_unregister();

2656

2657 nd_log(NDLS_DAEMON, NDLP_DEBUG, "Shutting down metadata thread");

2695 - completion_mark_complete(&wc->start_stop_complete);

2696 - if (wc->scan_complete) {

2697 - completion_destroy(wc->scan_complete);

2698 - freez(wc->scan_complete);

2658 + completion_mark_complete(&config->start_stop_complete);

2659 + if (config->scan_complete) {

2660 + completion_destroy(config->scan_complete);

2661 + freez(config->scan_complete);

2662 }

2663

2664 Word_t Index;

@@ -2720,16 +2683,8 @@ static void metadata_event_loop(void *arg)

2683 freez(pending_ctx_cleanup_list);

2684 }

2685

2723 - metadata_free_cmd_queue(wc);

2724 - return;

2725 -

2726 -error_after_timer_init:

2727 - uv_close((uv_handle_t *)&wc->async, NULL);

2728 -error_after_async_init:

2729 - fatal_assert(0 == uv_loop_close(loop));

2730 -error_after_loop_init:

2731 - freez(loop);

2732 - aral_by_size_release(wc->ar);

2686 + metadata_free_cmd_queue(config);

2687 + aral_by_size_release(config->ar);

2688 worker_unregister();

2689 }

2690

@@ -2753,7 +2708,7 @@ void metadata_sync_shutdown(void)

2708 void metadata_sync_shutdown_prepare(void)

2709 {

2710 static bool running = false;

2756 - if (unlikely(!metasync_worker.loop || running))

2711 + if (unlikely(!metasync_worker.initialized || running))

2712 return;

2713

2714 running = true;

@@ -2804,20 +2759,16 @@ void metadata_sync_shutdown_background_wait(void) {

2759

2760 void metadata_sync_init(void)

2761 {

2807 - struct metadata_wc *wc = &metasync_worker;

2808 -

2809 - memset(wc, 0, sizeof(*wc));

2810 - completion_init(&wc->start_stop_complete);

2811 -

2812 - fatal_assert(0 == uv_thread_create(&(wc->thread), metadata_event_loop, wc));

2762 + memset(&metasync_worker, 0, sizeof(metasync_worker));

2763 + completion_init(&metasync_worker.start_stop_complete);

2764

2814 - completion_wait_for(&wc->start_stop_complete);

2815 - completion_destroy(&wc->start_stop_complete);

2765 + fatal_assert(0 == uv_thread_create(&metasync_worker.thread, metadata_event_loop, &metasync_worker));

2766

2767 + completion_wait_for(&metasync_worker.start_stop_complete);

2768 + completion_destroy(&metasync_worker.start_stop_complete);

2769 nd_log(NDLS_DAEMON, NDLP_DEBUG, "SQLite metadata sync initialization complete");

2770 }

2771

2820 -

2772 // Helpers

2773

2774 static inline void queue_metadata_cmd(enum metadata_opcode opcode, const void *param0, const void *param1)

@@ -2833,8 +2784,9 @@ static inline void queue_metadata_cmd(enum metadata_opcode opcode, const void *p

2784 // Public

2785 void metaqueue_delete_dimension_uuid(nd_uuid_t *uuid)

2786 {

2836 - if (unlikely(!metasync_worker.loop))

2787 + if (unlikely(!uuid))

2788 return;

2789 +

2790 nd_uuid_t *use_uuid = mallocz(sizeof(*uuid));

2791 uuid_copy(*use_uuid, *uuid);

2792 queue_metadata_cmd(METADATA_DEL_DIMENSION, use_uuid, NULL);

@@ -2861,17 +2813,15 @@ void metaqueue_ml_load_models(RRDDIM *rd)

2813 rrddim_flag_set(rd, RRDDIM_FLAG_ML_MODEL_LOAD);

2814 }

2815

2864 -void metadata_queue_load_host_context(RRDHOST *host)

2816 +void metadata_queue_load_host_context()

2817 {

2866 - if (unlikely(!metasync_worker.loop))

2867 - return;

2868 - queue_metadata_cmd(METADATA_LOAD_HOST_CONTEXT, host, NULL);

2818 + queue_metadata_cmd(METADATA_LOAD_HOST_CONTEXT, NULL, NULL);

2819 nd_log(NDLS_DAEMON, NDLP_DEBUG, "Queued command to load host contexts");

2820 }

2821

2822 void metadata_queue_ctx_host_cleanup(nd_uuid_t *host_uuid, const char *context)

2823 {

2874 - if (unlikely(!metasync_worker.loop))

2824 + if (unlikely(!host_uuid || !context))

2825 return;

2826

2827 struct host_ctx_cleanup_s *ctx_cleanup = mallocz(sizeof(*ctx_cleanup));

@@ -2884,8 +2834,9 @@ void metadata_queue_ctx_host_cleanup(nd_uuid_t *host_uuid, const char *context)

2834

2835 void metadata_queue_ae_save(RRDHOST *host, ALARM_ENTRY *ae)

2836 {

2887 - if (unlikely(!metasync_worker.loop))

2837 + if (unlikely(!host || !ae))

2838 return;

2839 +

2840 __atomic_add_fetch(&host->health.pending_transitions, 1, __ATOMIC_RELAXED);

2841 __atomic_add_fetch(&ae->pending_save_count, 1, __ATOMIC_RELAXED);

2842 queue_metadata_cmd(METADATA_ADD_HOST_AE, host, ae);

@@ -2893,7 +2844,7 @@ void metadata_queue_ae_save(RRDHOST *host, ALARM_ENTRY *ae)

2844

2845 void metadata_queue_ae_deletion(ALARM_ENTRY *ae)

2846 {

2896 - if (unlikely(!metasync_worker.loop))

2847 + if (unlikely(!ae))

2848 return;

2849

2850 queue_metadata_cmd(METADATA_DEL_HOST_AE, ae, NULL);

@@ -2901,16 +2852,14 @@ void metadata_queue_ae_deletion(ALARM_ENTRY *ae)

2852

2853 void metadata_execute_store_statement(sqlite3_stmt *stmt)

2854 {

2904 - if (unlikely(!metasync_worker.loop))

2855 + if (unlikely(!stmt))

2856 return;

2857 +

2858 queue_metadata_cmd(METADATA_EXECUTE_STORE_STATEMENT, stmt, NULL);

2859 }

2860

2861 void commit_alert_transitions(RRDHOST *host __maybe_unused)

2862 {

2911 - if (unlikely(!metasync_worker.loop))

2912 - return;

2913 -

2863 queue_metadata_cmd(METADATA_SCAN_HOSTS, NULL, NULL);

2864 }

2865

src/database/sqlite/sqlite_metadata.h

+2 -2

@@ -32,7 +32,7 @@ void metaqueue_delete_dimension_uuid(nd_uuid_t *uuid);

32 void metaqueue_store_claim_id(nd_uuid_t *host_uuid, nd_uuid_t *claim_uuid);

33 void metaqueue_ml_load_models(RRDDIM *rd);

34 void detect_machine_guid_change(nd_uuid_t *host_uuid);

35 -void metadata_queue_load_host_context(RRDHOST *host);

35 +void metadata_queue_load_host_context();

36 void vacuum_database(sqlite3 *database, const char *db_alias, int threshold, int vacuum_pc);

38 int sql_metadata_cache_stats(int op);

@@ -60,7 +60,7 @@ void commit_alert_transitions(RRDHOST *host);

60 void metadata_sync_shutdown_background(void);

61 void metadata_sync_shutdown_background_wait(void);

62 void metadata_queue_ctx_host_cleanup(nd_uuid_t *host_uuid, const char *context);

63 -void store_host_info_and_metadata(RRDHOST *host, BUFFER *work_buffer, size_t *query_counter);

63 +void store_host_info_and_metadata(RRDHOST *host, BUFFER *work_buffer);

64 void metadata_execute_store_statement(sqlite3_stmt *stmt);

66 // UNIT TEST