#define NETDATA_RRD_INTERNALS

#include "rrd.h"

RRDHOST *localhost = NULL;

size_t rrd_hosts_available = 0;

netdata_rwlock_t rrd_rwlock = NETDATA_RWLOCK_INITIALIZER;

time_t rrdset_free_obsolete_time = 3600;

time_t rrdhost_free_orphan_time = 3600;

int rrdhost_compare(void* a, void* b) {

if(((RRDHOST *)a)->hash_machine_guid < ((RRDHOST *)b)->hash_machine_guid) return -1;

else if(((RRDHOST *)a)->hash_machine_guid > ((RRDHOST *)b)->hash_machine_guid) return 1;

else return strcmp(((RRDHOST *)a)->machine_guid, ((RRDHOST *)b)->machine_guid);

}

avl_tree_lock rrdhost_root_index = {

.avl_tree = { NULL, rrdhost_compare },

.rwlock = AVL_LOCK_INITIALIZER

};

RRDHOST *rrdhost_find_by_guid(const char *guid, uint32_t hash) {

debug(D_RRDHOST, "Searching in index for host with guid '%s'", guid);

RRDHOST tmp;

strncpyz(tmp.machine_guid, guid, GUID_LEN);

tmp.hash_machine_guid = (hash)?hash:simple_hash(tmp.machine_guid);

return (RRDHOST *)avl_search_lock(&(rrdhost_root_index), (avl_t *) &tmp);

}

RRDHOST *rrdhost_find_by_hostname(const char *hostname, uint32_t hash) {

if(unlikely(!strcmp(hostname, "localhost")))

return localhost;

if(unlikely(!hash)) hash = simple_hash(hostname);

rrd_rdlock();

RRDHOST *host;

rrdhost_foreach_read(host) {

if(unlikely((hash == host->hash_hostname && !strcmp(hostname, host->hostname)))) {

rrd_unlock();

return host;

}

}

rrd_unlock();

return NULL;

}

#define rrdhost_index_add(rrdhost) (RRDHOST *)avl_insert_lock(&(rrdhost_root_index), (avl_t *)(rrdhost))

#define rrdhost_index_del(rrdhost) (RRDHOST *)avl_remove_lock(&(rrdhost_root_index), (avl_t *)(rrdhost))

static inline void rrdhost_init_tags(RRDHOST *host, const char *tags) {

if(host->tags && tags && !strcmp(host->tags, tags))

return;

void *old = (void *)host->tags;

host->tags = (tags && *tags)?strdupz(tags):NULL;

freez(old);

}

static inline void rrdhost_init_hostname(RRDHOST *host, const char *hostname) {

if(host->hostname && hostname && !strcmp(host->hostname, hostname))

return;

void *old = host->hostname;

host->hostname = strdupz(hostname?hostname:"localhost");

host->hash_hostname = simple_hash(host->hostname);

freez(old);

}

static inline void rrdhost_init_os(RRDHOST *host, const char *os) {

if(host->os && os && !strcmp(host->os, os))

return;

void *old = (void *)host->os;

host->os = strdupz(os?os:"unknown");

freez(old);

}

static inline void rrdhost_init_timezone(RRDHOST *host, const char *timezone, const char *abbrev_timezone, int32_t utc_offset) {

if (host->timezone && timezone && !strcmp(host->timezone, timezone) && host->abbrev_timezone && abbrev_timezone &&

!strcmp(host->abbrev_timezone, abbrev_timezone) && host->utc_offset == utc_offset)

return;

void *old = (void *)host->timezone;

host->timezone = strdupz((timezone && *timezone)?timezone:"unknown");

freez(old);

old = (void *)host->abbrev_timezone;

host->abbrev_timezone = strdupz((abbrev_timezone && *abbrev_timezone) ? abbrev_timezone : "UTC");

freez(old);

host->utc_offset = utc_offset;

}

static inline void rrdhost_init_machine_guid(RRDHOST *host, const char *machine_guid) {

strncpy(host->machine_guid, machine_guid, GUID_LEN);

host->machine_guid[GUID_LEN] = '\0';

host->hash_machine_guid = simple_hash(host->machine_guid);

}

