Python xattr.set函数代码示例

 def _apply_linux_xattr_rec(self, path, restore_numeric_ids=False):
     if not xattr:
         if self.linux_xattr:
             add_error("%s: can't restore xattr; xattr support missing.\n"
                       % path)
         return
     existing_xattrs = set(xattr.list(path, nofollow=True))
     if self.linux_xattr:
         for k, v in self.linux_xattr:
             if k not in existing_xattrs \
                     or v != xattr.get(path, k, nofollow=True):
                 try:
                     xattr.set(path, k, v, nofollow=True)
                 except IOError, e:
                     if e.errno == errno.EPERM \
                             or e.errno == errno.EOPNOTSUPP:
                         raise ApplyError('xattr.set: %s' % e)
                     else:
                         raise
             existing_xattrs -= frozenset([k])
         for k in existing_xattrs:
             try:
                 xattr.remove(path, k, nofollow=True)
             except IOError, e:
                 if e.errno == errno.EPERM:
                     raise ApplyError('xattr.remove: %s' % e)
                 else:
                     raise

		def _copyxattr(src, dest, exclude=None):

			try:
				attrs = xattr.list(src)
			except IOError as e:
				if e.errno != OperationNotSupported.errno:
					raise
				attrs = ()

			if attrs:
				if exclude is not None and isinstance(attrs[0], bytes):
					exclude = exclude.encode(_encodings['fs'])
				exclude = _get_xattr_excluder(exclude)

			for attr in attrs:
				if exclude(attr):
					continue
				try:
					xattr.set(dest, attr, xattr.get(src, attr))
					raise_exception = False
				except IOError:
					raise_exception = True
				if raise_exception:
					raise OperationNotSupported(_("Filesystem containing file '%s' "
						"does not support extended attribute '%s'") %
						(_unicode_decode(dest), _unicode_decode(attr)))

def preserve_xattrs(path, nofollow=False, namespace=None):
	"""Context manager to save/restore extended attributes on |path|

	If you want to rewrite a file (possibly replacing it with a new one), but
	want to preserve the extended attributes, this will do the trick.

	# First read all the extended attributes.
	with save_xattrs('/some/file'):
		... rewrite the file ...
	# Now the extended attributes are restored as needed.
	"""
	kwargs = {'nofollow': nofollow,}
	if namespace:
		# Compiled xattr python module does not like it when namespace=None.
		kwargs['namespace'] = namespace

	old_attrs = dict(xattr.get_all(path, **kwargs))
	try:
		yield
	finally:
		new_attrs = dict(xattr.get_all(path, **kwargs))
		for name, value in new_attrs.items():
			if name not in old_attrs:
				# Clear out new ones.
				xattr.remove(path, name, **kwargs)
			elif new_attrs[name] != old_attrs[name]:
				# Update changed ones.
				xattr.set(path, name, value, **kwargs)

		for name, value in old_attrs.items():
			if name not in new_attrs:
				# Re-add missing ones.
				xattr.set(path, name, value, **kwargs)

	def _fix(self):
		logger.debug("Fixing records for %s", self)
		files = Set(os.listdir(self.dirpath))
		attrs = {}
		for filename in files:
			path = os.path.join(self.dirpath, filename)
			if os.path.islink(path):
				# just copy symlink attrs, as they can't be placed on a symlink
				try:
					attrs[filename] = self._saved_attrs[filename]
				except KeyError: pass # no entry in self._saved_attrs
				continue

			try:
				recovered_attrs = self._saved_attrs[filename]
			except KeyError: pass
			else:
				file_attrs = self._get_xattrs(filename)
				logger.debug("xattrs for %s: %r", filename, file_attrs)
				for key, val in recovered_attrs.items():
					xattr_val = file_attrs.get(key, None)
					if xattr_val != val:
						logger.info("File %s has xattr %r=%s, but serialized data has %s - using serialized data", filename, key, xattr_val, val)
					xattr.set(path, key, val, namespace=xattr.NS_USER)
			self._update_saved_attrs(filename, dest=attrs)

		removed_files = Set(self._saved_attrs.keys()).difference(Set(attrs.keys()))
		for filename in removed_files:
			logger.debug("Dropping metadata for missing file %s: %r", os.path.join(self.dirpath, filename), self._saved_attrs[filename])

		if attrs != self._saved_attrs:
			self._update(attrs)

	def test_xattrs_with_no_serialized_value_are_kept(self):
		dumbattr.set(self.file1, "test1", "1")
		xattr.set(self.file1, "test2", "2", namespace=xattr.NS_USER)

		self.assertEqual(self.serialized_metadata(), {'file1': {'test1':'1'}})
		self.assertEqual(dumbattr.load(self.file1).copy(), {'test1': '1', 'test2':'2'})
		self.assertEqual(self.serialized_metadata(), {'file1': {'test1': '1', 'test2':'2'}})

