def test_check_dmesg_calltrace(self): ''' :avocado: tags=test_check_dmesg_calltrace,fast_check,kernel_tier1 polarion_id: RHEL7-103851 bz#: 1777179 ''' self.session.connect(timeout=self.ssh_wait_timeout) aws.run_cmd(self, 'dmesg', expect_ret=0, expect_not_kw='Call Trace')
def test_check_avclog(self): ''' :avocado: tags=test_check_avclog,fast_check,kernel_tier1 polarion_id: N/A ''' self.session.connect(timeout=self.ssh_wait_timeout) cmd = "sudo ausearch -m AVC -ts today" aws.run_cmd(self, cmd, expect_not_ret=0, msg='Checking avc log!') aws.run_cmd(self, 'uname -r', msg='Get instance kernel version')
def test_multi_disk_hotplug(self): ''' :avocado: tags=test_multi_disk_hotplug,acceptance check disk hotplug when instance running will add disk read&write test later polarion_id: RHEL7-93570 ''' disk_dict = { self.disk1: 'sds', self.disk2: 'sdt', self.disk3: 'sdu', self.disk4: 'sdv' } if self.vm.is_stopped(): self.vm.start() self.session.connect(timeout=self.ssh_wait_timeout) self.session = self.session aws.check_session(self) count1 = self._get_disk_online() dmesg1 = self.session.cmd_output('dmesg') for i in disk_dict.keys(): if i.is_attached(): i.detach_from_instance(force=True) if not i.attach_to_instance(self.vm.instance_id, disk_dict.get(i)): aws.get_debug_log(self) self.fail("Attached failed!") aws.run_cmd(self, 'dmesg|tail -20', msg='save dmesg after attached!') time.sleep(30) count2 = self._get_disk_online() if count2 - count1 != 4: self.fail("count2(%s) - count1(%s) not equal new addded 4!" % (count2, count1)) for i in disk_dict.keys(): if not i.detach_from_instance(): aws.get_debug_log(self) self.fail("Dettached failed!") dmesg2 = self.session.cmd_output('dmesg') if not aws.compare_dmesg(dmesg1, dmesg2): self.fail("dmesg log check fail!") # test system can reboot with multidisks for i in disk_dict.keys(): if i.attach_to_instance(self.vm.instance_id, disk_dict.get(i)): self.log.info('Attached successfully!') else: aws.get_debug_log(self) self.fail("Attached failed!") self.vm.reboot() self.session.connect(timeout=self.ssh_wait_timeout) self._check_disk_count() for i in disk_dict.keys(): if i.detach_from_instance(): self.log.info('Dettached successfully!') else: aws.get_debug_log(self) self.fail("Dettached failed!")
def test_check_modload(self): ''' :avocado: tags=test_check_modload,fast_check polarion_id: ''' self.session.connect(timeout=self.ssh_wait_timeout) utils_lib.run_cmd(self, 'lsmod', expect_ret=0) aws.run_cmd(self, 'uname -r', msg='Get instance kernel version')
def test_ethtool_C_coalesce(self): ''' :avocado: tags=test_ethtool_C_coalesce,fast_check polarion_id: ''' self.session1.connect(timeout=self.ssh_wait_timeout) self.session = self.session1 aws.check_session(self) cmd = ' sudo ethtool -c eth0' aws.run_cmd(self, cmd, msg='Show current settings.') cmd = "ethtool -C eth0 rx-usecs 3" output = aws.run_cmd(self, cmd) if "Operation not supported" in output: self.cancel("Operation not supported!") if "Operation not permitted" in output: self.cancel("Operation not permitted") self.log.info("Trying to change coalesce") coalesce_list = [ 'stats-block-usecs', 'sample-interval', 'pkt-rate-low', 'pkt-rate-high', 'rx-usecs', 'rx-frames', 'rx-usecs-irq', 'rx-frames-irq', 'tx-usecs', 'tx-frames', 'tx-usecs-irq', 'tx-frames-irq', 'rx-usecs-low', 'rx-frame-low', 'tx-usecs-low', 'tx-frame-low', 'rx-usecs-high', 'rx-frame-high', 'tx-usecs-high', 'tx-frame-high' ] for coalesce in coalesce_list: cmd = 'sudo ethtool -C eth0 %s 2' % coalesce aws.run_cmd(self, cmd, expect_ret=0) cmd = 'sudo ethtool -c eth0' aws.run_cmd(self, cmd, expect_kw="%s: 2" % coalesce) cmd = 'dmesg|tail -20' aws.run_cmd(self, cmd)
def test_check_microcode_load(self): ''' :avocado: tags=test_check_microcode_load,fast_check For bug 1607899, RHEL should not update microcode inside VMs. This case checks it from dmesg output. polarion_id: N/A ''' self.session.connect(timeout=self.ssh_wait_timeout) lscpu_output = aws.run_cmd(self, 'lscpu', expect_ret=0) aws.run_cmd(self, 'lscpu', expect_ret=0, cancel_not_kw="aarch64,AMD", msg="Only run in intel platform") cmd = 'rpm -qa|grep microcode' aws.run_cmd(self, cmd) cmd = 'dmesg|grep microcode|grep -v "no microcode"' if 'Xen' in lscpu_output or 'KVM' in lscpu_output: aws.run_cmd(self, cmd, expect_not_ret=0, msg='microcode should not load in VMs') else: aws.run_cmd(self, cmd, expect_ret=0, msg='microcode should load in bare metals')
def test_check_memleaks(self): ''' :avocado: tags=test_check_memleaks polarion_id: RHEL-117648 ''' self.log.info("Check memory leaks") self.session.connect(timeout=self.ssh_wait_timeout) aws.run_cmd(self, 'uname -a', expect_ret=0, cancel_kw="debug", msg="Only run in debug kernel") aws.run_cmd(self, 'cat /proc/cmdline', expect_ret=0, cancel_kw="kmemleak=on", msg="Only run with kmemleak=on") aws.run_cmd(self, 'sudo su', expect_ret=0) cmd = 'echo scan > /sys/kernel/debug/kmemleak' aws.run_cmd(self, cmd, expect_ret=0, timeout=1800) cmd = 'cat /sys/kernel/debug/kmemleak' output = aws.run_cmd(self, cmd, expect_ret=0) if len(output) > 0: self.fail('Memory leak found!')
def test_check_dmesg_unknownsymbol(self): ''' :avocado: tags=test_check_dmesg_unknownsymbol,fast_check,kernel_tier1 polarion_id: bz#: 1649215 ''' self.session.connect(timeout=self.ssh_wait_timeout) aws.run_cmd(self, 'dmesg', expect_ret=0, expect_not_kw='Unknown symbol', msg='Check there is no Unknown symbol')
def test_create_vm(self): ''' :avocado: tags=test_create_vm ''' self.session.connect(timeout=self.ssh_wait_timeout) aws.check_session(self) aws.run_cmd(self, 'whoami', expect_ret=0, expect_output=self.vm.vm_username, msg="New VM is created: %s" % self.vm.instance_id) aws.run_cmd(self, 'uname -r', msg='Get instance kernel version')
def test_check_journalctl_traceback(self): ''' :avocado: tags=test_check_journalctl_traceback,fast_check polarion_id: bz#: 1801999, 1736818 ''' self.session.connect(timeout=self.ssh_wait_timeout) # redirect journalctl output to a file as it is not get return # normally in RHEL7 cmd = 'journalctl > /tmp/journalctl.log' aws.run_cmd(self, cmd, expect_ret=0) cmd = 'cat /tmp/journalctl.log' aws.run_cmd(self, cmd, expect_ret=0, expect_not_kw='Traceback,Backtrace')
def test_check_journalctl_dumpedcore(self): ''' :avocado: tags=test_check_journalctl_dumpedcore,fast_check polarion_id: bz#: 1797973 ''' self.session.connect(timeout=self.ssh_wait_timeout) # redirect journalctl output to a file as it is not get return # normally in RHEL7 cmd = 'journalctl > /tmp/journalctl.log' aws.run_cmd(self, cmd, expect_ret=0) cmd = 'cat /tmp/journalctl.log' aws.run_cmd(self, cmd, expect_ret=0, expect_not_kw='dumped core')
def tearDown(self): self.session = self.session1 if self.session.session.is_responsive( ) is not None and self.vm1.is_started(): if self.name.name.endswith("test_pci_reset"): cmd = 'sudo dmesg --clear' aws.run_cmd(self, cmd, msg='Clear dmesg') aws.gcov_get(self) aws.get_memleaks(self) self.session.close() self.session1.close() if self.name.name.endswith("test_iperf_ipv4"): self.session2.close()
def test_ltp_ipsec_icmp(self): ''' :avocado: tags=test_ltp_ipsec_icmp polarion_id: RHEL7-98754 ''' utils_lib.ltp_run(self, case_name="icmp4-uni-vti11", file_name='net_stress.ipsec_icmp') self.log.info("Try to remove ccm module after test.") try: aws.run_cmd(self, 'sudo modprobe -r ccm', expect_ret=0) except Exception as err: aws.handle_exception(self.vm, err) self.fail("Got exceptions during test!")
def test_collect_log(self): ''' :avocado: tags=test_collect_log polarion_id: N/A ''' self.log.info("This case is only saving log for future check purpose") self.session.connect(timeout=self.ssh_wait_timeout) aws.check_cmd(self, cmd='wget') aws.check_cmd(self, cmd='tar') aws.check_cmd(self, cmd='unzip') virt_utils_url = "https://github.com/SCHEN2015/virt-utils/archive/\ master.zip" self.log.info("Download %s" % virt_utils_url) cmd = "wget %s ; unzip master.zip" % virt_utils_url aws.run_cmd(self, cmd, expect_ret=0) cmd = "virt-utils-master/vm_check/vm_check.sh" aws.run_cmd(self, cmd, expect_ret=0) cmd = "tar zcf vmlog.tar.gz workspace/log" aws.run_cmd(self, cmd, expect_ret=0) remote_path = "vmlog.tar.gz" local_path = "%s/%s_vmlog.tar.gz" % (self.job.logdir, self.vm.instance_type) self.log.info("Copy %s from guest to %s, please wait" % (remote_path, local_path)) self.session.copy_files_from(remote_path, local_path, timeout=600) aws.run_cmd(self, 'uname -r', msg='Get instance kernel version')
def _get_blktest(self): ''' Clone blktests from github ''' test_disk = self._get_test_disk() cmd = 'sudo yum install -y blktrace fio nvme-cli git sysstat' aws.run_cmd(self, cmd) cmd = 'which git' aws.run_cmd(self, cmd, expect_ret=0) aws.run_cmd(self, 'sudo rm -rf blktests', expect_ret=0) cmd = 'git clone https://github.com/osandov/blktests.git' aws.run_cmd(self, cmd, expect_ret=0) cmd = "echo 'TEST_DEVS=(/dev/%s)' > blktests/config" % test_disk aws.run_cmd(self, cmd, expect_ret=0)
def test_disk_info(self): ''' :avocado: tags=test_disk_info,acceptance,fast_check check disk information via fdisk and lsblk. For now, no exactly check result as output format may different on RHEL6/7/8. Only comparing disk count from fdisk and lsblk to vm assigned. polarion_id: RHEL7-103855 ''' self.session.connect(timeout=self.ssh_wait_timeout) self.session = self.session aws.check_session(self) fdisk_cmd = 'sudo fdisk -l' aws.run_cmd(self, fdisk_cmd, expect_ret=0)
def test_check_journalctl_invalid(self): ''' :avocado: tags=test_check_journalctl_invalid,fast_check polarion_id: BZ#:1750417 ''' self.session.connect(timeout=self.ssh_wait_timeout) # redirect journalctl output to a file as it is not get return # normally in RHEL7 # skip sshd to filter out invalid user message cmd = 'journalctl|grep -v sshd|grep -v MTU > /tmp/journalctl.log' aws.run_cmd(self, cmd, expect_ret=0) cmd = 'cat /tmp/journalctl.log' aws.run_cmd(self, cmd, expect_ret=0, expect_not_kw='invalid,Invalid')
def test_fio_crctest(self): ''' :avocado: tags=test_fio_crctest,acceptance,fast_check polarion_id: Test the speed of the built-in checksumming functions. ''' self.session.connect(timeout=self.ssh_wait_timeout) self.session = self.session aws.check_session(self) cmd = 'sudo fio --crctest' aws.run_cmd( self, cmd, expect_ret=0, msg='Test the speed of the built-in checksumming functions.')
def test_fio_cpuclock(self): ''' :avocado: tags=test_fio_cpuclock,acceptance,fast_check polarion_id: Perform test and validation of internal CPU clock. ''' self.session.connect(timeout=self.ssh_wait_timeout) self.session = self.session aws.check_session(self) aws.run_cmd(self, 'sudo lscpu', cancel_not_kw="aarch64") cmd = 'sudo fio --cpuclock-test' aws.run_cmd(self, cmd, expect_ret=0, expect_kw="Pass", msg='Perform test and validation of internal CPU clock.')
def test_check_release_name(self): ''' :avocado: tags=test_check_release_name,fast_check check /etc/redhat-release have the correct name polarion_id: RHEL7-103850 ''' self.session.connect(timeout=self.ssh_wait_timeout) check_cmd = r"sudo cat /etc/redhat-release" self.log.info("Check release name cmd: %s" % check_cmd) status, output = self.session.cmd_status_output(check_cmd) kernel_ver = aws.run_cmd(self, 'uname -r') self.log.info("Guest kernel version: %s " % kernel_ver) if status == 0: if '2.6.32' in kernel_ver: self.assertIn( 'Red Hat Enterprise Linux Server release 6', output, msg="It should be like: Red Hat Enterprise Linux \ Server release 6.n\n but it is %s" % output) elif '3.10.0' in kernel_ver: self.assertIn( 'Red Hat Enterprise Linux Server release 7', output, msg="It should be like: Red Hat Enterprise Linux \ Server release 7.n\n but it is %s" % output) elif 'el8' in kernel_ver: self.assertIn( 'Red Hat Enterprise Linux release 8', output, msg="It should be like: Red Hat Enterprise Linux \ release 8.n\n but it is %s" % output) self.log.info("Check PASS: %s" % output) else: self.fail("Failed to get /etc/redhat-release information!")
def test_start_vm(self): ''' :avocado: tags=test_start_vm polarion_id: RHEL7-103633 ''' if not self.vm.is_stopped(): self.vm.stop(loops=4) if not self.vm.is_stopped(): self.fail("Instance is not in stopped state!") self.log.info("Start instance %s" % self.vm.instance_id) if self.vm.start(wait=True): self.log.info("Instance is started: %s" % self.vm.instance_id) self.session.connect(timeout=self.ssh_wait_timeout) aws.check_session(self) aws.run_cmd(self, 'uname -r', msg='Get instance kernel version') else: self.fail("Failed to start instance!")
def test_xenfs_mount(self): ''' :avocado: tags=test_xenfs_mount,fast_check polarion_id: ''' self.session.connect(timeout=self.ssh_wait_timeout) aws.run_cmd(self, 'sudo lscpu', expect_ret=0, cancel_kw="Xen", msg="Only run in xen instance") cmd = r'sudo mount -t xenfs xenfs /proc/xen/' aws.run_cmd(self, cmd, expect_ret=0) utils_lib.run_cmd(self, 'sudo ls /proc/xen', expect_ret=0, expect_kw='capabilities privcmd xenbus')
def test_kdump_no_specify_cpu(self): ''' :avocado: tags=test_kdump_no_specify_cpu,acceptance,fast_check polarion_id: RHEL7-58669 bz#: 1654962 ''' if not self.kdump_status: self.cancel("Cancle test as kdump not running!") self.session.connect(timeout=self.ssh_wait_timeout) time.sleep(10) output = utils_lib.run_cmd(self, 'lscpu', expect_ret=0) if 'aarch64' in output and 'metal' not in self.vm.instance_type: self.log.info("arm instance") self.cancel("Cancel it as bug 1654962 in arm instances which \ no plan to fix it in the near future!") aws.run_cmd(self, r'sudo rm -rf /var/crash/*', expect_ret=0, msg='clean /var/crash firstly') aws.run_cmd(self, r'sudo sync', expect_ret=0) self.log.info("Before system crash %s" % self.vm.instance_id) aws.run_cmd(self, r'find /var/crash', expect_ret=0, msg='list /var/crash') self.log.info("Crashing %s via ssh" % self.vm.instance_id) self._trigger_kdump_on_cpu() if 'metal' in self.vm.instance_type: self.log.info("Wait %s" % self.ssh_wait_timeout) time.sleep(self.ssh_wait_timeout) else: self.log.info("Wait 30s") time.sleep(30) self.session.connect(timeout=640) self.log.info("After system crash %s" % self.vm.instance_id) aws.run_cmd(self, r'find /var/crash', expect_ret=0, msg='list /var/crash after crash') cmd = r'sudo cat /var/crash/1*/vmcore-dmesg.txt|tail -50' aws.run_cmd(self, cmd, expect_ret=0, expect_kw='write_sysrq_trigger')
def test_sriov_ixbgevf(self): ''' :avocado: tags=test_sriov_ixbgevf,fast_check polarion_id: RHEL7-87119 ''' self.session1.connect(timeout=self.ssh_wait_timeout) if not self.name.name.endswith("test_cleanup"): self.session = self.session1 aws.check_session(self) eth_cmd = "ethtool -i eth0" if self.params.get('ixgbevf', '*/instance_types/*') > 0: self.log.info("Configure shows this instance supports ixgbevf") else: aws.run_cmd(self, eth_cmd, expect_ret=0, cancel_kw='ixgbevf') self.log.info("Trying to check sriov ixbgevf interface!") mod_cmd = "modinfo ixgbevf" self.log.info("Get eth0 module infomation: %s" % self.vm1.instance_id) status, output = self.session1.cmd_status_output(eth_cmd) if status > 0: self.fail("Failed to check eth0 status: cmd : %s output:%s" % (eth_cmd, output)) elif status == 0: if 'ixgbevf' in output: self.log.info("eth0 has ixgbevf loaded. cmd: %s result: %s" % (eth_cmd, output)) else: self.fail( "eth0 does not have ixgbevf loaded. cmd : %s result:%s" % (eth_cmd, output)) self.log.info("Get ixgbevf module infomation: %s" % self.vm1.instance_id) status, output = self.session1.cmd_status_output(mod_cmd) if status > 0: self.fail( "Failed to get ixgbevf module information: cmd : %s result:%s" % (eth_cmd, output)) elif status == 0: self.log.info("Below is ixgbevf information. cmd: %s result: %s" % (eth_cmd, output))
def test_start_vm_iommu(self): ''' :avocado: tags=test_start_vm_iommu polarion_id: This test bare metal instance can boot up with iommu ''' if 'metal' in self.vm.instance_type: self.log.info("Instance is bare metal") else: self.log.info("Instance is xen/kvm") self.cancel("Only run in bare metal instances!") self.session.connect(timeout=self.ssh_wait_timeout) aws.check_session(self) aws.run_cmd(self, 'uname -r', msg='Get instance kernel version') aws.run_cmd(self, 'lscpu', expect_ret=0, cancel_not_kw="Xen,aarch64,AuthenticAMD") cmd = 'sudo grubby --update-kernel=ALL --args="intel_iommu=on"' aws.run_cmd(self, cmd, expect_ret=0) if not self.vm.is_stopped(): self.vm.stop(loops=4) if not self.vm.is_stopped(): self.fail("Instance is not in stopped state!") self.log.info("Start instance %s" % self.vm.instance_id) if self.vm.start(wait=True): self.session.connect(timeout=self.ssh_wait_timeout) aws.check_session(self) aws.run_cmd(self, 'cat /proc/cmdline', msg='Get instance boot cmdline') cmd = 'sudo grubby --update-kernel=ALL \ --remove-args="intel_iommu=on"' aws.run_cmd(self, cmd, expect_ret=0) else: self.fail("Failed to start instance!")
def test_ltp_cpuhotplug(self): ''' :avocado: tags=test_ltp_cpuhotplug polarion_id: RHEL7-98752 BZ#: 1464095 ''' # ltp will considering fail if more than 1 cpus cannot be offline # in bare metal instance # but in large metal instances, it is expected. So do not do it in # bare metal instances aws.run_cmd(self, 'lscpu', expect_ret=0, cancel_not_kw="Xen", msg="Not run in xen instance as bug \ 1641510 which is very low priority") if 'metal' in self.vm.instance_type: self.cancel('Cancel test as bare metal needs 1+ cpus working \ at least which ltp not handle') else: utils_lib.ltp_run(self, case_name="cpuhotplug")
def _get_test_disk(self): ''' If there 2+ disks found inside system, return its name for block testing ''' cmd = 'lsblk -l -o NAME -d|grep -v NAME' output = aws.run_cmd(self, cmd, expect_ret=0) disk_list = output.split('\n') if 'xvda' in disk_list: disk_list.remove('xvda') else: cmd = " sudo lsblk -o NAME,MOUNTPOINT|grep -w '/'" out = aws.run_cmd(self, cmd) bootdisk = re.findall('nvme[0-9]+', out)[0] self.log.info("Boot disk is %s" % bootdisk) disk_list.remove('%sn1' % bootdisk) if len(disk_list) > 0: self.log.info("%s selected for testing." % disk_list[0]) return disk_list[0] else: self.cancel("No addtional disk for testing. Skip test")
def test_network_hotplug(self): ''' :avocado: tags=test_network_hotplug,fast_check polarion_id: RHEL7-103904 ''' self.network = NetworkInterface(self.params) self.assertTrue(self.network.create(), msg='network interface create failed!') self.session1.connect(timeout=self.ssh_wait_timeout) self.session = self.session1 netdev_index = 1 self.network.attach_to_instance(self.vm1.instance_id, netdev_index) for i in range(1, 4): time.sleep(5) self.log.info('Check network in guest, loop%s' % i) cmd = "lspci" output1 = aws.run_cmd(self, cmd) cmd = "ifconfig" output1 = aws.run_cmd(self, cmd) if 'eth%s' % netdev_index not in output1: self.log.info("Added nic not found") self.network.detach_from_instance(self.vm1.instance_id) time.sleep(5) cmd = "ifconfig" aws.run_cmd(self, cmd) self.network.delete() self.assertIn('eth%d' % netdev_index, output1, msg='eth%d not found after attached nic' % netdev_index) cmd = 'dmesg' aws.run_cmd(self, cmd, expect_not_kw='Call Trace')
def test_blktests_block(self): ''' :avocado: tags=test_blktests_block run blktests block test polarion_id: N/A ''' self.session.connect(timeout=self.ssh_wait_timeout) self.session = self.session aws.check_session(self) if int(self.params.get('disks', '*/instance_types/*')) == 1: self.log.info("Only 1 disk available, attached more for blktest.") disk_dict = { self.disk1: 'sds', self.disk2: 'sdt', self.disk3: 'sdu', self.disk4: 'sdv' } self.session.connect(timeout=self.ssh_wait_timeout) self.session = self.session for i in disk_dict.keys(): if i.is_attached(): i.detach_from_instance(force=True) self.log.info("Try to attach %s to %s" % (i.res_id, self.vm.instance_id)) if not i.attach_to_instance(self.vm.instance_id, disk_dict.get(i)): self.fail("Attached failed!") self._get_blktest() cmd = '' cmd = 'cd blktests;sudo ./check block' # Not all cases are pass due to test tool issue output = aws.run_cmd(self, cmd, timeout=1200) if output is None: self.fail("Cannot get output!") if output.count('[failed]') > 1: self.fail("%s failed found" % output.count('[failed]')) cmd = 'dmesg' aws.run_cmd(self, cmd, msg="dmesg after test")
def test_sriov_ena(self): ''' :avocado: tags=test_sriov_ena,fast_check polarion_id: RHEL7-87117 ''' self.session1.connect(timeout=self.ssh_wait_timeout) self.session = self.session1 aws.check_session(self) eth_cmd = "ethtool -i eth0" if self.params.get('ena', '*/instance_types/*') > 0: self.log.info("Configure shows this instance supports ena") else: aws.run_cmd(self, eth_cmd, expect_ret=0, cancel_kw='ena') self.log.info("Trying to check sriov ena interface!") mod_cmd = "modinfo ena" self.log.info("Get eth0 module infomation: %s" % self.vm1.instance_id) status, output = self.session1.cmd_status_output(eth_cmd) if status > 0: self.fail("Failed to check eth0 status: cmd : %s output:%s" % (eth_cmd, output)) elif status == 0: if 'ena' in output: self.log.info("eth0 has ena loaded. cmd: %s result: %s" % (eth_cmd, output)) else: self.fail("eth0 does not have ena loaded. cmd : %s result:%s" % (eth_cmd, output)) self.log.info("Get ena module infomation: %s" % self.vm1.instance_id) status, output = self.session1.cmd_status_output(mod_cmd) if status > 0: self.fail( "Failed to get ena module information: cmd : %s result:%s" % (eth_cmd, output)) elif status == 0: self.log.info("Below is ena information. cmd: %s result: %s" % (eth_cmd, output))