void set_host_properties(RRDHOST *host, int update_every, RRD_MEMORY_MODE memory_mode, const char *hostname,

const char *registry_hostname, const char *guid, const char *os, const char *tags,

const char *tzone, const char *abbrev_tzone, int32_t utc_offset, const char *program_name,

const char *program_version)

{

host->rrd_update_every = update_every;

host->rrd_memory_mode = memory_mode;

rrdhost_init_hostname(host, hostname);

rrdhost_init_machine_guid(host, guid);

rrdhost_init_os(host, os);

rrdhost_init_timezone(host, tzone, abbrev_tzone, utc_offset);

rrdhost_init_tags(host, tags);

host->program_name = strdupz((program_name && *program_name) ? program_name : "unknown");

host->program_version = strdupz((program_version && *program_version) ? program_version : "unknown");

host->registry_hostname = strdupz((registry_hostname && *registry_hostname) ? registry_hostname : host->hostname);

}

RRDHOST *rrdhost_create(const char *hostname,

) {

debug(D_RRDHOST, "Host '%s': adding with guid '%s'", hostname, guid);

#ifdef ENABLE_DBENGINE

int is_legacy = (memory_mode == RRD_MEMORY_MODE_DBENGINE) && is_legacy_child(guid);

int is_legacy = 1;

rrd_check_wrlock();

int is_in_multihost = (memory_mode == RRD_MEMORY_MODE_DBENGINE && !is_legacy);

RRDHOST *host = callocz(1, sizeof(RRDHOST));

set_host_properties(host, (update_every > 0)?update_every:1, memory_mode, hostname, registry_hostname, guid, os,

tags, timezone, abbrev_timezone, utc_offset, program_name, program_version);

host->rrd_history_entries = align_entries_to_pagesize(memory_mode, entries);

host->health_enabled = ((memory_mode == RRD_MEMORY_MODE_NONE)) ? 0 : health_enabled;

host->sender = mallocz(sizeof(*host->sender));

sender_init(host->sender, host);

netdata_mutex_init(&host->receiver_lock);

host->rrdpush_send_enabled = (rrdpush_enabled && rrdpush_destination && *rrdpush_destination && rrdpush_api_key && *rrdpush_api_key) ? 1 : 0;

host->rrdpush_send_destination = (host->rrdpush_send_enabled)?strdupz(rrdpush_destination):NULL;

host->rrdpush_send_api_key = (host->rrdpush_send_enabled)?strdupz(rrdpush_api_key):NULL;

host->rrdpush_send_charts_matching = simple_pattern_create(rrdpush_send_charts_matching, NULL, SIMPLE_PATTERN_EXACT);

host->rrdpush_sender_pipe[0] = -1;

host->rrdpush_sender_pipe[1] = -1;

host->rrdpush_sender_socket = -1;

//host->stream_version = STREAMING_PROTOCOL_CURRENT_VERSION; Unused?

#ifdef ENABLE_HTTPS

host->ssl.conn = NULL;

host->ssl.flags = NETDATA_SSL_START;

host->stream_ssl.conn = NULL;

host->stream_ssl.flags = NETDATA_SSL_START;

netdata_rwlock_init(&host->rrdhost_rwlock);

netdata_rwlock_init(&host->labels.labels_rwlock);

netdata_mutex_init(&host->aclk_state_lock);

host->system_info = system_info;

avl_init_lock(&(host->rrdset_root_index), rrdset_compare);

avl_init_lock(&(host->rrdset_root_index_name), rrdset_compare_name);

avl_init_lock(&(host->rrdfamily_root_index), rrdfamily_compare);

avl_init_lock(&(host->rrdvar_root_index), rrdvar_compare);

if(config_get_boolean(CONFIG_SECTION_GLOBAL, "delete obsolete charts files", 1))

rrdhost_flag_set(host, RRDHOST_FLAG_DELETE_OBSOLETE_CHARTS);

if(config_get_boolean(CONFIG_SECTION_GLOBAL, "delete orphan hosts files", 1) && !is_localhost)

rrdhost_flag_set(host, RRDHOST_FLAG_DELETE_ORPHAN_HOST);

host->health_default_warn_repeat_every = config_get_duration(CONFIG_SECTION_HEALTH, "default repeat warning", "never");

host->health_default_crit_repeat_every = config_get_duration(CONFIG_SECTION_HEALTH, "default repeat critical", "never");

avl_init_lock(&(host->alarms_idx_health_log), alarm_compare_id);

avl_init_lock(&(host->alarms_idx_name), alarm_compare_name);

// ------------------------------------------------------------------------

// initialize health variables

host->health_log.next_log_id = 1;

host->health_log.next_alarm_id = 1;

host->health_log.max = 1000;

host->health_log.next_log_id = (uint32_t)now_realtime_sec();

host->health_log.next_alarm_id = 0;

long n = config_get_number(CONFIG_SECTION_HEALTH, "in memory max health log entries", host->health_log.max);

if(n < 10) {

error("Host '%s': health configuration has invalid max log entries %ld. Using default %u", host->hostname, n, host->health_log.max);

config_set_number(CONFIG_SECTION_HEALTH, "in memory max health log entries", (long)host->health_log.max);

}

else

host->health_log.max = (unsigned int)n;

netdata_rwlock_init(&host->health_log.alarm_log_rwlock);

char filename[FILENAME_MAX + 1];

if(is_localhost) {

host->cache_dir = strdupz(netdata_configured_cache_dir);

host->varlib_dir = strdupz(netdata_configured_varlib_dir);

}

else {

// this is not localhost - append our GUID to localhost path

if (is_in_multihost) { // don't append to cache dir in multihost

host->cache_dir = strdupz(netdata_configured_cache_dir);

} else {

snprintfz(filename, FILENAME_MAX, "%s/%s", netdata_configured_cache_dir, host->machine_guid);

host->cache_dir = strdupz(filename);

}

if((host->rrd_memory_mode == RRD_MEMORY_MODE_MAP || host->rrd_memory_mode == RRD_MEMORY_MODE_SAVE || (

host->rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE && is_legacy))) {

int r = mkdir(host->cache_dir, 0775);

if(r != 0 && errno != EEXIST)

error("Host '%s': cannot create directory '%s'", host->hostname, host->cache_dir);

}

snprintfz(filename, FILENAME_MAX, "%s/%s", netdata_configured_varlib_dir, host->machine_guid);

host->varlib_dir = strdupz(filename);

if(host->health_enabled) {

int r = mkdir(host->varlib_dir, 0775);

if(r != 0 && errno != EEXIST)

error("Host '%s': cannot create directory '%s'", host->hostname, host->varlib_dir);

}

}

if(host->health_enabled) {

snprintfz(filename, FILENAME_MAX, "%s/health", host->varlib_dir);

int r = mkdir(filename, 0775);

if(r != 0 && errno != EEXIST)

error("Host '%s': cannot create directory '%s'", host->hostname, filename);

}

snprintfz(filename, FILENAME_MAX, "%s/health/health-log.db", host->varlib_dir);

host->health_log_filename = strdupz(filename);

snprintfz(filename, FILENAME_MAX, "%s/alarm-notify.sh", netdata_configured_primary_plugins_dir);

host->health_default_exec = strdupz(config_get(CONFIG_SECTION_HEALTH, "script to execute on alarm", filename));

host->health_default_recipient = strdupz("root");

// ------------------------------------------------------------------------

// load health configuration

if(host->health_enabled) {

rrdhost_wrlock(host);

health_readdir(host, health_user_config_dir(), health_stock_config_dir(), NULL);

rrdhost_unlock(host);

health_alarm_log_load(host);

health_alarm_log_open(host);

}

RRDHOST *t = rrdhost_index_add(host);

if(t != host) {

error("Host '%s': cannot add host with machine guid '%s' to index. It already exists as host '%s' with machine guid '%s'.", host->hostname, host->machine_guid, t->hostname, t->machine_guid);

rrdhost_free(host);

return NULL;

}

if (likely(!uuid_parse(host->machine_guid, host->host_uuid))) {

int rc = sql_store_host(&host->host_uuid, hostname, registry_hostname, update_every, os, timezone, tags);

if (unlikely(rc))

error_report("Failed to store machine GUID to the database");

sql_load_node_id(host);

}

else

error_report("Host machine GUID %s is not valid", host->machine_guid);

if (host->rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE) {

#ifdef ENABLE_DBENGINE

char dbenginepath[FILENAME_MAX + 1];

int ret;

snprintfz(dbenginepath, FILENAME_MAX, "%s/dbengine", host->cache_dir);

ret = mkdir(dbenginepath, 0775);

if (ret != 0 && errno != EEXIST)

error("Host '%s': cannot create directory '%s'", host->hostname, dbenginepath);

else ret = 0; // succeed

if (is_legacy) // initialize legacy dbengine instance as needed

ret = rrdeng_init(host, &host->rrdeng_ctx, dbenginepath, default_rrdeng_page_cache_mb,

default_rrdeng_disk_quota_mb); // may fail here for legacy dbengine initialization

else

host->rrdeng_ctx = &multidb_ctx;

if (ret) { // check legacy or multihost initialization success

error(

"Host '%s': cannot initialize host with machine guid '%s'. Failed to initialize DB engine at '%s'.",

host->hostname, host->machine_guid, host->cache_dir);

rrdhost_free(host);

host = NULL;

//rrd_hosts_available++; //TODO: maybe we want this?

return host;

}

fatal("RRD_MEMORY_MODE_DBENGINE is not supported in this platform.");

}

else {

#ifdef ENABLE_DBENGINE

host->rrdeng_ctx = &multidb_ctx;

}

// ------------------------------------------------------------------------

// link it and add it to the index

if(is_localhost) {

host->next = localhost;

localhost = host;

}

else {

if(localhost) {

host->next = localhost->next;

localhost->next = host;

}

else localhost = host;

}

info("Host '%s' (at registry as '%s') with guid '%s' initialized"

", os '%s'"

", timezone '%s'"

", tags '%s'"

", program_name '%s'"

", program_version '%s'"

", update every %d"

", memory mode %s"

", history entries %ld"

", streaming %s"

" (to '%s' with api key '%s')"

", health %s"

", cache_dir '%s'"

", varlib_dir '%s'"

", health_log '%s'"

", alarms default handler '%s'"

", alarms default recipient '%s'"

, host->hostname

, host->registry_hostname

, host->machine_guid

, host->os

, host->timezone

, (host->tags)?host->tags:""

, host->program_name

, host->program_version

, host->rrd_update_every

, rrd_memory_mode_name(host->rrd_memory_mode)

, host->rrd_history_entries

, host->rrdpush_send_enabled?"enabled":"disabled"

, host->rrdpush_send_destination?host->rrdpush_send_destination:""

, host->rrdpush_send_api_key?host->rrdpush_send_api_key:""

, host->health_enabled?"enabled":"disabled"

, host->cache_dir

, host->varlib_dir

, host->health_log_filename

, host->health_default_exec

, host->health_default_recipient

);

rrd_hosts_available++;

return host;

}

