def volumeStatvfs(volumeName, host=GLUSTER_VOL_HOST,
port=GLUSTER_VOL_PORT,
protocol=GLUSTER_VOL_PROTOCOL):
module = "gluster.gfapi"
command = [constants.EXT_PYTHON, '-m', module, '-v', volumeName,
'-p', str(port), '-H', host, '-t', protocol, '-c', 'statvfs']
# to include /usr/share/vdsm in python path
env = os.environ.copy()
env['PYTHONPATH'] = "%s:%s" % (
env.get("PYTHONPATH", ""), constants.P_VDSM)
env['PYTHONPATH'] = ":".join(map(os.path.abspath,
env['PYTHONPATH'].split(":")))
rc, out, err = commands.execCmd(command, raw=True, env=env)
if rc != 0:
raise ge.GlfsStatvfsException(rc, [out], [err])
res = json.loads(out)
return os.statvfs_result((res['f_bsize'],
res['f_frsize'],
res['f_blocks'],
res['f_bfree'],
res['f_bavail'],
res['f_files'],
res['f_ffree'],
res['f_favail'],
res['f_flag'],
res['f_namemax']))
def volumeStatvfsGet(volumeId, host=GLUSTER_VOL_HOST,
port=GLUSTER_VOL_PORT,
protocol=GLUSTER_VOL_PROTOCOL):
statvfsdata = StatVfsStruct()
fs = glfsInit(volumeId, host, port, protocol)
rc = _glfs_statvfs(fs, GLUSTER_VOL_PATH, ctypes.byref(statvfsdata))
if rc != 0:
raise ge.GlfsStatvfsException(rc=rc)
glfsFini(fs, volumeId)
# To convert to os.statvfs_result we need to pass tuple/list in
# following order: bsize, frsize, blocks, bfree, bavail, files,
# ffree, favail, flag, namemax
return os.statvfs_result((statvfsdata.f_bsize,
statvfsdata.f_frsize,
statvfsdata.f_blocks,
statvfsdata.f_bfree,
statvfsdata.f_bavail,
statvfsdata.f_files,
statvfsdata.f_ffree,
statvfsdata.f_favail,
statvfsdata.f_flag,
statvfsdata.f_namemax))
def useddiskspace(path): return 0 # for testing purposes if sys.platform == "linux2": r=os.statvfs_result(os.statvfs(path)) return r.f_bsize*r.f_blocks-r.f_bsize*r.f_bfree else: return 0 #could be a bad idea
def test_ignore_unmounted_and_virtual_mountpoints(self):
"""
Make sure autofs and virtual mountpoints are ignored. This is to
ensure non-regression on bug #1045374.
"""
self.read_access = True
content = "\n".join([
"auto_direct /opt/whatever autofs", "none /run/lock tmpfs",
"proc /proc proc", "/dev/sda1 /home ext4"
])
f = open(self.mount_file, "w")
f.write(content)
f.close()
self.stat_results["/home"] = os.statvfs_result(
(4096, 0, 1000, 500, 0, 0, 0, 0, 0, 0))
result = [x for x in get_mount_info(self.mount_file, self.statvfs)]
expected = {
"device": "/dev/sda1",
"mount-point": "/home",
"filesystem": "ext4",
"total-space": 3,
"free-space": 1
}
self.assertEqual([expected], result)
def test_statvfs_attributes(self):
if not hasattr(os, "statvfs"):
return
try:
result = os.statvfs(self.fname)
except OSError as e:
# On AtheOS, glibc always returns ENOSYS
if e.errno == errno.ENOSYS:
return
# Make sure direct access works
self.assertEqual(result.f_bfree, result[3])
# Make sure all the attributes are there.
members = ('bsize', 'frsize', 'blocks', 'bfree', 'bavail', 'files',
'ffree', 'favail', 'flag', 'namemax')
for value, member in enumerate(members):
self.assertEqual(getattr(result, 'f_' + member), result[value])
# Make sure that assignment really fails
try:
result.f_bfree = 1
self.fail("No exception thrown")
except AttributeError:
pass
try:
result.parrot = 1
self.fail("No exception thrown")
except AttributeError:
pass
# Use the constructor with a too-short tuple.
try:
result2 = os.statvfs_result((10, ))
self.fail("No exception thrown")
except TypeError:
pass
# Use the constructor with a too-long tuple.
try:
result2 = os.statvfs_result(
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
except TypeError:
pass
def test_statvfs_attributes(self):
if not hasattr(os, "statvfs"):
return
try:
result = os.statvfs(self.fname)
except OSError as e:
# On AtheOS, glibc always returns ENOSYS
import errno
if e.errno == errno.ENOSYS:
return
# Make sure direct access works
self.assertEquals(result.f_bfree, result[3])
# Make sure all the attributes are there.
members = ('bsize', 'frsize', 'blocks', 'bfree', 'bavail', 'files',
'ffree', 'favail', 'flag', 'namemax')
for value, member in enumerate(members):
self.assertEquals(getattr(result, 'f_' + member), result[value])
# Make sure that assignment really fails
try:
result.f_bfree = 1
self.fail("No exception thrown")
except AttributeError:
pass
try:
result.parrot = 1
self.fail("No exception thrown")
except AttributeError:
pass
# Use the constructor with a too-short tuple.
try:
result2 = os.statvfs_result((10,))
self.fail("No exception thrown")
except TypeError:
pass
# Use the constructr with a too-long tuple.
try:
result2 = os.statvfs_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
except TypeError:
pass
def test_statvfs_attributes(self):
if not hasattr(os, "statvfs"):
return
import statvfs
result = os.statvfs(self.fname)
# Make sure direct access works
self.assertEquals(result.f_bfree, result[statvfs.F_BFREE])
# Make sure all the attributes are there
members = dir(result)
for name in dir(statvfs):
if name[:2] == 'F_':
attr = name.lower()
self.assertEquals(getattr(result, attr),
result[getattr(statvfs, name)])
self.assert_(attr in members)
# Make sure that assignment really fails
try:
result.f_bfree = 1
self.fail("No exception thrown")
except TypeError:
pass
try:
result.parrot = 1
self.fail("No exception thrown")
except AttributeError:
pass
# Use the constructor with a too-short tuple.
try:
result2 = os.statvfs_result((10, ))
self.fail("No exception thrown")
except TypeError:
pass
# Use the constructr with a too-long tuple.
try:
result2 = os.statvfs_result(
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
except TypeError:
pass
def test_statvfs_attributes(self):
if not hasattr(os, "statvfs"):
return
import statvfs
result = os.statvfs(self.fname)
# Make sure direct access works
self.assertEquals(result.f_bfree, result[statvfs.F_BFREE])
# Make sure all the attributes are there
members = dir(result)
for name in dir(statvfs):
if name[:2] == "F_":
attr = name.lower()
self.assertEquals(getattr(result, attr), result[getattr(statvfs, name)])
self.assert_(attr in members)
# Make sure that assignment really fails
try:
result.f_bfree = 1
self.fail("No exception thrown")
except TypeError:
pass
try:
result.parrot = 1
self.fail("No exception thrown")
except AttributeError:
pass
# Use the constructor with a too-short tuple.
try:
result2 = os.statvfs_result((10,))
self.fail("No exception thrown")
except TypeError:
pass
# Use the constructr with a too-long tuple.
try:
result2 = os.statvfs_result((0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
except TypeError:
pass
def statvfs(self, path):
"""
:param str path: Absolute path on target.
:rtype: os.statvfs_result
Return statvfs information (disk size, free space etc.) about remote
filesystem.
"""
st = self.evaluate(f'import os; print(os.statvfs({str(path)!r}))')
return os.statvfs_result(st)
def get_mount_info(self, *args, **kwargs):
if "mounts_file" not in kwargs:
kwargs["mounts_file"] = self.makeFile("/dev/hda1 / ext3 rw 0 0\n")
if "mtab_file" not in kwargs:
kwargs["mtab_file"] = self.makeFile("/dev/hda1 / ext3 rw 0 0\n")
if "statvfs" not in kwargs:
kwargs["statvfs"] = lambda path: os.statvfs_result(
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
plugin = MountInfo(*args, **kwargs)
# To make sure tests are isolated from the real system by default.
plugin.is_device_removable = lambda x: False
return plugin
def add_mount(self,
point,
block_size=4096,
capacity=1000,
unused=1000,
fs="ext3",
device=None):
if device is None:
device = "/dev/" + point.replace("/", "_")
self.stat_results[point] = os.statvfs_result(
(block_size, 0, capacity, unused, 0, 0, 0, 0, 0, 0))
f = open(self.mount_file, "a")
f.write("/dev/%s %s %s rw 0 0\n" % (device, point, fs))
f.close()
def mock_os_statvfs(self):
f_bsize = 4096
f_frsize = 4096
f_blocks = 12868767
f_bfree = 11503139
f_bavail = 10847779
f_files = 3276800
f_ffree = 3220784
f_favail = 3220784
f_flag = 4096
f_namemax = 255
return os.statvfs_result((f_bsize, f_frsize,
f_blocks, f_bfree,
f_bavail, f_files,
f_ffree, f_favail,
f_flag, f_namemax))
def statvfs(volume, host='localhost', port=24007, protocal='tcp'):
_lazy_init_libgfapi()
data = StatVfsData()
_api.glfs_statvfs.restype = ctypes.c_int
_api.glfs_statvfs.argtypes = [
ctypes.c_void_p, ctypes.c_char_p,
ctypes.POINTER(StatVfsData)
]
fs = _mount_gluster_volume(volume, host, port, protocal)
rc = _api.glfs_statvfs(fs, "/", ctypes.byref(data))
# To convert to os.statvfs_result we need to pass tuple/list in
# following order: bsize, frsize, blocks, bfree, bavail, files
# ffree, favail, flag, namemax
return os.statvfs_result(
(data.f_bsize, data.f_frsize, data.f_blocks, data.f_bfree,
data.f_bavail, data.f_files, data.f_ffree, data.f_favail, data.f_flag,
data.f_namemax))
def set_mount_points(self, points, read_access=True, fs='ext4'):
"""
This method prepares a fake mounts file containing the
mount points specified in the C{points} list of strings. This file
can then be used by referencing C{self.mount_file}.
If C{read_access} is set to C{False}, then all mount points will
yield a permission denied error when inspected.
"""
self.read_access = read_access
content = "\n".join("/dev/sda%d %s %s rw 0 0" % (i, point, fs)
for i, point in enumerate(points))
f = open(self.mount_file, "w")
f.write(content)
f.close()
for point in points:
self.stat_results[point] = os.statvfs_result(
(4096, 0, 1000, 500, 0, 0, 0, 0, 0, 0))
def volumeStatvfs(volumeName, host=GLUSTER_VOL_HOST, port=GLUSTER_VOL_PORT, protocol=GLUSTER_VOL_PROTOCOL):
module = "gluster.gfapi"
command = [
constants.EXT_PYTHON,
"-m",
module,
"-v",
volumeName,
"-p",
str(port),
"-H",
host,
"-t",
protocol,
"-c",
"statvfs",
]
# to include /usr/share/vdsm in python path
env = os.environ.copy()
env["PYTHONPATH"] = "%s:%s" % (env.get("PYTHONPATH", ""), constants.P_VDSM)
env["PYTHONPATH"] = ":".join(map(os.path.abspath, env["PYTHONPATH"].split(":")))
rc, out, err = commands.execCmd(command, raw=True, env=env)
if rc != 0:
raise ge.GlfsStatvfsException(rc, [out], [err])
res = json.loads(out)
return os.statvfs_result(
(
res["f_bsize"],
res["f_frsize"],
res["f_blocks"],
res["f_bfree"],
res["f_bavail"],
res["f_files"],
res["f_ffree"],
res["f_favail"],
res["f_flag"],
res["f_namemax"],
)
)
def volumeStatvfsGet(volumeId,
host=GLUSTER_VOL_HOST,
port=GLUSTER_VOL_PORT,
protocol=GLUSTER_VOL_PROTOCOL):
statvfsdata = StatVfsStruct()
fs = glfsInit(volumeId, host, port, protocol)
rc = _glfs_statvfs(fs, GLUSTER_VOL_PATH, ctypes.byref(statvfsdata))
if rc != 0:
raise ge.GlfsStatvfsException(rc=rc)
glfsFini(fs, volumeId)
# To convert to os.statvfs_result we need to pass tuple/list in
# following order: bsize, frsize, blocks, bfree, bavail, files,
# ffree, favail, flag, namemax
return os.statvfs_result(
(statvfsdata.f_bsize, statvfsdata.f_frsize, statvfsdata.f_blocks,
statvfsdata.f_bfree, statvfsdata.f_bavail, statvfsdata.f_files,
statvfsdata.f_ffree, statvfsdata.f_favail, statvfsdata.f_flag,
statvfsdata.f_namemax))
def statvfs(volume, host='localhost', port=24007, protocal='tcp'):
_lazy_init_libgfapi()
data = StatVfsData()
_api.glfs_statvfs.restype = ctypes.c_int
_api.glfs_statvfs.argtypes = [ctypes.c_void_p,
ctypes.c_char_p,
ctypes.POINTER(StatVfsData)]
fs = _mount_gluster_volume(volume, host, port, protocal)
rc = _api.glfs_statvfs(fs, "/", ctypes.byref(data))
# To convert to os.statvfs_result we need to pass tuple/list in
# following order: bsize, frsize, blocks, bfree, bavail, files
# ffree, favail, flag, namemax
return os.statvfs_result((data.f_bsize,
data.f_frsize,
data.f_blocks,
data.f_bfree,
data.f_bavail,
data.f_files,
data.f_ffree,
data.f_favail,
data.f_flag,
data.f_namemax))
def volumeStatvfs(volumeName,
host=GLUSTER_VOL_HOST,
port=GLUSTER_VOL_PORT,
protocol=GLUSTER_VOL_PROTOCOL):
module = "gluster.gfapi"
command = [
constants.EXT_PYTHON, '-m', module, '-v', volumeName, '-p',
str(port), '-H', host, '-t', protocol, '-c', 'statvfs'
]
# to include /usr/share/vdsm in python path
env = os.environ.copy()
env['PYTHONPATH'] = "%s:%s" % (env.get("PYTHONPATH", ""), constants.P_VDSM)
env['PYTHONPATH'] = ":".join(
map(os.path.abspath, env['PYTHONPATH'].split(":")))
rc, out, err = utils.execCmd(command, raw=True, env=env)
if rc != 0:
raise ge.GlfsStatvfsException(rc, [out], [err])
res = json.loads(out)
return os.statvfs_result(
(res['f_bsize'], res['f_frsize'], res['f_blocks'], res['f_bfree'],
res['f_bavail'], res['f_files'], res['f_ffree'], res['f_favail'],
res['f_flag'], res['f_namemax']))
def freediskspace(path): if sys.platform == "linux2": r=os.statvfs_result(os.statvfs(path)) return r.f_bsize*r.f_bavail else: return 0 #could be a bad idea
def make_statvfs_result(tup):
return os.statvfs_result(tup)
def get_free_space(self):
st = os.statvfs_result(".")
du = st.f_bavail * st.f_frsize
return du
class StatAttributeTests(unittest.TestCase):
def setUp(self):
os.mkdir(test_support.TESTFN)
self.fname = os.path.join(test_support.TESTFN, "f1")
f = open(self.fname, 'wb')
f.write("ABC")
f.close()
def tearDown(self):
os.unlink(self.fname)
os.rmdir(test_support.TESTFN)
def test_stat_attributes(self):
if not hasattr(os, "stat"):
return
import stat
result = os.stat(self.fname)
# Make sure direct access works
self.assertEquals(result[stat.ST_SIZE], 3)
self.assertEquals(result.st_size, 3)
import sys
# Make sure all the attributes are there
members = dir(result)
for name in dir(stat):
if name[:3] == 'ST_':
attr = name.lower()
if name.endswith("TIME"):
def trunc(x):
return int(x)
else:
def trunc(x):
return x
self.assertEquals(trunc(getattr(result, attr)),
result[getattr(stat, name)])
self.assert_(attr in members)
try:
result[200]
self.fail("No exception thrown")
except IndexError:
pass
# Make sure that assignment fails
try:
result.st_mode = 1
self.fail("No exception thrown")
except TypeError:
pass
try:
result.st_rdev = 1
self.fail("No exception thrown")
except (AttributeError, TypeError):
pass
try:
result.parrot = 1
self.fail("No exception thrown")
except AttributeError:
pass
# Use the stat_result constructor with a too-short tuple.
try:
result2 = os.stat_result((10, ))
self.fail("No exception thrown")
except TypeError:
pass
# Use the constructr with a too-long tuple.
try:
result2 = os.stat_result(
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
except TypeError:
pass
def test_statvfs_attributes(self):
if not hasattr(os, "statvfs"):
return
import statvfs
try:
result = os.statvfs(self.fname)
except OSError, e:
# On AtheOS, glibc always returns ENOSYS
import errno
if e.errno == errno.ENOSYS:
return
# Make sure direct access works
self.assertEquals(result.f_bfree, result[statvfs.F_BFREE])
# Make sure all the attributes are there
members = dir(result)
for name in dir(statvfs):
if name[:2] == 'F_':
attr = name.lower()
self.assertEquals(getattr(result, attr),
result[getattr(statvfs, name)])
self.assert_(attr in members)
# Make sure that assignment really fails
try:
result.f_bfree = 1
self.fail("No exception thrown")
except TypeError:
pass
try:
result.parrot = 1
self.fail("No exception thrown")
except AttributeError:
pass
# Use the constructor with a too-short tuple.
try:
result2 = os.statvfs_result((10, ))
self.fail("No exception thrown")
except TypeError:
pass
# Use the constructr with a too-long tuple.
try:
result2 = os.statvfs_result(
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
except TypeError:
pass
def _hijack(self, path):
return os.statvfs_result((0, 1, int(self.bytes_total), int(self.bytes_free), 0, 0, 0, 0, 0, 255))
def make_statvfs_result(tup):
return os.statvfs_result(tup)
def make_statvfs_result(tup):
args = tuple(
lltype.cast_primitive(TYPE, value)
for value, (name, TYPE) in zip(tup, STATVFS_FIELDS))
return os.statvfs_result(args)
def statvfs(request):
with mock.patch('os.statvfs') as statvfs:
expected = os.statvfs_result(
(4096, 4096, 100000, 10000, 10000, 10000, 1000, 100, 4096, 255))
statvfs.side_effect = lambda path: expected
yield (expected.f_frsize, expected.f_bavail, expected.f_blocks)
def get_free_space(self):
st = os.statvfs_result(".")
du = st.f_bavail * st.f_frsize
return du
def test_simfs(self):
self.patch('os.statvfs', lambda fs: os.statvfs_result(
(4096, 4096, 20971520, 17750785, 17750785, 1600000, 1275269, 1275269, 4096, 255)
))
self.assertEqual(ms.get_disk_info('simfs'), '80 GiB')
def statvfs_result_fixture(path):
"""Fixture for a dummy statvfs_result."""
return os.statvfs_result((4096, 0, mb(1000), mb(100), 0, 0, 0, 0, 0, 0))
def statvfs(self):
"""
See :meth:`FileJuggler.do_statvfs`.
"""
return os.statvfs_result(self._execute(['STATVFS']))
def statvfs(self, path):
"""return stat information about remote filesystem"""
st = self.evaluate('import os; print(os.statvfs({!r}))'.format(
str(path)))
return os.statvfs_result(st)
def statvfs(path, multiplier=lambda: next(counter)):
return os.statvfs_result(
(4096, 0, mb(1000), mb(multiplier() * 100), 0, 0, 0, 0, 0, 0))
def test_get_filesystem_subpath(self):
self.set_mount_points(["/"])
self.stat_results["/"] = os.statvfs_result(
(4096, 0, 1000, 500, 0, 0, 0, 0, 0, 0))
info = get_filesystem_for_path("/home", self.mount_file, self.statvfs)
self.assertEqual(info["mount-point"], "/")
def make_statvfs_result(tup):
args = tuple(lltype.cast_primitive(TYPE, value) for value, (name, TYPE) in zip(tup, STATVFS_FIELDS))
return os.statvfs_result(args)
def test_simfs(self):
self.patch(
'os.statvfs', lambda fs: os.statvfs_result(
(4096, 4096, 20971520, 17750785, 17750785, 1600000, 1275269,
1275269, 4096, 255)))
self.assertEqual(ms.get_disk_info('simfs'), '80 GiB')
class StatAttributeTests(unittest.TestCase):
def setUp(self):
os.mkdir(test_support.TESTFN)
self.fname = os.path.join(test_support.TESTFN, "f1")
f = open(self.fname, 'wb')
f.write("ABC")
f.close()
def tearDown(self):
os.unlink(self.fname)
os.rmdir(test_support.TESTFN)
@unittest.skipUnless(hasattr(os, 'stat'), 'test needs os.stat()')
def test_stat_attributes(self):
import stat
result = os.stat(self.fname)
# Make sure direct access works
self.assertEqual(result[stat.ST_SIZE], 3)
self.assertEqual(result.st_size, 3)
# Make sure all the attributes are there
members = dir(result)
for name in dir(stat):
if name[:3] == 'ST_':
attr = name.lower()
if name.endswith("TIME"):
def trunc(x): return int(x)
else:
def trunc(x): return x
self.assertEqual(trunc(getattr(result, attr)),
result[getattr(stat, name)])
self.assertIn(attr, members)
try:
result[200]
self.fail("No exception raised")
except IndexError:
pass
# Make sure that assignment fails
try:
result.st_mode = 1
self.fail("No exception raised")
except (AttributeError, TypeError):
pass
try:
result.st_rdev = 1
self.fail("No exception raised")
except (AttributeError, TypeError):
pass
try:
result.parrot = 1
self.fail("No exception raised")
except AttributeError:
pass
# Use the stat_result constructor with a too-short tuple.
try:
result2 = os.stat_result((10,))
self.fail("No exception raised")
except TypeError:
pass
# Use the constructor with a too-long tuple.
try:
result2 = os.stat_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
except TypeError:
pass
@unittest.skipUnless(hasattr(os, 'statvfs'), 'test needs os.statvfs()')
def test_statvfs_attributes(self):
try:
result = os.statvfs(self.fname)
except OSError, e:
# On AtheOS, glibc always returns ENOSYS
if e.errno == errno.ENOSYS:
self.skipTest('glibc always returns ENOSYS on AtheOS')
# Make sure direct access works
self.assertEqual(result.f_bfree, result[3])
# Make sure all the attributes are there.
members = ('bsize', 'frsize', 'blocks', 'bfree', 'bavail', 'files',
'ffree', 'favail', 'flag', 'namemax')
for value, member in enumerate(members):
self.assertEqual(getattr(result, 'f_' + member), result[value])
# Make sure that assignment really fails
try:
result.f_bfree = 1
self.fail("No exception raised")
except TypeError:
pass
try:
result.parrot = 1
self.fail("No exception raised")
except AttributeError:
pass
# Use the constructor with a too-short tuple.
try:
result2 = os.statvfs_result((10,))
self.fail("No exception raised")
except TypeError:
pass
# Use the constructor with a too-long tuple.
try:
result2 = os.statvfs_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
except TypeError:
pass
def statvfs(request):
with mock.patch('os.statvfs') as statvfs:
expected = os.statvfs_result(
(4096, 4096, 100000, 10000, 10000, 10000, 1000, 100, 4096, 255))
statvfs.side_effect = lambda path: expected
yield expected
