def test_extractMountInfo(self): outputLine = "device type size used available percent mountpoint" result = Hardware.extractMountInfo(outputLine) self.assertEquals(result['device'], 'device') self.assertEquals(result['type'], 'type') self.assertEquals(result['size'], 'size') self.assertEquals(result['used'], 'used') self.assertEquals(result['available'], 'available') self.assertEquals(result['percent'], 'percent') self.assertEquals(result['mountpoint'], 'mountpoint') outputLine = "" result = Hardware.extractMountInfo(outputLine) self.assertEquals(result, None) outputLine = "device type size used available percent" result = Hardware.extractMountInfo(outputLine) self.assertEquals(result, None) outputLine = "device type size used available percent mountpoint info" result = Hardware.extractMountInfo(outputLine) self.assertEquals(result, None)
def test_build(self, get_os_version_mock, get_os_type_mock): get_os_type_mock.return_value = "suse" get_os_version_mock.return_value = "11" hardware = Hardware() result = hardware.get() osdisks = hardware.osdisks() for dev_item in result['mounts']: self.assertTrue(dev_item['available'] >= 0) self.assertTrue(dev_item['used'] >= 0) self.assertTrue(dev_item['percent'] != None) self.assertTrue(dev_item['device'] != None) self.assertTrue(dev_item['mountpoint'] != None) self.assertTrue(dev_item['type'] != None) self.assertTrue(dev_item['size'] > 0) for os_disk_item in osdisks: self.assertTrue(os_disk_item['available'] >= 0) self.assertTrue(os_disk_item['used'] >= 0) self.assertTrue(os_disk_item['percent'] != None) self.assertTrue(os_disk_item['device'] != None) self.assertTrue(os_disk_item['mountpoint'] != None) self.assertTrue(os_disk_item['type'] != None) self.assertTrue(os_disk_item['size'] > 0) self.assertTrue(len(result['mounts']) == len(osdisks))
def test_facterBin(self, ps_path_exists_mock): hardware = Hardware(AmbariConfig().getConfig()) ps_path_exists_mock.return_value = False result = hardware.facterBin("bla bla bla") self.assertEquals(result, "facter") ps_path_exists_mock.return_value = True result = hardware.facterBin("bla bla bla") self.assertEquals(result, "bla bla bla/bin/facter")
def __init__(self, initializer_module): self.initializer_module = initializer_module self.report_interval = initializer_module.config.host_status_report_interval self.stop_event = initializer_module.stop_event self.config = initializer_module.config self.host_info = HostInfo(initializer_module.config) self.last_report = {} self.hardware = Hardware(config=initializer_module.config, cache_info=False) threading.Thread.__init__(self)
def test_configureEnviron(self, hrdware_facterinfo_mock, subproc_popen, os_path_exists_mock): config = AmbariConfig().getConfig() config.set("puppet", "ruby_home", AmbariConfig().getConfig().get("stack", "installprefix")) hardware = Hardware(config) os_path_exists_mock.return_value = True result = hardware.configureEnviron({'PATH': ""}) self.assertEquals(result['PATH'], AmbariConfig().getConfig().get("stack", "installprefix") + "/bin:") self.assertEquals(result['MY_RUBY_HOME'], AmbariConfig().getConfig().get("stack", "installprefix")) config.remove_option("puppet", "ruby_home")
def test_configureEnviron(self, hrdware_facterinfo_mock, subproc_popen, os_path_exists_mock): config = AmbariConfig().getConfig() tmpdir = tempfile.gettempdir() config.set("puppet", "ruby_home", tmpdir) hardware = Hardware(config) os_path_exists_mock.return_value = True result = hardware.configureEnviron({'PATH': ""}) self.assertEquals(result['PATH'], tmpdir + "/bin:") self.assertEquals(result['MY_RUBY_HOME'], tmpdir) config.remove_option("puppet", "ruby_home")
def test_osdisks_parsing(self, shell_call_mock, isfile_mock, chk_writable_mount_mock): df_output =\ """Filesystem Type 1024-blocks Used Available Capacity Mounted on /dev/mapper/docker-253:0-4980899-d45c264d37ab18c8ed14f890f4d59ac2b81e1c52919eb36a79419787209515f3 xfs 31447040 1282384 30164656 5% / tmpfs tmpfs 32938336 4 32938332 1% /dev tmpfs tmpfs 32938336 0 32938336 0% /sys/fs/cgroup /dev/mapper/fedora-root ext4 224161316 12849696 199901804 7% /etc/resolv.conf /dev/mapper/fedora-root ext4 224161316 12849696 199901804 7% /etc/hostname /dev/mapper/fedora-root ext4 224161316 12849696 199901804 7% /etc/hosts shm tmpfs 65536 0 65536 0% /dev/shm /dev/mapper/fedora-root ext4 224161316 12849696 199901804 7% /run/secrets """ def isfile_side_effect(path): assume_files = ["/etc/resolv.conf", "/etc/hostname", "/etc/hosts"] return path in assume_files def chk_writable_mount_side_effect(path): assume_read_only = ["/run/secrets"] return path not in assume_read_only isfile_mock.side_effect = isfile_side_effect chk_writable_mount_mock.side_effect = chk_writable_mount_side_effect shell_call_mock.return_value = (0, df_output, '') result = Hardware.osdisks() self.assertEquals(1, len(result)) expected_mounts_left = ["/"] mounts_left = [item["mountpoint"] for item in result] self.assertEquals(expected_mounts_left, mounts_left)
def test_parse_df_line(self): df_line_sample = "device type size used available percent mountpoint" samples = [{ "sample": df_line_sample, "expected": dict(zip(df_line_sample.split(), df_line_sample.split())) }, { "sample": "device type size used available percent", "expected": None, }, { "sample": "device type size used available percent mountpoint info", "expected": None, }, { "sample": "", "expected": None }] for sample in samples: result = Hardware._parse_df_line(sample["sample"]) self.assertEquals( result, sample["expected"], "Failed with sample: '{0}', expected: {1}, got: {2}".format( sample["sample"], sample["expected"], result))
class Register: """ Registering with the server. Get the hardware profile and declare success for now """ def __init__(self, config): self.config = config self.hardware = Hardware(self.config) self.init_time_ms = int(1000 * time.time()) def build(self, response_id='-1'): timestamp = int(time.time() * 1000) hostInfo = HostInfo(self.config) agentEnv = {} hostInfo.register(agentEnv, runExpensiveChecks=True) current_ping_port = self.config.get('agent', 'ping_port') register = { 'id': int(response_id), 'timestamp': timestamp, 'hostname': hostname.hostname(self.config), 'currentPingPort': int(current_ping_port), 'publicHostname': hostname.public_hostname(self.config), 'hardwareProfile': self.hardware.get(), 'agentEnv': agentEnv, 'agentVersion': Utils.read_agent_version(self.config), 'prefix': self.config.get('agent', 'prefix'), 'agentStartTime': self.init_time_ms } return register
def build(self, id='-1', add_state=False, componentsMapped=False): global clusterId, clusterDefinitionRevision, firstContact timestamp = int(time.time()*1000) queueResult = self.actionQueue.result() recovery_timestamp = self.actionQueue.controller.recovery_manager.recovery_timestamp nodeStatus = { "status" : "HEALTHY", "cause" : "NONE" } heartbeat = { 'responseId' : int(id), 'timestamp' : timestamp, 'hostname' : hostname(self.config), 'nodeStatus' : nodeStatus, 'recoveryTimestamp' : recovery_timestamp } rec_status = self.actionQueue.controller.recovery_manager.get_recovery_status() heartbeat['recoveryReport'] = rec_status commandsInProgress = False if not self.actionQueue.commandQueue.empty(): commandsInProgress = True if len(queueResult) != 0: heartbeat['reports'] = queueResult['reports'] heartbeat['componentStatus'] = queueResult['componentStatus'] if len(heartbeat['reports']) > 0: # There may be IN_PROGRESS tasks commandsInProgress = True pass # For first request/heartbeat assume no components are mapped if int(id) == 0: componentsMapped = False logger.debug("Building Heartbeat: {responseId = %s, timestamp = %s, " "commandsInProgress = %s, componentsMapped = %s," "recoveryTimestamp = %s}", str(id), str(timestamp), repr(commandsInProgress), repr(componentsMapped), str(recovery_timestamp)) logger.debug("Heartbeat: %s", pformat(heartbeat)) hostInfo = HostInfo(self.config) if add_state: logger.info("Adding host info/state to heartbeat message.") nodeInfo = { } # for now, just do the same work as registration # this must be the last step before returning heartbeat hostInfo.register(nodeInfo, componentsMapped, commandsInProgress) heartbeat['agentEnv'] = nodeInfo mounts = Hardware(config=self.config, cache_info=False).osdisks() heartbeat['mounts'] = mounts logger.debug("agentEnv: %s", str(nodeInfo)) logger.debug("mounts: %s", str(mounts)) if self.collector is not None: heartbeat['alerts'] = self.collector.alerts() return heartbeat
def test_parse_df_line(self): df_line_sample = "device type size used available percent mountpoint" samples = [{ "sample": df_line_sample, "expected": dict(zip(df_line_sample.split(), df_line_sample.split())) }, { "sample": "device type size used available percent", "expected": None, }, { "sample": "device type size used available percent mountpoint info", "expected": None, }, { "sample": "", "expected": None }] for sample in samples: try: result = Hardware(cache_info=False)._parse_df( [sample["sample"]]).next() except StopIteration: result = None self.assertEquals( result, sample["expected"], "Failed with sample: '{0}', expected: {1}, got: {2}".format( sample["sample"], sample["expected"], result))
class HostStatusReporter(threading.Thread): """ The thread reports host status to server if it changed from previous report every 'host_status_report_interval' seconds. """ def __init__(self, initializer_module): self.initializer_module = initializer_module self.report_interval = initializer_module.config.host_status_report_interval self.stop_event = initializer_module.stop_event self.config = initializer_module.config self.host_info = HostInfo(initializer_module.config) self.last_report = {} self.server_responses_listener = initializer_module.server_responses_listener self.hardware = Hardware(config=initializer_module.config, cache_info=False) threading.Thread.__init__(self) def run(self): while not self.stop_event.is_set(): try: if self.initializer_module.is_registered: report = self.get_report() if self.initializer_module.is_registered and not Utils.are_dicts_equal( report, self.last_report, keys_to_skip=["agentTimeStampAtReporting"]): correlation_id = self.initializer_module.connection.send( message=report, destination=Constants.HOST_STATUS_REPORTS_ENDPOINT) self.server_responses_listener.listener_functions_on_success[ correlation_id] = lambda headers, message: self.save_last_report( report) except ConnectionIsAlreadyClosed: # server and agent disconnected during sending data. Not an issue pass except: logger.exception( "Exception in HostStatusReporter. Re-running it") self.stop_event.wait(self.report_interval) logger.info("HostStatusReporter has successfully finished") def save_last_report(self, report): self.last_report = report def get_report(self): host_info_dict = {} self.host_info.register(host_info_dict) report = { 'agentEnv': host_info_dict, 'mounts': self.hardware.osdisks(), } return report def clean_cache(self): self.last_report = {}
def test_osdisks_blacklist(self, shell_call_mock, isfile_mock, chk_writable_mount_mock): df_output = \ """Filesystem Type 1024-blocks Used Available Capacity Mounted on /dev/mapper/docker-253:0-4980899-d45c264d37ab18c8ed14f890f4d59ac2b81e1c52919eb36a79419787209515f3 xfs 31447040 1282384 30164656 5% / tmpfs tmpfs 32938336 4 32938332 1% /dev tmpfs tmpfs 32938336 0 32938336 0% /sys/fs/cgroup /dev/mapper/fedora-root ext4 224161316 12849696 199901804 7% /etc/resolv.conf /dev/mapper/fedora-root ext4 224161316 12849696 199901804 7% /etc/hostname /dev/mapper/fedora-root ext4 224161316 12849696 199901804 7% /etc/hosts shm tmpfs 65536 0 65536 0% /dev/shm /dev/mapper/fedora-root ext4 224161316 12849696 199901804 7% /run/secrets /dev/mapper/fedora-root ext4 224161316 12849696 199901804 7% /mnt/blacklisted_mount /dev/mapper/fedora-root ext4 224161316 12849696 199901804 7% /mnt/blacklisted_mount/sub-dir """ def isfile_side_effect(path): assume_files = ["/etc/resolv.conf", "/etc/hostname", "/etc/hosts"] return path in assume_files def chk_writable_mount_side_effect(path): assume_read_only = ["/run/secrets"] return path not in assume_read_only isfile_mock.side_effect = isfile_side_effect chk_writable_mount_mock.side_effect = chk_writable_mount_side_effect config_dict = { "agent": { "ignore_mount_points": "/mnt/blacklisted_mount" } } shell_call_mock.return_value = (0, df_output, '') def conf_get(section, key, default=""): if section in config_dict and key in config_dict[section]: return config_dict[section][key] return default def has_option(section, key): return section in config_dict and key in config_dict[section] conf = Mock() attr = { 'get.side_effect': conf_get, 'has_option.side_effect': has_option } conf.configure_mock(**attr) result = Hardware.osdisks(conf) self.assertEquals(1, len(result)) expected_mounts_left = ["/"] mounts_left = [item["mountpoint"] for item in result] self.assertEquals(expected_mounts_left, mounts_left)
def build(self, id='-1', state_interval=-1, componentsMapped=False): global clusterId, clusterDefinitionRevision, firstContact timestamp = int(time.time()*1000) queueResult = self.actionQueue.result() nodeStatus = { "status" : "HEALTHY", "cause" : "NONE" } heartbeat = { 'responseId' : int(id), 'timestamp' : timestamp, 'hostname' : hostname(self.config), 'nodeStatus' : nodeStatus } rec_status = self.actionQueue.controller.recovery_manager.get_recovery_status() heartbeat['recoveryReport'] = rec_status commandsInProgress = False if not self.actionQueue.commandQueue.empty(): commandsInProgress = True if len(queueResult) != 0: heartbeat['reports'] = queueResult['reports'] heartbeat['componentStatus'] = queueResult['componentStatus'] if len(heartbeat['reports']) > 0: # There may be IN_PROGRESS tasks commandsInProgress = True pass # For first request/heartbeat assume no components are mapped if int(id) == 0: componentsMapped = False logger.info("Building Heartbeat: {responseId = %s, timestamp = %s, commandsInProgress = %s, componentsMapped = %s}", str(id), str(timestamp), repr(commandsInProgress), repr(componentsMapped)) if logger.isEnabledFor(logging.DEBUG): logger.debug("Heartbeat: %s", pformat(heartbeat)) hostInfo = HostInfo(self.config) if (int(id) >= 0) and state_interval > 0 and (int(id) % state_interval) == 0: nodeInfo = { } # for now, just do the same work as registration # this must be the last step before returning heartbeat hostInfo.register(nodeInfo, componentsMapped, commandsInProgress) heartbeat['agentEnv'] = nodeInfo mounts = Hardware.osdisks(self.config) heartbeat['mounts'] = mounts if logger.isEnabledFor(logging.DEBUG): logger.debug("agentEnv: %s", str(nodeInfo)) logger.debug("mounts: %s", str(mounts)) if self.collector is not None: heartbeat['alerts'] = self.collector.alerts() return heartbeat
def build(self, id='-1', state_interval=-1, componentsMapped=False): global clusterId, clusterDefinitionRevision, firstContact timestamp = int(time.time() * 1000) queueResult = self.actionQueue.result() nodeStatus = {"status": "HEALTHY", "cause": "NONE"} heartbeat = { 'responseId': int(id), 'timestamp': timestamp, 'hostname': hostname(self.config), 'nodeStatus': nodeStatus } commandsInProgress = False if not self.actionQueue.commandQueue.empty(): commandsInProgress = True if len(queueResult) != 0: heartbeat['reports'] = queueResult['reports'] heartbeat['componentStatus'] = queueResult['componentStatus'] if len(heartbeat['reports']) > 0: # There may be IN_PROGRESS tasks commandsInProgress = True pass # For first request/heartbeat assume no components are mapped if int(id) == 0: componentsMapped = False logger.info( "Building Heartbeat: {responseId = %s, timestamp = %s, commandsInProgress = %s, componentsMapped = %s}", str(id), str(timestamp), repr(commandsInProgress), repr(componentsMapped)) if logger.isEnabledFor(logging.DEBUG): logger.debug("Heartbeat: %s", pformat(heartbeat)) hostInfo = HostInfo(self.config) if (int(id) >= 0) and state_interval > 0 and (int(id) % state_interval) == 0: nodeInfo = {} # for now, just do the same work as registration # this must be the last step before returning heartbeat hostInfo.register(nodeInfo, componentsMapped, commandsInProgress) heartbeat['agentEnv'] = nodeInfo mounts = Hardware.osdisks() heartbeat['mounts'] = mounts if logger.isEnabledFor(logging.DEBUG): logger.debug("agentEnv: %s", str(nodeInfo)) logger.debug("mounts: %s", str(mounts)) if self.collector is not None: heartbeat['alerts'] = self.collector.alerts() return heartbeat
def osdiskAvailableSpace(self, path): diskInfo = {} try: df = subprocess.Popen(["df", "-kPT", path], stdout=subprocess.PIPE) dfdata = df.communicate()[0] return Hardware.extractMountInfo(dfdata.splitlines()[-1]) except: pass return diskInfo
def test_facterInfo(self, os_path_exists_mock, hardware_facterLib_mock, subprocess_popen_mock): config = AmbariConfig().getConfig() config.set("puppet", "facter_home", AmbariConfig().getConfig().get("stack", "installprefix")) hardware = Hardware(config) facter = MagicMock() facter.communicate.return_value = ["memoryfree => 1 GB\n memorysize => 25 MB\n memorytotal => 300 KB\n " + "physicalprocessorcount => 25\n is_virtual => true\n", "no errors"] facter.returncode = 0 os.environ['RUBYLIB'] = AmbariConfig().getConfig().get("stack", "installprefix"); subprocess_popen_mock.return_value = facter os_path_exists_mock.return_value = True hardware_facterLib_mock.return_value = "bla bla bla" facterInfo = hardware.facterInfo() self.assertEquals(facterInfo['memoryfree'], 1048576L) self.assertEquals(facterInfo['memorysize'], 25600L) self.assertEquals(facterInfo['memorytotal'], 300L) self.assertEquals(facterInfo['physicalprocessorcount'], 25) self.assertTrue(facterInfo['is_virtual']) self.assertEquals(subprocess_popen_mock.call_args[1]['env']['RUBYLIB'], AmbariConfig().getConfig().get("stack", "installprefix") + ":" + "bla bla bla") facter.communicate.return_value = ["memoryfree => 1 G\n memorysize => 25 M\n memorytotal => 300 K\n " + "someinfo => 12 Byte\n ssh_name_key => Aa06Fdd\n", "no errors"] facterInfo = hardware.facterInfo() facter.returncode = 1 self.assertEquals(facterInfo['memoryfree'], 1048576L) self.assertEquals(facterInfo['memorysize'], 25600L) self.assertEquals(facterInfo['memorytotal'], 300L) self.assertEquals(facterInfo['someinfo'], '12 Byte') self.assertFalse(facterInfo.has_key('ssh_name_key')) facter.communicate.return_value = ["memoryfree => 1024 M B\n memorytotal => 1024 Byte" , "no errors"] facterInfo = hardware.facterInfo() self.assertEquals(facterInfo['memoryfree'], 1L) self.assertEquals(facterInfo['memorytotal'], 1L) os_path_exists_mock.return_value = False facterInfo = hardware.facterInfo() self.assertEquals(facterInfo, {})
def test_build(self): hardware = Hardware() result = hardware.get() osdisks = hardware.osdisks() for dev_item in result['mounts']: self.assertTrue(dev_item['available'] >= 0) self.assertTrue(dev_item['used'] >= 0) self.assertTrue(dev_item['percent'] != None) self.assertTrue(dev_item['device'] != None) self.assertTrue(dev_item['mountpoint'] != None) self.assertTrue(dev_item['size'] > 0) for os_disk_item in osdisks: self.assertTrue(os_disk_item['available'] >= 0) self.assertTrue(os_disk_item['used'] >= 0) self.assertTrue(os_disk_item['percent'] != None) self.assertTrue(os_disk_item['device'] != None) self.assertTrue(os_disk_item['mountpoint'] != None) self.assertTrue(os_disk_item['size'] > 0) self.assertTrue(len(result['mounts']) == len(osdisks))
def test_build(self): hardware = Hardware(AmbariConfig().getConfig()) result = hardware.get() osdisks = hardware.osdisks() for dev_item in result['mounts']: self.assertTrue(dev_item['available'] >= 0) self.assertTrue(dev_item['used'] >= 0) self.assertTrue(dev_item['percent'] != None) self.assertTrue(dev_item['device'] != None) self.assertTrue(dev_item['mountpoint'] != None) self.assertTrue(dev_item['type'] != None) self.assertTrue(dev_item['size'] > 0) for os_disk_item in osdisks: self.assertTrue(os_disk_item['available'] >= 0) self.assertTrue(os_disk_item['used'] >= 0) self.assertTrue(os_disk_item['percent'] != None) self.assertTrue(os_disk_item['device'] != None) self.assertTrue(os_disk_item['mountpoint'] != None) self.assertTrue(os_disk_item['type'] != None) self.assertTrue(os_disk_item['size'] > 0) self.assertTrue(len(result['mounts']) == len(osdisks))
def test_facterInfo(self, os_path_exists_mock, hardware_facterLib_mock, subprocess_popen_mock): config = AmbariConfig().getConfig() config.set("puppet", "facter_home", AmbariConfig().getConfig().get("stack", "installprefix")) hardware = Hardware(config) facter = MagicMock() facter.communicate.return_value = [ "memoryfree => 1 GB\n memorysize => 25 MB\n memorytotal => 300 KB\n " + "physicalprocessorcount => 25\n is_virtual => true\n", "no errors" ] facter.returncode = 0 os.environ['RUBYLIB'] = AmbariConfig().getConfig().get( "stack", "installprefix") subprocess_popen_mock.return_value = facter os_path_exists_mock.return_value = True hardware_facterLib_mock.return_value = "bla bla bla" facterInfo = hardware.facterInfo() self.assertEquals(facterInfo['memoryfree'], 1048576L) self.assertEquals(facterInfo['memorysize'], 25600L) self.assertEquals(facterInfo['memorytotal'], 300L) self.assertEquals(facterInfo['physicalprocessorcount'], 25) self.assertTrue(facterInfo['is_virtual']) self.assertEquals( subprocess_popen_mock.call_args[1]['env']['RUBYLIB'], AmbariConfig().getConfig().get("stack", "installprefix") + ":" + "bla bla bla") facter.communicate.return_value = [ "memoryfree => 1 G\n memorysize => 25 M\n memorytotal => 300 K\n " + "someinfo => 12 Byte\n ssh_name_key => Aa06Fdd\n", "no errors" ] facterInfo = hardware.facterInfo() facter.returncode = 1 self.assertEquals(facterInfo['memoryfree'], 1048576L) self.assertEquals(facterInfo['memorysize'], 25600L) self.assertEquals(facterInfo['memorytotal'], 300L) self.assertEquals(facterInfo['someinfo'], '12 Byte') self.assertFalse(facterInfo.has_key('ssh_name_key')) facter.communicate.return_value = [ "memoryfree => 1024 M B\n memorytotal => 1024 Byte", "no errors" ] facterInfo = hardware.facterInfo() self.assertEquals(facterInfo['memoryfree'], 1L) self.assertEquals(facterInfo['memorytotal'], 1L) os_path_exists_mock.return_value = False facterInfo = hardware.facterInfo() self.assertEquals(facterInfo, {})
def test_osdisks_no_ignore_property(self, shell_call_mock, isfile_mock, chk_writable_mount_mock): df_output = \ """Filesystem Type 1024-blocks Used Available Capacity Mounted on /dev/mapper/docker-253:0-4980899-d45c264d37ab18c8ed14f890f4d59ac2b81e1c52919eb36a79419787209515f3 xfs 31447040 1282384 30164656 5% / """ isfile_mock.return_value = False chk_writable_mount_mock.return_value = True shell_call_mock.return_value = (0, df_output, '') config = AmbariConfig() # check, that config do not define ignore_mount_points property self.assertEquals( "test", config.get('agent', 'ignore_mount_points', default="test")) result = Hardware(config=config, cache_info=False).osdisks() self.assertEquals(1, len(result)) expected_mounts_left = ["/"] mounts_left = [item["mountpoint"] for item in result] self.assertEquals(expected_mounts_left, mounts_left)
def test_osdisks_remote(self, communicate_mock, popen_mock, get_os_version_mock, get_os_type_mock): get_os_type_mock.return_value = "suse" get_os_version_mock.return_value = "11" Hardware.osdisks() popen_mock.assert_called_with(['timeout', '10', "df","-kPT"], stdout=-1) config = AmbariConfig() Hardware.osdisks(config) popen_mock.assert_called_with(['timeout', '10', "df","-kPT"], stdout=-1) config.add_section(AmbariConfig.AMBARI_PROPERTIES_CATEGORY) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_KEY, "true") Hardware.osdisks(config) popen_mock.assert_called_with(['timeout', '10', "df","-kPT"], stdout=-1) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_KEY, "false") Hardware.osdisks(config) popen_mock.assert_called_with(['timeout', '10', "df","-kPT", "-l"], stdout=-1) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_TIMEOUT_KEY, "0") Hardware.osdisks(config) popen_mock.assert_called_with(['timeout', '10', "df","-kPT","-l"], stdout=-1) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_TIMEOUT_KEY, "1") Hardware.osdisks(config) popen_mock.assert_called_with(["timeout","1","df","-kPT","-l"], stdout=-1) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_TIMEOUT_KEY, "2") Hardware.osdisks(config) popen_mock.assert_called_with(["timeout","2","df","-kPT","-l"], stdout=-1)
def test_build(self): hardware = Hardware() result = hardware.get() self.assertTrue(result['coreCount'] >= 1) self.assertTrue(result['netSpeed'] != None)
def __init__(self, config): self.config = config self.hardware = Hardware(self.config) self.init_time_ms = int(1000 * time.time())
def __init__(self, config): self.config = config self.hardware = Hardware(self.config)
def test_osdisks_remote(self, shell_call_mock, get_os_version_mock, get_os_type_mock): get_os_type_mock.return_value = "suse" get_os_version_mock.return_value = "11" Hardware.osdisks() timeout = 10 shell_call_mock.assert_called_with( ['timeout', str(timeout), "df", "-kPT"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout, quiet=True) config = AmbariConfig() Hardware.osdisks(config) shell_call_mock.assert_called_with( ['timeout', str(timeout), "df", "-kPT"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout, quiet=True) config.add_section(AmbariConfig.AMBARI_PROPERTIES_CATEGORY) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_KEY, "true") Hardware.osdisks(config) shell_call_mock.assert_called_with( ['timeout', str(timeout), "df", "-kPT"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout, quiet=True) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_KEY, "false") Hardware.osdisks(config) shell_call_mock.assert_called_with( ['timeout', str(timeout), "df", "-kPT", "-l"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout, quiet=True) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_TIMEOUT_KEY, "0") Hardware.osdisks(config) shell_call_mock.assert_called_with( ['timeout', str(timeout), "df", "-kPT", "-l"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout, quiet=True) timeout = 1 config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_TIMEOUT_KEY, str(timeout)) Hardware.osdisks(config) shell_call_mock.assert_called_with( ['timeout', str(timeout), "df", "-kPT", "-l"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout, quiet=True) timeout = 2 config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_TIMEOUT_KEY, str(timeout)) Hardware.osdisks(config) shell_call_mock.assert_called_with( ['timeout', str(timeout), "df", "-kPT", "-l"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout, quiet=True)
def test_facterLib(self): hardware = Hardware(AmbariConfig().getConfig()) facterLib = hardware.facterLib("/home") self.assertEquals(facterLib, "/home/lib/")
def test_osdisks_remote(self, communicate_mock, popen_mock, get_os_version_mock, get_os_type_mock): get_os_type_mock.return_value = "suse" get_os_version_mock.return_value = "11" Hardware.osdisks() popen_mock.assert_called_with(['timeout', '10', "df", "-kPT"], stdout=-1) config = AmbariConfig() Hardware.osdisks(config) popen_mock.assert_called_with(['timeout', '10', "df", "-kPT"], stdout=-1) config.add_section(AmbariConfig.AMBARI_PROPERTIES_CATEGORY) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_KEY, "true") Hardware.osdisks(config) popen_mock.assert_called_with(['timeout', '10', "df", "-kPT"], stdout=-1) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_KEY, "false") Hardware.osdisks(config) popen_mock.assert_called_with(['timeout', '10', "df", "-kPT", "-l"], stdout=-1) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_TIMEOUT_KEY, "0") Hardware.osdisks(config) popen_mock.assert_called_with(['timeout', '10', "df", "-kPT", "-l"], stdout=-1) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_TIMEOUT_KEY, "1") Hardware.osdisks(config) popen_mock.assert_called_with(["timeout", "1", "df", "-kPT", "-l"], stdout=-1) config.set(AmbariConfig.AMBARI_PROPERTIES_CATEGORY, Hardware.CHECK_REMOTE_MOUNTS_TIMEOUT_KEY, "2") Hardware.osdisks(config) popen_mock.assert_called_with(["timeout", "2", "df", "-kPT", "-l"], stdout=-1)