void rrdhost_update(RRDHOST *host

)

{

UNUSED(guid);

UNUSED(rrdpush_enabled);

UNUSED(rrdpush_destination);

UNUSED(rrdpush_api_key);

UNUSED(rrdpush_send_charts_matching);

host->health_enabled = (mode == RRD_MEMORY_MODE_NONE) ? 0 : health_enabled;

//host->stream_version = STREAMING_PROTOCOL_CURRENT_VERSION; Unused?

rrdhost_system_info_free(host->system_info);

host->system_info = system_info;

rrdhost_init_os(host, os);

rrdhost_init_timezone(host, timezone, abbrev_timezone, utc_offset);

freez(host->registry_hostname);

host->registry_hostname = strdupz((registry_hostname && *registry_hostname)?registry_hostname:hostname);

if(strcmp(host->hostname, hostname) != 0) {

info("Host '%s' has been renamed to '%s'. If this is not intentional it may mean multiple hosts are using the same machine_guid.", host->hostname, hostname);

char *t = host->hostname;

host->hostname = strdupz(hostname);

host->hash_hostname = simple_hash(host->hostname);

freez(t);

}

if(strcmp(host->program_name, program_name) != 0) {

info("Host '%s' switched program name from '%s' to '%s'", host->hostname, host->program_name, program_name);

char *t = host->program_name;

host->program_name = strdupz(program_name);

freez(t);

}

if(strcmp(host->program_version, program_version) != 0) {

info("Host '%s' switched program version from '%s' to '%s'", host->hostname, host->program_version, program_version);

char *t = host->program_version;

host->program_version = strdupz(program_version);

freez(t);

}

if(host->rrd_update_every != update_every)

error("Host '%s' has an update frequency of %d seconds, but the wanted one is %d seconds. Restart netdata here to apply the new settings.", host->hostname, host->rrd_update_every, update_every);

if(host->rrd_history_entries < history)

error("Host '%s' has history of %ld entries, but the wanted one is %ld entries. Restart netdata here to apply the new settings.", host->hostname, host->rrd_history_entries, history);

if(host->rrd_memory_mode != mode)

error("Host '%s' has memory mode '%s', but the wanted one is '%s'. Restart netdata here to apply the new settings.", host->hostname, rrd_memory_mode_name(host->rrd_memory_mode), rrd_memory_mode_name(mode));

// update host tags

rrdhost_init_tags(host, tags);

if (rrdhost_flag_check(host, RRDHOST_FLAG_ARCHIVED)) {

rrdhost_flag_clear(host, RRDHOST_FLAG_ARCHIVED);

if(host->health_enabled) {

int r;

char filename[FILENAME_MAX + 1];

if (host != localhost) {

r = mkdir(host->varlib_dir, 0775);

if (r != 0 && errno != EEXIST)

error("Host '%s': cannot create directory '%s'", host->hostname, host->varlib_dir);

}

snprintfz(filename, FILENAME_MAX, "%s/health", host->varlib_dir);

r = mkdir(filename, 0775);

if(r != 0 && errno != EEXIST)

error("Host '%s': cannot create directory '%s'", host->hostname, filename);

rrdhost_wrlock(host);

health_readdir(host, health_user_config_dir(), health_stock_config_dir(), NULL);

rrdhost_unlock(host);

health_alarm_log_load(host);

health_alarm_log_open(host);

}

rrd_hosts_available++;

info("Host %s is not in archived mode anymore", host->hostname);

}

return;

}

