fn lookup()

in src/rust/engine/fs/brfs/src/main.rs [397:485]
89 lines of code
1 McCabe index (conditional complexity)

  fn lookup(
    &mut self,
    _req: &fuse::Request<'_>,
    parent: Inode,
    name: &OsStr,
    reply: fuse::ReplyEntry,
  ) {
    let r = match (parent, name.to_str()) {
      (ROOT, Some("digest")) => Ok(dir_attr_for(DIGEST_ROOT)),
      (ROOT, Some("directory")) => Ok(dir_attr_for(DIRECTORY_ROOT)),
      (DIGEST_ROOT, Some(digest_str)) => match digest_from_filepath(digest_str) {
        Ok(digest) => self
          .inode_for_file(digest, true)
          .map_err(|err| {
            error!("Error loading file by digest {}: {}", digest_str, err);
            libc::EINVAL
          })
          .and_then(|maybe_inode| {
            maybe_inode
              .and_then(|inode| self.file_attr_for(inode))
              .ok_or(libc::ENOENT)
          }),
        Err(err) => {
          warn!("Invalid digest for file in digest root: {}", err);
          Err(libc::ENOENT)
        }
      },
      (DIRECTORY_ROOT, Some(digest_str)) => match digest_from_filepath(digest_str) {
        Ok(digest) => self.dir_attr_for(digest),
        Err(err) => {
          warn!("Invalid digest for directroy in directory root: {}", err);
          Err(libc::ENOENT)
        }
      },
      (parent, Some(filename)) => {
        let maybe_cache_entry = self
          .inode_digest_cache
          .get(&parent)
          .cloned()
          .ok_or(libc::ENOENT);
        maybe_cache_entry
          .and_then(|cache_entry| {
            let parent_digest = cache_entry.digest;
            self
              .runtime
              .block_on(self.store.load_directory(parent_digest))
              .map_err(|err| {
                error!("Error reading directory {:?}: {}", parent_digest, err);
                libc::EINVAL
              })?
              .and_then(|directory| self.node_for_digest(&directory, filename))
              .ok_or(libc::ENOENT)
          })
          .and_then(|node| match node {
            Node::Directory(directory_node) => {
              let digest_result: Result<Digest, String> = directory_node.get_digest().into();
              let digest = digest_result.map_err(|err| {
                error!("Error parsing digest: {:?}", err);
                libc::ENOENT
              })?;
              self.dir_attr_for(digest)
            }
            Node::File(file_node) => {
              let digest_result: Result<Digest, String> = file_node.get_digest().into();
              let digest = digest_result.map_err(|err| {
                error!("Error parsing digest: {:?}", err);
                libc::ENOENT
              })?;
              self
                .inode_for_file(digest, file_node.get_is_executable())
                .map_err(|err| {
                  error!("Error loading file by digest {}: {}", filename, err);
                  libc::EINVAL
                })
                .and_then(|maybe_inode| {
                  maybe_inode
                    .and_then(|inode| self.file_attr_for(inode))
                    .ok_or(libc::ENOENT)
                })
            }
          })
      }
      _ => Err(libc::ENOENT),
    };
    match r {
      Ok(r) => reply.entry(&TTL, &r, 1),
      Err(err) => reply.error(err),
    }
  }