X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/06d87aa4fe72ad86c94593e4909be08bad6acb35..a830b5b560251c3143a7b1fd60db3f50a7021b34:/services/fuse/arvados_fuse/__init__.py diff --git a/services/fuse/arvados_fuse/__init__.py b/services/fuse/arvados_fuse/__init__.py index d5350f431a..91e1907f20 100644 --- a/services/fuse/arvados_fuse/__init__.py +++ b/services/fuse/arvados_fuse/__init__.py @@ -1,6 +1,49 @@ -# -# FUSE driver for Arvados Keep -# +"""FUSE driver for Arvados Keep + +Architecture: + +There is one `Operations` object per mount point. It is the entry point for all +read and write requests from the llfuse module. + +The operations object owns an `Inodes` object. The inodes object stores the +mapping from numeric inode (used throughout the file system API to uniquely +identify files) to the Python objects that implement files and directories. + +The `Inodes` object owns an `InodeCache` object. The inode cache records the +memory footprint of file system objects and when they are last used. When the +cache limit is exceeded, the least recently used objects are cleared. + +File system objects inherit from `fresh.FreshBase` which manages the object lifecycle. + +File objects inherit from `fusefile.File`. Key methods are `readfrom` and `writeto` +which implement actual reads and writes. + +Directory objects inherit from `fusedir.Directory`. The directory object wraps +a Python dict which stores the mapping from filenames to directory entries. +Directory contents can be accessed through the Python operators such as `[]` +and `in`. These methods automatically check if the directory is fresh (up to +date) or stale (needs update) and will call `update` if necessary before +returing a result. + +The general FUSE operation flow is as follows: + +- The request handler is called with either an inode or file handle that is the + subject of the operation. + +- Look up the inode using the Inodes table or the file handle in the + filehandles table to get the file system object. + +- For methods that alter files or directories, check that the operation is + valid and permitted using _check_writable(). + +- Call the relevant method on the file system object. + +- Return the result. + +The FUSE driver supports the Arvados event bus. When an event is received for +an object that is live in the inode cache, that object is immediately updated. + +""" import os import sys @@ -29,10 +72,11 @@ from fusefile import StringFile, FuseArvadosFile _logger = logging.getLogger('arvados.arvados_fuse') -log_handler = logging.StreamHandler() -llogger = logging.getLogger('llfuse') -llogger.addHandler(log_handler) -llogger.setLevel(logging.DEBUG) +# Uncomment this to enable llfuse debug logging. +# log_handler = logging.StreamHandler() +# llogger = logging.getLogger('llfuse') +# llogger.addHandler(log_handler) +# llogger.setLevel(logging.DEBUG) class Handle(object): """Connects a numeric file handle to a File or Directory object that has @@ -47,8 +91,7 @@ class Handle(object): self.obj.dec_use() def flush(self): - with llfuse.lock_released: - return self.obj.flush() + return self.obj.flush() class FileHandle(Handle): @@ -67,6 +110,17 @@ class DirectoryHandle(Handle): class InodeCache(object): + """Records the memory footprint of objects and when they are last used. + + When the cache limit is exceeded, the least recently used objects are + cleared. Clearing the object means discarding its contents to release + memory. The next time the object is accessed, it must be re-fetched from + the server. Note that the inode cache limit is a soft limit; the cache + limit may be exceeded if necessary to load very large objects, it may also + be exceeded if open file handles prevent objects from being cleared. + + """ + def __init__(self, cap, min_entries=4): self._entries = collections.OrderedDict() self._by_uuid = {} @@ -80,18 +134,18 @@ class InodeCache(object): def _remove(self, obj, clear): if clear and not obj.clear(): - _logger.debug("Could not clear %s in_use %s", obj, obj.in_use()) + _logger.debug("InodeCache could not clear %i in_use %s", obj.inode, obj.in_use()) return False self._total -= obj.cache_size del self._entries[obj.cache_priority] if obj.cache_uuid: del self._by_uuid[obj.cache_uuid] obj.cache_uuid = None - _logger.debug("Cleared %s total now %i", obj, self._total) + if clear: + _logger.debug("InodeCache cleared %i total now %i", obj.inode, self._total) return True def cap_cache(self): - _logger.debug("total is %i cap is %i", self._total, self.cap) if self._total > self.cap: for key in list(self._entries.keys()): if self._total < self.cap or len(self._entries) < self.min_entries: @@ -107,7 +161,7 @@ class InodeCache(object): if obj.cache_uuid: self._by_uuid[obj.cache_uuid] = obj self._total += obj.objsize() - _logger.debug("Managing %s total now %i", obj, self._total) + _logger.debug("InodeCache touched %i (size %i) total now %i", obj.inode, obj.objsize(), self._total) self.cap_cache() else: obj.cache_priority = None @@ -117,7 +171,6 @@ class InodeCache(object): if obj.cache_priority in self._entries: self._remove(obj, False) self.manage(obj) - _logger.debug("Touched %s (%i) total now %i", obj, obj.objsize(), self._total) def unmanage(self, obj): if obj.persisted() and obj.cache_priority in self._entries: @@ -130,10 +183,11 @@ class Inodes(object): """Manage the set of inodes. This is the mapping from a numeric id to a concrete File or Directory object""" - def __init__(self, inode_cache): + def __init__(self, inode_cache, encoding="utf-8"): self._entries = {} self._counter = itertools.count(llfuse.ROOT_INODE) self.inode_cache = inode_cache + self.encoding = encoding def __getitem__(self, item): return self._entries[item] @@ -167,13 +221,17 @@ class Inodes(object): _logger.debug("Deleting inode %i", entry.inode) self.inode_cache.unmanage(entry) llfuse.invalidate_inode(entry.inode) + entry.finalize() del self._entries[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 catch_exceptions(orig_func): + """Catch uncaught exceptions and log them consistently.""" + @functools.wraps(orig_func) def catch_exceptions_wrapper(self, *args, **kwargs): try: @@ -206,10 +264,9 @@ class Operations(llfuse.Operations): if not inode_cache: inode_cache = InodeCache(cap=256*1024*1024) - self.inodes = Inodes(inode_cache) + self.inodes = Inodes(inode_cache, encoding=encoding) self.uid = uid self.gid = gid - self.encoding = encoding # dict of inode to filehandle self._filehandles = {} @@ -228,28 +285,46 @@ class Operations(llfuse.Operations): # initializing to continue self.initlock.set() + @catch_exceptions def destroy(self): if self.events: self.events.close() + self.events = None + + for k,v in self.inodes.items(): + v.finalize() + self.inodes = None def access(self, inode, mode, ctx): return True def listen_for_events(self, api_client): - self.event = arvados.events.subscribe(api_client, + self.events = arvados.events.subscribe(api_client, [["event_type", "in", ["create", "update", "delete"]]], self.on_event) + @catch_exceptions def on_event(self, ev): if 'event_type' in ev: with llfuse.lock: item = self.inodes.inode_cache.find(ev["object_uuid"]) - if item: + if item is not None: item.invalidate() - item.update() + if ev["object_kind"] == "arvados#collection": + new_attr = ev.get("properties") and ev["properties"].get("new_attributes") and ev["properties"]["new_attributes"] + record_version = (new_attr["modified_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) + if olditemparent is not None: + olditemparent.invalidate() + olditemparent.update() itemparent = self.inodes.inode_cache.find(ev["object_owner_uuid"]) - if itemparent: + if itemparent is not None: itemparent.invalidate() itemparent.update() @@ -263,8 +338,8 @@ class Operations(llfuse.Operations): entry = llfuse.EntryAttributes() entry.st_ino = inode entry.generation = 0 - entry.entry_timeout = 300 - entry.attr_timeout = 300 + entry.entry_timeout = 60 + entry.attr_timeout = 60 entry.st_mode = stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH if isinstance(e, Directory): @@ -285,16 +360,29 @@ class Operations(llfuse.Operations): entry.st_size = e.size() entry.st_blksize = 512 - entry.st_blocks = (e.size()/512)+1 + entry.st_blocks = (entry.st_size/512)+1 entry.st_atime = int(e.atime()) entry.st_mtime = int(e.mtime()) entry.st_ctime = int(e.mtime()) return entry + @catch_exceptions + def setattr(self, inode, attr): + entry = self.getattr(inode) + + e = self.inodes[inode] + + if attr.st_size is not None and isinstance(e, FuseArvadosFile): + with llfuse.lock_released: + e.arvfile.truncate(attr.st_size) + entry.st_size = e.arvfile.size() + + return entry + @catch_exceptions def lookup(self, parent_inode, name): - name = unicode(name, self.encoding) + name = unicode(name, self.inodes.encoding) inode = None if name == '.': @@ -354,10 +442,9 @@ class Operations(llfuse.Operations): self.inodes.touch(handle.obj) try: - with llfuse.lock_released: - return handle.obj.readfrom(off, size, self.num_retries) + return handle.obj.readfrom(off, size, self.num_retries) except arvados.errors.NotFoundError as e: - _logger.warning("Block not found: " + str(e)) + _logger.error("Block not found: " + str(e)) raise llfuse.FUSEError(errno.EIO) @catch_exceptions @@ -373,8 +460,7 @@ class Operations(llfuse.Operations): self.inodes.touch(handle.obj) - with llfuse.lock_released: - return handle.obj.writeto(off, buf, self.num_retries) + return handle.obj.writeto(off, buf, self.num_retries) @catch_exceptions def release(self, fh): @@ -430,16 +516,13 @@ class Operations(llfuse.Operations): e = off while e < len(handle.entries): if handle.entries[e][1].inode in self.inodes: - try: - yield (handle.entries[e][0].encode(self.encoding), self.getattr(handle.entries[e][1].inode), e+1) - except UnicodeEncodeError: - pass + yield (handle.entries[e][0].encode(self.inodes.encoding), self.getattr(handle.entries[e][1].inode), e+1) e += 1 @catch_exceptions def statfs(self): st = llfuse.StatvfsData() - st.f_bsize = 64 * 1024 + st.f_bsize = 128 * 1024 st.f_blocks = 0 st.f_files = 0 @@ -464,17 +547,12 @@ class Operations(llfuse.Operations): if not p.writable(): raise llfuse.FUSEError(errno.EPERM) - if not isinstance(p, CollectionDirectoryBase): - raise llfuse.FUSEError(errno.EPERM) - return p @catch_exceptions def create(self, inode_parent, name, mode, flags, ctx): p = self._check_writable(inode_parent) - - with llfuse.lock_released: - p.collection.open(name, "w") + p.create(name) # The file entry should have been implicitly created by callback. f = p[name] @@ -490,9 +568,7 @@ class Operations(llfuse.Operations): _logger.debug("arv-mount mkdir: %i '%s' %o", inode_parent, name, mode) p = self._check_writable(inode_parent) - - with llfuse.lock_released: - p.collection.mkdirs(name) + p.mkdir(name) # The dir entry should have been implicitly created by callback. d = p[name] @@ -504,23 +580,20 @@ class Operations(llfuse.Operations): 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) - with llfuse.lock_released: - p.collection.remove(name) - + @catch_exceptions def rmdir(self, inode_parent, name): - self.unlink(inode_parent, name) + _logger.debug("arv-mount rmdir: %i '%s'", inode_parent, name) + p = self._check_writable(inode_parent) + p.rmdir(name) @catch_exceptions 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 = self._check_writable(inode_parent_new) - - with llfuse.lock_released: - dest.collection.rename(name_old, name_new, source_collection=src.collection, overwrite=True) - dest.flush() - src.flush() + dest.rename(name_old, name_new, src) @catch_exceptions def flush(self, fh):