RRDHOST *rrdhost_find_or_create(

) {

debug(D_RRDHOST, "Searching for host '%s' with guid '%s'", hostname, guid);

rrd_wrlock();

RRDHOST *host = rrdhost_find_by_guid(guid, 0);

if (unlikely(host && RRD_MEMORY_MODE_DBENGINE != mode && rrdhost_flag_check(host, RRDHOST_FLAG_ARCHIVED))) {

/* If a legacy memory mode instantiates all dbengine state must be discarded to avoid inconsistencies */

error("Archived host '%s' has memory mode '%s', but the wanted one is '%s'. Discarding archived state.",

host->hostname, rrd_memory_mode_name(host->rrd_memory_mode), rrd_memory_mode_name(mode));

rrdhost_free(host);

host = NULL;

}

if(!host) {

host = rrdhost_create(

hostname

, registry_hostname

, guid

, os

, timezone

, abbrev_timezone

, utc_offset

, tags

, program_name

, program_version

, update_every

, history

, mode

, health_enabled

, rrdpush_enabled

, rrdpush_destination

, rrdpush_api_key

, rrdpush_send_charts_matching

, system_info

, 0

);

}

else {

rrdhost_update(host

, hostname

, registry_hostname

, guid

, os

, timezone

, abbrev_timezone

, utc_offset

, tags

, program_name

, program_version

, update_every

, history

, mode

, health_enabled

, rrdpush_enabled

, rrdpush_destination

, rrdpush_api_key

, rrdpush_send_charts_matching

, system_info);

}

if (host) {

rrdhost_wrlock(host);

rrdhost_flag_clear(host, RRDHOST_FLAG_ORPHAN);

host->senders_disconnected_time = 0;

rrdhost_unlock(host);

}

rrdhost_cleanup_orphan_hosts_nolock(host);

rrd_unlock();

return host;

}

