self.obj.dec_use()
def flush(self):
- return self.obj.flush()
+ if self.obj.writable():
+ return self.obj.flush()
class FileHandle(Handle):
self._total -= obj.cache_size
del self._entries[obj.cache_priority]
if obj.cache_uuid:
- del self._by_uuid[obj.cache_uuid]
+ self._by_uuid[obj.cache_uuid].remove(obj)
+ if not self._by_uuid[obj.cache_uuid]:
+ del self._by_uuid[obj.cache_uuid]
obj.cache_uuid = None
if clear:
_logger.debug("InodeCache cleared %i total now %i", obj.inode, self._total)
self._entries[obj.cache_priority] = obj
obj.cache_uuid = obj.uuid()
if obj.cache_uuid:
- self._by_uuid[obj.cache_uuid] = obj
+ if obj.cache_uuid not in self._by_uuid:
+ self._by_uuid[obj.cache_uuid] = [obj]
+ else:
+ if obj not in self._by_uuid[obj.cache_uuid]:
+ self._by_uuid[obj.cache_uuid].append(obj)
self._total += obj.objsize()
- _logger.debug("InodeCache touched %i (size %i) total now %i", obj.inode, obj.objsize(), self._total)
+ _logger.debug("InodeCache touched %i (size %i) (uuid %s) total now %i", obj.inode, obj.objsize(), obj.cache_uuid, self._total)
self.cap_cache()
else:
obj.cache_priority = None
def find(self, uuid):
return self._by_uuid.get(uuid)
+ def clear(self):
+ self._entries.clear()
+ self._by_uuid.clear()
+ self._total = 0
+
class Inodes(object):
"""Manage the set of inodes. This is the mapping from a numeric id
to a concrete File or Directory object"""
def del_entry(self, entry):
if entry.ref_count == 0:
- _logger.debug("Deleting inode %i", entry.inode)
self.inode_cache.unmanage(entry)
- _logger.debug("(1) unmanaged inode %i", entry.inode)
-
del self._entries[entry.inode]
- _logger.debug("(2) deleted inode %i", entry.inode)
-
with llfuse.lock_released:
entry.finalize()
- _logger.debug("(3) finalized inode %i", entry.inode)
-
self.invalidate_inode(entry.inode)
- _logger.debug("(4) invalidated inode %i", entry.inode)
-
entry.inode = None
else:
entry.dead = True
_logger.debug("del_entry on inode %i with refcount %i", entry.inode, entry.ref_count)
def invalidate_inode(self, inode):
- self.deferred_invalidations.append((inode,))
+ llfuse.invalidate_inode(inode)
def invalidate_entry(self, inode, name):
- self.deferred_invalidations.append((inode, name))
+ llfuse.invalidate_entry(inode, name)
- def do_invalidations(self):
- di = self.deferred_invalidations
- self.deferred_invalidations = []
+ def clear(self):
+ self.inode_cache.clear()
+
+ for k,v in self._entries.items():
+ try:
+ v.finalize()
+ except Exception as e:
+ _logger.exception("Error during finalize of inode %i", k)
+
+ self._entries.clear()
- with llfuse.lock_released:
- for d in di:
- if len(d) == 1:
- llfuse.invalidate_inode(d[0])
- elif len(d) == 2:
- llfuse.invalidate_entry(d[0], d[1])
def catch_exceptions(orig_func):
"""Catch uncaught exceptions and log them consistently."""
raise
except EnvironmentError as e:
raise llfuse.FUSEError(e.errno)
+ except arvados.errors.KeepWriteError as e:
+ _logger.error("Keep write error: " + str(e))
+ raise llfuse.FUSEError(errno.EIO)
+ except arvados.errors.NotFoundError as e:
+ _logger.error("Block not found error: " + str(e))
+ raise llfuse.FUSEError(errno.EIO)
except:
_logger.exception("Unhandled exception during FUSE operation")
raise llfuse.FUSEError(errno.EIO)
return catch_exceptions_wrapper
-def deferred_invalidate(orig_func):
- @functools.wraps(orig_func)
- def deferred_invalidate_wrapper(self, *args, **kwargs):
- n = orig_func(self, *args, **kwargs)
- self.inodes.do_invalidations()
- return n
- return deferred_invalidate_wrapper
class Operations(llfuse.Operations):
"""This is the main interface with llfuse.
self.events.close()
self.events = None
- for k,v in self.inodes.items():
- v.finalize()
- self.inodes = None
+ self.inodes.clear()
def access(self, inode, mode, ctx):
return True
def on_event(self, ev):
if 'event_type' in ev:
with llfuse.lock:
- item = self.inodes.inode_cache.find(ev["object_uuid"])
- if item is not None:
- item.invalidate()
- if ev["object_kind"] == "arvados#collection":
- new_attr = ev.get("properties") and ev["properties"].get("new_attributes") and ev["properties"]["new_attributes"]
-
- # new_attributes.modified_at currently lacks subsecond precision (see #6347) so use event_at which
- # should always be the same.
- #record_version = (new_attr["modified_at"], new_attr["portable_data_hash"]) if new_attr else None
- record_version = (ev["event_at"], new_attr["portable_data_hash"]) if new_attr else None
-
- item.update(to_record_version=record_version)
- else:
- item.update()
+ items = self.inodes.inode_cache.find(ev["object_uuid"])
+ if items is not None:
+ for item in items:
+ item.invalidate()
+ if ev["object_kind"] == "arvados#collection":
+ new_attr = ev.get("properties") and ev["properties"].get("new_attributes") and ev["properties"]["new_attributes"]
+
+ # new_attributes.modified_at currently lacks subsecond precision (see #6347) so use event_at which
+ # should always be the same.
+ #record_version = (new_attr["modified_at"], new_attr["portable_data_hash"]) if new_attr else None
+ record_version = (ev["event_at"], new_attr["portable_data_hash"]) if new_attr else None
+
+ item.update(to_record_version=record_version)
+ else:
+ item.update()
oldowner = ev.get("properties") and ev["properties"].get("old_attributes") and ev["properties"]["old_attributes"].get("owner_uuid")
olditemparent = self.inodes.inode_cache.find(oldowner)
itemparent.invalidate()
itemparent.update()
- self.inodes.do_invalidations()
@catch_exceptions
def getattr(self, inode):
entry.st_size = e.size()
- _logger.debug("getattr got size")
-
entry.st_blksize = 512
entry.st_blocks = (entry.st_size/512)+1
entry.st_atime = int(e.atime())
raise llfuse.FUSEError(errno.ENOENT)
@catch_exceptions
- @deferred_invalidate
def forget(self, inodes):
for inode, nlookup in inodes:
ent = self.inodes[inode]
self.inodes.touch(handle.obj)
- try:
- return handle.obj.readfrom(off, size, self.num_retries)
- except arvados.errors.NotFoundError as e:
- _logger.error("Block not found: " + str(e))
- raise llfuse.FUSEError(errno.EIO)
+ return handle.obj.readfrom(off, size, self.num_retries)
@catch_exceptions
def write(self, fh, off, buf):
return handle.obj.writeto(off, buf, self.num_retries)
@catch_exceptions
- @deferred_invalidate
def release(self, fh):
if fh in self._filehandles:
try:
self._filehandles[fh].flush()
- except EnvironmentError as e:
- raise llfuse.FUSEError(e.errno)
except Exception:
- _logger.exception("Flush error")
- self._filehandles[fh].release()
- del self._filehandles[fh]
+ raise
+ finally:
+ self._filehandles[fh].release()
+ del self._filehandles[fh]
self.inodes.inode_cache.cap_cache()
def releasedir(self, fh):
self.release(fh)
@catch_exceptions
- @deferred_invalidate
def opendir(self, inode):
_logger.debug("arv-mount opendir: inode %i", inode)
return p
@catch_exceptions
- @deferred_invalidate
def create(self, inode_parent, name, mode, flags, ctx):
_logger.debug("arv-mount create: %i '%s' %o", inode_parent, name, mode)
return (fh, self.getattr(f.inode))
@catch_exceptions
- @deferred_invalidate
def mkdir(self, inode_parent, name, mode, ctx):
_logger.debug("arv-mount mkdir: %i '%s' %o", inode_parent, name, mode)
return self.getattr(d.inode)
@catch_exceptions
- @deferred_invalidate
def unlink(self, inode_parent, name):
_logger.debug("arv-mount unlink: %i '%s'", inode_parent, name)
p = self._check_writable(inode_parent)
p.unlink(name)
@catch_exceptions
- @deferred_invalidate
def rmdir(self, inode_parent, name):
_logger.debug("arv-mount rmdir: %i '%s'", inode_parent, name)
p = self._check_writable(inode_parent)
p.rmdir(name)
@catch_exceptions
- @deferred_invalidate
def rename(self, inode_parent_old, name_old, inode_parent_new, name_new):
_logger.debug("arv-mount rename: %i '%s' %i '%s'", inode_parent_old, name_old, inode_parent_new, name_new)
src = self._check_writable(inode_parent_old)
dest.rename(name_old, name_new, src)
@catch_exceptions
- @deferred_invalidate
def flush(self, fh):
if fh in self._filehandles:
self._filehandles[fh].flush()
projects / arvados.git / blobdiff