1#!/usr/bin/env python 2 3r""" 4See class prolog below for details. 5""" 6 7import os 8import re 9import sys 10import yaml 11import json 12import time 13import logging 14import platform 15from errno import EACCES, EPERM 16import subprocess 17from ssh_utility import SSHRemoteclient 18from telnet_utility import TelnetRemoteclient 19 20 21class FFDCCollector: 22 23 r""" 24 Sends commands from configuration file to the targeted system to collect log files. 25 Fetch and store generated files at the specified location. 26 27 """ 28 29 def __init__(self, 30 hostname, 31 username, 32 password, 33 ffdc_config, 34 location, 35 remote_type, 36 remote_protocol, 37 env_vars, 38 econfig, 39 log_level): 40 r""" 41 Description of argument(s): 42 43 hostname name/ip of the targeted (remote) system 44 username user on the targeted system with access to FFDC files 45 password password for user on targeted system 46 ffdc_config configuration file listing commands and files for FFDC 47 location where to store collected FFDC 48 remote_type os type of the remote host 49 remote_protocol Protocol to use to collect data 50 env_vars User define CLI env vars '{"key : "value"}' 51 econfig User define env vars YAML file 52 53 """ 54 55 self.hostname = hostname 56 self.username = username 57 self.password = password 58 self.ffdc_config = ffdc_config 59 self.location = location + "/" + remote_type.upper() 60 self.ssh_remoteclient = None 61 self.telnet_remoteclient = None 62 self.ffdc_dir_path = "" 63 self.ffdc_prefix = "" 64 self.target_type = remote_type.upper() 65 self.remote_protocol = remote_protocol.upper() 66 self.env_vars = env_vars 67 self.econfig = econfig 68 self.start_time = 0 69 self.elapsed_time = '' 70 self.logger = None 71 72 # Set prefix values for scp files and directory. 73 # Since the time stamp is at second granularity, these values are set here 74 # to be sure that all files for this run will have same timestamps 75 # and they will be saved in the same directory. 76 # self.location == local system for now 77 self.set_ffdc_defaults() 78 79 # Logger for this run. Need to be after set_ffdc_defaults() 80 self.script_logging(getattr(logging, log_level.upper())) 81 82 # Verify top level directory exists for storage 83 self.validate_local_store(self.location) 84 85 if self.verify_script_env(): 86 # Load default or user define YAML configuration file. 87 with open(self.ffdc_config, 'r') as file: 88 self.ffdc_actions = yaml.load(file, Loader=yaml.FullLoader) 89 90 if self.target_type not in self.ffdc_actions.keys(): 91 self.logger.error( 92 "\n\tERROR: %s is not listed in %s.\n\n" % (self.target_type, self.ffdc_config)) 93 sys.exit(-1) 94 else: 95 sys.exit(-1) 96 97 # Load ENV vars from user. 98 self.logger.info("\n\tENV: User define input YAML variables") 99 self.env_dict = {} 100 self. load_env() 101 102 def verify_script_env(self): 103 104 # Import to log version 105 import click 106 import paramiko 107 108 run_env_ok = True 109 110 redfishtool_version = self.run_tool_cmd('redfishtool -V').split(' ')[2].strip('\n') 111 ipmitool_version = self.run_tool_cmd('ipmitool -V').split(' ')[2] 112 113 self.logger.info("\n\t---- Script host environment ----") 114 self.logger.info("\t{:<10} {:<10}".format('Script hostname', os.uname()[1])) 115 self.logger.info("\t{:<10} {:<10}".format('Script host os', platform.platform())) 116 self.logger.info("\t{:<10} {:>10}".format('Python', platform.python_version())) 117 self.logger.info("\t{:<10} {:>10}".format('PyYAML', yaml.__version__)) 118 self.logger.info("\t{:<10} {:>10}".format('click', click.__version__)) 119 self.logger.info("\t{:<10} {:>10}".format('paramiko', paramiko.__version__)) 120 self.logger.info("\t{:<10} {:>9}".format('redfishtool', redfishtool_version)) 121 self.logger.info("\t{:<10} {:>12}".format('ipmitool', ipmitool_version)) 122 123 if eval(yaml.__version__.replace('.', ',')) < (5, 4, 1): 124 self.logger.error("\n\tERROR: Python or python packages do not meet minimum version requirement.") 125 self.logger.error("\tERROR: PyYAML version 5.4.1 or higher is needed.\n") 126 run_env_ok = False 127 128 self.logger.info("\t---- End script host environment ----") 129 return run_env_ok 130 131 def script_logging(self, 132 log_level_attr): 133 r""" 134 Create logger 135 136 """ 137 self.logger = logging.getLogger() 138 self.logger.setLevel(log_level_attr) 139 log_file_handler = logging.FileHandler(self.ffdc_dir_path + "collector.log") 140 141 stdout_handler = logging.StreamHandler(sys.stdout) 142 self.logger.addHandler(log_file_handler) 143 self.logger.addHandler(stdout_handler) 144 145 # Turn off paramiko INFO logging 146 logging.getLogger("paramiko").setLevel(logging.WARNING) 147 148 def target_is_pingable(self): 149 r""" 150 Check if target system is ping-able. 151 152 """ 153 response = os.system("ping -c 1 %s 2>&1 >/dev/null" % self.hostname) 154 if response == 0: 155 self.logger.info("\n\t[Check] %s is ping-able.\t\t [OK]" % self.hostname) 156 return True 157 else: 158 self.logger.error( 159 "\n\tERROR: %s is not ping-able. FFDC collection aborted.\n" % self.hostname) 160 sys.exit(-1) 161 162 def collect_ffdc(self): 163 r""" 164 Initiate FFDC Collection depending on requested protocol. 165 166 """ 167 168 self.logger.info("\n\t---- Start communicating with %s ----" % self.hostname) 169 self.start_time = time.time() 170 171 # Find the list of target and protocol supported. 172 check_protocol_list = [] 173 config_dict = self.ffdc_actions 174 175 for target_type in config_dict.keys(): 176 if self.target_type != target_type: 177 continue 178 179 for k, v in config_dict[target_type].items(): 180 if config_dict[target_type][k]['PROTOCOL'][0] not in check_protocol_list: 181 check_protocol_list.append(config_dict[target_type][k]['PROTOCOL'][0]) 182 183 self.logger.info("\n\t %s protocol type: %s" % (self.target_type, check_protocol_list)) 184 185 verified_working_protocol = self.verify_protocol(check_protocol_list) 186 187 if verified_working_protocol: 188 self.logger.info("\n\t---- Completed protocol pre-requisite check ----\n") 189 190 # Verify top level directory exists for storage 191 self.validate_local_store(self.location) 192 193 if ((self.remote_protocol not in verified_working_protocol) and (self.remote_protocol != 'ALL')): 194 self.logger.info("\n\tWorking protocol list: %s" % verified_working_protocol) 195 self.logger.error( 196 '\tERROR: Requested protocol %s is not in working protocol list.\n' 197 % self.remote_protocol) 198 sys.exit(-1) 199 else: 200 self.generate_ffdc(verified_working_protocol) 201 202 def ssh_to_target_system(self): 203 r""" 204 Open a ssh connection to targeted system. 205 206 """ 207 208 self.ssh_remoteclient = SSHRemoteclient(self.hostname, 209 self.username, 210 self.password) 211 212 if self.ssh_remoteclient.ssh_remoteclient_login(): 213 self.logger.info("\n\t[Check] %s SSH connection established.\t [OK]" % self.hostname) 214 215 # Check scp connection. 216 # If scp connection fails, 217 # continue with FFDC generation but skip scp files to local host. 218 self.ssh_remoteclient.scp_connection() 219 return True 220 else: 221 self.logger.info("\n\t[Check] %s SSH connection.\t [NOT AVAILABLE]" % self.hostname) 222 return False 223 224 def telnet_to_target_system(self): 225 r""" 226 Open a telnet connection to targeted system. 227 """ 228 self.telnet_remoteclient = TelnetRemoteclient(self.hostname, 229 self.username, 230 self.password) 231 if self.telnet_remoteclient.tn_remoteclient_login(): 232 self.logger.info("\n\t[Check] %s Telnet connection established.\t [OK]" % self.hostname) 233 return True 234 else: 235 self.logger.info("\n\t[Check] %s Telnet connection.\t [NOT AVAILABLE]" % self.hostname) 236 return False 237 238 def generate_ffdc(self, working_protocol_list): 239 r""" 240 Determine actions based on remote host type 241 242 Description of argument(s): 243 working_protocol_list list of confirmed working protocols to connect to remote host. 244 """ 245 246 self.logger.info("\n\t---- Executing commands on " + self.hostname + " ----") 247 self.logger.info("\n\tWorking protocol list: %s" % working_protocol_list) 248 249 config_dict = self.ffdc_actions 250 for target_type in config_dict.keys(): 251 if self.target_type != target_type: 252 continue 253 254 self.logger.info("\n\tFFDC Path: %s " % self.ffdc_dir_path) 255 self.logger.info("\tSystem Type: %s" % target_type) 256 for k, v in config_dict[target_type].items(): 257 258 if self.remote_protocol not in working_protocol_list \ 259 and self.remote_protocol != 'ALL': 260 continue 261 262 protocol = config_dict[target_type][k]['PROTOCOL'][0] 263 264 if protocol not in working_protocol_list: 265 continue 266 267 if protocol in working_protocol_list: 268 if protocol == 'SSH' or protocol == 'SCP': 269 self.protocol_ssh(protocol, target_type, k) 270 elif protocol == 'TELNET': 271 self.protocol_telnet(target_type, k) 272 elif protocol == 'REDFISH' or protocol == 'IPMI' or protocol == 'SHELL': 273 self.protocol_execute(protocol, target_type, k) 274 else: 275 self.logger.error("\n\tERROR: %s is not available for %s." % (protocol, self.hostname)) 276 277 # Close network connection after collecting all files 278 self.elapsed_time = time.strftime("%H:%M:%S", time.gmtime(time.time() - self.start_time)) 279 if self.ssh_remoteclient: 280 self.ssh_remoteclient.ssh_remoteclient_disconnect() 281 if self.telnet_remoteclient: 282 self.telnet_remoteclient.tn_remoteclient_disconnect() 283 284 def protocol_ssh(self, 285 protocol, 286 target_type, 287 sub_type): 288 r""" 289 Perform actions using SSH and SCP protocols. 290 291 Description of argument(s): 292 protocol Protocol to execute. 293 target_type OS Type of remote host. 294 sub_type Group type of commands. 295 """ 296 297 if protocol == 'SCP': 298 self.group_copy(self.ffdc_actions[target_type][sub_type]) 299 else: 300 self.collect_and_copy_ffdc(self.ffdc_actions[target_type][sub_type]) 301 302 def protocol_telnet(self, 303 target_type, 304 sub_type): 305 r""" 306 Perform actions using telnet protocol. 307 Description of argument(s): 308 target_type OS Type of remote host. 309 """ 310 self.logger.info("\n\t[Run] Executing commands on %s using %s" % (self.hostname, 'TELNET')) 311 telnet_files_saved = [] 312 progress_counter = 0 313 list_of_commands = self.ffdc_actions[target_type][sub_type]['COMMANDS'] 314 for index, each_cmd in enumerate(list_of_commands, start=0): 315 command_txt, command_timeout = self.unpack_command(each_cmd) 316 result = self.telnet_remoteclient.execute_command(command_txt, command_timeout) 317 if result: 318 try: 319 targ_file = self.ffdc_actions[target_type][sub_type]['FILES'][index] 320 except IndexError: 321 targ_file = command_txt 322 self.logger.warning( 323 "\n\t[WARN] Missing filename to store data from telnet %s." % each_cmd) 324 self.logger.warning("\t[WARN] Data will be stored in %s." % targ_file) 325 targ_file_with_path = (self.ffdc_dir_path 326 + self.ffdc_prefix 327 + targ_file) 328 # Creates a new file 329 with open(targ_file_with_path, 'wb') as fp: 330 fp.write(result) 331 fp.close 332 telnet_files_saved.append(targ_file) 333 progress_counter += 1 334 self.print_progress(progress_counter) 335 self.logger.info("\n\t[Run] Commands execution completed.\t\t [OK]") 336 for file in telnet_files_saved: 337 self.logger.info("\n\t\tSuccessfully save file " + file + ".") 338 339 def protocol_execute(self, 340 protocol, 341 target_type, 342 sub_type): 343 r""" 344 Perform actions for a given protocol. 345 346 Description of argument(s): 347 protocol Protocol to execute. 348 target_type OS Type of remote host. 349 sub_type Group type of commands. 350 """ 351 352 self.logger.info("\n\t[Run] Executing commands to %s using %s" % (self.hostname, protocol)) 353 executed_files_saved = [] 354 progress_counter = 0 355 list_of_cmd = self.get_command_list(self.ffdc_actions[target_type][sub_type]) 356 for index, each_cmd in enumerate(list_of_cmd, start=0): 357 result = self.run_tool_cmd(each_cmd) 358 if result: 359 try: 360 targ_file = self.get_file_list(self.ffdc_actions[target_type][sub_type])[index] 361 except IndexError: 362 targ_file = each_cmd.split('/')[-1] 363 self.logger.warning( 364 "\n\t[WARN] Missing filename to store data from %s." % each_cmd) 365 self.logger.warning("\t[WARN] Data will be stored in %s." % targ_file) 366 367 targ_file_with_path = (self.ffdc_dir_path 368 + self.ffdc_prefix 369 + targ_file) 370 371 # Creates a new file 372 with open(targ_file_with_path, 'w') as fp: 373 fp.write(result) 374 fp.close 375 executed_files_saved.append(targ_file) 376 377 progress_counter += 1 378 self.print_progress(progress_counter) 379 380 self.logger.info("\n\t[Run] Commands execution completed.\t\t [OK]") 381 382 for file in executed_files_saved: 383 self.logger.info("\n\t\tSuccessfully save file " + file + ".") 384 385 def collect_and_copy_ffdc(self, 386 ffdc_actions_for_target_type, 387 form_filename=False): 388 r""" 389 Send commands in ffdc_config file to targeted system. 390 391 Description of argument(s): 392 ffdc_actions_for_target_type commands and files for the selected remote host type. 393 form_filename if true, pre-pend self.target_type to filename 394 """ 395 396 # Executing commands, if any 397 self.ssh_execute_ffdc_commands(ffdc_actions_for_target_type, 398 form_filename) 399 400 # Copying files 401 if self.ssh_remoteclient.scpclient: 402 self.logger.info("\n\n\tCopying FFDC files from remote system %s.\n" % self.hostname) 403 404 # Retrieving files from target system 405 list_of_files = self.get_file_list(ffdc_actions_for_target_type) 406 self.scp_ffdc(self.ffdc_dir_path, self.ffdc_prefix, form_filename, list_of_files) 407 else: 408 self.logger.info("\n\n\tSkip copying FFDC files from remote system %s.\n" % self.hostname) 409 410 def get_command_list(self, 411 ffdc_actions_for_target_type): 412 r""" 413 Fetch list of commands from configuration file 414 415 Description of argument(s): 416 ffdc_actions_for_target_type commands and files for the selected remote host type. 417 """ 418 try: 419 list_of_commands = ffdc_actions_for_target_type['COMMANDS'] 420 except KeyError: 421 list_of_commands = [] 422 return list_of_commands 423 424 def get_file_list(self, 425 ffdc_actions_for_target_type): 426 r""" 427 Fetch list of commands from configuration file 428 429 Description of argument(s): 430 ffdc_actions_for_target_type commands and files for the selected remote host type. 431 """ 432 try: 433 list_of_files = ffdc_actions_for_target_type['FILES'] 434 except KeyError: 435 list_of_files = [] 436 return list_of_files 437 438 def unpack_command(self, 439 command): 440 r""" 441 Unpack command from config file 442 443 Description of argument(s): 444 command Command from config file. 445 """ 446 if isinstance(command, dict): 447 command_txt = next(iter(command)) 448 command_timeout = next(iter(command.values())) 449 elif isinstance(command, str): 450 command_txt = command 451 # Default command timeout 60 seconds 452 command_timeout = 60 453 454 return command_txt, command_timeout 455 456 def ssh_execute_ffdc_commands(self, 457 ffdc_actions_for_target_type, 458 form_filename=False): 459 r""" 460 Send commands in ffdc_config file to targeted system. 461 462 Description of argument(s): 463 ffdc_actions_for_target_type commands and files for the selected remote host type. 464 form_filename if true, pre-pend self.target_type to filename 465 """ 466 self.logger.info("\n\t[Run] Executing commands on %s using %s" 467 % (self.hostname, ffdc_actions_for_target_type['PROTOCOL'][0])) 468 469 list_of_commands = self.get_command_list(ffdc_actions_for_target_type) 470 # If command list is empty, returns 471 if not list_of_commands: 472 return 473 474 progress_counter = 0 475 for command in list_of_commands: 476 command_txt, command_timeout = self.unpack_command(command) 477 478 if form_filename: 479 command_txt = str(command_txt % self.target_type) 480 481 cmd_exit_code, err, response = \ 482 self.ssh_remoteclient.execute_command(command_txt, command_timeout) 483 484 if cmd_exit_code: 485 self.logger.warning( 486 "\n\t\t[WARN] %s exits with code %s." % (command_txt, str(cmd_exit_code))) 487 self.logger.warning("\t\t[WARN] %s " % err) 488 489 progress_counter += 1 490 self.print_progress(progress_counter) 491 492 self.logger.info("\n\t[Run] Commands execution completed.\t\t [OK]") 493 494 def group_copy(self, 495 ffdc_actions_for_target_type): 496 r""" 497 scp group of files (wild card) from remote host. 498 499 Description of argument(s): 500 fdc_actions_for_target_type commands and files for the selected remote host type. 501 """ 502 503 if self.ssh_remoteclient.scpclient: 504 self.logger.info("\n\tCopying files from remote system %s via SCP.\n" % self.hostname) 505 506 list_of_commands = self.get_command_list(ffdc_actions_for_target_type) 507 # If command list is empty, returns 508 if not list_of_commands: 509 return 510 511 for command in list_of_commands: 512 try: 513 filename = command.split('ls -AX')[1] 514 except IndexError: 515 self.logger.info("\t\tInvalid command %s" % command) 516 continue 517 518 cmd_exit_code, err, response = \ 519 self.ssh_remoteclient.execute_command(command) 520 521 # If file does not exist, code take no action. 522 # cmd_exit_code is ignored for this scenario. 523 if response: 524 scp_result = self.ssh_remoteclient.scp_file_from_remote(filename, self.ffdc_dir_path) 525 if scp_result: 526 self.logger.info("\t\tSuccessfully copied from " + self.hostname + ':' + filename) 527 else: 528 self.logger.info("\t\tThere is no " + filename) 529 530 else: 531 self.logger.info("\n\n\tSkip copying files from remote system %s.\n" % self.hostname) 532 533 def scp_ffdc(self, 534 targ_dir_path, 535 targ_file_prefix, 536 form_filename, 537 file_list=None, 538 quiet=None): 539 r""" 540 SCP all files in file_dict to the indicated directory on the local system. 541 542 Description of argument(s): 543 targ_dir_path The path of the directory to receive the files. 544 targ_file_prefix Prefix which will be pre-pended to each 545 target file's name. 546 file_dict A dictionary of files to scp from targeted system to this system 547 548 """ 549 550 progress_counter = 0 551 for filename in file_list: 552 if form_filename: 553 filename = str(filename % self.target_type) 554 source_file_path = filename 555 targ_file_path = targ_dir_path + targ_file_prefix + filename.split('/')[-1] 556 557 # If source file name contains wild card, copy filename as is. 558 if '*' in source_file_path: 559 scp_result = self.ssh_remoteclient.scp_file_from_remote(source_file_path, self.ffdc_dir_path) 560 else: 561 scp_result = self.ssh_remoteclient.scp_file_from_remote(source_file_path, targ_file_path) 562 563 if not quiet: 564 if scp_result: 565 self.logger.info( 566 "\t\tSuccessfully copied from " + self.hostname + ':' + source_file_path + ".\n") 567 else: 568 self.logger.info( 569 "\t\tFail to copy from " + self.hostname + ':' + source_file_path + ".\n") 570 else: 571 progress_counter += 1 572 self.print_progress(progress_counter) 573 574 def set_ffdc_defaults(self): 575 r""" 576 Set a default value for self.ffdc_dir_path and self.ffdc_prefix. 577 Collected ffdc file will be stored in dir /self.location/hostname_timestr/. 578 Individual ffdc file will have timestr_filename. 579 580 Description of class variables: 581 self.ffdc_dir_path The dir path where collected ffdc data files should be put. 582 583 self.ffdc_prefix The prefix to be given to each ffdc file name. 584 585 """ 586 587 timestr = time.strftime("%Y%m%d-%H%M%S") 588 self.ffdc_dir_path = self.location + "/" + self.hostname + "_" + timestr + "/" 589 self.ffdc_prefix = timestr + "_" 590 self.validate_local_store(self.ffdc_dir_path) 591 592 def validate_local_store(self, dir_path): 593 r""" 594 Ensure path exists to store FFDC files locally. 595 596 Description of variable: 597 dir_path The dir path where collected ffdc data files will be stored. 598 599 """ 600 601 if not os.path.exists(dir_path): 602 try: 603 os.makedirs(dir_path, 0o755) 604 except (IOError, OSError) as e: 605 # PermissionError 606 if e.errno == EPERM or e.errno == EACCES: 607 self.logger.error( 608 '\tERROR: os.makedirs %s failed with PermissionError.\n' % dir_path) 609 else: 610 self.logger.error( 611 '\tERROR: os.makedirs %s failed with %s.\n' % (dir_path, e.strerror)) 612 sys.exit(-1) 613 614 def print_progress(self, progress): 615 r""" 616 Print activity progress + 617 618 Description of variable: 619 progress Progress counter. 620 621 """ 622 623 sys.stdout.write("\r\t" + "+" * progress) 624 sys.stdout.flush() 625 time.sleep(.1) 626 627 def verify_redfish(self): 628 r""" 629 Verify remote host has redfish service active 630 631 """ 632 redfish_parm = 'redfishtool -r ' \ 633 + self.hostname + ' -S Always raw GET /redfish/v1/' 634 return(self.run_tool_cmd(redfish_parm, True)) 635 636 def verify_ipmi(self): 637 r""" 638 Verify remote host has IPMI LAN service active 639 640 """ 641 if self.target_type == 'OPENBMC': 642 ipmi_parm = 'ipmitool -I lanplus -C 17 -U ' + self.username + ' -P ' \ 643 + self.password + ' -H ' + self.hostname + ' power status' 644 else: 645 ipmi_parm = 'ipmitool -I lanplus -P ' \ 646 + self.password + ' -H ' + self.hostname + ' power status' 647 648 return(self.run_tool_cmd(ipmi_parm, True)) 649 650 def run_tool_cmd(self, 651 parms_string, 652 quiet=False): 653 r""" 654 Run CLI standard tool or scripts. 655 656 Description of variable: 657 parms_string tool command options. 658 quiet do not print tool error message if True 659 """ 660 661 result = subprocess.run([parms_string], 662 stdout=subprocess.PIPE, 663 stderr=subprocess.PIPE, 664 shell=True, 665 universal_newlines=True) 666 667 if result.stderr and not quiet: 668 self.logger.error('\n\t\tERROR with %s ' % parms_string) 669 self.logger.error('\t\t' + result.stderr) 670 671 return result.stdout 672 673 def verify_protocol(self, protocol_list): 674 r""" 675 Perform protocol working check. 676 677 Description of argument(s): 678 protocol_list List of protocol. 679 """ 680 681 tmp_list = [] 682 if self.target_is_pingable(): 683 tmp_list.append("SHELL") 684 685 for protocol in protocol_list: 686 if self.remote_protocol != 'ALL': 687 if self.remote_protocol != protocol: 688 continue 689 690 # Only check SSH/SCP once for both protocols 691 if protocol == 'SSH' or protocol == 'SCP' and protocol not in tmp_list: 692 if self.ssh_to_target_system(): 693 # Add only what user asked. 694 if self.remote_protocol != 'ALL': 695 tmp_list.append(self.remote_protocol) 696 else: 697 tmp_list.append('SSH') 698 tmp_list.append('SCP') 699 700 if protocol == 'TELNET': 701 if self.telnet_to_target_system(): 702 tmp_list.append(protocol) 703 704 if protocol == 'REDFISH': 705 if self.verify_redfish(): 706 tmp_list.append(protocol) 707 self.logger.info("\n\t[Check] %s Redfish Service.\t\t [OK]" % self.hostname) 708 else: 709 self.logger.info("\n\t[Check] %s Redfish Service.\t\t [NOT AVAILABLE]" % self.hostname) 710 711 if protocol == 'IPMI': 712 if self.verify_ipmi(): 713 tmp_list.append(protocol) 714 self.logger.info("\n\t[Check] %s IPMI LAN Service.\t\t [OK]" % self.hostname) 715 else: 716 self.logger.info("\n\t[Check] %s IPMI LAN Service.\t\t [NOT AVAILABLE]" % self.hostname) 717 718 return tmp_list 719 720 def load_env(self): 721 r""" 722 Perform protocol working check. 723 724 """ 725 # This is for the env vars a user can use in YAML to load it at runtime. 726 # Example YAML: 727 # -COMMANDS: 728 # - my_command ${hostname} ${username} ${password} 729 os.environ['hostname'] = self.hostname 730 os.environ['username'] = self.username 731 os.environ['password'] = self.password 732 733 # Append default Env. 734 self.env_dict['hostname'] = self.hostname 735 self.env_dict['username'] = self.username 736 self.env_dict['password'] = self.password 737 738 try: 739 tmp_env_dict = {} 740 if self.env_vars: 741 tmp_env_dict = json.loads(self.env_vars) 742 # Export ENV vars default. 743 for key, value in tmp_env_dict.items(): 744 os.environ[key] = value 745 self.env_dict[key] = str(value) 746 747 if self.econfig: 748 with open(self.econfig, 'r') as file: 749 tmp_env_dict = yaml.load(file, Loader=yaml.FullLoader) 750 # Export ENV vars. 751 for key, value in tmp_env_dict['env_params'].items(): 752 os.environ[key] = str(value) 753 self.env_dict[key] = str(value) 754 except json.decoder.JSONDecodeError as e: 755 self.logger.error("\n\tERROR: %s " % e) 756 sys.exit(-1) 757 758 # This to mask the password from displaying on the console. 759 mask_dict = self.env_dict.copy() 760 for k, v in mask_dict.items(): 761 if k.lower().find("password") != -1: 762 hidden_text = [] 763 hidden_text.append(v) 764 password_regex = '(' +\ 765 '|'.join([re.escape(x) for x in hidden_text]) + ')' 766 mask_dict[k] = re.sub(password_regex, "********", v) 767 768 self.logger.info(json.dumps(mask_dict, indent=8, sort_keys=False)) 769