inline int rrdhost_should_be_removed(RRDHOST *host, RRDHOST *protected_host, time_t now) {

if(host != protected_host

&& host != localhost

&& rrdhost_flag_check(host, RRDHOST_FLAG_ORPHAN)

&& host->receiver

&& host->senders_disconnected_time

&& host->senders_disconnected_time + rrdhost_free_orphan_time < now)

return 1;

return 0;

}

void rrdhost_cleanup_orphan_hosts_nolock(RRDHOST *protected_host) {

time_t now = now_realtime_sec();

RRDHOST *host;

restart_after_removal:

rrdhost_foreach_write(host) {

if(rrdhost_should_be_removed(host, protected_host, now)) {

info("Host '%s' with machine guid '%s' is obsolete - cleaning up.", host->hostname, host->machine_guid);

if (rrdhost_flag_check(host, RRDHOST_FLAG_DELETE_ORPHAN_HOST)

#ifdef ENABLE_DBENGINE

/* don't delete multi-host DB host files */

&& !(host->rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE && host->rrdeng_ctx == &multidb_ctx)

)

rrdhost_delete_charts(host);

else

rrdhost_save_charts(host);

rrdhost_free(host);

goto restart_after_removal;

}

}

}

int rrd_init(char *hostname, struct rrdhost_system_info *system_info) {

rrdset_free_obsolete_time = config_get_number(CONFIG_SECTION_GLOBAL, "cleanup obsolete charts after seconds", rrdset_free_obsolete_time);

// Current chart locking and invalidation scheme doesn't prevent Netdata from segmentaion faults if a short

// cleanup delay is set. Extensive stress tests showed that 10 seconds is quite a safe delay. Look at

// https://github.com/netdata/netdata/pull/11222#issuecomment-868367920 for more information.

if (rrdset_free_obsolete_time < 10) {

rrdset_free_obsolete_time = 10;

info("The \"cleanup obsolete charts after seconds\" option was set to 10 seconds. A lower delay can potentially cause a segmentaion fault.");

}

gap_when_lost_iterations_above = (int)config_get_number(CONFIG_SECTION_GLOBAL, "gap when lost iterations above", gap_when_lost_iterations_above);

if (gap_when_lost_iterations_above < 1)

gap_when_lost_iterations_above = 1;

if (unlikely(sql_init_database())) {

if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)

fatal("Failed to initialize SQLite");

info("Skipping SQLITE metadata initialization since memory mode is not db engine");

}

