1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
// SPDX-License-Identifier: GPL-3.0-or-later
#define NETDATA_RRD_INTERNALS 1
#include "rrd.h"
#include "storage_engine.h"
// ----------------------------------------------------------------------------
// globals
/*
// if not zero it gives the time (in seconds) to remove un-updated dimensions
// DO NOT ENABLE
// if dimensions are removed, the chart generation will have to run again
int rrd_delete_unupdated_dimensions = 0;
*/
int default_rrd_update_every = UPDATE_EVERY;
int default_rrd_history_entries = RRD_DEFAULT_HISTORY_ENTRIES;
#ifdef ENABLE_DBENGINE
RRD_MEMORY_MODE default_rrd_memory_mode = RRD_MEMORY_MODE_DBENGINE;
#else
RRD_MEMORY_MODE default_rrd_memory_mode = RRD_MEMORY_MODE_SAVE;
#endif
int gap_when_lost_iterations_above = 1;
// ----------------------------------------------------------------------------
// RRD - memory modes
inline const char *rrd_memory_mode_name(RRD_MEMORY_MODE id) {
switch(id) {
case RRD_MEMORY_MODE_RAM:
return RRD_MEMORY_MODE_RAM_NAME;
case RRD_MEMORY_MODE_MAP:
return RRD_MEMORY_MODE_MAP_NAME;
case RRD_MEMORY_MODE_NONE:
return RRD_MEMORY_MODE_NONE_NAME;
case RRD_MEMORY_MODE_SAVE:
return RRD_MEMORY_MODE_SAVE_NAME;
case RRD_MEMORY_MODE_ALLOC:
return RRD_MEMORY_MODE_ALLOC_NAME;
case RRD_MEMORY_MODE_DBENGINE:
return RRD_MEMORY_MODE_DBENGINE_NAME;
}
STORAGE_ENGINE* eng = storage_engine_get(id);
if (eng) {
return eng->name;
}
return RRD_MEMORY_MODE_SAVE_NAME;
}
RRD_MEMORY_MODE rrd_memory_mode_id(const char *name) {
STORAGE_ENGINE* eng = storage_engine_find(name);
if (eng) {
return eng->id;
}
return RRD_MEMORY_MODE_SAVE;
}
// ----------------------------------------------------------------------------
// RRD - algorithms types
RRD_ALGORITHM rrd_algorithm_id(const char *name) {
if(strcmp(name, RRD_ALGORITHM_INCREMENTAL_NAME) == 0)
return RRD_ALGORITHM_INCREMENTAL;
else if(strcmp(name, RRD_ALGORITHM_ABSOLUTE_NAME) == 0)
return RRD_ALGORITHM_ABSOLUTE;
else if(strcmp(name, RRD_ALGORITHM_PCENT_OVER_ROW_TOTAL_NAME) == 0)
return RRD_ALGORITHM_PCENT_OVER_ROW_TOTAL;
else if(strcmp(name, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL_NAME) == 0)
return RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL;
else
return RRD_ALGORITHM_ABSOLUTE;
}
const char *rrd_algorithm_name(RRD_ALGORITHM algorithm) {
switch(algorithm) {
case RRD_ALGORITHM_ABSOLUTE:
default:
return RRD_ALGORITHM_ABSOLUTE_NAME;
case RRD_ALGORITHM_INCREMENTAL:
return RRD_ALGORITHM_INCREMENTAL_NAME;
case RRD_ALGORITHM_PCENT_OVER_ROW_TOTAL:
return RRD_ALGORITHM_PCENT_OVER_ROW_TOTAL_NAME;
case RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL:
return RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL_NAME;
}
}
// ----------------------------------------------------------------------------
// RRD - chart types
inline RRDSET_TYPE rrdset_type_id(const char *name) {
if(unlikely(strcmp(name, RRDSET_TYPE_AREA_NAME) == 0))
return RRDSET_TYPE_AREA;
else if(unlikely(strcmp(name, RRDSET_TYPE_STACKED_NAME) == 0))
return RRDSET_TYPE_STACKED;
else // if(unlikely(strcmp(name, RRDSET_TYPE_LINE_NAME) == 0))
return RRDSET_TYPE_LINE;
}
const char *rrdset_type_name(RRDSET_TYPE chart_type) {
switch(chart_type) {
case RRDSET_TYPE_LINE:
default:
return RRDSET_TYPE_LINE_NAME;
case RRDSET_TYPE_AREA:
return RRDSET_TYPE_AREA_NAME;
case RRDSET_TYPE_STACKED:
return RRDSET_TYPE_STACKED_NAME;
}
}
// ----------------------------------------------------------------------------
// RRD - cache directory
char *rrdhost_cache_dir_for_rrdset_alloc(RRDHOST *host, const char *id) {
char *ret = NULL;
char b[FILENAME_MAX + 1];
char n[FILENAME_MAX + 1];
rrdset_strncpyz_name(b, id, FILENAME_MAX);
snprintfz(n, FILENAME_MAX, "%s/%s", host->cache_dir, b);
ret = strdupz(n);
if(host->rrd_memory_mode == RRD_MEMORY_MODE_MAP || host->rrd_memory_mode == RRD_MEMORY_MODE_SAVE) {
int r = mkdir(ret, 0775);
if(r != 0 && errno != EEXIST)
error("Cannot create directory '%s'", ret);
}
return ret;
}
// ----------------------------------------------------------------------------
// RRD - string management
STRING *rrd_string_strdupz(const char *s) {
if(unlikely(!s || !*s)) return string_strdupz(s);
char *tmp = strdupz(s);
json_fix_string(tmp);
STRING *ret = string_strdupz(tmp);
freez(tmp);
return ret;
}
|
