9 from apiclient import errors as apiclient_errors
13 from fusefile import StringFile, ObjectFile, FuncToJSONFile, FuseArvadosFile
14 from fresh import FreshBase, convertTime, use_counter, check_update
16 import arvados.collection
17 from arvados.util import portable_data_hash_pattern, uuid_pattern, collection_uuid_pattern, group_uuid_pattern, user_uuid_pattern, link_uuid_pattern
19 _logger = logging.getLogger('arvados.arvados_fuse')
22 # Match any character which FUSE or Linux cannot accommodate as part
23 # of a filename. (If present in a collection filename, they will
24 # appear as underscores in the fuse mount.)
25 _disallowed_filename_characters = re.compile('[\x00/]')
27 # '.' and '..' are not reachable if API server is newer than #6277
28 def sanitize_filename(dirty):
29 """Replace disallowed filename characters with harmless "_"."""
39 return _disallowed_filename_characters.sub('_', dirty)
42 class Directory(FreshBase):
43 """Generic directory object, backed by a dict.
45 Consists of a set of entries with the key representing the filename
46 and the value referencing a File or Directory object.
49 def __init__(self, parent_inode, inodes):
50 """parent_inode is the integer inode number"""
52 super(Directory, self).__init__()
55 if not isinstance(parent_inode, int):
56 raise Exception("parent_inode should be an int")
57 self.parent_inode = parent_inode
60 self._mtime = time.time()
62 # Overriden by subclasses to implement logic to update the entries dict
63 # when the directory is stale
68 # Only used when computing the size of the disk footprint of the directory
76 def checkupdate(self):
80 except apiclient.errors.HttpError as e:
85 def __getitem__(self, item):
86 return self._entries[item]
91 return list(self._entries.items())
95 def __contains__(self, k):
96 return k in self._entries
101 return len(self._entries)
104 self.inodes.touch(self)
105 super(Directory, self).fresh()
107 def merge(self, items, fn, same, new_entry):
108 """Helper method for updating the contents of the directory.
110 Takes a list describing the new contents of the directory, reuse
111 entries that are the same in both the old and new lists, create new
112 entries, and delete old entries missing from the new list.
114 :items: iterable with new directory contents
116 :fn: function to take an entry in 'items' and return the desired file or
117 directory name, or None if this entry should be skipped
119 :same: function to compare an existing entry (a File or Directory
120 object) with an entry in the items list to determine whether to keep
123 :new_entry: function to create a new directory entry (File or Directory
124 object) from an entry in the items list.
128 oldentries = self._entries
132 name = sanitize_filename(fn(i))
134 if name in oldentries and same(oldentries[name], i):
135 # move existing directory entry over
136 self._entries[name] = oldentries[name]
139 _logger.debug("Adding entry '%s' to inode %i", name, self.inode)
140 # create new directory entry
143 self._entries[name] = self.inodes.add_entry(ent)
146 # delete any other directory entries that were not in found in 'items'
148 _logger.debug("Forgetting about entry '%s' on inode %i", i, self.inode)
149 self.inodes.invalidate_entry(self.inode, i.encode(self.inodes.encoding))
150 self.inodes.del_entry(oldentries[i])
154 self.inodes.invalidate_inode(self.inode)
155 self._mtime = time.time()
159 def clear(self, force=False):
160 """Delete all entries"""
162 if not self.in_use() or force:
163 oldentries = self._entries
166 if not oldentries[n].clear(force):
167 self._entries = oldentries
170 self.inodes.invalidate_entry(self.inode, n.encode(self.inodes.encoding))
171 self.inodes.del_entry(oldentries[n])
172 self.inodes.invalidate_inode(self.inode)
187 def create(self, name):
188 raise NotImplementedError()
190 def mkdir(self, name):
191 raise NotImplementedError()
193 def unlink(self, name):
194 raise NotImplementedError()
196 def rmdir(self, name):
197 raise NotImplementedError()
199 def rename(self, name_old, name_new, src):
200 raise NotImplementedError()
203 class CollectionDirectoryBase(Directory):
204 """Represent an Arvados Collection as a directory.
206 This class is used for Subcollections, and is also the base class for
207 CollectionDirectory, which implements collection loading/saving on
210 Most operations act only the underlying Arvados `Collection` object. The
211 `Collection` object signals via a notify callback to
212 `CollectionDirectoryBase.on_event` that an item was added, removed or
213 modified. FUSE inodes and directory entries are created, deleted or
214 invalidated in response to these events.
218 def __init__(self, parent_inode, inodes, collection):
219 super(CollectionDirectoryBase, self).__init__(parent_inode, inodes)
220 self.collection = collection
222 def new_entry(self, name, item, mtime):
223 name = sanitize_filename(name)
224 if hasattr(item, "fuse_entry") and item.fuse_entry is not None:
225 if item.fuse_entry.dead is not True:
226 raise Exception("Can only reparent dead inode entry")
227 if item.fuse_entry.inode is None:
228 raise Exception("Reparented entry must still have valid inode")
229 item.fuse_entry.dead = False
230 self._entries[name] = item.fuse_entry
231 elif isinstance(item, arvados.collection.RichCollectionBase):
232 self._entries[name] = self.inodes.add_entry(CollectionDirectoryBase(self.inode, self.inodes, item))
233 self._entries[name].populate(mtime)
235 self._entries[name] = self.inodes.add_entry(FuseArvadosFile(self.inode, item, mtime))
236 item.fuse_entry = self._entries[name]
238 def on_event(self, event, collection, name, item):
239 if collection == self.collection:
240 name = sanitize_filename(name)
241 _logger.debug("collection notify %s %s %s %s", event, collection, name, item)
243 if event == arvados.collection.ADD:
244 self.new_entry(name, item, self.mtime())
245 elif event == arvados.collection.DEL:
246 ent = self._entries[name]
247 del self._entries[name]
248 self.inodes.invalidate_entry(self.inode, name.encode(self.inodes.encoding))
249 self.inodes.del_entry(ent)
250 elif event == arvados.collection.MOD:
251 if hasattr(item, "fuse_entry") and item.fuse_entry is not None:
252 self.inodes.invalidate_inode(item.fuse_entry.inode)
253 elif name in self._entries:
254 self.inodes.invalidate_inode(self._entries[name].inode)
256 def populate(self, mtime):
258 self.collection.subscribe(self.on_event)
259 for entry, item in self.collection.items():
260 self.new_entry(entry, item, self.mtime())
263 return self.collection.writable()
267 with llfuse.lock_released:
268 self.collection.root_collection().save()
272 def create(self, name):
273 with llfuse.lock_released:
274 self.collection.open(name, "w").close()
278 def mkdir(self, name):
279 with llfuse.lock_released:
280 self.collection.mkdirs(name)
284 def unlink(self, name):
285 with llfuse.lock_released:
286 self.collection.remove(name)
291 def rmdir(self, name):
292 with llfuse.lock_released:
293 self.collection.remove(name)
298 def rename(self, name_old, name_new, src):
299 if not isinstance(src, CollectionDirectoryBase):
300 raise llfuse.FUSEError(errno.EPERM)
305 if isinstance(ent, FuseArvadosFile) and isinstance(tgt, FuseArvadosFile):
307 elif isinstance(ent, CollectionDirectoryBase) and isinstance(tgt, CollectionDirectoryBase):
309 raise llfuse.FUSEError(errno.ENOTEMPTY)
310 elif isinstance(ent, CollectionDirectoryBase) and isinstance(tgt, FuseArvadosFile):
311 raise llfuse.FUSEError(errno.ENOTDIR)
312 elif isinstance(ent, FuseArvadosFile) and isinstance(tgt, CollectionDirectoryBase):
313 raise llfuse.FUSEError(errno.EISDIR)
315 with llfuse.lock_released:
316 self.collection.rename(name_old, name_new, source_collection=src.collection, overwrite=True)
321 class CollectionDirectory(CollectionDirectoryBase):
322 """Represents the root of a directory tree representing a collection."""
324 def __init__(self, parent_inode, inodes, api, num_retries, collection_record=None, explicit_collection=None):
325 super(CollectionDirectory, self).__init__(parent_inode, inodes, None)
327 self.num_retries = num_retries
328 self.collection_record_file = None
329 self.collection_record = None
332 self.poll_time = (api._rootDesc.get('blobSignatureTtl', 60*60*2)/2)
334 _logger.debug("Error getting blobSignatureTtl from discovery document: %s", sys.exc_info()[0])
335 self.poll_time = 60*60
337 if isinstance(collection_record, dict):
338 self.collection_locator = collection_record['uuid']
339 self._mtime = convertTime(collection_record.get('modified_at'))
341 self.collection_locator = collection_record
343 self._manifest_size = 0
344 if self.collection_locator:
345 self._writable = (uuid_pattern.match(self.collection_locator) is not None)
346 self._updating_lock = threading.Lock()
349 return i['uuid'] == self.collection_locator or i['portable_data_hash'] == self.collection_locator
352 return self.collection.writable() if self.collection is not None else self._writable
354 # Used by arv-web.py to switch the contents of the CollectionDirectory
355 def change_collection(self, new_locator):
356 """Switch the contents of the CollectionDirectory.
358 Must be called with llfuse.lock held.
361 self.collection_locator = new_locator
362 self.collection_record = None
365 def new_collection(self, new_collection_record, coll_reader):
367 self.clear(force=True)
369 self.collection_record = new_collection_record
371 if self.collection_record:
372 self._mtime = convertTime(self.collection_record.get('modified_at'))
373 self.collection_locator = self.collection_record["uuid"]
374 if self.collection_record_file is not None:
375 self.collection_record_file.update(self.collection_record)
377 self.collection = coll_reader
378 self.populate(self.mtime())
381 return self.collection_locator
384 def update(self, to_record_version=None):
386 if self.collection_record is not None and portable_data_hash_pattern.match(self.collection_locator):
389 if self.collection_locator is None:
394 with llfuse.lock_released:
395 self._updating_lock.acquire()
399 _logger.debug("Updating %s", to_record_version)
400 if self.collection is not None:
401 if self.collection.known_past_version(to_record_version):
402 _logger.debug("%s already processed %s", self.collection_locator, to_record_version)
404 self.collection.update()
406 if uuid_pattern.match(self.collection_locator):
407 coll_reader = arvados.collection.Collection(
408 self.collection_locator, self.api, self.api.keep,
409 num_retries=self.num_retries)
411 coll_reader = arvados.collection.CollectionReader(
412 self.collection_locator, self.api, self.api.keep,
413 num_retries=self.num_retries)
414 new_collection_record = coll_reader.api_response() or {}
415 # If the Collection only exists in Keep, there will be no API
416 # response. Fill in the fields we need.
417 if 'uuid' not in new_collection_record:
418 new_collection_record['uuid'] = self.collection_locator
419 if "portable_data_hash" not in new_collection_record:
420 new_collection_record["portable_data_hash"] = new_collection_record["uuid"]
421 if 'manifest_text' not in new_collection_record:
422 new_collection_record['manifest_text'] = coll_reader.manifest_text()
424 if self.collection_record is None or self.collection_record["portable_data_hash"] != new_collection_record.get("portable_data_hash"):
425 self.new_collection(new_collection_record, coll_reader)
427 self._manifest_size = len(coll_reader.manifest_text())
428 _logger.debug("%s manifest_size %i", self, self._manifest_size)
429 # end with llfuse.lock_released, re-acquire lock
434 self._updating_lock.release()
435 except arvados.errors.NotFoundError as e:
436 _logger.error("Error fetching collection '%s': %s", self.collection_locator, e)
437 except arvados.errors.ArgumentError as detail:
438 _logger.warning("arv-mount %s: error %s", self.collection_locator, detail)
439 if self.collection_record is not None and "manifest_text" in self.collection_record:
440 _logger.warning("arv-mount manifest_text is: %s", self.collection_record["manifest_text"])
442 _logger.exception("arv-mount %s: error", self.collection_locator)
443 if self.collection_record is not None and "manifest_text" in self.collection_record:
444 _logger.error("arv-mount manifest_text is: %s", self.collection_record["manifest_text"])
450 def __getitem__(self, item):
451 if item == '.arvados#collection':
452 if self.collection_record_file is None:
453 self.collection_record_file = ObjectFile(self.inode, self.collection_record)
454 self.inodes.add_entry(self.collection_record_file)
455 return self.collection_record_file
457 return super(CollectionDirectory, self).__getitem__(item)
459 def __contains__(self, k):
460 if k == '.arvados#collection':
463 return super(CollectionDirectory, self).__contains__(k)
465 def invalidate(self):
466 self.collection_record = None
467 self.collection_record_file = None
468 super(CollectionDirectory, self).invalidate()
471 return (self.collection_locator is not None)
474 # This is an empirically-derived heuristic to estimate the memory used
475 # to store this collection's metadata. Calculating the memory
476 # footprint directly would be more accurate, but also more complicated.
477 return self._manifest_size * 128
480 if self.collection is not None:
482 self.collection.save()
483 self.collection.stop_threads()
486 class TmpCollectionDirectory(CollectionDirectoryBase):
487 """A directory backed by an Arvados collection that never gets saved.
489 This supports using Keep as scratch space. A userspace program can
490 read the .arvados#collection file to get a current manifest in
491 order to save a snapshot of the scratch data or use it as a crunch
495 class UnsaveableCollection(arvados.collection.Collection):
501 def __init__(self, parent_inode, inodes, api_client, num_retries):
502 collection = self.UnsaveableCollection(
503 api_client=api_client,
504 keep_client=api_client.keep)
505 super(TmpCollectionDirectory, self).__init__(
506 parent_inode, inodes, collection)
507 self.collection_record_file = None
508 self.populate(self.mtime())
510 def on_event(self, *args, **kwargs):
511 super(TmpCollectionDirectory, self).on_event(*args, **kwargs)
512 if self.collection_record_file:
514 self.collection_record_file.invalidate()
515 self.inodes.invalidate_inode(self.collection_record_file.inode)
516 _logger.debug("%s invalidated collection record", self)
518 def collection_record(self):
519 with llfuse.lock_released:
522 "manifest_text": self.collection.manifest_text(),
523 "portable_data_hash": self.collection.portable_data_hash(),
526 def __contains__(self, k):
527 return (k == '.arvados#collection' or
528 super(TmpCollectionDirectory, self).__contains__(k))
531 def __getitem__(self, item):
532 if item == '.arvados#collection':
533 if self.collection_record_file is None:
534 self.collection_record_file = FuncToJSONFile(
535 self.inode, self.collection_record)
536 self.inodes.add_entry(self.collection_record_file)
537 return self.collection_record_file
538 return super(TmpCollectionDirectory, self).__getitem__(item)
547 self.collection.stop_threads()
549 def invalidate(self):
550 if self.collection_record_file:
551 self.collection_record_file.invalidate()
552 super(TmpCollectionDirectory, self).invalidate()
555 class MagicDirectory(Directory):
556 """A special directory that logically contains the set of all extant keep locators.
558 When a file is referenced by lookup(), it is tested to see if it is a valid
559 keep locator to a manifest, and if so, loads the manifest contents as a
560 subdirectory of this directory with the locator as the directory name.
561 Since querying a list of all extant keep locators is impractical, only
562 collections that have already been accessed are visible to readdir().
567 This directory provides access to Arvados collections as subdirectories listed
568 by uuid (in the form 'zzzzz-4zz18-1234567890abcde') or portable data hash (in
569 the form '1234567890abcdef0123456789abcdef+123').
571 Note that this directory will appear empty until you attempt to access a
572 specific collection subdirectory (such as trying to 'cd' into it), at which
573 point the collection will actually be looked up on the server and the directory
574 will appear if it exists.
578 def __init__(self, parent_inode, inodes, api, num_retries, pdh_only=False):
579 super(MagicDirectory, self).__init__(parent_inode, inodes)
581 self.num_retries = num_retries
582 self.pdh_only = pdh_only
584 def __setattr__(self, name, value):
585 super(MagicDirectory, self).__setattr__(name, value)
586 # When we're assigned an inode, add a README.
587 if ((name == 'inode') and (self.inode is not None) and
588 (not self._entries)):
589 self._entries['README'] = self.inodes.add_entry(
590 StringFile(self.inode, self.README_TEXT, time.time()))
591 # If we're the root directory, add an identical by_id subdirectory.
592 if self.inode == llfuse.ROOT_INODE:
593 self._entries['by_id'] = self.inodes.add_entry(MagicDirectory(
594 self.inode, self.inodes, self.api, self.num_retries, self.pdh_only))
596 def __contains__(self, k):
597 if k in self._entries:
600 if not portable_data_hash_pattern.match(k) and (self.pdh_only or not uuid_pattern.match(k)):
604 e = self.inodes.add_entry(CollectionDirectory(
605 self.inode, self.inodes, self.api, self.num_retries, k))
608 if k not in self._entries:
611 self.inodes.del_entry(e)
614 self.inodes.invalidate_entry(self.inode, k)
615 self.inodes.del_entry(e)
617 except Exception as ex:
618 _logger.debug('arv-mount exception keep %s', ex)
619 self.inodes.del_entry(e)
622 def __getitem__(self, item):
624 return self._entries[item]
626 raise KeyError("No collection with id " + item)
628 def clear(self, force=False):
632 class RecursiveInvalidateDirectory(Directory):
633 def invalidate(self):
635 super(RecursiveInvalidateDirectory, self).invalidate()
636 for a in self._entries:
637 self._entries[a].invalidate()
642 class TagsDirectory(RecursiveInvalidateDirectory):
643 """A special directory that contains as subdirectories all tags visible to the user."""
645 def __init__(self, parent_inode, inodes, api, num_retries, poll_time=60):
646 super(TagsDirectory, self).__init__(parent_inode, inodes)
648 self.num_retries = num_retries
650 self._poll_time = poll_time
654 with llfuse.lock_released:
655 tags = self.api.links().list(
656 filters=[['link_class', '=', 'tag']],
657 select=['name'], distinct=True
658 ).execute(num_retries=self.num_retries)
660 self.merge(tags['items'],
662 lambda a, i: a.tag == i['name'],
663 lambda i: TagDirectory(self.inode, self.inodes, self.api, self.num_retries, i['name'], poll=self._poll, poll_time=self._poll_time))
666 class TagDirectory(Directory):
667 """A special directory that contains as subdirectories all collections visible
668 to the user that are tagged with a particular tag.
671 def __init__(self, parent_inode, inodes, api, num_retries, tag,
672 poll=False, poll_time=60):
673 super(TagDirectory, self).__init__(parent_inode, inodes)
675 self.num_retries = num_retries
678 self._poll_time = poll_time
682 with llfuse.lock_released:
683 taggedcollections = self.api.links().list(
684 filters=[['link_class', '=', 'tag'],
685 ['name', '=', self.tag],
686 ['head_uuid', 'is_a', 'arvados#collection']],
688 ).execute(num_retries=self.num_retries)
689 self.merge(taggedcollections['items'],
690 lambda i: i['head_uuid'],
691 lambda a, i: a.collection_locator == i['head_uuid'],
692 lambda i: CollectionDirectory(self.inode, self.inodes, self.api, self.num_retries, i['head_uuid']))
695 class ProjectDirectory(Directory):
696 """A special directory that contains the contents of a project."""
698 def __init__(self, parent_inode, inodes, api, num_retries, project_object,
699 poll=False, poll_time=60):
700 super(ProjectDirectory, self).__init__(parent_inode, inodes)
702 self.num_retries = num_retries
703 self.project_object = project_object
704 self.project_object_file = None
705 self.project_uuid = project_object['uuid']
707 self._poll_time = poll_time
708 self._updating_lock = threading.Lock()
709 self._current_user = None
711 def createDirectory(self, i):
712 if collection_uuid_pattern.match(i['uuid']):
713 return CollectionDirectory(self.inode, self.inodes, self.api, self.num_retries, i)
714 elif group_uuid_pattern.match(i['uuid']):
715 return ProjectDirectory(self.inode, self.inodes, self.api, self.num_retries, i, self._poll, self._poll_time)
716 elif link_uuid_pattern.match(i['uuid']):
717 if i['head_kind'] == 'arvados#collection' or portable_data_hash_pattern.match(i['head_uuid']):
718 return CollectionDirectory(self.inode, self.inodes, self.api, self.num_retries, i['head_uuid'])
721 elif uuid_pattern.match(i['uuid']):
722 return ObjectFile(self.parent_inode, i)
727 return self.project_uuid
731 if self.project_object_file == None:
732 self.project_object_file = ObjectFile(self.inode, self.project_object)
733 self.inodes.add_entry(self.project_object_file)
737 if i['name'] is None or len(i['name']) == 0:
739 elif collection_uuid_pattern.match(i['uuid']) or group_uuid_pattern.match(i['uuid']):
740 # collection or subproject
742 elif link_uuid_pattern.match(i['uuid']) and i['head_kind'] == 'arvados#collection':
745 elif 'kind' in i and i['kind'].startswith('arvados#'):
747 return "{}.{}".format(i['name'], i['kind'][8:])
752 if isinstance(a, CollectionDirectory) or isinstance(a, ProjectDirectory):
753 return a.uuid() == i['uuid']
754 elif isinstance(a, ObjectFile):
755 return a.uuid() == i['uuid'] and not a.stale()
759 with llfuse.lock_released:
760 self._updating_lock.acquire()
764 if group_uuid_pattern.match(self.project_uuid):
765 self.project_object = self.api.groups().get(
766 uuid=self.project_uuid).execute(num_retries=self.num_retries)
767 elif user_uuid_pattern.match(self.project_uuid):
768 self.project_object = self.api.users().get(
769 uuid=self.project_uuid).execute(num_retries=self.num_retries)
771 contents = arvados.util.list_all(self.api.groups().contents,
772 self.num_retries, uuid=self.project_uuid)
774 # end with llfuse.lock_released, re-acquire lock
779 self.createDirectory)
781 self._updating_lock.release()
785 def __getitem__(self, item):
786 if item == '.arvados#project':
787 return self.project_object_file
789 return super(ProjectDirectory, self).__getitem__(item)
791 def __contains__(self, k):
792 if k == '.arvados#project':
795 return super(ProjectDirectory, self).__contains__(k)
800 with llfuse.lock_released:
801 if not self._current_user:
802 self._current_user = self.api.users().current().execute(num_retries=self.num_retries)
803 return self._current_user["uuid"] in self.project_object["writable_by"]
810 def mkdir(self, name):
812 with llfuse.lock_released:
813 self.api.collections().create(body={"owner_uuid": self.project_uuid,
815 "manifest_text": ""}).execute(num_retries=self.num_retries)
817 except apiclient_errors.Error as error:
819 raise llfuse.FUSEError(errno.EEXIST)
823 def rmdir(self, name):
825 raise llfuse.FUSEError(errno.ENOENT)
826 if not isinstance(self[name], CollectionDirectory):
827 raise llfuse.FUSEError(errno.EPERM)
828 if len(self[name]) > 0:
829 raise llfuse.FUSEError(errno.ENOTEMPTY)
830 with llfuse.lock_released:
831 self.api.collections().delete(uuid=self[name].uuid()).execute(num_retries=self.num_retries)
836 def rename(self, name_old, name_new, src):
837 if not isinstance(src, ProjectDirectory):
838 raise llfuse.FUSEError(errno.EPERM)
842 if not isinstance(ent, CollectionDirectory):
843 raise llfuse.FUSEError(errno.EPERM)
846 # POSIX semantics for replacing one directory with another is
847 # tricky (the target directory must be empty, the operation must be
848 # atomic which isn't possible with the Arvados API as of this
849 # writing) so don't support that.
850 raise llfuse.FUSEError(errno.EPERM)
852 self.api.collections().update(uuid=ent.uuid(),
853 body={"owner_uuid": self.uuid(),
854 "name": name_new}).execute(num_retries=self.num_retries)
856 # Acually move the entry from source directory to this directory.
857 del src._entries[name_old]
858 self._entries[name_new] = ent
859 self.inodes.invalidate_entry(src.inode, name_old.encode(self.inodes.encoding))
862 class SharedDirectory(Directory):
863 """A special directory that represents users or groups who have shared projects with me."""
865 def __init__(self, parent_inode, inodes, api, num_retries, exclude,
866 poll=False, poll_time=60):
867 super(SharedDirectory, self).__init__(parent_inode, inodes)
869 self.num_retries = num_retries
870 self.current_user = api.users().current().execute(num_retries=num_retries)
872 self._poll_time = poll_time
876 with llfuse.lock_released:
877 all_projects = arvados.util.list_all(
878 self.api.groups().list, self.num_retries,
879 filters=[['group_class','=','project']])
881 for ob in all_projects:
882 objects[ob['uuid']] = ob
886 for ob in all_projects:
887 if ob['owner_uuid'] != self.current_user['uuid'] and ob['owner_uuid'] not in objects:
889 root_owners[ob['owner_uuid']] = True
891 lusers = arvados.util.list_all(
892 self.api.users().list, self.num_retries,
893 filters=[['uuid','in', list(root_owners)]])
894 lgroups = arvados.util.list_all(
895 self.api.groups().list, self.num_retries,
896 filters=[['uuid','in', list(root_owners)]])
902 objects[l["uuid"]] = l
904 objects[l["uuid"]] = l
907 for r in root_owners:
911 contents[obr["name"]] = obr
912 #elif obr.get("username"):
913 # contents[obr["username"]] = obr
914 elif "first_name" in obr:
915 contents[u"{} {}".format(obr["first_name"], obr["last_name"])] = obr
919 if r['owner_uuid'] not in objects:
920 contents[r['name']] = r
922 # end with llfuse.lock_released, re-acquire lock
925 self.merge(contents.items(),
927 lambda a, i: a.uuid() == i[1]['uuid'],
928 lambda i: ProjectDirectory(self.inode, self.inodes, self.api, self.num_retries, i[1], poll=self._poll, poll_time=self._poll_time))