health_init();

rrdpush_init();

debug(D_RRDHOST, "Initializing localhost with hostname '%s'", hostname);

rrd_wrlock();

localhost = rrdhost_create(

hostname

, registry_get_this_machine_hostname()

, registry_get_this_machine_guid()

, os_type

, netdata_configured_timezone

, netdata_configured_abbrev_timezone

, netdata_configured_utc_offset

, config_get(CONFIG_SECTION_BACKEND, "host tags", "")

, program_name

, program_version

, default_rrd_update_every

, default_rrd_history_entries

, default_rrd_memory_mode

, default_health_enabled

, default_rrdpush_enabled

, default_rrdpush_destination

, default_rrdpush_api_key

, default_rrdpush_send_charts_matching

, system_info

, 1

);

if (unlikely(!localhost)) {

rrd_unlock();

return 1;

}

#ifdef ENABLE_DBENGINE

char dbenginepath[FILENAME_MAX + 1];

int ret;

snprintfz(dbenginepath, FILENAME_MAX, "%s/dbengine", localhost->cache_dir);

ret = mkdir(dbenginepath, 0775);

if (ret != 0 && errno != EEXIST)

error("Host '%s': cannot create directory '%s'", localhost->hostname, dbenginepath);

else // Unconditionally create multihost db to support on demand host creation

ret = rrdeng_init(NULL, NULL, dbenginepath, default_rrdeng_page_cache_mb, default_multidb_disk_quota_mb);

if (ret) {

error(

"Host '%s' with machine guid '%s' failed to initialize multi-host DB engine instance at '%s'.",

localhost->hostname, localhost->machine_guid, localhost->cache_dir);

rrdhost_free(localhost);

localhost = NULL;

rrd_unlock();

fatal("Failed to initialize dbengine");

}

sql_aclk_sync_init();

rrd_unlock();

web_client_api_v1_management_init();

return localhost==NULL;

}

void __rrdhost_check_rdlock(RRDHOST *host, const char *file, const char *function, const unsigned long line) {

debug(D_RRDHOST, "Checking read lock on host '%s'", host->hostname);

int ret = netdata_rwlock_trywrlock(&host->rrdhost_rwlock);

if(ret == 0)

fatal("RRDHOST '%s' should be read-locked, but it is not, at function %s() at line %lu of file '%s'", host->hostname, function, line, file);

}

