Method process_file

src/borg/archive.py:1415–1533

(self, *, path, parent_fd, name, st, cache, flags=flags_normal, last_try=False, strip_prefix)

        return status

    def process_file(self, *, path, parent_fd, name, st, cache, flags=flags_normal, last_try=False, strip_prefix):
        with self.create_helper(path, st, None, strip_prefix=strip_prefix) as (
            item,
            status,
            hardlinked,
            hl_chunks,
        ):  # no status yet
            if item is None:
                return status
            with OsOpen(path=path, parent_fd=parent_fd, name=name, flags=flags, noatime=True) as fd:
                with backup_io("fstat"):
                    st = stat_update_check(st, os.fstat(fd))
                item.update(self.metadata_collector.stat_simple_attrs(st, path, fd=fd))
                item.update(self.metadata_collector.stat_ext_attrs(st, path, fd=fd))
                maybe_exclude_by_attr(item)  # check early, before processing all the file content
                is_special_file = is_special(st.st_mode)
                if is_special_file:
                    # we process a special file like a regular file. reflect that in mode,
                    # so it can be extracted / accessed in FUSE mount like a regular file.
                    # this needs to be done early, so that part files also get the patched mode.
                    item.mode = stat.S_IFREG | stat.S_IMODE(item.mode)
                # we begin processing chunks now.
                if hl_chunks is not None:  # create_helper gave us chunks from a previous hard link
                    item.chunks = []
                    for chunk_id, chunk_size in hl_chunks:
                        # process one-by-one, so we will know in item.chunks how far we got
                        chunk_entry = cache.reuse_chunk(chunk_id, chunk_size, self.stats)
                        item.chunks.append(chunk_entry)
                else:  # normal case, no "2nd+" hard link
                    if not is_special_file:
                        hashed_path = safe_encode(item.path)  # path as in archive item!
                        started_hashing = time.monotonic()
                        path_hash = self.key.id_hash(hashed_path)
                        self.stats.hashing_time += time.monotonic() - started_hashing
                        known, chunks = cache.file_known_and_unchanged(hashed_path, path_hash, st)
                    else:
                        # in --read-special mode, we may be called for special files.
                        # there should be no information in the cache about special files processed in
                        # read-special mode, but we better play safe as this was wrong in the past:
                        hashed_path = path_hash = None
                        known, chunks = False, None
                    if chunks is not None:
                        # Make sure all ids are available
                        for chunk in chunks:
                            if not cache.seen_chunk(chunk.id):
                                # cache said it is unmodified, but we lost a chunk: process file like modified
                                status = "M"
                                break
                        else:
                            item.chunks = []
                            for chunk in chunks:
                                # process one-by-one, so we will know in item.chunks how far we got
                                cache.reuse_chunk(chunk.id, chunk.size, self.stats)
                                item.chunks.append(chunk)
                            status = "U"  # regular file, unchanged
                    else:
                        status = "M" if known else "A"  # regular file, modified or added
                    self.print_file_status(status, path)