Debian Codegraph @

connectors/vmware/src/centreon/script/centreon_vmware.pm

raw
1 #!/usr/bin/perl
2 # Copyright 2024 Centreon (http://www.centreon.com/)
3 #
4 # Centreon is a full-fledged industry-strength solution that meets
5 # the needs in IT infrastructure and application monitoring for
6 # service performance.
7 #
8 # Licensed under the Apache License, Version 2.0 (the "License");
9 # you may not use this file except in compliance with the License.
10 # You may obtain a copy of the License at
11 #
12 # http://www.apache.org/licenses/LICENSE-2.0
13 #
14 # Unless required by applicable law or agreed to in writing, software
15 # distributed under the License is distributed on an "AS IS" BASIS,
16 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 # See the License for the specific language governing permissions and
18 # limitations under the License.
19
20 package centreon::script::centreon_vmware;
21
22 use strict;
23 use warnings;
24 use VMware::VIRuntime;
25 use VMware::VILib;
26 use ZMQ::LibZMQ4;
27 use ZMQ::Constants qw(:all);
28 use File::Basename;
29 use Digest::MD5 qw(md5_hex);
30 use POSIX ":sys_wait_h";
31 use JSON::XS;
32 use centreon::vmware::script;
33 use centreon::vmware::common;
34 use centreon::vmware::connector;
35 use centreon::script::centreonvault;
36
37 my ($centreon_vmware, $frontend);
38
39 BEGIN {
40 # In new version version of LWP (version 6), the backend is now 'IO::Socket::SSL' (instead Crypt::SSLeay)
41 # it's a hack if you unset that
42 #$ENV{PERL_NET_HTTPS_SSL_SOCKET_CLASS} = "Net::SSL";
43
44 # The option is not omit to verify the certificate chain.
45 $ENV{PERL_LWP_SSL_VERIFY_HOSTNAME} = 0;
46
47 eval {
48 # required for new IO::Socket::SSL versions
49 require IO::Socket::SSL;
50 IO::Socket::SSL->import();
51 IO::Socket::SSL::set_ctx_defaults( SSL_verify_mode => 0, SSL_no_shutdown => 1 );
52 };
53 }
54
55 use base qw(centreon::vmware::script);
56
57 my $VERSION = '3.4.0';
58 my %handlers = (TERM => {}, HUP => {}, CHLD => {});
59
60 my @load_modules = (
61 'centreon::vmware::cmdalarmdatacenter',
62 'centreon::vmware::cmdalarmhost',
63 'centreon::vmware::cmdcountvmhost',
64 'centreon::vmware::cmdcpucluster',
65 'centreon::vmware::cmdcpuhost',
66 'centreon::vmware::cmdcpuvm',
67 'centreon::vmware::cmddatastorecountvm',
68 'centreon::vmware::cmddatastoreio',
69 'centreon::vmware::cmddatastoreiops',
70 'centreon::vmware::cmddatastorehost',
71 'centreon::vmware::cmddatastoresnapshot',
72 'centreon::vmware::cmddatastorevm',
73 'centreon::vmware::cmddatastoreusage',
74 'centreon::vmware::cmddevicevm',
75 'centreon::vmware::cmddiscovery',
76 'centreon::vmware::cmdgetmap',
77 'centreon::vmware::cmdhealthhost',
78 'centreon::vmware::cmdlicenses',
79 'centreon::vmware::cmdlimitvm',
80 'centreon::vmware::cmdlistclusters',
81 'centreon::vmware::cmdlistdatacenters',
82 'centreon::vmware::cmdlistdatastores',
83 'centreon::vmware::cmdlistnichost',
84 'centreon::vmware::cmdmemhost',
85 'centreon::vmware::cmdmaintenancehost',
86 'centreon::vmware::cmdmemvm',
87 'centreon::vmware::cmdnethost',
88 'centreon::vmware::cmdnetvm',
89 'centreon::vmware::cmdservicehost',
90 'centreon::vmware::cmdsnapshotvm',
91 'centreon::vmware::cmdstatuscluster',
92 'centreon::vmware::cmdstatushost',
93 'centreon::vmware::cmdstatusvm',
94 'centreon::vmware::cmdstoragehost',
95 'centreon::vmware::cmdswaphost',
96 'centreon::vmware::cmdswapvm',
97 'centreon::vmware::cmdthinprovisioningvm',
98 'centreon::vmware::cmdtimehost',
99 'centreon::vmware::cmdtoolsvm',
100 'centreon::vmware::cmduptimehost',
101 'centreon::vmware::cmdvmoperationcluster',
102 'centreon::vmware::cmdvsanclusterusage'
103 );
104
105 sub new {
106 my $class = shift;
107 my $self = $class->SUPER::new('centreon_vmware');
108
109 bless $self, $class;
110 $self->add_options(
111 'config-extra=s' => \$self->{opt_extra},
112 'check-config' => \$self->{opt_check_config},
113 'vault-config=s' => \$self->{opt_vault_config}
114 );
115
116 %{$self->{centreon_vmware_default_config}} = (
117 credstore_use => 0,
118 credstore_file => '/root/.vmware/credstore/vicredentials.xml',
119 timeout_vsphere => 60,
120 timeout => 60,
121 timeout_kill => 30,
122 dynamic_timeout_kill => 86400,
123 refresh_keeper_session => 15,
124 bind => '*',
125 port => 5700,
126 ipc_file => '/tmp/centreon_vmware/routing.ipc',
127 case_insensitive => 0,
128 vsphere_server => {
129 #'default' => {'url' => 'https://XXXXXX/sdk',
130 # 'username' => 'XXXXX',
131 # 'password' => 'XXXXX'},
132 #'testvc' => {'url' => 'https://XXXXXX/sdk',
133 # 'username' => 'XXXXX',
134 # 'password' => 'XXXXXX'}
135 },
136 vsan_sdk_path => '/usr/local/share/perl5/VMware'
137 );
138
139 $self->{return_child} = {};
140 $self->{stop} = 0;
141 $self->{children_vpshere_pid} = {};
142 $self->{counter_stats} = {};
143 $self->{whoaim} = undef; # to know which vsphere to connect
144 $self->{modules_registry} = {};
145 $self->{vault} = {};
146
147 return $self;
148 }
149
150 # read_configuration: reads the configuration file given as parameter
151 sub read_configuration {
152 my ($self, %options) = @_;
153
154 $self->{logger}->writeLogDebug("Reading configuration from " . $self->{opt_extra});
155 my $centreon_vmware_config_from_json;
156
157 if ($self->{opt_extra} =~ /.*\.pm$/i) {
158 our %centreon_vmware_config;
159 # loads the .pm configuration (compile time)
160 require($self->{opt_extra}) or $self->{logger}->writeLogFatal("There has been an error while requiring file " . $self->{opt_extra});
161 # We want all the keys to be lowercase
162 for my $conf_key (keys %{$centreon_vmware_config{vsphere_server}}) {
163 if ($conf_key ne lc($conf_key)) {
164 $self->{logger}->writeLogDebug("The container $conf_key has capital letters. We convert it to lower case.");
165 $centreon_vmware_config{vsphere_server}->{lc($conf_key)} = delete $centreon_vmware_config{vsphere_server}->{$conf_key};
166 }
167 }
168 # Concatenation of the default parameters with the ones from the config file
169 $self->{centreon_vmware_config} = {%{$self->{centreon_vmware_default_config}}, %centreon_vmware_config};
170 } elsif ($self->{opt_extra} =~ /.*\.json$/i) {
171 $centreon_vmware_config_from_json = centreon::vmware::common::parse_json_file( 'json_file' => $self->{opt_extra} );
172 if (defined($centreon_vmware_config_from_json->{error_message})) {
173 $self->{logger}->writeLogFatal("Error while parsing " . $self->{opt_extra} . ": " . $centreon_vmware_config_from_json->{error_message});
174 }
175 # The structure of the JSON is different from the .pm file. The code was designed to work with the latter, so
176 # the structure of $self->{centreon_vmware_config} must be adapted after parsing to avoid a massive refactoring of
177 # the whole program. The wanted structure is a key-object dictionary instead of an array of objects.
178 my %vsphere_server_dict = map { lc($_->{name}) => $_ } @{$centreon_vmware_config_from_json->{vsphere_server}};
179 # Replace the "raw" structure from the JSON file.
180 $centreon_vmware_config_from_json->{vsphere_server} = \%vsphere_server_dict;
181 # Concatenation of the default parameters with the ones from the config file
182 $self->{centreon_vmware_config} = {%{$self->{centreon_vmware_default_config}}, %$centreon_vmware_config_from_json};
183 } else {
184 $self->{logger}->writeLogFatal($self->{opt_extra} . " does not seem to be in a supported format (supported: .pm or .json).");
185 }
186 }
187
188 # report_config_check: writes a report of what has been loaded from the configuration file
189 sub report_config_check {
190 my ($self, %options) = @_;
191
192 my $nb_server_entries = scalar(keys %{$self->{centreon_vmware_config}->{vsphere_server}});
193 my $entry_spelling = ($nb_server_entries > 1) ? 'entries' : 'entry';
194
195 my $report = "Configuration file " . $self->{opt_extra} . " has been read correctly and has "
196 . $nb_server_entries . " " . $entry_spelling . ".";
197
198 $self->{logger}->writeLogInfo($report);
199 return $report;
200 }
201
202 sub init {
203 my $self = shift;
204 $self->SUPER::init();
205
206 # redefine to avoid out when we try modules
207 $SIG{__DIE__} = undef;
208
209 if ( ! defined($self->{opt_extra}) ) {
210 $self->{opt_extra} = "/etc/centreon/centreon_vmware.pm";
211 }
212
213 if ( ! -f $self->{opt_extra} ) {
214 $self->{logger}->writeLogFatal(
215 "Can't find config file '$self->{opt_extra}'. If a migration from "
216 . "/etc/centreon/centreon_vmware.pm to /etc/centreon/centreon_vmware.json is required, you may "
217 . "centreon_vmware_convert_config_file /etc/centreon/centreon_vmware.pm > /etc/centreon/centreon_vmware.json"
218 );
219 }
220
221 $self->read_configuration(filename => $self->{opt_extra});
222
223 if (! defined($self->{opt_vault_config}) || $self->{opt_vault_config} eq '') {
224 $self->{opt_vault_config} = '/var/lib/centreon/vault/vault.json';
225 $self->{logger}->writeLogInfo("No vault config file given. Applying default: " . $self->{opt_vault_config});
226 }
227
228 $self->{logger}->writeLogDebug("Vault config file " . $self->{opt_vault_config} . " exists. Creating the vault object.");
229 $self->{vault} = centreon::script::centreonvault->new(
230 'logger' => $self->{logger},
231 'config_file' => $self->{opt_vault_config}
232 );
233
234 ##### Load modules
235 $self->load_module(@load_modules);
236
237 $self->{vsan_enabled} = 0;
238 eval {
239 centreon::vmware::common::load_vsanmgmt_binding_files(
240 path => $self->{centreon_vmware_config}->{vsan_sdk_path},
241 files => ['VIM25VsanmgmtStub.pm', 'VIM25VsanmgmtRuntime.pm'],
242 );
243 $self->{vsan_enabled} = 1;
244 };
245
246 ##### credstore check #####
247 if (defined($self->{centreon_vmware_config}->{credstore_use}) && defined($self->{centreon_vmware_config}->{credstore_file}) &&
248 $self->{centreon_vmware_config}->{credstore_use} == 1 && -e "$self->{centreon_vmware_config}->{credstore_file}") {
249 eval 'require VMware::VICredStore';
250 if ($@) {
251 $self->{logger}->writeLogError("Could not load module VMware::VICredStore");
252 exit(1);
253 }
254 require VMware::VICredStore;
255
256 if (VMware::VICredStore::init(filename => $self->{centreon_vmware_config}->{credstore_file}) == 0) {
257 $self->{logger}->writeLogError("Credstore init failed: $@");
258 exit(1);
259 }
260 } else {
261 $self->{logger}->writeLogDebug("Not using credstore.");
262 $self->{centreon_vmware_config}->{credstore_use} = 0;
263 }
264
265 # Get passwords
266 foreach my $server (keys %{$self->{centreon_vmware_config}->{vsphere_server}}) {
267
268 # If appropriate, get the password from the vmware credentials store
269 if ($self->{centreon_vmware_config}->{credstore_use} == 1) {
270 $self->{centreon_vmware_config}->{vsphere_server}->{$server}->{password} = VMware::VICredStore::get_password(
271 server => $server,
272 username => $self->{centreon_vmware_config}->{vsphere_server}->{$server}->{username}
273 );
274 if (!defined($self->{centreon_vmware_config}->{vsphere_server}->{$server}->{password})) {
275 $self->{logger}->writeLogFatal("Can't get password for couple host='" . $server . "', username='" . $self->{centreon_vmware_config}->{vsphere_server}->{$server}->{username} . "' : $@");
276 }
277 } else {
278 # we let the vault object handle the secrets
279 for my $key ('username', 'password') {
280 $self->{logger}->writeLogDebug("Retrieving secret: $key");
281 $self->{centreon_vmware_config}->{vsphere_server}->{$server}->{$key}
282 = $self->{vault}->get_secret($self->{centreon_vmware_config}->{vsphere_server}->{$server}->{$key});
283 }
284 }
285 }
286
287 my $config_check_report = $self->report_config_check();
288 if (defined($self->{opt_check_config})) {
289 print($config_check_report . " Exiting now.");
290 exit(0);
291 }
292 $self->set_signal_handlers;
293 }
294
295
296 sub set_signal_handlers {
297 my $self = shift;
298
299 $SIG{TERM} = \&class_handle_TERM;
300 $handlers{TERM}->{$self} = sub { $self->handle_TERM() };
301 $SIG{HUP} = \&class_handle_HUP;
302 $handlers{HUP}->{$self} = sub { $self->handle_HUP() };
303 $SIG{CHLD} = \&class_handle_CHLD;
304 $handlers{CHLD}->{$self} = sub { $self->handle_CHLD() };
305 }
306
307 sub class_handle_TERM {
308 foreach (keys %{$handlers{TERM}}) {
309 &{$handlers{TERM}->{$_}}();
310 }
311 }
312
313 sub class_handle_HUP {
314 foreach (keys %{$handlers{HUP}}) {
315 &{$handlers{HUP}->{$_}}();
316 }
317 }
318
319 sub class_handle_CHLD {
320 foreach (keys %{$handlers{CHLD}}) {
321 &{$handlers{CHLD}->{$_}}();
322 }
323 }
324
325 sub handle_TERM {
326 my $self = shift;
327 $self->{logger}->writeLogInfo("$$ Receiving order to stop...");
328 $self->{stop} = 1;
329
330 foreach (keys %{$self->{children_vpshere_pid}}) {
331 kill('TERM', $_);
332 $self->{logger}->writeLogInfo("Send -TERM signal to '" . $self->{children_vpshere_pid}->{$_} . "' process..");
333 }
334 }
335
336 sub handle_HUP {
337 my $self = shift;
338 $self->{logger}->writeLogInfo("$$ Receiving order to reload but it has not been implemented yet...");
339 # TODO
340 }
341
342 sub handle_CHLD {
343 my $self = shift;
344 my $child_pid;
345
346 while (($child_pid = waitpid(-1, &WNOHANG)) > 0) {
347 $self->{return_child}{$child_pid} = {status => 1, rtime => time()};
348 }
349
350 $SIG{CHLD} = \&class_handle_CHLD;
351 }
352
353 sub load_module {
354 my $self = shift;
355
356 for (@_) {
357 (my $file = "$_.pm") =~ s{::}{/}g;
358 require $file;
359 my $obj = $_->new(logger => $self->{logger}, case_insensitive => $self->{centreon_vmware_config}->{case_insensitive});
360 $self->{modules_registry}->{ $obj->getCommandName() } = $obj;
361 }
362 }
363
364 sub verify_child_vsphere {
365 my $self = shift;
366
367 # Some dead process. need to relaunch it
368 foreach (keys %{$self->{return_child}}) {
369 delete $self->{return_child}->{$_};
370
371 if (defined($self->{children_vpshere_pid}->{$_})) {
372 if ($self->{stop} == 0) {
373 my $name = $self->{children_vpshere_pid}->{$_};
374 $self->{logger}->writeLogError("Sub-process for '" . $self->{children_vpshere_pid}->{$_} . "'???!! we relaunch it!!!");
375
376 if ($self->{centreon_vmware_config}->{vsphere_server}->{$self->{children_vpshere_pid}->{$_}}->{dynamic} == 0) {
377 # Can have the same pid (so we delete before)
378 delete $self->{children_vpshere_pid}->{$_};
379 $self->create_vsphere_child(vsphere_name => $name, dynamic => 0);
380 } else {
381 $self->{logger}->writeLogError("Sub-process for '" . $self->{children_vpshere_pid}->{$_} . "' is dead. But we don't relaunch it (dynamic sub-process)");
382 delete $self->{centreon_vmware_config}->{vsphere_server}->{$self->{children_vpshere_pid}->{$_}};
383 delete $self->{children_vpshere_pid}->{$_};
384 }
385 } else {
386 $self->{logger}->writeLogInfo("Sub-process for '" . $self->{children_vpshere_pid}->{$_} . "' dead ???!!");
387 $self->{centreon_vmware_config}->{vsphere_server}->{$self->{children_vpshere_pid}->{$_}}->{running} = 0;
388 delete $self->{children_vpshere_pid}->{$_};
389 }
390 }
391 }
392
393 my $count = 0;
394 foreach (keys %{$self->{centreon_vmware_config}->{vsphere_server}}) {
395 if ($self->{centreon_vmware_config}->{vsphere_server}->{$_}->{running} == 1) {
396 $count++;
397 }
398 if ($self->{centreon_vmware_config}->{vsphere_server}->{$_}->{dynamic} == 1 &&
399 time() - $self->{centreon_vmware_config}->{dynamic_timeout_kill} > $self->{centreon_vmware_config}->{vsphere_server}->{$_}->{last_request}) {
400 $self->{logger}->writeLogError("Send TERM signal for process '" . $_ . "': too many times without requests. We clean it.");
401 kill('TERM', $self->{centreon_vmware_config}->{vsphere_server}->{$_}->{pid});
402 }
403 }
404
405 return $count;
406 }
407
408 sub waiting_ready {
409 my ($self, %options) = @_;
410
411 return 1 if ($self->{centreon_vmware_config}->{vsphere_server}->{$options{container}}->{ready} == 1);
412
413 # Need to check if we need to relaunch (maybe it can have a problem)
414 $self->check_children();
415
416 my $time = time();
417 # We wait 10 seconds
418 while ($self->{centreon_vmware_config}->{vsphere_server}->{$options{container}}->{ready} == 0 &&
419 time() - $time < 10) {
420 zmq_poll($self->{poll}, 5000);
421 }
422
423 if ($self->{centreon_vmware_config}->{vsphere_server}->{$options{container}}->{ready} == 0) {
424 centreon::vmware::common::set_response(code => -1, short_message => "connector still not ready.");
425 centreon::vmware::common::response(token => 'RESPSERVER', endpoint => $frontend, identity => $options{identity});
426 return 0;
427 }
428
429 return 1;
430 }
431
432 sub request_dynamic {
433 my ($self, %options) = @_;
434
435 if (!defined($options{result}->{vsphere_username}) || $options{result}->{vsphere_username} eq '' ||
436 !defined($options{result}->{vsphere_password}) || $options{result}->{vsphere_password} eq '') {
437 centreon::vmware::common::set_response(code => -1, short_message => "Please set vsphere username or password");
438 centreon::vmware::common::response(token => 'RESPSERVER', endpoint => $frontend, identity => $options{identity});
439 return ;
440 }
441
442 my $container = md5_hex($options{result}->{vsphere_address} . $options{result}->{vsphere_username} . $options{result}->{vsphere_password});
443 # Need to create fork
444 if (!defined($self->{centreon_vmware_config}->{vsphere_server}->{$container})) {
445 $self->{centreon_vmware_config}->{vsphere_server}->{$container} = {
446 url => 'https://' . $options{result}->{vsphere_address} . '/sdk',
447 username => $options{result}->{vsphere_username},
448 password => $options{result}->{vsphere_password},
449 last_request => time()
450 };
451 $self->{logger}->writeLogError(
452 sprintf(
453 "Dynamic creation: identity = %s [address: %s] [username: %s] [password: %s]",
454 $container, $options{result}->{vsphere_address}, $options{result}->{vsphere_username}, $options{result}->{vsphere_password}
455 )
456 );
457 $centreon_vmware->create_vsphere_child(vsphere_name => $container, dynamic => 1);
458 }
459
460 return if ($self->waiting_ready(
461 container => $container, manager => $options{manager},
462 identity => $options{identity}) == 0);
463
464 $self->{centreon_vmware_config}->{vsphere_server}->{$container}->{last_request} = time();
465
466 my $flag = ZMQ_NOBLOCK | ZMQ_SNDMORE;
467 my $msg = zmq_msg_init_data("server-" . $container);
468 zmq_msg_send($msg, $frontend, $flag);
469 zmq_msg_close($msg);
470 $msg = zmq_msg_init_data('REQCLIENT ' . $options{data});
471 zmq_msg_send($msg, $frontend, ZMQ_NOBLOCK);
472 zmq_msg_close($msg);
473 }
474
475 sub request {
476 my ($self, %options) = @_;
477
478 # Decode json
479 my $result;
480 eval {
481 $result = JSON::XS->new->utf8->decode($options{data});
482 };
483 if ($@) {
484 centreon::vmware::common::set_response(code => 1, short_message => "Cannot decode json result: $@");
485 centreon::vmware::common::response(token => 'RESPSERVER', endpoint => $frontend, identity => $options{identity});
486 return ;
487 }
488 if ($result->{command} eq 'stats') {
489 centreon::vmware::common::stats_info(counters => $self->{counter_stats});
490 centreon::vmware::common::response(token => 'RESPSERVER', endpoint => $frontend, identity => $options{identity});
491 return ;
492 }
493 if (!defined($self->{modules_registry}->{ $result->{command} })) {
494 centreon::vmware::common::set_response(code => 1, short_message => "Unknown method name '$result->{command}'");
495 centreon::vmware::common::response(token => 'RESPSERVER', endpoint => $frontend, identity => $options{identity});
496 return ;
497 }
498 if ($self->{modules_registry}->{ $result->{command} }->checkArgs(
499 manager => $options{manager},
500 arguments => $result)) {
501 centreon::vmware::common::response(token => 'RESPSERVER', endpoint => $frontend, identity => $options{identity});
502 return ;
503 }
504
505 # Mode dynamic
506 if (defined($result->{vsphere_address}) && $result->{vsphere_address} ne '') {
507 $self->request_dynamic(result => $result, %options);
508 return ;
509 }
510
511 $result->{container} = lc($result->{container});
512 if (!defined($self->{centreon_vmware_config}->{vsphere_server}->{ $result->{container} })) {
513 centreon::vmware::common::set_response(code => 1, short_message => "Unknown container name '$result->{container}'");
514 centreon::vmware::common::response(token => 'RESPSERVER', endpoint => $frontend, identity => $options{identity});
515 return ;
516 }
517
518 return if ($self->waiting_ready(
519 container => $result->{container}, manager => $options{manager},
520 identity => $options{identity}) == 0);
521
522 $self->{counter_stats}->{ $result->{container} }++;
523
524 my $flag = ZMQ_NOBLOCK | ZMQ_SNDMORE;
525 my $msg = zmq_msg_init_data('server-' . $result->{container});
526 zmq_msg_send($msg, $frontend, $flag);
527 zmq_msg_close($msg);
528 $msg = zmq_msg_init_data('REQCLIENT ' . $options{data});
529 zmq_msg_send($msg, $frontend, ZMQ_NOBLOCK);
530 zmq_msg_close($msg);
531 }
532
533 sub repserver {
534 my ($self, %options) = @_;
535
536 # Decode json
537 my $result;
538 eval {
539 $result = JSON::XS->new->utf8->decode($options{data});
540 };
541 if ($@) {
542 $self->{logger}->writeLogError("Cannot decode JSON: $@ (options{data}");
543 return ;
544 }
545
546 $result->{identity} =~ /^client-(.*)$/;
547 my $identity = 'client-' . pack('H*', $1);
548
549 centreon::vmware::common::response(
550 token => 'RESPSERVER', endpoint => $frontend,
551 identity => $identity, force_response => $options{data}
552 );
553 }
554
555 sub router_event {
556 while (1) {
557 # Process all parts of the message
558 my $msg = zmq_msg_init();
559 zmq_msg_recv($msg, $frontend, ZMQ_DONTWAIT);
560 my $identity = zmq_msg_data($msg);
561 zmq_msg_close($msg);
562
563 $msg = zmq_msg_init();
564 zmq_msg_recv($msg, $frontend, ZMQ_DONTWAIT);
565 my $data = zmq_msg_data($msg);
566 zmq_msg_close($msg);
567
568 centreon::vmware::common::init_response();
569 if ($centreon_vmware->{stop} != 0) {
570 # We quit so we say we're leaving ;)
571 centreon::vmware::common::set_response(code => -1, short_message => 'Daemon is restarting/stopping...');
572 centreon::vmware::common::response(token => 'RESPSERVER', endpoint => $frontend, identity => $identity);
573 } elsif ($data =~ /^REQCLIENT\s+(.*)$/msi) {
574 $centreon_vmware->request(identity => $identity, data => $1);
575 } elsif ($data =~ /^RESPSERVER2\s+(.*)$/msi) {
576 $centreon_vmware->repserver(data => $1);
577 } elsif ($data =~ /^READY/msi) {
578 $identity =~ /server-(.*)/;
579 $centreon_vmware->{centreon_vmware_config}->{vsphere_server}->{$1}->{ready} = 1;
580 }
581
582 centreon::vmware::common::free_response();
583 my $more = zmq_getsockopt($frontend, ZMQ_RCVMORE);
584 last unless $more;
585 }
586 }
587
588 sub check_children {
589 my ($self, %options) = @_;
590
591 my $count = $self->verify_child_vsphere();
592 $self->{logger}->writeLogDebug("$count child(ren) found. Stop ? : " . $self->{stop});
593 if ($self->{stop} == 1) {
594 # No children
595 if ($count == 0) {
596 $self->{logger}->writeLogInfo("Quit main process");
597 zmq_close($frontend);
598 exit(0);
599 }
600 }
601 }
602
603 sub create_vsphere_child {
604 my ($self, %options) = @_;
605
606 $self->{whoaim} = $options{vsphere_name};
607 $self->{centreon_vmware_config}->{vsphere_server}->{$self->{whoaim}}->{running} = 0;
608 $self->{centreon_vmware_config}->{vsphere_server}->{$self->{whoaim}}->{ready} = 0;
609 $self->{logger}->writeLogInfo("Create vsphere sub-process for '" . $options{vsphere_name} . "'");
610
611 my $child_vpshere_pid = fork();
612 if (!defined($child_vpshere_pid)) {
613 $self->{logger}->writeLogError("Cannot fork for '" . $options{vsphere_name} . "': $!");
614 return -1;
615 }
616 if ($child_vpshere_pid == 0) {
617 my $connector = centreon::vmware::connector->new(
618 name => $self->{whoaim},
619 modules_registry => $self->{modules_registry},
620 config => $self->{centreon_vmware_config},
621 logger => $self->{logger},
622 vsan_enabled => $self->{vsan_enabled}
623 );
624 $connector->run();
625 exit(0);
626 }
627 $self->{children_vpshere_pid}->{$child_vpshere_pid} = $self->{whoaim};
628
629 $self->{centreon_vmware_config}->{vsphere_server}->{$self->{whoaim}}->{running} = 1;
630 $self->{centreon_vmware_config}->{vsphere_server}->{$self->{whoaim}}->{dynamic} = $options{dynamic};
631 $self->{centreon_vmware_config}->{vsphere_server}->{$self->{whoaim}}->{pid} = $child_vpshere_pid;
632 }
633
634 sub bind_ipc {
635 my ($self, %options) = @_;
636
637 if (zmq_bind($options{socket}, 'ipc://' . $options{ipc_file}) == -1) {
638 $self->{logger}->writeLogError("Cannot bind ipc '$options{ipc_file}': $!");
639 # try create dir
640 $self->{logger}->writeLogError("Maybe directory does not exist. Attempting to create it!!!");
641 if (!mkdir(dirname($options{ipc_file}))) {
642 zmq_close($options{socket});
643 exit(1);
644 }
645 if (zmq_bind($options{socket}, 'ipc://' . $options{ipc_file}) == -1) {
646 zmq_close($options{socket});
647 exit(1);
648 }
649 }
650 }
651
652 sub run {
653 $centreon_vmware = shift;
654
655 $centreon_vmware->SUPER::run();
656 $centreon_vmware->{logger}->redirect_output();
657
658 $centreon_vmware->{logger}->writeLogDebug("centreon_vmware launched....");
659 $centreon_vmware->{logger}->writeLogDebug("PID: $$");
660
661 my $context = zmq_init();
662 $frontend = zmq_socket($context, ZMQ_ROUTER);
663 if (!defined($frontend)) {
664 $centreon_vmware->{logger}->writeLogFatal("Can't setup server: $!");
665 }
666
667 zmq_setsockopt($frontend, ZMQ_LINGER, 0); # we discard
668 zmq_bind($frontend, 'tcp://' . $centreon_vmware->{centreon_vmware_config}->{bind} . ':' . $centreon_vmware->{centreon_vmware_config}->{port});
669 $centreon_vmware->bind_ipc(socket => $frontend, ipc_file => $centreon_vmware->{centreon_vmware_config}->{ipc_file});
670
671 foreach (keys %{$centreon_vmware->{centreon_vmware_config}->{vsphere_server}}) {
672 $centreon_vmware->{counter_stats}->{$_} = 0;
673 $centreon_vmware->{logger}->writeLogDebug("Creating vSphere child for $_");
674 $centreon_vmware->create_vsphere_child(vsphere_name => $_, dynamic => 0);
675 }
676
677 $centreon_vmware->{logger}->writeLogInfo("[Server accepting clients]");
678
679 # Initialize poll set
680 $centreon_vmware->{poll} = [
681 {
682 socket => $frontend,
683 events => ZMQ_POLLIN,
684 callback => \&router_event
685 }
686 ];
687 $centreon_vmware->{logger}->writeLogDebug("Global loop starting...");
688 # Switch messages between sockets
689 while (1) {
690 $centreon_vmware->check_children();
691 zmq_poll($centreon_vmware->{poll}, 5000);
692 }
693 }
694
695 1;
696
697 __END__
698