void __rrdhost_check_wrlock(RRDHOST *host, const char *file, const char *function, const unsigned long line) {

debug(D_RRDHOST, "Checking write lock on host '%s'", host->hostname);

int ret = netdata_rwlock_tryrdlock(&host->rrdhost_rwlock);

if(ret == 0)

fatal("RRDHOST '%s' should be write-locked, but it is not, at function %s() at line %lu of file '%s'", host->hostname, function, line, file);

}

void __rrd_check_rdlock(const char *file, const char *function, const unsigned long line) {

debug(D_RRDHOST, "Checking read lock on all RRDs");

int ret = netdata_rwlock_trywrlock(&rrd_rwlock);

if(ret == 0)

fatal("RRDs should be read-locked, but it are not, at function %s() at line %lu of file '%s'", function, line, file);

}

void __rrd_check_wrlock(const char *file, const char *function, const unsigned long line) {

debug(D_RRDHOST, "Checking write lock on all RRDs");

int ret = netdata_rwlock_tryrdlock(&rrd_rwlock);

if(ret == 0)

fatal("RRDs should be write-locked, but it are not, at function %s() at line %lu of file '%s'", function, line, file);

}

void rrdhost_system_info_free(struct rrdhost_system_info *system_info) {

info("SYSTEM_INFO: free %p", system_info);

if(likely(system_info)) {

freez(system_info->host_os_name);

freez(system_info->host_os_id);

freez(system_info->host_os_id_like);

freez(system_info->host_os_version);

freez(system_info->host_os_version_id);

freez(system_info->host_os_detection);

freez(system_info->host_cores);

freez(system_info->host_cpu_freq);

freez(system_info->host_ram_total);

freez(system_info->host_disk_space);

freez(system_info->container_os_name);

freez(system_info->container_os_id);

freez(system_info->container_os_id_like);

freez(system_info->container_os_version);

freez(system_info->container_os_version_id);

freez(system_info->container_os_detection);

freez(system_info->kernel_name);

freez(system_info->kernel_version);

freez(system_info->architecture);

freez(system_info->virtualization);

freez(system_info->virt_detection);

freez(system_info->container);

freez(system_info->container_detection);

freez(system_info->is_k8s_node);

freez(system_info);

}

}

void destroy_receiver_state(struct receiver_state *rpt);

