def __init__(self, config=None, handlers=[], name=None, configfile=None):
super(BaseCollector, self).__init__(config, handlers, name, configfile)
self.cpu_collector = CPUCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.memory_collector = MemoryCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.loadavg_collector = LoadAverageCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.network_collector = NetworkCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.diskusage_collector = DiskUsageCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.diskspace_collector = DiskSpaceCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.vmstat_collector = VMStatCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
class BaseCollector(diamond.collector.Collector):
def __init__(self, config=None, handlers=[], name=None, configfile=None):
super(BaseCollector, self).__init__(config, handlers, name, configfile)
self.cpu_collector = CPUCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.memory_collector = MemoryCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.loadavg_collector = LoadAverageCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.network_collector = NetworkCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.diskusage_collector = DiskUsageCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.diskspace_collector = DiskSpaceCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.vmstat_collector = VMStatCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
def get_default_config_help(self):
config_help = super(BaseCollector, self).get_default_config_help()
config_help.update({
'simple': 'run simple mode on of its sub collectors',
})
return config_help
def get_default_config(self):
config = super(BaseCollector, self).get_default_config()
return config
def collect(self):
self.cpu_collector.collect()
self.memory_collector.collect()
self.loadavg_collector.collect()
self.network_collector.collect()
self.diskusage_collector.collect()
self.diskspace_collector.collect()
self.vmstat_collector.collect()
return True
def test_should_work_with_tmpfs(self, publish_mock):
config = get_collector_config(
'DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
'exclude_filters': [],
'filesystems': 'tmpfs'
})
self.collector = DiskSpaceCollector(config, None)
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
os_stat_mock = patch('os.stat')
os_major_mock = patch('os.major', Mock(return_value=4))
os_minor_mock = patch('os.minor', Mock(return_value=0))
os_path_isdir_mock = patch('os.path.isdir', Mock(return_value=False))
open_mock = patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_mounts')))
os_statvfs_mock = patch('os.statvfs', Mock(return_value=statvfs_mock))
os_stat_mock.start()
os_major_mock.start()
os_minor_mock.start()
os_path_isdir_mock.start()
open_mock.start()
os_statvfs_mock.start()
self.collector.collect()
os_stat_mock.stop()
os_major_mock.stop()
os_minor_mock.stop()
os_path_isdir_mock.stop()
open_mock.stop()
os_statvfs_mock.stop()
metrics = {
'tmp.gigabyte_used': (284.525, 2),
'tmp.gigabyte_free': (1090.826, 2),
'tmp.gigabyte_avail': (1020.962, 2),
'tmp.inodes_used': 348873,
'tmp.inodes_free': 91229495,
'tmp.inodes_avail': 91229495,
}
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
def setUp(self):
config = get_collector_config(
'DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
'exclude_filters': [
'^/export/home',
]
})
self.collector = DiskSpaceCollector(config, None)
class BaseCollector(diamond.collector.Collector):
def __init__(self, config=None, handlers=[], name=None, configfile=None):
super(BaseCollector, self).__init__(config, handlers, name, configfile)
self.cpu_collector = CPUCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.memory_collector = MemoryCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.loadavg_collector = LoadAverageCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.network_collector = NetworkCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.diskusage_collector = DiskUsageCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.diskspace_collector = DiskSpaceCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.vmstat_collector = VMStatCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
def get_default_config_help(self):
config_help = super(BaseCollector, self).get_default_config_help()
config_help.update({
'simple':
'run simple mode on of its sub collectors',
})
return config_help
def get_default_config(self):
config = super(BaseCollector, self).get_default_config()
return config
def collect(self):
self.cpu_collector.collect()
self.memory_collector.collect()
self.loadavg_collector.collect()
self.network_collector.collect()
self.diskusage_collector.collect()
self.diskspace_collector.collect()
self.vmstat_collector.collect()
return True
def setUp(self):
config = get_collector_config(
"DiskSpaceCollector",
{"interval": 10, "byte_unit": ["gigabyte"], "exclude_filters": ["^/export/home", "^/tmpfs"]},
)
self.collector = DiskSpaceCollector(config, None)
def setUp(self):
config = get_collector_config('DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
})
self.collector = DiskSpaceCollector(config, None)
def __init__(self, config=None, handlers=[], name=None, configfile=None):
super(BaseCollector, self).__init__(config, handlers, name, configfile)
self.cpu_collector = CPUCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.memory_collector = MemoryCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.loadavg_collector = LoadAverageCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.network_collector = NetworkCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.diskusage_collector = DiskUsageCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.diskspace_collector = DiskSpaceCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.vmstat_collector = VMStatCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
def test_should_work_with_tmpfs(self, publish_mock):
config = get_collector_config('DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
'exclude_filters': [],
'filesystems': 'tmpfs'
})
self.collector = DiskSpaceCollector(config, None)
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
os_stat_mock = patch('os.stat')
os_major_mock = patch('os.major', Mock(return_value=4))
os_minor_mock = patch('os.minor', Mock(return_value=0))
os_path_isdir_mock = patch('os.path.isdir', Mock(return_value=False))
open_mock = patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_mounts')))
os_statvfs_mock = patch('os.statvfs', Mock(return_value=statvfs_mock))
os_stat_mock.start()
os_major_mock.start()
os_minor_mock.start()
os_path_isdir_mock.start()
open_mock.start()
os_statvfs_mock.start()
self.collector.collect()
os_stat_mock.stop()
os_major_mock.stop()
os_minor_mock.stop()
os_path_isdir_mock.stop()
open_mock.stop()
os_statvfs_mock.stop()
metrics = {
'tmp.gigabyte_used': (284.525, 2),
'tmp.gigabyte_free': (1090.826, 2),
'tmp.gigabyte_avail': (1020.962, 2),
'tmp.inodes_used': 348873,
'tmp.inodes_free': 91229495,
'tmp.inodes_avail': 91229495,
}
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
def setUp(self):
config = get_collector_config('DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
'exclude_filters': [
'^/export/home',
]
})
self.collector = DiskSpaceCollector(config, None)
def test_should_work_in_system_directories(self, publish_mock):
config = get_collector_config(
'DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
'exclude_filters': [],
'filesystems': 'tmpfs',
'exclude_filters': '^/tmp'
})
self.collector = DiskSpaceCollector(config, None)
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
self.run_collection(statvfs_mock, 4, 0)
metrics = {
'_sys_fs_cgroup.gigabyte_used': (284.525, 2),
'_sys_fs_cgroup.gigabyte_free': (1090.826, 2),
'_sys_fs_cgroup.gigabyte_avail': (1020.962, 2),
'_sys_fs_cgroup.inodes_used': 348873,
'_sys_fs_cgroup.inodes_free': 91229495,
'_sys_fs_cgroup.inodes_avail': 91229495,
}
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
def test_should_work_in_system_directories(self, publish_mock):
config = get_collector_config('DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
'exclude_filters': [],
'filesystems': 'tmpfs',
'exclude_filters': '^/tmp'
})
self.collector = DiskSpaceCollector(config, None)
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
self.run_collection(statvfs_mock, 4, 0)
metrics = {
'_sys_fs_cgroup.gigabyte_used': (284.525, 2),
'_sys_fs_cgroup.gigabyte_free': (1090.826, 2),
'_sys_fs_cgroup.gigabyte_avail': (1020.962, 2),
'_sys_fs_cgroup.inodes_used': 348873,
'_sys_fs_cgroup.inodes_free': 91229495,
'_sys_fs_cgroup.inodes_avail': 91229495,
}
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
class TestDiskSpaceCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config(
'DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
'exclude_filters': [
'^/export/home',
'^/tmpfs',
]
})
self.collector = DiskSpaceCollector(config, None)
def test_import(self):
self.assertTrue(DiskSpaceCollector)
@run_only_if_major_is_available
@patch('os.access', Mock(return_value=True))
def test_get_file_systems(self):
result = None
os_stat_mock = patch('os.stat')
os_major_mock = patch('os.major')
os_minor_mock = patch('os.minor')
os_realpath_mock = patch('os.path.realpath')
open_mock = patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_mounts')))
stat_mock = os_stat_mock.start()
stat_mock.return_value.st_dev = 42
major_mock = os_major_mock.start()
major_mock.return_value = 9
minor_mock = os_minor_mock.start()
minor_mock.return_value = 0
realpath_mock = os_realpath_mock.start()
realpath_mock.return_value = '/dev/sda1'
omock = open_mock.start()
result = self.collector.get_file_systems()
os_stat_mock.stop()
os_major_mock.stop()
os_minor_mock.stop()
os_realpath_mock.stop()
open_mock.stop()
stat_mock.assert_called_once_with('/')
major_mock.assert_called_once_with(42)
minor_mock.assert_called_once_with(42)
realpath_mock.assert_called_once_with(
'/dev/disk/by-uuid/81969733-a724-4651-9cf5-64970f86daba')
self.assertEqual(result, {
(9, 0): {
'device': '/dev/sda1',
'fs_type': 'ext3',
'mount_point': '/'
}
})
omock.assert_called_once_with('/host_proc/mounts')
return result
@run_only_if_major_is_available
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
os_stat_mock = patch('os.stat')
os_major_mock = patch('os.major', Mock(return_value=9))
os_minor_mock = patch('os.minor', Mock(return_value=0))
os_path_isdir_mock = patch('os.path.isdir', Mock(return_value=False))
open_mock = patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_mounts')))
os_statvfs_mock = patch('os.statvfs', Mock(return_value=statvfs_mock))
os_stat_mock.start()
os_major_mock.start()
os_minor_mock.start()
os_path_isdir_mock.start()
open_mock.start()
os_statvfs_mock.start()
self.collector.collect()
os_stat_mock.stop()
os_major_mock.stop()
os_minor_mock.stop()
os_path_isdir_mock.stop()
open_mock.stop()
os_statvfs_mock.stop()
metrics = {
'root.gigabyte_used': (284.525, 2),
'root.gigabyte_free': (1090.826, 2),
'root.gigabyte_avail': (1020.962, 2),
'root.inodes_used': 348873,
'root.inodes_free': 91229495,
'root.inodes_avail': 91229495
}
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
class TestDiskSpaceCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskSpaceCollector', {
'interval': 10,
})
self.collector = DiskSpaceCollector(config, None)
@patch('os.access', Mock(return_value=True))
def test_get_file_systems(self):
result = None
with nested(
patch('os.stat'), patch('os.major'), patch('os.minor'),
patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_mounts')))) as (
os_stat_mock, os_major_mock, os_minor_mock,
open_mock):
os_stat_mock.return_value.st_dev = 42
os_major_mock.return_value = 9
os_minor_mock.return_value = 0
result = self.collector.get_file_systems()
os_stat_mock.assert_called_once_with('/')
os_major_mock.assert_called_once_with(42)
os_minor_mock.assert_called_once_with(42)
self.assertEqual(
result, {
(9, 0): {
'device':
'/dev/disk/by-uuid/81969733-a724-4651-9cf5-64970f86daba',
'fs_type': 'ext3',
'mount_point': '/'
}
})
open_mock.assert_called_once_with('/proc/mounts')
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
with nested(
patch('os.stat'), patch('os.major', Mock(return_value=9)),
patch('os.minor', Mock(return_value=0)),
patch('os.path.isdir', Mock(return_value=False)),
patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_mounts'))),
patch('os.statvfs', Mock(return_value=statvfs_mock))):
self.collector.collect()
metrics = {
'root.gigabyte_used': (284.525, 2),
'root.gigabyte_free': (1090.826, 2),
'root.gigabyte_avail': (1020.962, 2),
'root.inodes_used': 348873,
'root.inodes_free': 91229495,
'root.inodes_avail': 91229495
}
self.setDocExample(self.collector.__class__.__name__, metrics)
self.assertPublishedMany(publish_mock, metrics)
class TestDiskSpaceCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
})
self.collector = DiskSpaceCollector(config, None)
@patch('os.access', Mock(return_value=True))
def test_get_file_systems(self):
result = None
with nested(
patch('os.stat'),
patch('os.major'),
patch('os.minor'),
patch('__builtin__.open', Mock(
return_value=self.getFixture('proc_mounts')))
) as (os_stat_mock, os_major_mock, os_minor_mock, open_mock):
os_stat_mock.return_value.st_dev = 42
os_major_mock.return_value = 9
os_minor_mock.return_value = 0
result = self.collector.get_file_systems()
os_stat_mock.assert_called_once_with('/')
os_major_mock.assert_called_once_with(42)
os_minor_mock.assert_called_once_with(42)
self.assertEqual(result, {
(9, 0): {
'device':
'/dev/disk/by-uuid/81969733-a724-4651-9cf5-64970f86daba',
'fs_type': 'ext3',
'mount_point': '/'}
})
open_mock.assert_called_once_with('/proc/mounts')
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
with nested(
patch('os.stat'),
patch('os.major', Mock(return_value=9)),
patch('os.minor', Mock(return_value=0)),
patch('os.path.isdir', Mock(return_value=False)),
patch('__builtin__.open', Mock(
return_value=self.getFixture('proc_mounts'))),
patch('os.statvfs', Mock(return_value=statvfs_mock))
):
self.collector.collect()
metrics = {
'root.gigabyte_used': (284.525, 2),
'root.gigabyte_free': (1090.826, 2),
'root.gigabyte_avail': (1020.962, 2),
'root.inodes_used': 348873,
'root.inodes_free': 91229495,
'root.inodes_avail': 91229495
}
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
def setUp(self):
config = get_collector_config('DiskSpaceCollector', {
'interval': 10,
})
self.collector = DiskSpaceCollector(config, None)
class TestDiskSpaceCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskSpaceCollector', {
'interval': 10,
})
self.collector = DiskSpaceCollector(config, None)
@patch('__builtin__.open')
@patch('os.access', Mock(return_value=True))
def test_get_file_systems(self, open_mock):
result = None
open_mock.return_value = StringIO("""
rootfs / rootfs rw 0 0
none /sys sysfs rw,nosuid,nodev,noexec,relatime 0 0
none /proc proc rw,nosuid,nodev,noexec,relatime 0 0
none /dev devtmpfs rw,relatime,size=24769364k,nr_inodes=6192341,mode=755 0 0
none /dev/pts devpts rw,nosuid,noexec,relatime,gid=5,mode=620,ptmxmode=000 0 0
fusectl /sys/fs/fuse/connections fusectl rw,relatime 0 0
/dev/disk/by-uuid/81969733-a724-4651-9cf5-64970f86daba / ext3 rw,relatime,errors=continue,barrier=0,data=ordered 0 0
none /sys/kernel/debug debugfs rw,relatime 0 0
none /sys/kernel/security securityfs rw,relatime 0 0
none /dev/shm tmpfs rw,nosuid,nodev,relatime 0 0
none /var/run tmpfs rw,nosuid,relatime,mode=755 0 0
none /var/lock tmpfs rw,nosuid,nodev,noexec,relatime 0 0
""".strip())
with nested(patch('os.stat'), patch('os.major'),
patch('os.minor')) as (os_stat_mock, os_major_mock,
os_minor_mock):
os_stat_mock.return_value.st_dev = 42
os_major_mock.return_value = 9
os_minor_mock.return_value = 0
result = self.collector.get_file_systems()
os_stat_mock.assert_called_once_with('/')
os_major_mock.assert_called_once_with(42)
os_minor_mock.assert_called_once_with(42)
self.assertEqual(
result, {
(9, 0): {
'device':
'/dev/disk/by-uuid/81969733-a724-4651-9cf5-64970f86daba',
'fs_type': 'ext3',
'mount_point': '/'
}
})
open_mock.assert_called_once_with('/proc/mounts')
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
with nested(
patch('os.stat'), patch('os.major', Mock(return_value=9)),
patch('os.minor', Mock(return_value=0)),
patch('os.path.isdir', Mock(return_value=False)),
patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_mounts'))),
patch('os.statvfs', Mock(return_value=statvfs_mock))):
self.collector.collect()
self.assertPublishedMany(
publish_mock, {
'root.gigabyte_used': (284.525, 2),
'root.gigabyte_free': (1090.826, 2),
'root.gigabyte_avail': (1020.962, 2),
'root.inodes_used': 348873,
'root.inodes_free': 91229495,
'root.inodes_avail': 91229495
})
class TestDiskSpaceCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config(
"DiskSpaceCollector",
{"interval": 10, "byte_unit": ["gigabyte"], "exclude_filters": ["^/export/home", "^/tmpfs"]},
)
self.collector = DiskSpaceCollector(config, None)
def test_import(self):
self.assertTrue(DiskSpaceCollector)
@run_only_if_major_is_available
@patch("os.access", Mock(return_value=True))
def test_get_file_systems(self):
result = None
os_stat_mock = patch("os.stat")
os_major_mock = patch("os.major")
os_minor_mock = patch("os.minor")
os_realpath_mock = patch("os.path.realpath")
open_mock = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_mounts")))
stat_mock = os_stat_mock.start()
stat_mock.return_value.st_dev = 42
major_mock = os_major_mock.start()
major_mock.return_value = 9
minor_mock = os_minor_mock.start()
minor_mock.return_value = 0
realpath_mock = os_realpath_mock.start()
realpath_mock.return_value = "/dev/sda1"
omock = open_mock.start()
result = self.collector.get_file_systems()
os_stat_mock.stop()
os_major_mock.stop()
os_minor_mock.stop()
os_realpath_mock.stop()
open_mock.stop()
stat_mock.assert_called_once_with("/")
major_mock.assert_called_once_with(42)
minor_mock.assert_called_once_with(42)
realpath_mock.assert_called_once_with("/dev/disk/by-uuid/81969733-a724-4651-9cf5-64970f86daba")
self.assertEqual(result, {(9, 0): {"device": "/dev/sda1", "fs_type": "ext3", "mount_point": "/"}})
omock.assert_called_once_with("/proc/mounts")
return result
@run_only_if_major_is_available
@patch("os.access", Mock(return_value=True))
@patch.object(Collector, "publish")
def test_should_work_with_real_data(self, publish_mock):
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
os_stat_mock = patch("os.stat")
os_major_mock = patch("os.major", Mock(return_value=9))
os_minor_mock = patch("os.minor", Mock(return_value=0))
os_path_isdir_mock = patch("os.path.isdir", Mock(return_value=False))
open_mock = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_mounts")))
os_statvfs_mock = patch("os.statvfs", Mock(return_value=statvfs_mock))
os_stat_mock.start()
os_major_mock.start()
os_minor_mock.start()
os_path_isdir_mock.start()
open_mock.start()
os_statvfs_mock.start()
self.collector.collect()
os_stat_mock.stop()
os_major_mock.stop()
os_minor_mock.stop()
os_path_isdir_mock.stop()
open_mock.stop()
os_statvfs_mock.stop()
metrics = {
"root.gigabyte_used": (284.525, 2),
"root.gigabyte_free": (1090.826, 2),
"root.gigabyte_avail": (1020.962, 2),
"root.inodes_used": 348873,
"root.inodes_free": 91229495,
"root.inodes_avail": 91229495,
}
self.setDocExample(
collector=self.collector.__class__.__name__, metrics=metrics, defaultpath=self.collector.config["path"]
)
self.assertPublishedMany(publish_mock, metrics)
class TestDiskSpaceCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
'exclude_filters': [
'^/export/home',
]
})
self.collector = DiskSpaceCollector(config, None)
def test_import(self):
self.assertTrue(DiskSpaceCollector)
def run_collection(self, statvfs_mock, os_major, os_minor):
os_stat_mock = patch('os.stat')
os_path_isdir_mock = patch('os.path.isdir', Mock(return_value=False))
open_mock = patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_mounts')))
os_statvfs_mock = patch('os.statvfs', Mock(return_value=statvfs_mock))
os_stat_mock.start()
os_path_isdir_mock.start()
open_mock.start()
os_statvfs_mock.start()
self.collector.collect()
os_stat_mock.stop()
os_path_isdir_mock.stop()
open_mock.stop()
os_statvfs_mock.stop()
@patch('os.access', Mock(return_value=True))
def test_get_file_systems(self):
result = None
os_stat_mock = patch('os.stat')
os_realpath_mock = patch('os.path.realpath')
open_mock = patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_mounts')))
stat_mock = os_stat_mock.start()
stat_mock.return_value.st_dev = 42
realpath_mock = os_realpath_mock.start()
realpath_mock.return_value = '/dev/sda1'
omock = open_mock.start()
result = self.collector.get_file_systems()
os_stat_mock.stop()
os_realpath_mock.stop()
open_mock.stop()
stat_mock.assert_called_once_with('/')
realpath_mock.assert_called_once_with(
'/dev/disk/by-uuid/81969733-a724-4651-9cf5-64970f86daba')
self.assertEqual(result, {
42: {
'device':
'/dev/sda1',
'fs_type': 'ext3',
'mount_point': '/'}
})
omock.assert_called_once_with('/proc/mounts')
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
statvfs_mock = Mock()
statvfs_mock.f_bsize = 1048576
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
self.run_collection(statvfs_mock, 9, 0)
metrics = {
'root.gigabyte_used': (284.525, 2),
'root.gigabyte_free': (1090.826, 2),
'root.gigabyte_avail': (1020.962, 2),
'root.inodes_used': 348873,
'root.inodes_free': 91229495,
'root.inodes_avail': 91229495,
}
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_tmpfs(self, publish_mock):
config = get_collector_config('DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
'exclude_filters': [],
'filesystems': 'tmpfs',
'exclude_filters': '^/sys'
})
self.collector = DiskSpaceCollector(config, None)
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
self.run_collection(statvfs_mock, 4, 0)
metrics = {
'tmp.gigabyte_used': (284.525, 2),
'tmp.gigabyte_free': (1090.826, 2),
'tmp.gigabyte_avail': (1020.962, 2),
'tmp.inodes_used': 348873,
'tmp.inodes_free': 91229495,
'tmp.inodes_avail': 91229495,
}
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_in_system_directories(self, publish_mock):
config = get_collector_config('DiskSpaceCollector', {
'interval': 10,
'byte_unit': ['gigabyte'],
'exclude_filters': [],
'filesystems': 'tmpfs',
'exclude_filters': '^/tmp'
})
self.collector = DiskSpaceCollector(config, None)
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
self.run_collection(statvfs_mock, 4, 0)
metrics = {
'_sys_fs_cgroup.gigabyte_used': (284.525, 2),
'_sys_fs_cgroup.gigabyte_free': (1090.826, 2),
'_sys_fs_cgroup.gigabyte_avail': (1020.962, 2),
'_sys_fs_cgroup.inodes_used': 348873,
'_sys_fs_cgroup.inodes_free': 91229495,
'_sys_fs_cgroup.inodes_avail': 91229495,
}
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
class TestDiskSpaceCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskSpaceCollector', {
'interval' : 10,
})
self.collector = DiskSpaceCollector(config, None)
@patch('__builtin__.open')
@patch('os.access', Mock(return_value=True))
def test_get_file_systems(self, open_mock):
result = None
open_mock.return_value = StringIO("""
rootfs / rootfs rw 0 0
none /sys sysfs rw,nosuid,nodev,noexec,relatime 0 0
none /proc proc rw,nosuid,nodev,noexec,relatime 0 0
none /dev devtmpfs rw,relatime,size=24769364k,nr_inodes=6192341,mode=755 0 0
none /dev/pts devpts rw,nosuid,noexec,relatime,gid=5,mode=620,ptmxmode=000 0 0
fusectl /sys/fs/fuse/connections fusectl rw,relatime 0 0
/dev/disk/by-uuid/81969733-a724-4651-9cf5-64970f86daba / ext3 rw,relatime,errors=continue,barrier=0,data=ordered 0 0
none /sys/kernel/debug debugfs rw,relatime 0 0
none /sys/kernel/security securityfs rw,relatime 0 0
none /dev/shm tmpfs rw,nosuid,nodev,relatime 0 0
none /var/run tmpfs rw,nosuid,relatime,mode=755 0 0
none /var/lock tmpfs rw,nosuid,nodev,noexec,relatime 0 0
""".strip())
with nested(
patch('os.stat'), patch('os.major'), patch('os.minor')
) as (os_stat_mock, os_major_mock, os_minor_mock):
os_stat_mock.return_value.st_dev = 42
os_major_mock.return_value = 9
os_minor_mock.return_value = 0
result = self.collector.get_file_systems()
os_stat_mock.assert_called_once_with('/')
os_major_mock.assert_called_once_with(42)
os_minor_mock.assert_called_once_with(42)
self.assertEqual(result, {
(9, 0) : {'device' : '/dev/disk/by-uuid/81969733-a724-4651-9cf5-64970f86daba', 'fs_type': 'ext3', 'mount_point' : '/'}
})
open_mock.assert_called_once_with('/proc/mounts')
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
statvfs_mock = Mock()
statvfs_mock.f_bsize = 4096
statvfs_mock.f_frsize = 4096
statvfs_mock.f_blocks = 360540255
statvfs_mock.f_bfree = 285953527
statvfs_mock.f_bavail = 267639130
statvfs_mock.f_files = 91578368
statvfs_mock.f_ffree = 91229495
statvfs_mock.f_favail = 91229495
statvfs_mock.f_flag = 4096
statvfs_mock.f_namemax = 255
with nested(
patch('os.stat'),
patch('os.major', Mock(return_value = 9)),
patch('os.minor', Mock(return_value = 0)),
patch('os.path.isdir', Mock(return_value = False)),
patch('__builtin__.open', Mock(return_value = self.getFixture('proc_mounts'))),
patch('os.statvfs', Mock(return_value = statvfs_mock))
):
self.collector.collect()
self.assertPublishedMany(publish_mock, {
'root.gigabyte_used' : ( 284.525, 2),
'root.gigabyte_free' : (1090.826, 2),
'root.gigabyte_avail' : (1020.962, 2),
'root.inodes_used' : 348873,
'root.inodes_free' : 91229495,
'root.inodes_avail' : 91229495
})
def setUp(self):
config = get_collector_config('DiskSpaceCollector', {
'interval' : 10,
})
self.collector = DiskSpaceCollector(config, None)