def xattr_sync(file_name, meta):
    """ Synchronize the xattrs on a file with a hash of our choosing """
    to_delete, to_set = xattr_sync_impl(file_name, meta)
    for k in to_delete:
        xattr.remove(file_name, k)
    for k,v in to_set.items():
        xattr.set(file_name, k, v, namespace=xattr.NS_USER)

	def test_xattrs_overriden_by_serialized_attrs(self):
		dumbattr.set(self.file1, "test1", "1")
		xattr.set(self.file1, "test1", "2", namespace=xattr.NS_USER)

		self.assertEqual(self.serialized_metadata(), {'file1': {'test1':'1'}})
		# load() has the side effect of fixing any discrepancies, just like `fix()`
		self.assertEqual(dumbattr.load(self.file1).copy(), {'test1': '1'})
		self.assertEqual(self.all_xattrs(self.file1), {b'test1': b'1'})

 def _checkListSetGet(self, item, symlink=False, use_ns=False):
     """check list, set, get operations against an item"""
     self.assertEqual(self._ignore(xattr.list(item, symlink)),
                      [])
     self.assertRaises(EnvironmentError, xattr.set, item,
                       self.USER_ATTR, self.USER_VAL, flags=XATTR_REPLACE)
     self.assertRaises(EnvironmentError, xattr.set, item,
                       self.USER_NN, self.USER_VAL, flags=XATTR_REPLACE,
                       namespace=NS_USER)
     try:
         if use_ns:
             xattr.set(item, self.USER_NN, self.USER_VAL,
                       namespace=NS_USER,
                       nofollow=symlink)
         else:
             xattr.set(item, self.USER_ATTR, self.USER_VAL,
                       nofollow=symlink)
     except IOError:
         err = sys.exc_info()[1]
         if err.errno == errno.EPERM and symlink:
             # symlinks may fail, in which case we abort the rest
             # of the test for this case
             return
         raise
     self.assertRaises(EnvironmentError, xattr.set, item,
                       self.USER_ATTR, self.USER_VAL, flags=XATTR_CREATE)
     self.assertRaises(EnvironmentError, xattr.set, item,
                       self.USER_NN, self.USER_VAL,
                       flags=XATTR_CREATE, namespace=NS_USER)
     self.assertEqual(self._ignore(xattr.list(item, nofollow=symlink)),
                      [self.USER_ATTR])
     self.assertEqual(self._ignore(xattr.list(item, nofollow=symlink,
                                              namespace=EMPTY_NS)),
                      [self.USER_ATTR])
     self.assertEqual(xattr.list(item, namespace=NS_USER, nofollow=symlink),
                      [self.USER_NN])
     self.assertEqual(xattr.get(item, self.USER_ATTR, nofollow=symlink),
                      self.USER_VAL)
     self.assertEqual(xattr.get(item, self.USER_NN, nofollow=symlink,
                                namespace=NS_USER), self.USER_VAL)
     self.assertEqual(self._ignore_tuples(xattr.get_all(item,
                                                        nofollow=symlink)),
                      [(self.USER_ATTR, self.USER_VAL)])
     self.assertEqual(xattr.get_all(item, nofollow=symlink,
                                    namespace=NS_USER),
                      [(self.USER_NN, self.USER_VAL)])
     if use_ns:
         xattr.remove(item, self.USER_NN, namespace=NS_USER)
     else:
         xattr.remove(item, self.USER_ATTR)
     self.assertEqual(self._ignore(xattr.list(item, symlink)), [])
     self.assertEqual(self._ignore_tuples(xattr.get_all(item,
                                                        nofollow=symlink)),
                      [])
     self.assertRaises(EnvironmentError, xattr.remove,
                       item, self.USER_ATTR, nofollow=symlink)
     self.assertRaises(EnvironmentError, xattr.remove, item,
                       self.USER_NN, namespace=NS_USER, nofollow=symlink)

		def _copyxattr(src, dest):
			for attr in xattr.list(src):
				try:
					xattr.set(dest, attr, xattr.get(src, attr))
					raise_exception = False
				except IOError:
					raise_exception = True
				if raise_exception:
					raise OperationNotSupported("Filesystem containing file '%s' does not support extended attributes" % dest)

	def write_cache(self):
		if not xattr:
			return
		try:
			self.clear_cache()
			xattr.set(self.name, 'user.pyanidb.mtime', str(int(self.mtime)))
			for n in ('ed2k', 'md5', 'sha1', 'crc32'):
				if hasattr(self, n):
					xattr.set(self.name, 'user.pyanidb.' + n, getattr(self, n))
		except IOError:
			pass