void rrdhost_free(RRDHOST *host) {

if(!host) return;

info("Freeing all memory for host '%s'...", host->hostname);

rrd_check_wrlock(); // make sure the RRDs are write locked

// ------------------------------------------------------------------------

// clean up streaming

rrdpush_sender_thread_stop(host); // stop a possibly running thread

cbuffer_free(host->sender->buffer);

buffer_free(host->sender->build);

freez(host->sender);

host->sender = NULL;

if (netdata_exit) {

netdata_mutex_lock(&host->receiver_lock);

if (host->receiver) {

if (!host->receiver->exited)

netdata_thread_cancel(host->receiver->thread);

netdata_mutex_unlock(&host->receiver_lock);

struct receiver_state *rpt = host->receiver;

while (host->receiver && !rpt->exited)

sleep_usec(50 * USEC_PER_MS);

// If the receiver detached from the host then its thread will destroy the state

if (host->receiver == rpt)

destroy_receiver_state(host->receiver);

}

else

netdata_mutex_unlock(&host->receiver_lock);

}

rrdhost_wrlock(host); // lock this RRDHOST

// ------------------------------------------------------------------------

// release its children resources

#ifdef ENABLE_DBENGINE

if (host->rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE) {

if (host->rrdeng_ctx != &multidb_ctx)

rrdeng_prepare_exit(host->rrdeng_ctx);

}

while(host->rrdset_root)

rrdset_free(host->rrdset_root);

freez(host->exporting_flags);

while(host->alarms)

rrdcalc_unlink_and_free(host, host->alarms);

RRDCALC *rc,*nc;

for(rc = host->alarms_with_foreach; rc ; rc = nc) {

nc = rc->next;

rrdcalc_free(rc);

}

host->alarms_with_foreach = NULL;

while(host->templates)

rrdcalctemplate_unlink_and_free(host, host->templates);

RRDCALCTEMPLATE *rt,*next;

for(rt = host->alarms_template_with_foreach; rt ; rt = next) {

next = rt->next;

rrdcalctemplate_free(rt);

}

host->alarms_template_with_foreach = NULL;

debug(D_RRD_CALLS, "RRDHOST: Cleaning up remaining host variables for host '%s'", host->hostname);

rrdvar_free_remaining_variables(host, &host->rrdvar_root_index);

health_alarm_log_free(host);

#ifdef ENABLE_DBENGINE

if (host->rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE && host->rrdeng_ctx != &multidb_ctx)

rrdeng_exit(host->rrdeng_ctx);

// ------------------------------------------------------------------------

// remove it from the indexes

if(rrdhost_index_del(host) != host)

error("RRDHOST '%s' removed from index, deleted the wrong entry.", host->hostname);

// ------------------------------------------------------------------------

// unlink it from the host

if(host == localhost) {

localhost = host->next;

}

else {

// find the previous one

RRDHOST *h;

for(h = localhost; h && h->next != host ; h = h->next) ;

// bypass it

if(h) h->next = host->next;

else error("Request to free RRDHOST '%s': cannot find it", host->hostname);

}

// ------------------------------------------------------------------------

// free it

pthread_mutex_destroy(&host->aclk_state_lock);

freez(host->aclk_state.claimed_id);

freez((void *)host->tags);

free_label_list(host->labels.head);

freez((void *)host->os);

freez((void *)host->timezone);

freez((void *)host->abbrev_timezone);

freez(host->program_version);

freez(host->program_name);

rrdhost_system_info_free(host->system_info);

freez(host->cache_dir);

freez(host->varlib_dir);

freez(host->rrdpush_send_api_key);

freez(host->rrdpush_send_destination);

freez(host->health_default_exec);

freez(host->health_default_recipient);

freez(host->health_log_filename);

freez(host->hostname);

freez(host->registry_hostname);

simple_pattern_free(host->rrdpush_send_charts_matching);

rrdhost_unlock(host);

netdata_rwlock_destroy(&host->labels.labels_rwlock);

netdata_rwlock_destroy(&host->health_log.alarm_log_rwlock);

netdata_rwlock_destroy(&host->rrdhost_rwlock);

freez(host->node_id);

freez(host);

rrd_hosts_available--;

}

void rrdhost_free_all(void) {

rrd_wrlock();

/* Make sure child-hosts are released before the localhost. */

while(localhost->next) rrdhost_free(localhost->next);

rrdhost_free(localhost);

rrd_unlock();

}

void rrdhost_save_charts(RRDHOST *host) {

if(!host) return;

info("Saving/Closing database of host '%s'...", host->hostname);

RRDSET *st;

// we get a write lock

// to ensure only one thread is saving the database

rrdhost_wrlock(host);

rrdset_foreach_write(st, host) {

rrdset_rdlock(st);

rrdset_save(st);

rrdset_unlock(st);

}

rrdhost_unlock(host);

}

static struct label *rrdhost_load_auto_labels(void)

{

struct label *label_list = NULL;

if (localhost->system_info->host_os_name)

label_list =

add_label_to_list(label_list, "_os_name", localhost->system_info->host_os_name, LABEL_SOURCE_AUTO);

if (localhost->system_info->host_os_version)

label_list =

add_label_to_list(label_list, "_os_version", localhost->system_info->host_os_version, LABEL_SOURCE_AUTO);

if (localhost->system_info->kernel_version)

label_list =

add_label_to_list(label_list, "_kernel_version", localhost->system_info->kernel_version, LABEL_SOURCE_AUTO);

if (localhost->system_info->host_cores)

label_list =

add_label_to_list(label_list, "_system_cores", localhost->system_info->host_cores, LABEL_SOURCE_AUTO);

if (localhost->system_info->host_cpu_freq)

label_list =

add_label_to_list(label_list, "_system_cpu_freq", localhost->system_info->host_cpu_freq, LABEL_SOURCE_AUTO);

if (localhost->system_info->host_ram_total)

label_list =

add_label_to_list(label_list, "_system_ram_total", localhost->system_info->host_ram_total, LABEL_SOURCE_AUTO);

if (localhost->system_info->host_disk_space)

label_list =

add_label_to_list(label_list, "_system_disk_space", localhost->system_info->host_disk_space, LABEL_SOURCE_AUTO);