1 /*
2 ** Zabbix
3 ** Copyright (C) 2001-2021 Zabbix SIA
4 **
5 ** This program is free software; you can redistribute it and/or modify
6 ** it under the terms of the GNU General Public License as published by
7 ** the Free Software Foundation; either version 2 of the License, or
8 ** (at your option) any later version.
9 **
10 ** This program is distributed in the hope that it will be useful,
11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 ** GNU General Public License for more details.
14 **
15 ** You should have received a copy of the GNU General Public License
16 ** along with this program; if not, write to the Free Software
17 ** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 **/
19
20 #include "checks_simple_vmware.h"
21 #include "checks_simple.h"
22 #include "simple.h"
23 #include "log.h"
24
25 #include "zbxself.h"
26
27 typedef int (*vmfunc_t)(AGENT_REQUEST *, const char *, const char *, AGENT_RESULT *);
28
29 #define ZBX_VMWARE_PREFIX "vmware."
30
31 typedef struct
32 {
33 const char *key;
34 vmfunc_t func;
35 }
36 zbx_vmcheck_t;
37
38 #if defined(HAVE_LIBXML2) && defined(HAVE_LIBCURL)
39 # define VMCHECK_FUNC(func) func
40 #else
41 # define VMCHECK_FUNC(func) NULL
42 #endif
43
44 static zbx_vmcheck_t vmchecks[] =
45 {
46 {"cluster.discovery", VMCHECK_FUNC(check_vcenter_cluster_discovery)},
47 {"cluster.status", VMCHECK_FUNC(check_vcenter_cluster_status)},
48 {"version", VMCHECK_FUNC(check_vcenter_version)},
49 {"fullname", VMCHECK_FUNC(check_vcenter_fullname)},
50 {"datastore.discovery", VMCHECK_FUNC(check_vcenter_datastore_discovery)},
51 {"datastore.read", VMCHECK_FUNC(check_vcenter_datastore_read)},
52 {"datastore.size", VMCHECK_FUNC(check_vcenter_datastore_size)},
53 {"datastore.write", VMCHECK_FUNC(check_vcenter_datastore_write)},
54 {"datastore.hv.list", VMCHECK_FUNC(check_vcenter_datastore_hv_list)},
55
56 {"hv.cluster.name", VMCHECK_FUNC(check_vcenter_hv_cluster_name)},
57 {"hv.cpu.usage", VMCHECK_FUNC(check_vcenter_hv_cpu_usage)},
58 {"hv.cpu.usage.perf", VMCHECK_FUNC(check_vcenter_hv_cpu_usage_perf)},
59 {"hv.cpu.utilization", VMCHECK_FUNC(check_vcenter_hv_cpu_utilization)},
60 {"hv.datacenter.name", VMCHECK_FUNC(check_vcenter_hv_datacenter_name)},
61 {"hv.datastore.discovery", VMCHECK_FUNC(check_vcenter_hv_datastore_discovery)},
62 {"hv.datastore.read", VMCHECK_FUNC(check_vcenter_hv_datastore_read)},
63 {"hv.datastore.size", VMCHECK_FUNC(check_vcenter_hv_datastore_size)},
64 {"hv.datastore.write", VMCHECK_FUNC(check_vcenter_hv_datastore_write)},
65 {"hv.datastore.list", VMCHECK_FUNC(check_vcenter_hv_datastore_list)},
66 {"hv.datastore.multipath", VMCHECK_FUNC(check_vcenter_hv_datastore_multipath)},
67 {"hv.discovery", VMCHECK_FUNC(check_vcenter_hv_discovery)},
68 {"hv.fullname", VMCHECK_FUNC(check_vcenter_hv_fullname)},
69 {"hv.hw.cpu.num", VMCHECK_FUNC(check_vcenter_hv_hw_cpu_num)},
70 {"hv.hw.cpu.freq", VMCHECK_FUNC(check_vcenter_hv_hw_cpu_freq)},
71 {"hv.hw.cpu.model", VMCHECK_FUNC(check_vcenter_hv_hw_cpu_model)},
72 {"hv.hw.cpu.threads", VMCHECK_FUNC(check_vcenter_hv_hw_cpu_threads)},
73 {"hv.hw.memory", VMCHECK_FUNC(check_vcenter_hv_hw_memory)},
74 {"hv.hw.model", VMCHECK_FUNC(check_vcenter_hv_hw_model)},
75 {"hv.hw.uuid", VMCHECK_FUNC(check_vcenter_hv_hw_uuid)},
76 {"hv.hw.vendor", VMCHECK_FUNC(check_vcenter_hv_hw_vendor)},
77 {"hv.memory.size.ballooned", VMCHECK_FUNC(check_vcenter_hv_memory_size_ballooned)},
78 {"hv.memory.used", VMCHECK_FUNC(check_vcenter_hv_memory_used)},
79 {"hv.network.in", VMCHECK_FUNC(check_vcenter_hv_network_in)},
80 {"hv.network.out", VMCHECK_FUNC(check_vcenter_hv_network_out)},
81 {"hv.perfcounter", VMCHECK_FUNC(check_vcenter_hv_perfcounter)},
82 {"hv.power", VMCHECK_FUNC(check_vcenter_hv_power)},
83 {"hv.sensor.health.state", VMCHECK_FUNC(check_vcenter_hv_sensor_health_state)},
84 {"hv.status", VMCHECK_FUNC(check_vcenter_hv_status)},
85 {"hv.maintenance", VMCHECK_FUNC(check_vcenter_hv_maintenance)},
86 {"hv.uptime", VMCHECK_FUNC(check_vcenter_hv_uptime)},
87 {"hv.version", VMCHECK_FUNC(check_vcenter_hv_version)},
88 {"hv.sensors.get", VMCHECK_FUNC(check_vcenter_hv_sensors_get)},
89 {"hv.vm.num", VMCHECK_FUNC(check_vcenter_hv_vm_num)},
90
91 {"vm.cluster.name", VMCHECK_FUNC(check_vcenter_vm_cluster_name)},
92 {"vm.cpu.num", VMCHECK_FUNC(check_vcenter_vm_cpu_num)},
93 {"vm.cpu.ready", VMCHECK_FUNC(check_vcenter_vm_cpu_ready)},
94 {"vm.cpu.usage", VMCHECK_FUNC(check_vcenter_vm_cpu_usage)},
95 {"vm.cpu.usage.perf", VMCHECK_FUNC(check_vcenter_vm_cpu_usage_perf)},
96 {"vm.cpu.latency", VMCHECK_FUNC(check_vcenter_vm_cpu_latency)},
97 {"vm.cpu.readiness", VMCHECK_FUNC(check_vcenter_vm_cpu_readiness)},
98 {"vm.cpu.swapwait", VMCHECK_FUNC(check_vcenter_vm_cpu_swapwait)},
99 {"vm.datacenter.name", VMCHECK_FUNC(check_vcenter_vm_datacenter_name)},
100 {"vm.discovery", VMCHECK_FUNC(check_vcenter_vm_discovery)},
101 {"vm.guest.osuptime", VMCHECK_FUNC(check_vcenter_vm_guest_uptime)},
102 {"vm.hv.name", VMCHECK_FUNC(check_vcenter_vm_hv_name)},
103 {"vm.memory.size", VMCHECK_FUNC(check_vcenter_vm_memory_size)},
104 {"vm.memory.size.ballooned", VMCHECK_FUNC(check_vcenter_vm_memory_size_ballooned)},
105 {"vm.memory.size.compressed", VMCHECK_FUNC(check_vcenter_vm_memory_size_compressed)},
106 {"vm.memory.size.swapped", VMCHECK_FUNC(check_vcenter_vm_memory_size_swapped)},
107 {"vm.memory.size.usage.guest", VMCHECK_FUNC(check_vcenter_vm_memory_size_usage_guest)},
108 {"vm.memory.size.usage.host", VMCHECK_FUNC(check_vcenter_vm_memory_size_usage_host)},
109 {"vm.memory.size.private", VMCHECK_FUNC(check_vcenter_vm_memory_size_private)},
110 {"vm.memory.size.shared", VMCHECK_FUNC(check_vcenter_vm_memory_size_shared)},
111 {"vm.memory.size.consumed", VMCHECK_FUNC(check_vcenter_vm_memory_size_consumed)},
112 {"vm.memory.usage", VMCHECK_FUNC(check_vcenter_vm_memory_usage)},
113 {"vm.guest.memory.size.swapped", VMCHECK_FUNC(check_vcenter_vm_guest_memory_size_swapped)},
114 {"vm.net.if.discovery", VMCHECK_FUNC(check_vcenter_vm_net_if_discovery)},
115 {"vm.net.if.in", VMCHECK_FUNC(check_vcenter_vm_net_if_in)},
116 {"vm.net.if.out", VMCHECK_FUNC(check_vcenter_vm_net_if_out)},
117 {"vm.net.if.usage", VMCHECK_FUNC(check_vcenter_vm_net_if_usage)},
118 {"vm.perfcounter", VMCHECK_FUNC(check_vcenter_vm_perfcounter)},
119 {"vm.powerstate", VMCHECK_FUNC(check_vcenter_vm_powerstate)},
120 {"vm.storage.committed", VMCHECK_FUNC(check_vcenter_vm_storage_committed)},
121 {"vm.storage.unshared", VMCHECK_FUNC(check_vcenter_vm_storage_unshared)},
122 {"vm.storage.uncommitted", VMCHECK_FUNC(check_vcenter_vm_storage_uncommitted)},
123 {"vm.storage.readoio", VMCHECK_FUNC(check_vcenter_vm_storage_readoio)},
124 {"vm.storage.writeoio", VMCHECK_FUNC(check_vcenter_vm_storage_writeoio)},
125 {"vm.storage.totalwritelatency", VMCHECK_FUNC(check_vcenter_vm_storage_totalwritelatency)},
126 {"vm.storage.totalreadlatency", VMCHECK_FUNC(check_vcenter_vm_storage_totalreadlatency)},
127 {"vm.uptime", VMCHECK_FUNC(check_vcenter_vm_uptime)},
128 {"vm.vfs.dev.discovery", VMCHECK_FUNC(check_vcenter_vm_vfs_dev_discovery)},
129 {"vm.vfs.dev.read", VMCHECK_FUNC(check_vcenter_vm_vfs_dev_read)},
130 {"vm.vfs.dev.write", VMCHECK_FUNC(check_vcenter_vm_vfs_dev_write)},
131 {"vm.vfs.fs.discovery", VMCHECK_FUNC(check_vcenter_vm_vfs_fs_discovery)},
132 {"vm.vfs.fs.size", VMCHECK_FUNC(check_vcenter_vm_vfs_fs_size)},
133
134 {"dc.discovery", VMCHECK_FUNC(check_vcenter_dc_discovery)},
135
136 {"cl.perfcounter", VMCHECK_FUNC(check_vcenter_cl_perfcounter)},
137
138 {NULL, NULL}
139 };
140
141 /******************************************************************************
142 * *
143 * Function: get_vmware_function *
144 * *
145 * Purpose: Retrieves a handler of the item key *
146 * *
147 * Parameters: key - [IN] an item key (without parameters) *
148 * vmfunc - [OUT] a handler of the item key; can be NULL if *
149 * libxml2 or libcurl is not compiled in *
150 * *
151 * Return value: SUCCEED if key is a valid VMware key, FAIL - otherwise *
152 * *
153 ******************************************************************************/
get_vmware_function(const char * key,vmfunc_t * vmfunc)154 static int get_vmware_function(const char *key, vmfunc_t *vmfunc)
155 {
156 zbx_vmcheck_t *check;
157
158 if (0 != strncmp(key, ZBX_VMWARE_PREFIX, ZBX_CONST_STRLEN(ZBX_VMWARE_PREFIX)))
159 return FAIL;
160
161 for (check = vmchecks; NULL != check->key; check++)
162 {
163 if (0 == strcmp(key + ZBX_CONST_STRLEN(ZBX_VMWARE_PREFIX), check->key))
164 {
165 *vmfunc = check->func;
166 return SUCCEED;
167 }
168 }
169
170 return FAIL;
171 }
172
get_value_simple(const DC_ITEM * item,AGENT_RESULT * result,zbx_vector_ptr_t * add_results)173 int get_value_simple(const DC_ITEM *item, AGENT_RESULT *result, zbx_vector_ptr_t *add_results)
174 {
175 AGENT_REQUEST request;
176 vmfunc_t vmfunc;
177 int ret = NOTSUPPORTED;
178
179 zabbix_log(LOG_LEVEL_DEBUG, "In %s() key_orig:'%s' addr:'%s'", __func__, item->key_orig, item->interface.addr);
180
181 init_request(&request);
182
183 if (SUCCEED != parse_item_key(item->key, &request))
184 {
185 SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid item key format."));
186 goto out;
187 }
188
189 request.lastlogsize = item->lastlogsize;
190
191 if (0 == strcmp(request.key, "net.tcp.service") || 0 == strcmp(request.key, "net.udp.service"))
192 {
193 if (SYSINFO_RET_OK == check_service(&request, item->interface.addr, result, 0))
194 ret = SUCCEED;
195 }
196 else if (0 == strcmp(request.key, "net.tcp.service.perf") || 0 == strcmp(request.key, "net.udp.service.perf"))
197 {
198 if (SYSINFO_RET_OK == check_service(&request, item->interface.addr, result, 1))
199 ret = SUCCEED;
200 }
201 else if (SUCCEED == get_vmware_function(request.key, &vmfunc))
202 {
203 if (NULL != vmfunc)
204 {
205 if (0 == get_process_type_forks(ZBX_PROCESS_TYPE_VMWARE))
206 {
207 SET_MSG_RESULT(result, zbx_strdup(NULL, "No \"vmware collector\" processes started."));
208 goto out;
209 }
210
211 if (SYSINFO_RET_OK == vmfunc(&request, item->username, item->password, result))
212 ret = SUCCEED;
213 }
214 else
215 SET_MSG_RESULT(result, zbx_strdup(NULL, "Support for VMware checks was not compiled in."));
216 }
217 else if (0 == strcmp(request.key, ZBX_VMWARE_PREFIX "eventlog"))
218 {
219 #if defined(HAVE_LIBXML2) && defined(HAVE_LIBCURL)
220 if (SYSINFO_RET_OK == check_vcenter_eventlog(&request, item, result, add_results))
221 ret = SUCCEED;
222 #else
223 ZBX_UNUSED(add_results);
224 SET_MSG_RESULT(result, zbx_strdup(NULL, "Support for VMware checks was not compiled in."));
225 #endif
226 }
227 else
228 {
229 /* it will execute item from a loadable module if any */
230 if (SUCCEED == process(item->key, PROCESS_MODULE_COMMAND, result))
231 ret = SUCCEED;
232 }
233
234 if (NOTSUPPORTED == ret && !ISSET_MSG(result))
235 SET_MSG_RESULT(result, zbx_strdup(NULL, "Simple check is not supported."));
236
237 out:
238 free_request(&request);
239
240 zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __func__, zbx_result_string(ret));
241
242 return ret;
243 }
244