def save_license(license_text, license_signature):
    license_file = os.path.join(get_oscar_dir(), "etc/license.txt")
    with open(license_file, "w") as f:
        f.write(license_text + '\n')
        f.write(license_signature + '\n')

    license_file = os.path.join(get_oscar_dir(), "bin/oscar")
    try:
        xattr.set(license_file, "user.oscar.license", license_text)
        xattr.set(license_file, "user.oscar.license.signature", license_signature)
    except IOError, e:
        if e.errno != errno.ENODATA: raise e

def check_user_xattr(path):
    if not os.path.exists(path):
        return False
    try:
        xattr.set(path, 'user.test.key1', 'value1')
    except IOError as err:
        logging.exception("check_user_xattr: set failed on %s err: %s", path, str(err))
        raise
    try:
        xattr.remove(path, 'user.test.key1')
    except Exception, err:
        logging.exception("xattr.remove failed on %s err: %s", path, str(err))

 def testSymlinkOps(self):
     """test symlink operations"""
     _, sname = self._getsymlink()
     self.assertRaises(EnvironmentError, xattr.list, sname)
     self._checkListSetGet(sname, symlink=True)
     self._checkListSetGet(sname, symlink=True, use_ns=True)
     target, sname = self._getsymlink(dangling=False)
     xattr.set(target, self.USER_ATTR, self.USER_VAL)
     self.assertEqual(xattr.list(target), [self.USER_ATTR])
     self.assertEqual(xattr.list(sname, nofollow=True), [])
     self.assertRaises(EnvironmentError, xattr.remove, sname, self.USER_ATTR, nofollow=True)
     xattr.remove(sname, self.USER_ATTR, nofollow=False)

def check_user_xattr(path):
    if not os.path.exists(path):
        return False
    try:
        xattr.set(path, 'user.test.key1', 'value1')
    except IOError as err:
        logging.exception("check_user_xattr: set failed on %s err: %s", path, str(err))
        raise
    try:
        xattr.remove(path, 'user.test.key1')
    except IOError as err:
        logging.exception("check_user_xattr: remove failed on %s err: %s", path, str(err))
        #Remove xattr may fail in case of concurrent remove.
    return True

 def testMixedAccess(self):
     """test mixed access to file"""
     fh, fname = self._getfile()
     fo = os.fdopen(fh)
     self.assertEqual(xattr.list(fname), [])
     xattr.set(fname, self.USER_ATTR, self.USER_VAL)
     self.assertEqual(xattr.list(fh), [self.USER_ATTR])
     self.assertEqual(xattr.list(fh, namespace=NS_USER), [self.USER_NN])
     self.assertEqual(xattr.get(fo, self.USER_ATTR), self.USER_VAL)
     self.assertEqual(xattr.get(fo, self.USER_NN, namespace=NS_USER), self.USER_VAL)
     self.assertEqual(xattr.get_all(fo), [(self.USER_ATTR, self.USER_VAL)])
     self.assertEqual(xattr.get_all(fo, namespace=NS_USER), [(self.USER_NN, self.USER_VAL)])
     self.assertEqual(xattr.get_all(fname), [(self.USER_ATTR, self.USER_VAL)])
     self.assertEqual(xattr.get_all(fname, namespace=NS_USER), [(self.USER_NN, self.USER_VAL)])
     fo.close()