#ifdef linux /* and likely others */
+#define HAVE_BUP_STAT 1
+static PyObject *bup_stat(PyObject *self, PyObject *args)
+{
+ int rc;
+ char *filename;
+
+ if (!PyArg_ParseTuple(args, "s", &filename))
+ return NULL;
+
+ struct stat st;
+ rc = stat(filename, &st);
+ if (rc != 0)
+ return PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
+
+ return Py_BuildValue("kkkkkkkk"
+ "(ll)"
+ "(ll)"
+ "(ll)",
+ (unsigned long) st.st_mode,
+ (unsigned long) st.st_ino,
+ (unsigned long) st.st_dev,
+ (unsigned long) st.st_nlink,
+ (unsigned long) st.st_uid,
+ (unsigned long) st.st_gid,
+ (unsigned long) st.st_rdev,
+ (unsigned long) st.st_size,
+ (long) st.st_atime,
+ (long) st.st_atim.tv_nsec,
+ (long) st.st_mtime,
+ (long) st.st_mtim.tv_nsec,
+ (long) st.st_ctime,
+ (long) st.st_ctim.tv_nsec);
+}
+
+
#define HAVE_BUP_LSTAT 1
static PyObject *bup_lstat(PyObject *self, PyObject *args)
{
(long) st.st_ctim.tv_nsec);
}
+
#define HAVE_BUP_FSTAT 1
static PyObject *bup_fstat(PyObject *self, PyObject *args)
{
{ "utimensat", bup_utimensat, METH_VARARGS,
"Change file timestamps with nanosecond precision." },
#endif
+#ifdef HAVE_BUP_STAT
+ { "stat", bup_stat, METH_VARARGS,
+ "Extended version of stat." },
+#endif
#ifdef HAVE_BUP_LSTAT
{ "lstat", bup_lstat, METH_VARARGS,
"Extended version of lstat." },
PyModule_AddObject(m, "AT_SYMLINK_NOFOLLOW",
Py_BuildValue("i", AT_SYMLINK_NOFOLLOW));
#endif
-#ifdef HAVE_BUP_LSTAT
+#ifdef HAVE_BUP_STAT
PyModule_AddObject(m, "_have_ns_fs_timestamps", Py_BuildValue("i", 1));
#endif
}
return date
-class FSTime():
- # Class to represent filesystem timestamps. Use integer
- # nanoseconds on platforms where we have the higher resolution
- # lstat. Use the native python stat representation (floating
- # point seconds) otherwise.
-
- def __cmp__(self, x):
- return self._value.__cmp__(x._value)
-
- def to_timespec(self):
- """Return (s, ns) where ns is always non-negative
- and t = s + ns / 10e8""" # metadata record rep (and libc rep)
- s_ns = self.secs_nsecs()
- if s_ns[0] > 0 or s_ns[1] >= 0:
- return s_ns
- return (s_ns[0] - 1, 10**9 + s_ns[1]) # ns is negative
-
- if _helpers.lstat: # Use integer nanoseconds.
-
- @staticmethod
- def from_secs(secs):
- ts = FSTime()
- ts._value = int(secs * 10**9)
- return ts
-
- @staticmethod
- def from_timespec(timespec):
- ts = FSTime()
- ts._value = timespec[0] * 10**9 + timespec[1]
- return ts
-
- @staticmethod
- def from_stat_time(stat_time):
- return FSTime.from_timespec(stat_time)
-
- def approx_secs(self):
- return self._value / 10e8;
-
- def secs_nsecs(self):
- "Return a (s, ns) pair: -1.5s -> (-1, -10**9 / 2)."
- if self._value >= 0:
- return (self._value / 10**9, self._value % 10**9)
- abs_val = -self._value
- return (- (abs_val / 10**9), - (abs_val % 10**9))
-
- else: # Use python default floating-point seconds.
-
- @staticmethod
- def from_secs(secs):
- ts = FSTime()
- ts._value = secs
- return ts
-
- @staticmethod
- def from_timespec(timespec):
- ts = FSTime()
- ts._value = timespec[0] + (timespec[1] / 10e8)
- return ts
-
- @staticmethod
- def from_stat_time(stat_time):
- ts = FSTime()
- ts._value = stat_time
- return ts
-
- def approx_secs(self):
- return self._value
-
- def secs_nsecs(self):
- "Return a (s, ns) pair: -1.5s -> (-1, -5**9)."
- x = math.modf(self._value)
- return (x[1], x[0] * 10**9)
-
-
-def lutime(path, times):
- if _helpers.utimensat:
- atime = times[0].to_timespec()
- mtime = times[1].to_timespec()
- return _helpers.utimensat(_helpers.AT_FDCWD, path, (atime, mtime),
- _helpers.AT_SYMLINK_NOFOLLOW)
- else:
- return None
-
-
-def utime(path, times):
- if _helpers.utimensat:
- atime = times[0].to_timespec()
- mtime = times[1].to_timespec()
- return _helpers.utimensat(_helpers.AT_FDCWD, path, (atime, mtime), 0)
- else:
- atime = times[0].approx_secs()
- mtime = times[1].approx_secs()
- os.utime(path, (atime, mtime))
-
-
-class stat_result():
-
- @staticmethod
- def from_stat_rep(st):
- result = stat_result()
- if _helpers._have_ns_fs_timestamps:
- (result.st_mode,
- result.st_ino,
- result.st_dev,
- result.st_nlink,
- result.st_uid,
- result.st_gid,
- result.st_rdev,
- result.st_size,
- atime,
- mtime,
- ctime) = st
- else:
- result.st_mode = st.st_mode
- result.st_ino = st.st_ino
- result.st_dev = st.st_dev
- result.st_nlink = st.st_nlink
- result.st_uid = st.st_uid
- result.st_gid = st.st_gid
- result.st_rdev = st.st_rdev
- result.st_size = st.st_size
- atime = FSTime.from_stat_time(st.st_atime)
- mtime = FSTime.from_stat_time(st.st_mtime)
- ctime = FSTime.from_stat_time(st.st_ctime)
- result.st_atime = FSTime.from_stat_time(atime)
- result.st_mtime = FSTime.from_stat_time(mtime)
- result.st_ctime = FSTime.from_stat_time(ctime)
- return result
-
-
-def fstat(path):
- if _helpers.fstat:
- st = _helpers.fstat(path)
- else:
- st = os.fstat(path)
- return stat_result.from_stat_rep(st)
-
-
-def lstat(path):
- if _helpers.lstat:
- st = _helpers.lstat(path)
- else:
- st = os.lstat(path)
- return stat_result.from_stat_rep(st)
-
-
# hashlib is only available in python 2.5 or higher, but the 'sha' module
# produces a DeprecationWarning in python 2.6 or higher. We want to support
# python 2.4 and above without any stupid warnings, so let's try using hashlib
from cStringIO import StringIO
from bup import vint
-from bup.helpers import add_error, mkdirp, log, utime, lutime, lstat, FSTime
+from bup.helpers import add_error, mkdirp, log
+from bup.xstat import utime, lutime, lstat, FSTime
import bup._helpers as _helpers
if _helpers.get_linux_file_attr:
WVPASS(detect_fakeroot())
else:
WVPASS(not detect_fakeroot())
-
-
-def _test_fstime():
- def approx_eq(x, y):
- return math.fabs(x - y) < 1 / 10e8
- def ts_eq_ish(x, y):
- return approx_eq(x[0], y[0]) and approx_eq(x[1], y[1])
- def fst_eq_ish(x, y):
- return approx_eq(x.approx_secs(), y.approx_secs())
- def s_ns_eq_ish(fst, s, ns):
- (fst_s, fst_ns) = fst.secs_nsecs()
- return approx_eq(fst_s, s) and approx_eq(fst_ns, ns)
- from_secs = FSTime.from_secs
- from_ts = FSTime.from_timespec
- WVPASS(from_secs(0) == from_secs(0))
- WVPASS(from_secs(0) < from_secs(1))
- WVPASS(from_secs(-1) < from_secs(1))
- WVPASS(from_secs(1) > from_secs(0))
- WVPASS(from_secs(1) > from_secs(-1))
-
- WVPASS(fst_eq_ish(from_secs(0), from_ts((0, 0))))
- WVPASS(fst_eq_ish(from_secs(1), from_ts((1, 0))))
- WVPASS(fst_eq_ish(from_secs(-1), from_ts((-1, 0))))
- WVPASS(fst_eq_ish(from_secs(-0.5), from_ts((-1, 10**9 / 2))))
- WVPASS(fst_eq_ish(from_secs(-1.5), from_ts((-2, 10**9 / 2))))
- WVPASS(fst_eq_ish(from_secs(1 / 10e8), from_ts((0, 1))))
- WVPASS(fst_eq_ish(from_secs(-1 / 10e8), from_ts((-1, 10**9 - 1))))
-
- WVPASS(ts_eq_ish(from_secs(0).to_timespec(), (0, 0)))
- WVPASS(ts_eq_ish(from_secs(1).to_timespec(), (1, 0)))
- WVPASS(ts_eq_ish(from_secs(-1).to_timespec(), (-1, 0)))
- WVPASS(ts_eq_ish(from_secs(-0.5).to_timespec(), (-1, 10**9 / 2)))
- WVPASS(ts_eq_ish(from_secs(-1.5).to_timespec(), (-2, 10**9 / 2)))
- WVPASS(ts_eq_ish(from_secs(1 / 10e8).to_timespec(), (0, 1)))
- WVPASS(ts_eq_ish(from_secs(-1 / 10e8).to_timespec(), (-1, 10**9 - 1)))
-
- WVPASS(s_ns_eq_ish(from_secs(0), 0, 0))
- WVPASS(s_ns_eq_ish(from_secs(1), 1, 0))
- WVPASS(s_ns_eq_ish(from_secs(-1), -1, 0))
- WVPASS(s_ns_eq_ish(from_secs(-0.5), 0, - 10**9 / 2))
- WVPASS(s_ns_eq_ish(from_secs(-1.5), -1, - 10**9 / 2))
- WVPASS(s_ns_eq_ish(from_secs(-1 / 10e8), 0, -1))
-
-@wvtest
-def test_fstime():
- _test_fstime();
- if _helpers._have_ns_fs_timestamps: # Test native python timestamp rep too.
- orig = _helpers._have_ns_fs_timestamps
- try:
- _helpers._have_ns_fs_timestamps = None
- _test_fstime();
- finally:
- _helpers._have_ns_fs_timestamps = orig
--- /dev/null
+import math
+from wvtest import *
+import bup._helpers as _helpers
+from bup.xstat import FSTime
+
+def _test_fstime():
+ def approx_eq(x, y):
+ return math.fabs(x - y) < 1 / 10e8
+ def ts_eq_ish(x, y):
+ return approx_eq(x[0], y[0]) and approx_eq(x[1], y[1])
+ def fst_eq_ish(x, y):
+ return approx_eq(x.approx_secs(), y.approx_secs())
+ def s_ns_eq_ish(fst, s, ns):
+ (fst_s, fst_ns) = fst.secs_nsecs()
+ return approx_eq(fst_s, s) and approx_eq(fst_ns, ns)
+ from_secs = FSTime.from_secs
+ from_ts = FSTime.from_timespec
+ WVPASS(from_secs(0) == from_secs(0))
+ WVPASS(from_secs(0) < from_secs(1))
+ WVPASS(from_secs(-1) < from_secs(1))
+ WVPASS(from_secs(1) > from_secs(0))
+ WVPASS(from_secs(1) > from_secs(-1))
+
+ WVPASS(fst_eq_ish(from_secs(0), from_ts((0, 0))))
+ WVPASS(fst_eq_ish(from_secs(1), from_ts((1, 0))))
+ WVPASS(fst_eq_ish(from_secs(-1), from_ts((-1, 0))))
+ WVPASS(fst_eq_ish(from_secs(-0.5), from_ts((-1, 10**9 / 2))))
+ WVPASS(fst_eq_ish(from_secs(-1.5), from_ts((-2, 10**9 / 2))))
+ WVPASS(fst_eq_ish(from_secs(1 / 10e8), from_ts((0, 1))))
+ WVPASS(fst_eq_ish(from_secs(-1 / 10e8), from_ts((-1, 10**9 - 1))))
+
+ WVPASS(ts_eq_ish(from_secs(0).to_timespec(), (0, 0)))
+ WVPASS(ts_eq_ish(from_secs(1).to_timespec(), (1, 0)))
+ WVPASS(ts_eq_ish(from_secs(-1).to_timespec(), (-1, 0)))
+ WVPASS(ts_eq_ish(from_secs(-0.5).to_timespec(), (-1, 10**9 / 2)))
+ WVPASS(ts_eq_ish(from_secs(-1.5).to_timespec(), (-2, 10**9 / 2)))
+ WVPASS(ts_eq_ish(from_secs(1 / 10e8).to_timespec(), (0, 1)))
+ WVPASS(ts_eq_ish(from_secs(-1 / 10e8).to_timespec(), (-1, 10**9 - 1)))
+
+ WVPASS(s_ns_eq_ish(from_secs(0), 0, 0))
+ WVPASS(s_ns_eq_ish(from_secs(1), 1, 0))
+ WVPASS(s_ns_eq_ish(from_secs(-1), -1, 0))
+ WVPASS(s_ns_eq_ish(from_secs(-0.5), 0, - 10**9 / 2))
+ WVPASS(s_ns_eq_ish(from_secs(-1.5), -1, - 10**9 / 2))
+ WVPASS(s_ns_eq_ish(from_secs(-1 / 10e8), 0, -1))
+
+@wvtest
+def test_fstime():
+ _test_fstime();
+ if _helpers._have_ns_fs_timestamps: # Test native python timestamp rep too.
+ orig = _helpers._have_ns_fs_timestamps
+ try:
+ _helpers._have_ns_fs_timestamps = None
+ _test_fstime();
+ finally:
+ _helpers._have_ns_fs_timestamps = orig
--- /dev/null
+"""Enhanced stat operations for bup."""
+import os
+import bup._helpers as _helpers
+
+class FSTime():
+ # Class to represent filesystem timestamps. Use integer
+ # nanoseconds on platforms where we have the higher resolution
+ # lstat. Use the native python stat representation (floating
+ # point seconds) otherwise.
+
+ def __cmp__(self, x):
+ return self._value.__cmp__(x._value)
+
+ def to_timespec(self):
+ """Return (s, ns) where ns is always non-negative
+ and t = s + ns / 10e8""" # metadata record rep (and libc rep)
+ s_ns = self.secs_nsecs()
+ if s_ns[0] > 0 or s_ns[1] >= 0:
+ return s_ns
+ return (s_ns[0] - 1, 10**9 + s_ns[1]) # ns is negative
+
+ if _helpers.lstat: # Use integer nanoseconds.
+
+ @staticmethod
+ def from_secs(secs):
+ ts = FSTime()
+ ts._value = int(secs * 10**9)
+ return ts
+
+ @staticmethod
+ def from_timespec(timespec):
+ ts = FSTime()
+ ts._value = timespec[0] * 10**9 + timespec[1]
+ return ts
+
+ @staticmethod
+ def from_stat_time(stat_time):
+ return FSTime.from_timespec(stat_time)
+
+ def approx_secs(self):
+ return self._value / 10e8;
+
+ def secs_nsecs(self):
+ "Return a (s, ns) pair: -1.5s -> (-1, -10**9 / 2)."
+ if self._value >= 0:
+ return (self._value / 10**9, self._value % 10**9)
+ abs_val = -self._value
+ return (- (abs_val / 10**9), - (abs_val % 10**9))
+
+ else: # Use python default floating-point seconds.
+
+ @staticmethod
+ def from_secs(secs):
+ ts = FSTime()
+ ts._value = secs
+ return ts
+
+ @staticmethod
+ def from_timespec(timespec):
+ ts = FSTime()
+ ts._value = timespec[0] + (timespec[1] / 10e8)
+ return ts
+
+ @staticmethod
+ def from_stat_time(stat_time):
+ ts = FSTime()
+ ts._value = stat_time
+ return ts
+
+ def approx_secs(self):
+ return self._value
+
+ def secs_nsecs(self):
+ "Return a (s, ns) pair: -1.5s -> (-1, -5**9)."
+ x = math.modf(self._value)
+ return (x[1], x[0] * 10**9)
+
+
+def lutime(path, times):
+ if _helpers.utimensat:
+ atime = times[0].to_timespec()
+ mtime = times[1].to_timespec()
+ return _helpers.utimensat(_helpers.AT_FDCWD, path, (atime, mtime),
+ _helpers.AT_SYMLINK_NOFOLLOW)
+ else:
+ return None
+
+
+def utime(path, times):
+ if _helpers.utimensat:
+ atime = times[0].to_timespec()
+ mtime = times[1].to_timespec()
+ return _helpers.utimensat(_helpers.AT_FDCWD, path, (atime, mtime), 0)
+ else:
+ atime = times[0].approx_secs()
+ mtime = times[1].approx_secs()
+ os.utime(path, (atime, mtime))
+
+
+class stat_result():
+
+ @staticmethod
+ def from_stat_rep(st):
+ result = stat_result()
+ if _helpers._have_ns_fs_timestamps:
+ (result.st_mode,
+ result.st_ino,
+ result.st_dev,
+ result.st_nlink,
+ result.st_uid,
+ result.st_gid,
+ result.st_rdev,
+ result.st_size,
+ atime,
+ mtime,
+ ctime) = st
+ else:
+ result.st_mode = st.st_mode
+ result.st_ino = st.st_ino
+ result.st_dev = st.st_dev
+ result.st_nlink = st.st_nlink
+ result.st_uid = st.st_uid
+ result.st_gid = st.st_gid
+ result.st_rdev = st.st_rdev
+ result.st_size = st.st_size
+ atime = FSTime.from_stat_time(st.st_atime)
+ mtime = FSTime.from_stat_time(st.st_mtime)
+ ctime = FSTime.from_stat_time(st.st_ctime)
+ result.st_atime = FSTime.from_stat_time(atime)
+ result.st_mtime = FSTime.from_stat_time(mtime)
+ result.st_ctime = FSTime.from_stat_time(ctime)
+ return result
+
+
+def stat(path):
+ if _helpers.stat:
+ st = _helpers.stat(path)
+ else:
+ st = os.stat(path)
+ return stat_result.from_stat_rep(st)
+
+
+def fstat(path):
+ if _helpers.fstat:
+ st = _helpers.fstat(path)
+ else:
+ st = os.fstat(path)
+ return stat_result.from_stat_rep(st)
+
+
+def lstat(path):
+ if _helpers.lstat:
+ st = _helpers.lstat(path)
+ else:
+ st = os.lstat(path)
+ return stat_result.from_stat_rep(st)
projects / bup.git / commitdiff