| # Copyright 2013 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| from copy import deepcopy |
| |
| from file_system import FileSystem, StatInfo, FileNotFoundError |
| from future import Gettable, Future |
| |
| class _AsyncFetchFuture(object): |
| def __init__(self, |
| unpatched_files_future, |
| patched_files_future, |
| dirs_value, |
| patched_file_system): |
| self._unpatched_files_future = unpatched_files_future |
| self._patched_files_future = patched_files_future |
| self._dirs_value = dirs_value |
| self._patched_file_system = patched_file_system |
| |
| def Get(self): |
| files = self._unpatched_files_future.Get() |
| files.update(self._patched_files_future.Get()) |
| files.update( |
| dict((path, self._PatchDirectoryListing(path, self._dirs_value[path])) |
| for path in self._dirs_value)) |
| return files |
| |
| def _PatchDirectoryListing(self, path, original_listing): |
| added, deleted, modified = ( |
| self._patched_file_system._GetDirectoryListingFromPatch(path)) |
| if original_listing is None: |
| if len(added) == 0: |
| raise FileNotFoundError('Directory %s not found in the patch.' % path) |
| return added |
| return list((set(original_listing) | set(added)) - set(deleted)) |
| |
| class PatchedFileSystem(FileSystem): |
| ''' Class to fetch resources with a patch applied. |
| ''' |
| def __init__(self, base_file_system, patcher): |
| self._base_file_system = base_file_system |
| self._patcher = patcher |
| |
| def Read(self, paths, binary=False): |
| patched_files = set() |
| added, deleted, modified = self._patcher.GetPatchedFiles() |
| if set(paths) & set(deleted): |
| def raise_file_not_found(): |
| raise FileNotFoundError('Files are removed from the patch.') |
| return Future(delegate=Gettable(raise_file_not_found)) |
| patched_files |= (set(added) | set(modified)) |
| dir_paths = set(path for path in paths if path.endswith('/')) |
| file_paths = set(paths) - dir_paths |
| patched_paths = file_paths & patched_files |
| unpatched_paths = file_paths - patched_files |
| return Future(delegate=_AsyncFetchFuture( |
| self._base_file_system.Read(unpatched_paths, binary), |
| self._patcher.Apply(patched_paths, self._base_file_system, binary), |
| self._TryReadDirectory(dir_paths, binary), |
| self)) |
| |
| ''' Given the list of patched files, it's not possible to determine whether |
| a directory to read exists in self._base_file_system. So try reading each one |
| and handle FileNotFoundError. |
| ''' |
| def _TryReadDirectory(self, paths, binary): |
| value = {} |
| for path in paths: |
| assert path.endswith('/') |
| try: |
| value[path] = self._base_file_system.ReadSingle(path, binary).Get() |
| except FileNotFoundError: |
| value[path] = None |
| return value |
| |
| def _GetDirectoryListingFromPatch(self, path): |
| assert path.endswith('/') |
| def _FindChildrenInPath(files, path): |
| result = [] |
| for f in files: |
| if f.startswith(path): |
| child_path = f[len(path):] |
| if '/' in child_path: |
| child_name = child_path[0:child_path.find('/') + 1] |
| else: |
| child_name = child_path |
| result.append(child_name) |
| return result |
| |
| added, deleted, modified = (tuple( |
| _FindChildrenInPath(files, path) |
| for files in self._patcher.GetPatchedFiles())) |
| |
| # A patch applies to files only. It cannot delete directories. |
| deleted_files = [child for child in deleted if not child.endswith('/')] |
| # However, these directories are actually modified because their children |
| # are patched. |
| modified += [child for child in deleted if child.endswith('/')] |
| |
| return (added, deleted_files, modified) |
| |
| def _PatchStat(self, stat_info, version, added, deleted, modified): |
| assert len(added) + len(deleted) + len(modified) > 0 |
| assert stat_info.child_versions is not None |
| |
| # Deep copy before patching to make sure it doesn't interfere with values |
| # cached in memory. |
| stat_info = deepcopy(stat_info) |
| |
| stat_info.version = version |
| for child in added + modified: |
| stat_info.child_versions[child] = version |
| for child in deleted: |
| if stat_info.child_versions.get(child): |
| del stat_info.child_versions[child] |
| |
| return stat_info |
| |
| def Stat(self, path): |
| version = self._patcher.GetVersion() |
| assert version is not None |
| version = 'patched_%s' % version |
| |
| directory, filename = path.rsplit('/', 1) |
| added, deleted, modified = self._GetDirectoryListingFromPatch( |
| directory + '/') |
| |
| if len(added) > 0: |
| # There are new files added. It's possible (if |directory| is new) that |
| # self._base_file_system.Stat will throw an exception. |
| try: |
| stat_info = self._PatchStat( |
| self._base_file_system.Stat(directory + '/'), |
| version, |
| added, |
| deleted, |
| modified) |
| except FileNotFoundError: |
| stat_info = StatInfo( |
| version, |
| dict((child, version) for child in added + modified)) |
| elif len(deleted) + len(modified) > 0: |
| # No files were added. |
| stat_info = self._PatchStat(self._base_file_system.Stat(directory + '/'), |
| version, |
| added, |
| deleted, |
| modified) |
| else: |
| # No changes are made in this directory. |
| return self._base_file_system.Stat(path) |
| |
| if stat_info.child_versions is not None: |
| if filename: |
| if filename in stat_info.child_versions: |
| stat_info = StatInfo(stat_info.child_versions[filename]) |
| else: |
| raise FileNotFoundError('%s was not in child versions' % filename) |
| return stat_info |
| |
| def GetIdentity(self): |
| return '%s(%s,%s)' % (self.__class__.__name__, |
| self._base_file_system.GetIdentity(), |
| self._patcher.GetIdentity()) |
