1#!/usr/bin/env python3 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 17 18script_dir = os.path.dirname(os.path.abspath(__file__)) 19sys.path.append(script_dir) 20# Walk path and append to sys.path 21for root, dirs, files in os.walk(script_dir): 22 for dir in dirs: 23 sys.path.append(os.path.join(root, dir)) 24 25from ssh_utility import SSHRemoteclient 26from telnet_utility import TelnetRemoteclient 27 28r""" 29User define plugins python functions. 30 31It will imports files from directory plugins 32 33plugins 34├── file1.py 35└── file2.py 36 37Example how to define in YAML: 38 - plugin: 39 - plugin_name: plugin.foo_func.foo_func_yaml 40 - plugin_args: 41 - arg1 42 - arg2 43""" 44plugin_dir = __file__.split(__file__.split("/")[-1])[0] + '/plugins' 45sys.path.append(plugin_dir) 46try: 47 for module in os.listdir(plugin_dir): 48 if module == '__init__.py' or module[-3:] != '.py': 49 continue 50 plugin_module = "plugins." + module[:-3] 51 # To access the module plugin.<module name>.<function> 52 # Example: plugin.foo_func.foo_func_yaml() 53 try: 54 plugin = __import__(plugin_module, globals(), locals(), [], 0) 55 except Exception as e: 56 print("PLUGIN: Module import failed: %s" % module) 57 pass 58except FileNotFoundError as e: 59 print("PLUGIN: %s" % e) 60 pass 61 62r""" 63This is for plugin functions returning data or responses to the caller 64in YAML plugin setup. 65 66Example: 67 68 - plugin: 69 - plugin_name: version = plugin.ssh_execution.ssh_execute_cmd 70 - plugin_args: 71 - ${hostname} 72 - ${username} 73 - ${password} 74 - "cat /etc/os-release | grep VERSION_ID | awk -F'=' '{print $2}'" 75 - plugin: 76 - plugin_name: plugin.print_vars.print_vars 77 - plugin_args: 78 - version 79 80where first plugin "version" var is used by another plugin in the YAML 81block or plugin 82 83""" 84global global_log_store_path 85global global_plugin_dict 86global global_plugin_list 87 88# Hold the plugin return values in dict and plugin return vars in list. 89# Dict is to reference and update vars processing in parser where as 90# list is for current vars from the plugin block which needs processing. 91global_plugin_dict = {} 92global_plugin_list = [] 93 94# Hold the plugin return named declared if function returned values are list,dict. 95# Refer this name list to look up the plugin dict for eval() args function 96# Example ['version'] 97global_plugin_type_list = [] 98 99# Path where logs are to be stored or written. 100global_log_store_path = '' 101 102# Plugin error state defaults. 103plugin_error_dict = { 104 'exit_on_error': False, 105 'continue_on_error': False, 106} 107 108 109class ffdc_collector: 110 111 r""" 112 Execute commands from configuration file to collect log files. 113 Fetch and store generated files at the specified location. 114 115 """ 116 117 def __init__(self, 118 hostname, 119 username, 120 password, 121 ffdc_config, 122 location, 123 remote_type, 124 remote_protocol, 125 env_vars, 126 econfig, 127 log_level): 128 r""" 129 Description of argument(s): 130 131 hostname name/ip of the targeted (remote) system 132 username user on the targeted system with access to FFDC files 133 password password for user on targeted system 134 ffdc_config configuration file listing commands and files for FFDC 135 location where to store collected FFDC 136 remote_type os type of the remote host 137 remote_protocol Protocol to use to collect data 138 env_vars User define CLI env vars '{"key : "value"}' 139 econfig User define env vars YAML file 140 141 """ 142 143 self.hostname = hostname 144 self.username = username 145 self.password = password 146 self.ffdc_config = ffdc_config 147 self.location = location + "/" + remote_type.upper() 148 self.ssh_remoteclient = None 149 self.telnet_remoteclient = None 150 self.ffdc_dir_path = "" 151 self.ffdc_prefix = "" 152 self.target_type = remote_type.upper() 153 self.remote_protocol = remote_protocol.upper() 154 self.env_vars = env_vars 155 self.econfig = econfig 156 self.start_time = 0 157 self.elapsed_time = '' 158 self.logger = None 159 160 # Set prefix values for scp files and directory. 161 # Since the time stamp is at second granularity, these values are set here 162 # to be sure that all files for this run will have same timestamps 163 # and they will be saved in the same directory. 164 # self.location == local system for now 165 self.set_ffdc_default_store_path() 166 167 # Logger for this run. Need to be after set_ffdc_default_store_path() 168 self.script_logging(getattr(logging, log_level.upper())) 169 170 # Verify top level directory exists for storage 171 self.validate_local_store(self.location) 172 173 if self.verify_script_env(): 174 # Load default or user define YAML configuration file. 175 with open(self.ffdc_config, 'r') as file: 176 try: 177 self.ffdc_actions = yaml.load(file, Loader=yaml.SafeLoader) 178 except yaml.YAMLError as e: 179 self.logger.error(e) 180 sys.exit(-1) 181 182 if self.target_type not in self.ffdc_actions.keys(): 183 self.logger.error( 184 "\n\tERROR: %s is not listed in %s.\n\n" % (self.target_type, self.ffdc_config)) 185 sys.exit(-1) 186 else: 187 sys.exit(-1) 188 189 # Load ENV vars from user. 190 self.logger.info("\n\tENV: User define input YAML variables") 191 self.env_dict = {} 192 self.load_env() 193 194 def verify_script_env(self): 195 196 # Import to log version 197 import click 198 import paramiko 199 200 run_env_ok = True 201 202 redfishtool_version = self.run_tool_cmd('redfishtool -V').split(' ')[2].strip('\n') 203 ipmitool_version = self.run_tool_cmd('ipmitool -V').split(' ')[2] 204 205 self.logger.info("\n\t---- Script host environment ----") 206 self.logger.info("\t{:<10} {:<10}".format('Script hostname', os.uname()[1])) 207 self.logger.info("\t{:<10} {:<10}".format('Script host os', platform.platform())) 208 self.logger.info("\t{:<10} {:>10}".format('Python', platform.python_version())) 209 self.logger.info("\t{:<10} {:>10}".format('PyYAML', yaml.__version__)) 210 self.logger.info("\t{:<10} {:>10}".format('click', click.__version__)) 211 self.logger.info("\t{:<10} {:>10}".format('paramiko', paramiko.__version__)) 212 self.logger.info("\t{:<10} {:>9}".format('redfishtool', redfishtool_version)) 213 self.logger.info("\t{:<10} {:>12}".format('ipmitool', ipmitool_version)) 214 215 if eval(yaml.__version__.replace('.', ',')) < (5, 3, 0): 216 self.logger.error("\n\tERROR: Python or python packages do not meet minimum version requirement.") 217 self.logger.error("\tERROR: PyYAML version 5.3.0 or higher is needed.\n") 218 run_env_ok = False 219 220 self.logger.info("\t---- End script host environment ----") 221 return run_env_ok 222 223 def script_logging(self, 224 log_level_attr): 225 r""" 226 Create logger 227 228 """ 229 self.logger = logging.getLogger() 230 self.logger.setLevel(log_level_attr) 231 log_file_handler = logging.FileHandler(self.ffdc_dir_path + "collector.log") 232 233 stdout_handler = logging.StreamHandler(sys.stdout) 234 self.logger.addHandler(log_file_handler) 235 self.logger.addHandler(stdout_handler) 236 237 # Turn off paramiko INFO logging 238 logging.getLogger("paramiko").setLevel(logging.WARNING) 239 240 def target_is_pingable(self): 241 r""" 242 Check if target system is ping-able. 243 244 """ 245 response = os.system("ping -c 1 %s 2>&1 >/dev/null" % self.hostname) 246 if response == 0: 247 self.logger.info("\n\t[Check] %s is ping-able.\t\t [OK]" % self.hostname) 248 return True 249 else: 250 self.logger.error( 251 "\n\tERROR: %s is not ping-able. FFDC collection aborted.\n" % self.hostname) 252 sys.exit(-1) 253 254 def collect_ffdc(self): 255 r""" 256 Initiate FFDC Collection depending on requested protocol. 257 258 """ 259 260 self.logger.info("\n\t---- Start communicating with %s ----" % self.hostname) 261 self.start_time = time.time() 262 263 # Find the list of target and protocol supported. 264 check_protocol_list = [] 265 config_dict = self.ffdc_actions 266 267 for target_type in config_dict.keys(): 268 if self.target_type != target_type: 269 continue 270 271 for k, v in config_dict[target_type].items(): 272 if config_dict[target_type][k]['PROTOCOL'][0] not in check_protocol_list: 273 check_protocol_list.append(config_dict[target_type][k]['PROTOCOL'][0]) 274 275 self.logger.info("\n\t %s protocol type: %s" % (self.target_type, check_protocol_list)) 276 277 verified_working_protocol = self.verify_protocol(check_protocol_list) 278 279 if verified_working_protocol: 280 self.logger.info("\n\t---- Completed protocol pre-requisite check ----\n") 281 282 # Verify top level directory exists for storage 283 self.validate_local_store(self.location) 284 285 if ((self.remote_protocol not in verified_working_protocol) and (self.remote_protocol != 'ALL')): 286 self.logger.info("\n\tWorking protocol list: %s" % verified_working_protocol) 287 self.logger.error( 288 '\tERROR: Requested protocol %s is not in working protocol list.\n' 289 % self.remote_protocol) 290 sys.exit(-1) 291 else: 292 self.generate_ffdc(verified_working_protocol) 293 294 def ssh_to_target_system(self): 295 r""" 296 Open a ssh connection to targeted system. 297 298 """ 299 300 self.ssh_remoteclient = SSHRemoteclient(self.hostname, 301 self.username, 302 self.password) 303 304 if self.ssh_remoteclient.ssh_remoteclient_login(): 305 self.logger.info("\n\t[Check] %s SSH connection established.\t [OK]" % self.hostname) 306 307 # Check scp connection. 308 # If scp connection fails, 309 # continue with FFDC generation but skip scp files to local host. 310 self.ssh_remoteclient.scp_connection() 311 return True 312 else: 313 self.logger.info("\n\t[Check] %s SSH connection.\t [NOT AVAILABLE]" % self.hostname) 314 return False 315 316 def telnet_to_target_system(self): 317 r""" 318 Open a telnet connection to targeted system. 319 """ 320 self.telnet_remoteclient = TelnetRemoteclient(self.hostname, 321 self.username, 322 self.password) 323 if self.telnet_remoteclient.tn_remoteclient_login(): 324 self.logger.info("\n\t[Check] %s Telnet connection established.\t [OK]" % self.hostname) 325 return True 326 else: 327 self.logger.info("\n\t[Check] %s Telnet connection.\t [NOT AVAILABLE]" % self.hostname) 328 return False 329 330 def generate_ffdc(self, working_protocol_list): 331 r""" 332 Determine actions based on remote host type 333 334 Description of argument(s): 335 working_protocol_list list of confirmed working protocols to connect to remote host. 336 """ 337 338 self.logger.info("\n\t---- Executing commands on " + self.hostname + " ----") 339 self.logger.info("\n\tWorking protocol list: %s" % working_protocol_list) 340 341 config_dict = self.ffdc_actions 342 for target_type in config_dict.keys(): 343 if self.target_type != target_type: 344 continue 345 346 self.logger.info("\n\tFFDC Path: %s " % self.ffdc_dir_path) 347 global_plugin_dict['global_log_store_path'] = self.ffdc_dir_path 348 self.logger.info("\tSystem Type: %s" % target_type) 349 for k, v in config_dict[target_type].items(): 350 351 if self.remote_protocol not in working_protocol_list \ 352 and self.remote_protocol != 'ALL': 353 continue 354 355 protocol = config_dict[target_type][k]['PROTOCOL'][0] 356 357 if protocol not in working_protocol_list: 358 continue 359 360 if protocol in working_protocol_list: 361 if protocol == 'SSH' or protocol == 'SCP': 362 self.protocol_ssh(protocol, target_type, k) 363 elif protocol == 'TELNET': 364 self.protocol_telnet(target_type, k) 365 elif protocol == 'REDFISH' or protocol == 'IPMI' or protocol == 'SHELL': 366 self.protocol_execute(protocol, target_type, k) 367 else: 368 self.logger.error("\n\tERROR: %s is not available for %s." % (protocol, self.hostname)) 369 370 # Close network connection after collecting all files 371 self.elapsed_time = time.strftime("%H:%M:%S", time.gmtime(time.time() - self.start_time)) 372 if self.ssh_remoteclient: 373 self.ssh_remoteclient.ssh_remoteclient_disconnect() 374 if self.telnet_remoteclient: 375 self.telnet_remoteclient.tn_remoteclient_disconnect() 376 377 def protocol_ssh(self, 378 protocol, 379 target_type, 380 sub_type): 381 r""" 382 Perform actions using SSH and SCP protocols. 383 384 Description of argument(s): 385 protocol Protocol to execute. 386 target_type OS Type of remote host. 387 sub_type Group type of commands. 388 """ 389 390 if protocol == 'SCP': 391 self.group_copy(self.ffdc_actions[target_type][sub_type]) 392 else: 393 self.collect_and_copy_ffdc(self.ffdc_actions[target_type][sub_type]) 394 395 def protocol_telnet(self, 396 target_type, 397 sub_type): 398 r""" 399 Perform actions using telnet protocol. 400 Description of argument(s): 401 target_type OS Type of remote host. 402 """ 403 self.logger.info("\n\t[Run] Executing commands on %s using %s" % (self.hostname, 'TELNET')) 404 telnet_files_saved = [] 405 progress_counter = 0 406 list_of_commands = self.ffdc_actions[target_type][sub_type]['COMMANDS'] 407 for index, each_cmd in enumerate(list_of_commands, start=0): 408 command_txt, command_timeout = self.unpack_command(each_cmd) 409 result = self.telnet_remoteclient.execute_command(command_txt, command_timeout) 410 if result: 411 try: 412 targ_file = self.ffdc_actions[target_type][sub_type]['FILES'][index] 413 except IndexError: 414 targ_file = command_txt 415 self.logger.warning( 416 "\n\t[WARN] Missing filename to store data from telnet %s." % each_cmd) 417 self.logger.warning("\t[WARN] Data will be stored in %s." % targ_file) 418 targ_file_with_path = (self.ffdc_dir_path 419 + self.ffdc_prefix 420 + targ_file) 421 # Creates a new file 422 with open(targ_file_with_path, 'w') as fp: 423 fp.write(result) 424 fp.close 425 telnet_files_saved.append(targ_file) 426 progress_counter += 1 427 self.print_progress(progress_counter) 428 self.logger.info("\n\t[Run] Commands execution completed.\t\t [OK]") 429 for file in telnet_files_saved: 430 self.logger.info("\n\t\tSuccessfully save file " + file + ".") 431 432 def protocol_execute(self, 433 protocol, 434 target_type, 435 sub_type): 436 r""" 437 Perform actions for a given protocol. 438 439 Description of argument(s): 440 protocol Protocol to execute. 441 target_type OS Type of remote host. 442 sub_type Group type of commands. 443 """ 444 445 self.logger.info("\n\t[Run] Executing commands to %s using %s" % (self.hostname, protocol)) 446 executed_files_saved = [] 447 progress_counter = 0 448 list_of_cmd = self.get_command_list(self.ffdc_actions[target_type][sub_type]) 449 for index, each_cmd in enumerate(list_of_cmd, start=0): 450 plugin_call = False 451 if isinstance(each_cmd, dict): 452 if 'plugin' in each_cmd: 453 # If the error is set and plugin explicitly 454 # requested to skip execution on error.. 455 if plugin_error_dict['exit_on_error'] and \ 456 self.plugin_error_check(each_cmd['plugin']): 457 self.logger.info("\n\t[PLUGIN-ERROR] exit_on_error: %s" % 458 plugin_error_dict['exit_on_error']) 459 self.logger.info("\t[PLUGIN-SKIP] %s" % 460 each_cmd['plugin'][0]) 461 continue 462 plugin_call = True 463 # call the plugin 464 self.logger.info("\n\t[PLUGIN-START]") 465 result = self.execute_plugin_block(each_cmd['plugin']) 466 self.logger.info("\t[PLUGIN-END]\n") 467 else: 468 each_cmd = self.yaml_env_and_plugin_vars_populate(each_cmd) 469 470 if not plugin_call: 471 result = self.run_tool_cmd(each_cmd) 472 if result: 473 try: 474 file_name = self.get_file_list(self.ffdc_actions[target_type][sub_type])[index] 475 # If file is specified as None. 476 if file_name == "None": 477 continue 478 targ_file = self.yaml_env_and_plugin_vars_populate(file_name) 479 except IndexError: 480 targ_file = each_cmd.split('/')[-1] 481 self.logger.warning( 482 "\n\t[WARN] Missing filename to store data from %s." % each_cmd) 483 self.logger.warning("\t[WARN] Data will be stored in %s." % targ_file) 484 485 targ_file_with_path = (self.ffdc_dir_path 486 + self.ffdc_prefix 487 + targ_file) 488 489 # Creates a new file 490 with open(targ_file_with_path, 'w') as fp: 491 if isinstance(result, dict): 492 fp.write(json.dumps(result)) 493 else: 494 fp.write(result) 495 fp.close 496 executed_files_saved.append(targ_file) 497 498 progress_counter += 1 499 self.print_progress(progress_counter) 500 501 self.logger.info("\n\t[Run] Commands execution completed.\t\t [OK]") 502 503 for file in executed_files_saved: 504 self.logger.info("\n\t\tSuccessfully save file " + file + ".") 505 506 def collect_and_copy_ffdc(self, 507 ffdc_actions_for_target_type, 508 form_filename=False): 509 r""" 510 Send commands in ffdc_config file to targeted system. 511 512 Description of argument(s): 513 ffdc_actions_for_target_type commands and files for the selected remote host type. 514 form_filename if true, pre-pend self.target_type to filename 515 """ 516 517 # Executing commands, if any 518 self.ssh_execute_ffdc_commands(ffdc_actions_for_target_type, 519 form_filename) 520 521 # Copying files 522 if self.ssh_remoteclient.scpclient: 523 self.logger.info("\n\n\tCopying FFDC files from remote system %s.\n" % self.hostname) 524 525 # Retrieving files from target system 526 list_of_files = self.get_file_list(ffdc_actions_for_target_type) 527 self.scp_ffdc(self.ffdc_dir_path, self.ffdc_prefix, form_filename, list_of_files) 528 else: 529 self.logger.info("\n\n\tSkip copying FFDC files from remote system %s.\n" % self.hostname) 530 531 def get_command_list(self, 532 ffdc_actions_for_target_type): 533 r""" 534 Fetch list of commands from configuration file 535 536 Description of argument(s): 537 ffdc_actions_for_target_type commands and files for the selected remote host type. 538 """ 539 try: 540 list_of_commands = ffdc_actions_for_target_type['COMMANDS'] 541 except KeyError: 542 list_of_commands = [] 543 return list_of_commands 544 545 def get_file_list(self, 546 ffdc_actions_for_target_type): 547 r""" 548 Fetch list of commands from configuration file 549 550 Description of argument(s): 551 ffdc_actions_for_target_type commands and files for the selected remote host type. 552 """ 553 try: 554 list_of_files = ffdc_actions_for_target_type['FILES'] 555 except KeyError: 556 list_of_files = [] 557 return list_of_files 558 559 def unpack_command(self, 560 command): 561 r""" 562 Unpack command from config file 563 564 Description of argument(s): 565 command Command from config file. 566 """ 567 if isinstance(command, dict): 568 command_txt = next(iter(command)) 569 command_timeout = next(iter(command.values())) 570 elif isinstance(command, str): 571 command_txt = command 572 # Default command timeout 60 seconds 573 command_timeout = 60 574 575 return command_txt, command_timeout 576 577 def ssh_execute_ffdc_commands(self, 578 ffdc_actions_for_target_type, 579 form_filename=False): 580 r""" 581 Send commands in ffdc_config file to targeted system. 582 583 Description of argument(s): 584 ffdc_actions_for_target_type commands and files for the selected remote host type. 585 form_filename if true, pre-pend self.target_type to filename 586 """ 587 self.logger.info("\n\t[Run] Executing commands on %s using %s" 588 % (self.hostname, ffdc_actions_for_target_type['PROTOCOL'][0])) 589 590 list_of_commands = self.get_command_list(ffdc_actions_for_target_type) 591 # If command list is empty, returns 592 if not list_of_commands: 593 return 594 595 progress_counter = 0 596 for command in list_of_commands: 597 command_txt, command_timeout = self.unpack_command(command) 598 599 if form_filename: 600 command_txt = str(command_txt % self.target_type) 601 602 cmd_exit_code, err, response = \ 603 self.ssh_remoteclient.execute_command(command_txt, command_timeout) 604 605 if cmd_exit_code: 606 self.logger.warning( 607 "\n\t\t[WARN] %s exits with code %s." % (command_txt, str(cmd_exit_code))) 608 self.logger.warning("\t\t[WARN] %s " % err) 609 610 progress_counter += 1 611 self.print_progress(progress_counter) 612 613 self.logger.info("\n\t[Run] Commands execution completed.\t\t [OK]") 614 615 def group_copy(self, 616 ffdc_actions_for_target_type): 617 r""" 618 scp group of files (wild card) from remote host. 619 620 Description of argument(s): 621 fdc_actions_for_target_type commands and files for the selected remote host type. 622 """ 623 624 if self.ssh_remoteclient.scpclient: 625 self.logger.info("\n\tCopying files from remote system %s via SCP.\n" % self.hostname) 626 627 list_of_commands = self.get_command_list(ffdc_actions_for_target_type) 628 # If command list is empty, returns 629 if not list_of_commands: 630 return 631 632 for command in list_of_commands: 633 try: 634 command = self.yaml_env_and_plugin_vars_populate(command) 635 except IndexError: 636 self.logger.error("\t\tInvalid command %s" % command) 637 continue 638 639 cmd_exit_code, err, response = \ 640 self.ssh_remoteclient.execute_command(command) 641 642 # If file does not exist, code take no action. 643 # cmd_exit_code is ignored for this scenario. 644 if response: 645 scp_result = \ 646 self.ssh_remoteclient.scp_file_from_remote(response.split('\n'), 647 self.ffdc_dir_path) 648 if scp_result: 649 self.logger.info("\t\tSuccessfully copied from " + self.hostname + ':' + command) 650 else: 651 self.logger.info("\t\t%s has no result" % command) 652 653 else: 654 self.logger.info("\n\n\tSkip copying files from remote system %s.\n" % self.hostname) 655 656 def scp_ffdc(self, 657 targ_dir_path, 658 targ_file_prefix, 659 form_filename, 660 file_list=None, 661 quiet=None): 662 r""" 663 SCP all files in file_dict to the indicated directory on the local system. 664 665 Description of argument(s): 666 targ_dir_path The path of the directory to receive the files. 667 targ_file_prefix Prefix which will be pre-pended to each 668 target file's name. 669 file_dict A dictionary of files to scp from targeted system to this system 670 671 """ 672 673 progress_counter = 0 674 for filename in file_list: 675 if form_filename: 676 filename = str(filename % self.target_type) 677 source_file_path = filename 678 targ_file_path = targ_dir_path + targ_file_prefix + filename.split('/')[-1] 679 680 # If source file name contains wild card, copy filename as is. 681 if '*' in source_file_path: 682 scp_result = self.ssh_remoteclient.scp_file_from_remote(source_file_path, self.ffdc_dir_path) 683 else: 684 scp_result = self.ssh_remoteclient.scp_file_from_remote(source_file_path, targ_file_path) 685 686 if not quiet: 687 if scp_result: 688 self.logger.info( 689 "\t\tSuccessfully copied from " + self.hostname + ':' + source_file_path + ".\n") 690 else: 691 self.logger.info( 692 "\t\tFail to copy from " + self.hostname + ':' + source_file_path + ".\n") 693 else: 694 progress_counter += 1 695 self.print_progress(progress_counter) 696 697 def set_ffdc_default_store_path(self): 698 r""" 699 Set a default value for self.ffdc_dir_path and self.ffdc_prefix. 700 Collected ffdc file will be stored in dir /self.location/hostname_timestr/. 701 Individual ffdc file will have timestr_filename. 702 703 Description of class variables: 704 self.ffdc_dir_path The dir path where collected ffdc data files should be put. 705 706 self.ffdc_prefix The prefix to be given to each ffdc file name. 707 708 """ 709 710 timestr = time.strftime("%Y%m%d-%H%M%S") 711 self.ffdc_dir_path = self.location + "/" + self.hostname + "_" + timestr + "/" 712 self.ffdc_prefix = timestr + "_" 713 self.validate_local_store(self.ffdc_dir_path) 714 715 # Need to verify local store path exists prior to instantiate this class. 716 # This class method is used to share the same code between CLI input parm 717 # and Robot Framework "${EXECDIR}/logs" before referencing this class. 718 @classmethod 719 def validate_local_store(cls, dir_path): 720 r""" 721 Ensure path exists to store FFDC files locally. 722 723 Description of variable: 724 dir_path The dir path where collected ffdc data files will be stored. 725 726 """ 727 728 if not os.path.exists(dir_path): 729 try: 730 os.makedirs(dir_path, 0o755) 731 except (IOError, OSError) as e: 732 # PermissionError 733 if e.errno == EPERM or e.errno == EACCES: 734 self.logger.error( 735 '\tERROR: os.makedirs %s failed with PermissionError.\n' % dir_path) 736 else: 737 self.logger.error( 738 '\tERROR: os.makedirs %s failed with %s.\n' % (dir_path, e.strerror)) 739 sys.exit(-1) 740 741 def print_progress(self, progress): 742 r""" 743 Print activity progress + 744 745 Description of variable: 746 progress Progress counter. 747 748 """ 749 750 sys.stdout.write("\r\t" + "+" * progress) 751 sys.stdout.flush() 752 time.sleep(.1) 753 754 def verify_redfish(self): 755 r""" 756 Verify remote host has redfish service active 757 758 """ 759 redfish_parm = 'redfishtool -r ' \ 760 + self.hostname + ' -S Always raw GET /redfish/v1/' 761 return(self.run_tool_cmd(redfish_parm, True)) 762 763 def verify_ipmi(self): 764 r""" 765 Verify remote host has IPMI LAN service active 766 767 """ 768 if self.target_type == 'OPENBMC': 769 ipmi_parm = 'ipmitool -I lanplus -C 17 -U ' + self.username + ' -P ' \ 770 + self.password + ' -H ' + self.hostname + ' power status' 771 else: 772 ipmi_parm = 'ipmitool -I lanplus -P ' \ 773 + self.password + ' -H ' + self.hostname + ' power status' 774 775 return(self.run_tool_cmd(ipmi_parm, True)) 776 777 def run_tool_cmd(self, 778 parms_string, 779 quiet=False): 780 r""" 781 Run CLI standard tool or scripts. 782 783 Description of variable: 784 parms_string tool command options. 785 quiet do not print tool error message if True 786 """ 787 788 result = subprocess.run([parms_string], 789 stdout=subprocess.PIPE, 790 stderr=subprocess.PIPE, 791 shell=True, 792 universal_newlines=True) 793 794 if result.stderr and not quiet: 795 self.logger.error('\n\t\tERROR with %s ' % parms_string) 796 self.logger.error('\t\t' + result.stderr) 797 798 return result.stdout 799 800 def verify_protocol(self, protocol_list): 801 r""" 802 Perform protocol working check. 803 804 Description of argument(s): 805 protocol_list List of protocol. 806 """ 807 808 tmp_list = [] 809 if self.target_is_pingable(): 810 tmp_list.append("SHELL") 811 812 for protocol in protocol_list: 813 if self.remote_protocol != 'ALL': 814 if self.remote_protocol != protocol: 815 continue 816 817 # Only check SSH/SCP once for both protocols 818 if protocol == 'SSH' or protocol == 'SCP' and protocol not in tmp_list: 819 if self.ssh_to_target_system(): 820 # Add only what user asked. 821 if self.remote_protocol != 'ALL': 822 tmp_list.append(self.remote_protocol) 823 else: 824 tmp_list.append('SSH') 825 tmp_list.append('SCP') 826 827 if protocol == 'TELNET': 828 if self.telnet_to_target_system(): 829 tmp_list.append(protocol) 830 831 if protocol == 'REDFISH': 832 if self.verify_redfish(): 833 tmp_list.append(protocol) 834 self.logger.info("\n\t[Check] %s Redfish Service.\t\t [OK]" % self.hostname) 835 else: 836 self.logger.info("\n\t[Check] %s Redfish Service.\t\t [NOT AVAILABLE]" % self.hostname) 837 838 if protocol == 'IPMI': 839 if self.verify_ipmi(): 840 tmp_list.append(protocol) 841 self.logger.info("\n\t[Check] %s IPMI LAN Service.\t\t [OK]" % self.hostname) 842 else: 843 self.logger.info("\n\t[Check] %s IPMI LAN Service.\t\t [NOT AVAILABLE]" % self.hostname) 844 845 return tmp_list 846 847 def load_env(self): 848 r""" 849 Perform protocol working check. 850 851 """ 852 # This is for the env vars a user can use in YAML to load it at runtime. 853 # Example YAML: 854 # -COMMANDS: 855 # - my_command ${hostname} ${username} ${password} 856 os.environ['hostname'] = self.hostname 857 os.environ['username'] = self.username 858 os.environ['password'] = self.password 859 860 # Append default Env. 861 self.env_dict['hostname'] = self.hostname 862 self.env_dict['username'] = self.username 863 self.env_dict['password'] = self.password 864 865 try: 866 tmp_env_dict = {} 867 if self.env_vars: 868 tmp_env_dict = json.loads(self.env_vars) 869 # Export ENV vars default. 870 for key, value in tmp_env_dict.items(): 871 os.environ[key] = value 872 self.env_dict[key] = str(value) 873 874 if self.econfig: 875 with open(self.econfig, 'r') as file: 876 try: 877 tmp_env_dict = yaml.load(file, Loader=yaml.SafeLoader) 878 except yaml.YAMLError as e: 879 self.logger.error(e) 880 sys.exit(-1) 881 # Export ENV vars. 882 for key, value in tmp_env_dict['env_params'].items(): 883 os.environ[key] = str(value) 884 self.env_dict[key] = str(value) 885 except json.decoder.JSONDecodeError as e: 886 self.logger.error("\n\tERROR: %s " % e) 887 sys.exit(-1) 888 889 # This to mask the password from displaying on the console. 890 mask_dict = self.env_dict.copy() 891 for k, v in mask_dict.items(): 892 if k.lower().find("password") != -1: 893 hidden_text = [] 894 hidden_text.append(v) 895 password_regex = '(' +\ 896 '|'.join([re.escape(x) for x in hidden_text]) + ')' 897 mask_dict[k] = re.sub(password_regex, "********", v) 898 899 self.logger.info(json.dumps(mask_dict, indent=8, sort_keys=False)) 900 901 def execute_python_eval(self, eval_string): 902 r""" 903 Execute qualified python function string using eval. 904 905 Description of argument(s): 906 eval_string Execute the python object. 907 908 Example: 909 eval(plugin.foo_func.foo_func(10)) 910 """ 911 try: 912 self.logger.info("\tExecuting plugin func()") 913 self.logger.debug("\tCall func: %s" % eval_string) 914 result = eval(eval_string) 915 self.logger.info("\treturn: %s" % str(result)) 916 except (ValueError, 917 SyntaxError, 918 NameError, 919 AttributeError, 920 TypeError) as e: 921 self.logger.error("\tERROR: execute_python_eval: %s" % e) 922 # Set the plugin error state. 923 plugin_error_dict['exit_on_error'] = True 924 self.logger.info("\treturn: PLUGIN_EVAL_ERROR") 925 return 'PLUGIN_EVAL_ERROR' 926 927 return result 928 929 def execute_plugin_block(self, plugin_cmd_list): 930 r""" 931 Pack the plugin command to qualifed python string object. 932 933 Description of argument(s): 934 plugin_list_dict Plugin block read from YAML 935 [{'plugin_name': 'plugin.foo_func.my_func'}, 936 {'plugin_args': [10]}] 937 938 Example: 939 - plugin: 940 - plugin_name: plugin.foo_func.my_func 941 - plugin_args: 942 - arg1 943 - arg2 944 945 - plugin: 946 - plugin_name: result = plugin.foo_func.my_func 947 - plugin_args: 948 - arg1 949 - arg2 950 951 - plugin: 952 - plugin_name: result1,result2 = plugin.foo_func.my_func 953 - plugin_args: 954 - arg1 955 - arg2 956 """ 957 try: 958 idx = self.key_index_list_dict('plugin_name', plugin_cmd_list) 959 plugin_name = plugin_cmd_list[idx]['plugin_name'] 960 # Equal separator means plugin function returns result. 961 if ' = ' in plugin_name: 962 # Ex. ['result', 'plugin.foo_func.my_func'] 963 plugin_name_args = plugin_name.split(' = ') 964 # plugin func return data. 965 for arg in plugin_name_args: 966 if arg == plugin_name_args[-1]: 967 plugin_name = arg 968 else: 969 plugin_resp = arg.split(',') 970 # ['result1','result2'] 971 for x in plugin_resp: 972 global_plugin_list.append(x) 973 global_plugin_dict[x] = "" 974 975 # Walk the plugin args ['arg1,'arg2'] 976 # If the YAML plugin statement 'plugin_args' is not declared. 977 if any('plugin_args' in d for d in plugin_cmd_list): 978 idx = self.key_index_list_dict('plugin_args', plugin_cmd_list) 979 plugin_args = plugin_cmd_list[idx]['plugin_args'] 980 if plugin_args: 981 plugin_args = self.yaml_args_populate(plugin_args) 982 else: 983 plugin_args = [] 984 else: 985 plugin_args = self.yaml_args_populate([]) 986 987 # Pack the args arg1, arg2, .... argn into 988 # "arg1","arg2","argn" string as params for function. 989 parm_args_str = self.yaml_args_string(plugin_args) 990 if parm_args_str: 991 plugin_func = plugin_name + '(' + parm_args_str + ')' 992 else: 993 plugin_func = plugin_name + '()' 994 995 # Execute plugin function. 996 if global_plugin_dict: 997 resp = self.execute_python_eval(plugin_func) 998 # Update plugin vars dict if there is any. 999 if resp != 'PLUGIN_EVAL_ERROR': 1000 self.response_args_data(resp) 1001 else: 1002 resp = self.execute_python_eval(plugin_func) 1003 except Exception as e: 1004 # Set the plugin error state. 1005 plugin_error_dict['exit_on_error'] = True 1006 self.logger.error("\tERROR: execute_plugin_block: %s" % e) 1007 pass 1008 1009 # There is a real error executing the plugin function. 1010 if resp == 'PLUGIN_EVAL_ERROR': 1011 return resp 1012 1013 # Check if plugin_expects_return (int, string, list,dict etc) 1014 if any('plugin_expects_return' in d for d in plugin_cmd_list): 1015 idx = self.key_index_list_dict('plugin_expects_return', plugin_cmd_list) 1016 plugin_expects = plugin_cmd_list[idx]['plugin_expects_return'] 1017 if plugin_expects: 1018 if resp: 1019 if self.plugin_expect_type(plugin_expects, resp) == 'INVALID': 1020 self.logger.error("\tWARN: Plugin error check skipped") 1021 elif not self.plugin_expect_type(plugin_expects, resp): 1022 self.logger.error("\tERROR: Plugin expects return data: %s" 1023 % plugin_expects) 1024 plugin_error_dict['exit_on_error'] = True 1025 elif not resp: 1026 self.logger.error("\tERROR: Plugin func failed to return data") 1027 plugin_error_dict['exit_on_error'] = True 1028 1029 return resp 1030 1031 def response_args_data(self, plugin_resp): 1032 r""" 1033 Parse the plugin function response and update plugin return variable. 1034 1035 plugin_resp Response data from plugin function. 1036 """ 1037 resp_list = [] 1038 resp_data = "" 1039 1040 # There is nothing to update the plugin response. 1041 if len(global_plugin_list) == 0 or plugin_resp == 'None': 1042 return 1043 1044 if isinstance(plugin_resp, str): 1045 resp_data = plugin_resp.strip('\r\n\t') 1046 resp_list.append(resp_data) 1047 elif isinstance(plugin_resp, bytes): 1048 resp_data = str(plugin_resp, 'UTF-8').strip('\r\n\t') 1049 resp_list.append(resp_data) 1050 elif isinstance(plugin_resp, tuple): 1051 if len(global_plugin_list) == 1: 1052 resp_list.append(plugin_resp) 1053 else: 1054 resp_list = list(plugin_resp) 1055 resp_list = [x.strip('\r\n\t') for x in resp_list] 1056 elif isinstance(plugin_resp, list): 1057 if len(global_plugin_list) == 1: 1058 resp_list.append([x.strip('\r\n\t') for x in plugin_resp]) 1059 else: 1060 resp_list = [x.strip('\r\n\t') for x in plugin_resp] 1061 elif isinstance(plugin_resp, int) or isinstance(plugin_resp, float): 1062 resp_list.append(plugin_resp) 1063 1064 # Iterate if there is a list of plugin return vars to update. 1065 for idx, item in enumerate(resp_list, start=0): 1066 # Exit loop, done required loop. 1067 if idx >= len(global_plugin_list): 1068 break 1069 # Find the index of the return func in the list and 1070 # update the global func return dictionary. 1071 try: 1072 dict_idx = global_plugin_list[idx] 1073 global_plugin_dict[dict_idx] = item 1074 except (IndexError, ValueError) as e: 1075 self.logger.warn("\tWARN: response_args_data: %s" % e) 1076 pass 1077 1078 # Done updating plugin dict irrespective of pass or failed, 1079 # clear all the list element for next plugin block execute. 1080 global_plugin_list.clear() 1081 1082 def yaml_args_string(self, plugin_args): 1083 r""" 1084 Pack the args into string. 1085 1086 plugin_args arg list ['arg1','arg2,'argn'] 1087 """ 1088 args_str = '' 1089 for args in plugin_args: 1090 if args: 1091 if isinstance(args, (int, float)): 1092 args_str += str(args) 1093 elif args in global_plugin_type_list: 1094 args_str += str(global_plugin_dict[args]) 1095 else: 1096 args_str += '"' + str(args.strip('\r\n\t')) + '"' 1097 # Skip last list element. 1098 if args != plugin_args[-1]: 1099 args_str += "," 1100 return args_str 1101 1102 def yaml_args_populate(self, yaml_arg_list): 1103 r""" 1104 Decode env and plugin vars and populate. 1105 1106 Description of argument(s): 1107 yaml_arg_list arg list read from YAML 1108 1109 Example: 1110 - plugin_args: 1111 - arg1 1112 - arg2 1113 1114 yaml_arg_list: [arg2, arg2] 1115 """ 1116 # Get the env loaded keys as list ['hostname', 'username', 'password']. 1117 env_vars_list = list(self.env_dict) 1118 1119 if isinstance(yaml_arg_list, list): 1120 tmp_list = [] 1121 for arg in yaml_arg_list: 1122 if isinstance(arg, (int, float)): 1123 tmp_list.append(arg) 1124 continue 1125 elif isinstance(arg, str): 1126 arg_str = self.yaml_env_and_plugin_vars_populate(str(arg)) 1127 tmp_list.append(arg_str) 1128 else: 1129 tmp_list.append(arg) 1130 1131 # return populated list. 1132 return tmp_list 1133 1134 def yaml_env_and_plugin_vars_populate(self, yaml_arg_str): 1135 r""" 1136 Update ${MY_VAR} and plugin vars. 1137 1138 Description of argument(s): 1139 yaml_arg_str arg string read from YAML. 1140 1141 Example: 1142 - cat ${MY_VAR} 1143 - ls -AX my_plugin_var 1144 """ 1145 # Parse the string for env vars ${env_vars}. 1146 try: 1147 # Example, list of matching env vars ['username', 'password', 'hostname'] 1148 # Extra escape \ for special symbols. '\$\{([^\}]+)\}' works good. 1149 var_name_regex = '\\$\\{([^\\}]+)\\}' 1150 env_var_names_list = re.findall(var_name_regex, yaml_arg_str) 1151 for var in env_var_names_list: 1152 env_var = os.environ[var] 1153 env_replace = '${' + var + '}' 1154 yaml_arg_str = yaml_arg_str.replace(env_replace, env_var) 1155 except Exception as e: 1156 self.logger.error("\tERROR:yaml_env_vars_populate: %s" % e) 1157 pass 1158 1159 # Parse the string for plugin vars. 1160 try: 1161 # Example, list of plugin vars ['my_username', 'my_data'] 1162 plugin_var_name_list = global_plugin_dict.keys() 1163 for var in plugin_var_name_list: 1164 # skip env var list already populated above code block list. 1165 if var in env_var_names_list: 1166 continue 1167 # If this plugin var exist but empty in dict, don't replace. 1168 # This is either a YAML plugin statement incorrectly used or 1169 # user added a plugin var which is not going to be populated. 1170 if yaml_arg_str in global_plugin_dict: 1171 if isinstance(global_plugin_dict[var], (list, dict)): 1172 # List data type or dict can't be replaced, use directly 1173 # in eval function call. 1174 global_plugin_type_list.append(var) 1175 else: 1176 yaml_arg_str = yaml_arg_str.replace(str(var), str(global_plugin_dict[var])) 1177 # Just a string like filename or command. 1178 else: 1179 yaml_arg_str = yaml_arg_str.replace(str(var), str(global_plugin_dict[var])) 1180 except (IndexError, ValueError) as e: 1181 self.logger.error("\tERROR: yaml_plugin_vars_populate: %s" % e) 1182 pass 1183 1184 return yaml_arg_str 1185 1186 def plugin_error_check(self, plugin_dict): 1187 r""" 1188 Plugin error dict processing. 1189 1190 Description of argument(s): 1191 plugin_dict Dictionary of plugin error. 1192 """ 1193 if any('plugin_error' in d for d in plugin_dict): 1194 for d in plugin_dict: 1195 if 'plugin_error' in d: 1196 value = d['plugin_error'] 1197 # Reference if the error is set or not by plugin. 1198 return plugin_error_dict[value] 1199 1200 def key_index_list_dict(self, key, list_dict): 1201 r""" 1202 Iterate list of dictionary and return index if the key match is found. 1203 1204 Description of argument(s): 1205 key Valid Key in a dict. 1206 list_dict list of dictionary. 1207 """ 1208 for i, d in enumerate(list_dict): 1209 if key in d.keys(): 1210 return i 1211 1212 def plugin_expect_type(self, type, data): 1213 r""" 1214 Plugin expect directive type check. 1215 """ 1216 if type == 'int': 1217 return isinstance(data, int) 1218 elif type == 'float': 1219 return isinstance(data, float) 1220 elif type == 'str': 1221 return isinstance(data, str) 1222 elif type == 'list': 1223 return isinstance(data, list) 1224 elif type == 'dict': 1225 return isinstance(data, dict) 1226 elif type == 'tuple': 1227 return isinstance(data, tuple) 1228 else: 1229 self.logger.info("\tInvalid data type requested: %s" % type) 1230 return 'INVALID' 1231