diff --git a/requirements.txt b/requirements.txt index f03579d..c737527 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,7 +1,8 @@ # Add here external Python modules dependencies, one per line. Module names # should match https://pypi.python.org/pypi names. For the full spec or # dependency lines, see https://pip.readthedocs.org/en/1.1/requirements.html click iso8601 subvertpy >= 0.9.4 +tenacity >= 6.2 typing-extensions diff --git a/swh/loader/svn/replay.py b/swh/loader/svn/replay.py index b600fb5..66180c9 100644 --- a/swh/loader/svn/replay.py +++ b/swh/loader/svn/replay.py @@ -1,1041 +1,1036 @@ # Copyright (C) 2016-2022 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information """Remote Access client to svn server. """ from __future__ import annotations import codecs from collections import defaultdict from dataclasses import dataclass, field from distutils.dir_util import copy_tree from itertools import chain import logging import os import shutil import tempfile from typing import ( TYPE_CHECKING, Any, BinaryIO, Callable, Dict, List, Optional, Set, Tuple, Union, cast, ) import click from subvertpy import SubversionException, delta, properties from subvertpy.ra import Auth, RemoteAccess, get_username_provider from swh.model import from_disk, hashutil from swh.model.from_disk import DiskBackedContent from swh.model.model import Content, Directory, SkippedContent if TYPE_CHECKING: from swh.loader.svn.svn import SvnRepo from swh.loader.svn.utils import ( is_recursive_external, parse_external_definition, svn_urljoin, ) _eol_style = {"native": b"\n", "CRLF": b"\r\n", "LF": b"\n", "CR": b"\r"} logger = logging.getLogger(__name__) def _normalize_line_endings(lines: bytes, eol_style: str = "native") -> bytes: r"""Normalize line endings to unix (\\n), windows (\\r\\n) or mac (\\r). Args: lines: The lines to normalize eol_style: The line ending format as defined for svn:eol-style property. Acceptable values are 'native', 'CRLF', 'LF' and 'CR' Returns: Lines with endings normalized """ if eol_style in _eol_style: lines = lines.replace(_eol_style["CRLF"], _eol_style["LF"]).replace( _eol_style["CR"], _eol_style["LF"] ) if _eol_style[eol_style] != _eol_style["LF"]: lines = lines.replace(_eol_style["LF"], _eol_style[eol_style]) return lines def apply_txdelta_handler( sbuf: bytes, target_stream: BinaryIO ) -> Callable[[Any, bytes, BinaryIO], None]: """Return a function that can be called repeatedly with txdelta windows. When done, closes the target_stream. Adapted from subvertpy.delta.apply_txdelta_handler to close the stream when done. Args: sbuf: Source buffer target_stream: Target stream to write to. Returns: Function to be called to apply txdelta windows """ def apply_window( window: Any, sbuf: bytes = sbuf, target_stream: BinaryIO = target_stream ): if window is None: target_stream.close() return # Last call patch = delta.apply_txdelta_window(sbuf, window) target_stream.write(patch) return apply_window def read_svn_link(data: bytes) -> Tuple[bytes, bytes]: """Read the svn link's content. Args: data: svn link's raw content Returns: The tuple of (filetype, destination path) """ split_byte = b" " first_line = data.split(b"\n")[0] filetype, *src = first_line.split(split_byte) target = split_byte.join(src) return filetype, target def is_file_an_svnlink_p(fullpath: bytes) -> Tuple[bool, bytes]: """Determine if a filepath is an svnlink or something else. Args: fullpath: Full path to the potential symlink to check Returns: Tuple containing a boolean value to determine if it's indeed a symlink (as per svn) and the link target. """ if os.path.islink(fullpath): return False, b"" with open(fullpath, "rb") as f: filetype, src = read_svn_link(f.read()) return filetype == b"link", src def _ra_codecs_error_handler(e: UnicodeError) -> Tuple[Union[str, bytes], int]: """Subvertpy may fail to decode to utf-8 the user svn properties. As they are not used by the loader, return an empty string instead of the decoded content. Args: e: exception raised during the svn properties decoding. """ return "", cast(UnicodeDecodeError, e).end DEFAULT_FLAG = 0 EXEC_FLAG = 1 NOEXEC_FLAG = 2 SVN_PROPERTY_EOL = "svn:eol-style" @dataclass class FileState: """Persists some file states (eg. end of lines style) across revisions while replaying them.""" eol_style: Optional[str] = None """EOL state check mess""" svn_special_path_non_link_data: Optional[bytes] = None """keep track of non link file content with svn:special property set""" # default value: 0, 1: set the flag, 2: remove the exec flag executable: int = DEFAULT_FLAG """keep track if file is executable when setting svn:executable property""" link: bool = False """keep track if file is a svn link when setting svn:special property""" class FileEditor: """File Editor in charge of updating file on disk and memory objects. """ __slots__ = [ "directory", "path", "fullpath", "executable", "link", "state", "svnrepo", "editor", ] def __init__( self, directory: from_disk.Directory, rootpath: bytes, path: bytes, state: FileState, svnrepo: SvnRepo, ): self.directory = directory self.path = path self.fullpath = os.path.join(rootpath, path) self.state = state self.svnrepo = svnrepo self.editor = svnrepo.swhreplay.editor self.editor.modified_paths.add(path) def change_prop(self, key: str, value: str) -> None: if key == properties.PROP_EXECUTABLE: if value is None: # bit flip off self.state.executable = NOEXEC_FLAG else: self.state.executable = EXEC_FLAG elif key == properties.PROP_SPECIAL: # Possibly a symbolic link. We cannot check further at # that moment though, patch(s) not being applied yet self.state.link = value is not None elif key == SVN_PROPERTY_EOL: # backup end of line style for file self.state.eol_style = value def __make_symlink(self, src: bytes) -> None: """Convert the svnlink to a symlink on disk. This function expects self.fullpath to be a svn link. Args: src: Path to the link's source Return: tuple: The svnlink's data tuple: - type (should be only 'link') - """ os.remove(self.fullpath) os.symlink(src=src, dst=self.fullpath) def __make_svnlink(self) -> bytes: """Convert the symlink to a svnlink on disk. Return: The symlink's svnlink data (``b'type '``) """ # we replace the symlink by a svnlink # to be able to patch the file on future commits src = os.readlink(self.fullpath) os.remove(self.fullpath) sbuf = b"link " + src with open(self.fullpath, "wb") as f: f.write(sbuf) return sbuf def apply_textdelta(self, base_checksum) -> Callable[[Any, bytes, BinaryIO], None]: # if the filepath matches an external, do not apply local patch if self.path in self.editor.external_paths: return lambda *args: None if os.path.lexists(self.fullpath): if os.path.islink(self.fullpath): # svn does not deal with symlink so we transform into # real svn symlink for potential patching in later # commits sbuf = self.__make_svnlink() self.state.link = True else: with open(self.fullpath, "rb") as f: sbuf = f.read() else: sbuf = b"" t = open(self.fullpath, "wb") return apply_txdelta_handler(sbuf, target_stream=t) def close(self) -> None: """When done with the file, this is called. So the file exists and is updated, we can: - adapt accordingly its execution flag if any - compute the objects' checksums - replace the svnlink with a real symlink (for disk computation purposes) """ if self.state.link: # can only check now that the link is a real one # since patch has been applied is_link, src = is_file_an_svnlink_p(self.fullpath) if is_link: self.__make_symlink(src) elif not os.path.isdir(self.fullpath): # not a real link ... # when a file with the svn:special property set is not a svn link, # the svn export operation might extract a truncated version of it # if it is a binary file, so ensure to produce the same file as the # export operation. with open(self.fullpath, "rb") as f: content = f.read() - self.svnrepo.client.export( + self.svnrepo.export( os.path.join(self.svnrepo.remote_url.encode(), self.path), to=self.fullpath, peg_rev=self.editor.revnum, ignore_keywords=True, overwrite=True, ) with open(self.fullpath, "rb") as f: exported_data = f.read() if exported_data != content: # keep track of original file content in order to restore # it if the svn:special property gets unset in another revision self.state.svn_special_path_non_link_data = content elif os.path.islink(self.fullpath): # path was a symbolic link in previous revision but got the property # svn:special unset in current one, revert its content to svn link format self.__make_svnlink() elif self.state.svn_special_path_non_link_data is not None: # path was a non link file with the svn:special property previously set # and got truncated on export, restore its original content with open(self.fullpath, "wb") as f: f.write(self.state.svn_special_path_non_link_data) self.state.svn_special_path_non_link_data = None is_link = os.path.islink(self.fullpath) if not is_link: # if a link, do nothing regarding flag if self.state.executable == EXEC_FLAG: os.chmod(self.fullpath, 0o755) elif self.state.executable == NOEXEC_FLAG: os.chmod(self.fullpath, 0o644) # And now compute file's checksums if self.state.eol_style and not is_link: # ensure to normalize line endings as defined by svn:eol-style # property to get the same file checksum as after an export # or checkout operation with subversion with open(self.fullpath, "rb") as f: data = f.read() data = _normalize_line_endings(data, self.state.eol_style) mode = os.lstat(self.fullpath).st_mode self.directory[self.path] = from_disk.Content.from_bytes( mode=mode, data=data ) else: self.directory[self.path] = from_disk.Content.from_file(path=self.fullpath) ExternalDefinition = Tuple[str, Optional[int], bool] @dataclass class DirState: """Persists some directory states (eg. externals) across revisions while replaying them.""" externals: Dict[str, List[ExternalDefinition]] = field(default_factory=dict) """Map a path in the directory to a list of (external_url, revision, relative_url) targeting it""" class DirEditor: """Directory Editor in charge of updating directory hashes computation. This implementation includes empty folder in the hash computation. """ __slots__ = [ "directory", "rootpath", "path", "file_states", "dir_states", "svnrepo", "editor", "externals", ] def __init__( self, directory: from_disk.Directory, rootpath: bytes, path: bytes, file_states: Dict[bytes, FileState], dir_states: Dict[bytes, DirState], svnrepo: SvnRepo, ): self.directory = directory self.rootpath = rootpath self.path = path # build directory on init os.makedirs(rootpath, exist_ok=True) self.file_states = file_states self.dir_states = dir_states self.svnrepo = svnrepo self.editor = svnrepo.swhreplay.editor self.externals: Dict[str, List[ExternalDefinition]] = {} # repository root dir has empty path if path: self.editor.modified_paths.add(path) def remove_child(self, path: bytes) -> None: """Remove a path from the current objects. The path can be resolved as link, file or directory. This function takes also care of removing the link between the child and the parent. Args: path: to remove from the current objects. """ try: entry_removed = self.directory[path] except KeyError: entry_removed = None else: del self.directory[path] fpath = os.path.join(self.rootpath, path) if isinstance(entry_removed, from_disk.Directory): shutil.rmtree(fpath) else: os.remove(fpath) # when deleting a directory ensure to remove any svn property for the # file it contains as they can be added again later in another revision # without the same property set fullpath = os.path.join(self.rootpath, path) for state_path in list(self.file_states): if state_path.startswith(fullpath + b"/"): del self.file_states[state_path] self.editor.modified_paths.discard(path) def open_directory(self, path: str, *args) -> DirEditor: """Updating existing directory. """ return DirEditor( self.directory, rootpath=self.rootpath, path=os.fsencode(path), file_states=self.file_states, dir_states=self.dir_states, svnrepo=self.svnrepo, ) def add_directory(self, path: str, *args) -> DirEditor: """Adding a new directory. """ path_bytes = os.fsencode(path) os.makedirs(os.path.join(self.rootpath, path_bytes), exist_ok=True) if path_bytes and path_bytes not in self.directory: self.dir_states[path_bytes] = DirState() self.directory[path_bytes] = from_disk.Directory() return DirEditor( self.directory, self.rootpath, path_bytes, self.file_states, self.dir_states, svnrepo=self.svnrepo, ) def open_file(self, path: str, *args) -> FileEditor: """Updating existing file. """ path_bytes = os.fsencode(path) self.directory[path_bytes] = from_disk.Content() fullpath = os.path.join(self.rootpath, path_bytes) return FileEditor( self.directory, rootpath=self.rootpath, path=path_bytes, state=self.file_states[fullpath], svnrepo=self.svnrepo, ) def add_file(self, path: str, *args) -> FileEditor: """Creating a new file. """ path_bytes = os.fsencode(path) self.directory[path_bytes] = from_disk.Content() fullpath = os.path.join(self.rootpath, path_bytes) self.file_states[fullpath] = FileState() return FileEditor( self.directory, self.rootpath, path_bytes, state=self.file_states[fullpath], svnrepo=self.svnrepo, ) def change_prop(self, key: str, value: str) -> None: """Change property callback on directory. """ if key == properties.PROP_EXTERNALS: logger.debug( "Setting '%s' property with value '%s' on path %s", key, value, self.path, ) self.externals = defaultdict(list) if value is not None: # externals are set on that directory path, parse and store them # for later processing in the close method for external in value.split("\n"): external = external.rstrip("\r") # skip empty line or comment if not external or external.startswith("#"): continue ( path, external_url, revision, relative_url, ) = parse_external_definition( external, os.fsdecode(self.path), self.svnrepo.origin_url ) self.externals[path].append((external_url, revision, relative_url)) if not self.externals: # externals might have been unset on that directory path, # remove associated paths from the reconstructed filesystem externals = self.dir_states[self.path].externals for path in externals.keys(): self.remove_external_path(os.fsencode(path)) self.dir_states[self.path].externals = {} def delete_entry(self, path: str, revision: int) -> None: """Remove a path. """ path_bytes = os.fsencode(path) if path_bytes not in self.editor.external_paths: fullpath = os.path.join(self.rootpath, path_bytes) self.file_states.pop(fullpath, None) self.remove_child(path_bytes) def close(self): """Function called when we finish processing a repository. SVN external definitions are processed by it. """ prev_externals = self.dir_states[self.path].externals if self.externals: # externals definition list might have changed in the current replayed # revision, we need to determine if some were removed and delete the # associated paths externals = self.externals prev_externals_set = { (path, url, rev) for path in prev_externals.keys() for (url, rev, _) in prev_externals[path] } externals_set = { (path, url, rev) for path in externals.keys() for (url, rev, _) in externals[path] } old_externals = prev_externals_set - externals_set for path, _, _ in old_externals: self.remove_external_path(os.fsencode(path)) else: # some external paths might have been removed in the current replayed # revision by a delete operation on an overlapping versioned path so we # need to restore them externals = prev_externals # For each external, try to export it in reconstructed filesystem for path, externals_def in externals.items(): for i, external in enumerate(externals_def): external_url, revision, relative_url = external self.process_external( path, external_url, revision, relative_url, remove_target_path=i == 0, ) # backup externals in directory state if self.externals: self.dir_states[self.path].externals = self.externals # do operations below only when closing the root directory if self.path == b"": self.svnrepo.has_relative_externals = any( relative_url for (_, relative_url) in self.editor.valid_externals.values() ) self.svnrepo.has_recursive_externals = any( is_recursive_external( self.svnrepo.origin_url, os.fsdecode(path), external_path, external_url, ) for path, dir_state in self.dir_states.items() for external_path in dir_state.externals.keys() for (external_url, _, _) in dir_state.externals[external_path] ) if self.svnrepo.has_recursive_externals: # If the repository has recursive externals, we stop processing # externals and remove those already exported, # We will then ignore externals when exporting the revision to # check for divergence with the reconstructed filesystem. for external_path in list(self.editor.external_paths): self.remove_external_path(external_path, force=True) def process_external( self, path: str, external_url: str, revision: Optional[int], relative_url: bool, remove_target_path: bool = True, ) -> None: external = (external_url, revision, relative_url) dest_path = os.fsencode(path) dest_fullpath = os.path.join(self.path, dest_path) prev_externals = self.dir_states[self.path].externals if ( path in prev_externals and external in prev_externals[path] and dest_fullpath in self.directory ): # external already exported, nothing to do return if is_recursive_external( self.svnrepo.origin_url, os.fsdecode(self.path), path, external_url ): # recursive external, skip it return logger.debug( "Exporting external %s%s to path %s", external_url, f"@{revision}" if revision else "", dest_fullpath, ) if external not in self.editor.externals_cache: try: # try to export external in a temporary path, destination path could # be versioned and must be overridden only if the external URL is # still valid temp_dir = os.fsencode( tempfile.mkdtemp(dir=self.editor.externals_cache_dir) ) temp_path = os.path.join(temp_dir, dest_path) os.makedirs(b"/".join(temp_path.split(b"/")[:-1]), exist_ok=True) if external_url not in self.editor.dead_externals: url = external_url.rstrip("/") origin_url = self.svnrepo.origin_url.rstrip("/") if ( url.startswith(origin_url + "/") and not self.svnrepo.has_relative_externals ): url = url.replace(origin_url, self.svnrepo.remote_url) - logger.debug( - "svn export --ignore-keywords %s%s", - url, - f"@{revision}" if revision else "", - ) - self.svnrepo.client.export( + self.svnrepo.export( url, to=temp_path, peg_rev=revision, ignore_keywords=True, ) self.editor.externals_cache[external] = temp_path except SubversionException as se: # external no longer available (404) logger.debug(se) self.editor.dead_externals.add(external_url) else: temp_path = self.editor.externals_cache[external] # subversion export will always create the subdirectories of the external # path regardless the validity of the remote URL dest_path_split = dest_path.split(b"/") current_path = self.path self.add_directory(os.fsdecode(current_path)) for subpath in dest_path_split[:-1]: current_path = os.path.join(current_path, subpath) self.add_directory(os.fsdecode(current_path)) if os.path.exists(temp_path): # external successfully exported if remove_target_path: # remove previous path in from_disk model self.remove_external_path(dest_path, remove_subpaths=False) # mark external as valid self.editor.valid_externals[dest_fullpath] = ( external_url, relative_url, ) # copy exported path to reconstructed filesystem fullpath = os.path.join(self.rootpath, dest_fullpath) # update from_disk model and store external paths self.editor.external_paths[dest_fullpath] += 1 self.editor.modified_paths.add(dest_fullpath) if os.path.isfile(temp_path): if os.path.islink(fullpath): # remove destination file if it is a link os.remove(fullpath) shutil.copy(os.fsdecode(temp_path), os.fsdecode(fullpath)) self.directory[dest_fullpath] = from_disk.Content.from_file( path=fullpath ) else: self.add_directory(os.fsdecode(dest_fullpath)) # copy_tree needs sub-directories to exist in destination for root, dirs, files in os.walk(temp_path): for dir in dirs: temp_dir_fullpath = os.path.join(root, dir) if os.path.islink(temp_dir_fullpath): # do not create folder if it's a link or copy_tree will fail continue subdir = temp_dir_fullpath.replace(temp_path + b"/", b"") self.add_directory( os.fsdecode(os.path.join(dest_fullpath, subdir)) ) copy_tree( os.fsdecode(temp_path), os.fsdecode(fullpath), preserve_symlinks=True, ) # TODO: replace code above by the line below once we use Python >= 3.8 in production # noqa # shutil.copytree(temp_path, fullpath, symlinks=True, dirs_exist_ok=True) # noqa self.directory[dest_fullpath] = from_disk.Directory.from_disk( path=fullpath ) external_paths = set() for root, dirs, files in os.walk(fullpath): external_paths.update( [ os.path.join(root.replace(self.rootpath + b"/", b""), p) for p in chain(dirs, files) ] ) for external_path in external_paths: self.editor.external_paths[external_path] += 1 self.editor.modified_paths.update(external_paths) # ensure hash update for the directory with externals set self.directory[self.path].update_hash(force=True) def remove_external_path( self, external_path: bytes, remove_subpaths: bool = True, force: bool = False ) -> None: """Remove a previously exported SVN external path from the reconstructed filesystem. """ fullpath = os.path.join(self.path, external_path) # decrement number of references for external path when we really remove it # (when remove_subpaths is False, we just cleanup the external path before # copying exported paths in it) if fullpath in self.editor.external_paths and remove_subpaths: self.editor.external_paths[fullpath] -= 1 if ( force or fullpath in self.editor.external_paths and self.editor.external_paths[fullpath] == 0 ): self.remove_child(fullpath) self.editor.external_paths.pop(fullpath, None) self.editor.valid_externals.pop(fullpath, None) for path in list(self.editor.external_paths): if path.startswith(fullpath + b"/"): self.editor.external_paths[path] -= 1 if self.editor.external_paths[path] == 0: self.editor.external_paths.pop(path) if remove_subpaths: subpath_split = external_path.split(b"/")[:-1] for i in reversed(range(1, len(subpath_split) + 1)): # delete external sub-directory only if it is not versioned subpath = os.path.join(self.path, b"/".join(subpath_split[0:i])) try: self.svnrepo.client.info( svn_urljoin(self.svnrepo.remote_url, os.fsdecode(subpath)), peg_revision=self.editor.revnum, revision=self.editor.revnum, ) except SubversionException: self.remove_child(subpath) else: break try: # externals can overlap with versioned files so we must restore # them after removing the path above dest_path = os.path.join(self.rootpath, fullpath) self.svnrepo.client.export( svn_urljoin(self.svnrepo.remote_url, os.fsdecode(fullpath)), to=dest_path, peg_rev=self.editor.revnum, ignore_keywords=True, ) if os.path.isfile(dest_path) or os.path.islink(dest_path): self.directory[fullpath] = from_disk.Content.from_file(path=dest_path) else: self.directory[fullpath] = from_disk.Directory.from_disk(path=dest_path) except SubversionException: pass class Editor: """Editor in charge of replaying svn events and computing objects along. This implementation accounts for empty folder during hash computations. """ def __init__( self, rootpath: bytes, directory: from_disk.Directory, svnrepo: SvnRepo, temp_dir: str, ): self.rootpath = rootpath self.directory = directory self.file_states: Dict[bytes, FileState] = defaultdict(FileState) self.dir_states: Dict[bytes, DirState] = defaultdict(DirState) self.external_paths: Dict[bytes, int] = defaultdict(int) self.valid_externals: Dict[bytes, Tuple[str, bool]] = {} self.dead_externals: Set[str] = set() self.externals_cache_dir = tempfile.mkdtemp(dir=temp_dir) self.externals_cache: Dict[ExternalDefinition, bytes] = {} self.svnrepo = svnrepo self.revnum = None # to store the set of paths added or modified when replaying a revision self.modified_paths: Set[bytes] = set() def set_target_revision(self, revnum) -> None: self.revnum = revnum def abort(self) -> None: pass def close(self) -> None: pass def open_root(self, base_revnum: int) -> DirEditor: # a new revision is being replayed so clear the modified_paths set self.modified_paths.clear() return DirEditor( self.directory, rootpath=self.rootpath, path=b"", file_states=self.file_states, dir_states=self.dir_states, svnrepo=self.svnrepo, ) class Replay: """Replay class. """ def __init__( self, conn: RemoteAccess, rootpath: bytes, svnrepo: SvnRepo, temp_dir: str, directory: Optional[from_disk.Directory] = None, ): self.conn = conn self.rootpath = rootpath if directory is None: directory = from_disk.Directory() self.directory = directory self.editor = Editor( rootpath=rootpath, directory=directory, svnrepo=svnrepo, temp_dir=temp_dir ) def replay(self, rev: int) -> from_disk.Directory: """Replay svn actions between rev and rev+1. This method updates in place the self.editor.directory, as well as the filesystem. Returns: The updated root directory """ codecs.register_error("strict", _ra_codecs_error_handler) self.conn.replay(rev, rev + 1, self.editor) codecs.register_error("strict", codecs.strict_errors) return self.editor.directory def compute_objects( self, rev: int ) -> Tuple[List[Content], List[SkippedContent], List[Directory]]: """Compute objects added or modified at revisions rev. Expects the state to be at previous revision's objects. Args: rev: The revision to start the replay from. Returns: The updated objects between rev and rev+1. Beware that this mutates the filesystem at rootpath accordingly. """ self.replay(rev) contents: List[Content] = [] skipped_contents: List[SkippedContent] = [] directories: List[Directory] = [] directories.append(self.editor.directory.to_model()) for path in self.editor.modified_paths: obj = self.directory[path].to_model() obj_type = obj.object_type if obj_type in (Content.object_type, DiskBackedContent.object_type): contents.append(obj.with_data()) elif obj_type == SkippedContent.object_type: skipped_contents.append(obj) elif obj_type == Directory.object_type: directories.append(obj) return contents, skipped_contents, directories @click.command() @click.option("--local-url", default="/tmp", help="local svn working copy") @click.option( "--svn-url", default="file:///home/storage/svn/repos/pkg-fox", help="svn repository's url.", ) @click.option( "--revision-start", default=1, type=click.INT, help="svn repository's starting revision.", ) @click.option( "--revision-end", default=-1, type=click.INT, help="svn repository's ending revision.", ) @click.option( "--debug/--nodebug", default=True, help="Indicates if the server should run in debug mode.", ) @click.option( "--cleanup/--nocleanup", default=True, help="Indicates whether to cleanup disk when done or not.", ) def main(local_url, svn_url, revision_start, revision_end, debug, cleanup): """Script to present how to use Replay class. """ conn = RemoteAccess(svn_url.encode("utf-8"), auth=Auth([get_username_provider()])) os.makedirs(local_url, exist_ok=True) rootpath = tempfile.mkdtemp( prefix=local_url, suffix="-" + os.path.basename(svn_url) ) rootpath = os.fsencode(rootpath) # Do not go beyond the repository's latest revision revision_end_max = conn.get_latest_revnum() if revision_end == -1: revision_end = revision_end_max revision_end = min(revision_end, revision_end_max) try: replay = Replay(conn, rootpath) for rev in range(revision_start, revision_end + 1): contents, skipped_contents, directories = replay.compute_objects(rev) print( "r%s %s (%s new contents, %s new directories)" % ( rev, hashutil.hash_to_hex(replay.directory.hash), len(contents) + len(skipped_contents), len(directories), ) ) if debug: print("%s" % rootpath.decode("utf-8")) finally: if cleanup: if os.path.exists(rootpath): shutil.rmtree(rootpath) if __name__ == "__main__": main() diff --git a/swh/loader/svn/svn.py b/swh/loader/svn/svn.py index e14aaba..84fc5ee 100644 --- a/swh/loader/svn/svn.py +++ b/swh/loader/svn/svn.py @@ -1,414 +1,526 @@ # Copyright (C) 2015-2022 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information """SVN client in charge of iterating over svn logs and yield commit representations including the hash tree/content computations per svn commit. """ - import logging import os import shutil import tempfile from typing import Dict, Iterator, List, Optional, Tuple, Union from subvertpy import SubversionException, client, properties from subvertpy.ra import Auth, RemoteAccess, get_username_provider from swh.model.from_disk import Directory as DirectoryFromDisk from swh.model.model import ( Content, Directory, Person, SkippedContent, TimestampWithTimezone, ) from . import converters, replay +from .svn_retry import svn_retry from .utils import is_recursive_external, parse_external_definition # When log message contains empty data DEFAULT_AUTHOR_MESSAGE = "" - logger = logging.getLogger(__name__) class SvnRepo: """Svn repository representation. Args: remote_url: Remove svn repository url origin_url: Associated origin identifier local_dirname: Path to write intermediary svn action results """ def __init__( self, remote_url: str, origin_url: str, local_dirname: str, max_content_length: int, from_dump: bool = False, ): self.remote_url = remote_url.rstrip("/") self.origin_url = origin_url self.from_dump = from_dump auth = Auth([get_username_provider()]) # one connection for log iteration - self.conn_log = RemoteAccess(self.remote_url, auth=auth) + self.conn_log = self.remote_access(auth) # another for replay - self.conn = RemoteAccess(self.remote_url, auth=auth) + self.conn = self.remote_access(auth) # one client for update operation self.client = client.Client(auth=auth) self.local_dirname = local_dirname local_name = os.path.basename(self.remote_url) self.local_url = os.path.join(self.local_dirname, local_name).encode("utf-8") self.uuid = self.conn.get_uuid().encode("utf-8") self.swhreplay = replay.Replay( conn=self.conn, rootpath=self.local_url, svnrepo=self, temp_dir=local_dirname, ) self.max_content_length = max_content_length self.has_relative_externals = False self.has_recursive_externals = False self.replay_started = False # compute root directory path from the remote repository URL, required to # properly load the sub-tree of a repository mounted from a dump file info = self.client.info(origin_url.rstrip("/")) repos_root_url = next(iter(info.values())).repos_root_url self.root_directory = origin_url.replace(repos_root_url, "", 1) def __str__(self): return str( { "swh-origin": self.origin_url, "remote_url": self.remote_url, "local_url": self.local_url, "uuid": self.uuid, } ) def head_revision(self) -> int: """Retrieve current head revision. """ return self.conn.get_latest_revnum() def initial_revision(self) -> int: """Retrieve the initial revision from which the remote url appeared. """ return 1 def convert_commit_message(self, msg: Union[str, bytes]) -> bytes: """Simply encode the commit message. Args: msg: the commit message to convert. Returns: The transformed message as bytes. """ if isinstance(msg, bytes): return msg return msg.encode("utf-8") def convert_commit_date(self, date: bytes) -> TimestampWithTimezone: """Convert the message commit date into a timestamp in swh format. The precision is kept. Args: date: the commit date to convert. Returns: The transformed date. """ return converters.svn_date_to_swh_date(date) def convert_commit_author(self, author: Optional[bytes]) -> Person: """Convert the commit author into an swh person. Args: author: the commit author to convert. Returns: Person as model object """ return converters.svn_author_to_swh_person(author) def __to_entry(self, log_entry: Tuple) -> Dict: changed_paths, rev, revprops, has_children = log_entry author_date = self.convert_commit_date( revprops.get(properties.PROP_REVISION_DATE) ) author = self.convert_commit_author( revprops.get(properties.PROP_REVISION_AUTHOR) ) message = self.convert_commit_message( revprops.get(properties.PROP_REVISION_LOG, DEFAULT_AUTHOR_MESSAGE) ) has_changes = ( not self.from_dump or changed_paths is not None and any( changed_path.startswith(self.root_directory) for changed_path in changed_paths.keys() ) ) return { "rev": rev, "author_date": author_date, "author_name": author, "message": message, "has_changes": has_changes, } def logs(self, revision_start: int, revision_end: int) -> Iterator[Dict]: """Stream svn logs between revision_start and revision_end by chunks of block_size logs. Yields revision and associated revision information between the revision start and revision_end. Args: revision_start: the svn revision starting bound revision_end: the svn revision ending bound Yields: tuple: tuple of revisions and logs: - revisions: list of revisions in order - logs: Dictionary with key revision number and value the log entry. The log entry is a dictionary with the following keys: - author_date: date of the commit - author_name: name of the author - message: commit message """ for log_entry in self.conn_log.iter_log( paths=None, start=revision_start, end=revision_end, discover_changed_paths=self.from_dump, ): yield self.__to_entry(log_entry) + @svn_retry() + def remote_access(self, auth: Auth) -> RemoteAccess: + """Simple wrapper around subvertpy.ra.RemoteAccess creation + enabling to retry the operation if a network error occurs.""" + return RemoteAccess(self.remote_url, auth=auth) + + @svn_retry() + def export( + self, + url: str, + to: str, + rev: Optional[int] = None, + peg_rev: Optional[int] = None, + recurse: bool = True, + ignore_externals: bool = False, + overwrite: bool = False, + ignore_keywords: bool = False, + ) -> int: + """Simple wrapper around subvertpy.client.Client.export enabling to retry + the command if a network error occurs. + + See documentation of svn_client_export5 function from subversion C API + to get details about parameters. + """ + # remove export path as command can be retried + if os.path.isfile(to) or os.path.islink(to): + os.remove(to) + elif os.path.isdir(to): + shutil.rmtree(to) + options = [] + if rev is not None: + options.append(f"-r {rev}") + if recurse: + options.append("--depth infinity") + if ignore_externals: + options.append("--ignore-externals") + if overwrite: + options.append("--force") + if ignore_keywords: + options.append("--ignore-keywords") + logger.debug( + "svn export %s %s%s %s", + " ".join(options), + url, + f"@{peg_rev}" if peg_rev else "", + to, + ) + return self.client.export( + url, + to=to, + rev=rev, + peg_rev=peg_rev, + recurse=recurse, + ignore_externals=ignore_externals, + overwrite=overwrite, + ignore_keywords=ignore_keywords, + ) + + @svn_retry() + def checkout( + self, + url: str, + path: str, + rev: Optional[int] = None, + peg_rev: Optional[int] = None, + recurse: bool = True, + ignore_externals: bool = False, + allow_unver_obstructions: bool = False, + ) -> int: + """Simple wrapper around subvertpy.client.Client.checkout enabling to retry + the command if a network error occurs. + + See documentation of svn_client_checkout3 function from subversion C API + to get details about parameters. + """ + # remove checkout path as command can be retried + if os.path.isdir(path): + shutil.rmtree(path) + options = [] + if rev is not None: + options.append(f"-r {rev}") + if recurse: + options.append("--depth infinity") + if ignore_externals: + options.append("--ignore-externals") + logger.debug( + "svn checkout %s %s%s %s", + " ".join(options), + self.remote_url, + f"@{peg_rev}" if peg_rev else "", + path, + ) + return self.client.checkout( + url, + path=path, + rev=rev, + peg_rev=peg_rev, + recurse=recurse, + ignore_externals=ignore_externals, + allow_unver_obstructions=allow_unver_obstructions, + ) + + @svn_retry() + def propget( + self, + name: str, + target: str, + peg_rev: Optional[int], + rev: Optional[int] = None, + recurse: bool = False, + ): + """Simple wrapper around subvertpy.client.Client.propget enabling to retry + the command if a network error occurs. + + See documentation of svn_client_propget5 function from subversion C API + to get details about parameters. + """ + return self.client.propget(name, target, peg_rev, rev, recurse) + def export_temporary(self, revision: int) -> Tuple[str, bytes]: """Export the repository to a given revision in a temporary location. This is up to the caller of this function to clean up the temporary location when done (cf. self.clean_fs method) Args: revision: Revision to export at Returns: The tuple local_dirname the temporary location root folder, local_url where the repository was exported. """ local_dirname = tempfile.mkdtemp( dir=self.local_dirname, prefix=f"check-revision-{revision}." ) local_name = os.path.basename(self.remote_url) local_url = os.path.join(local_dirname, local_name) url = self.remote_url # if some paths have external URLs relative to the repository URL but targeting # paths outside it, we need to export from the origin URL as the remote URL can # target a dump mounted on the local filesystem if self.replay_started and self.has_relative_externals: # externals detected while replaying revisions url = self.origin_url elif not self.replay_started: # revisions replay has not started, we need to check if svn:externals # properties are set from a checkout of the revision and if some # external URLs are relative to pick the right export URL, # recursive externals are also checked with tempfile.TemporaryDirectory( dir=self.local_dirname, prefix=f"checkout-revision-{revision}." ) as co_dirname: - logger.debug( - "svn checkout --ignore-externals %s@%s", self.remote_url, revision, - ) - self.client.checkout( + + self.checkout( self.remote_url, co_dirname, revision, ignore_externals=True ) # get all svn:externals properties recursively - externals = self.client.propget( - "svn:externals", co_dirname, None, None, True - ) + externals = self.propget("svn:externals", co_dirname, None, None, True) self.has_relative_externals = False self.has_recursive_externals = False for path, external_defs in externals.items(): if self.has_relative_externals or self.has_recursive_externals: break path = path.replace(self.remote_url.rstrip("/") + "/", "") for external_def in os.fsdecode(external_defs).split("\n"): # skip empty line or comment if not external_def or external_def.startswith("#"): continue ( external_path, external_url, _, relative_url, ) = parse_external_definition( external_def.rstrip("\r"), path, self.origin_url ) if is_recursive_external( self.origin_url, path, external_path, external_url, ): self.has_recursive_externals = True url = self.remote_url break if relative_url: self.has_relative_externals = True url = self.origin_url break try: url = url.rstrip("/") - logger.debug( - "svn export --ignore-keywords %s@%s", url, revision, - ) - self.client.export( + + self.export( url, to=local_url, rev=revision, ignore_keywords=True, ignore_externals=self.has_recursive_externals, ) except SubversionException as se: if se.args[0].startswith( ( "Error parsing svn:externals property", "Unrecognized format for the relative external URL", ) ): pass else: raise if self.from_dump: # when exporting a subpath of a subversion repository mounted from # a dump file generated by svnrdump, exported paths are relative to # the repository root path while they are relative to the subpath # otherwise, so we need to adjust the URL of the exported filesystem root_dir_local_url = os.path.join(local_url, self.root_directory.strip("/")) # check that root directory of a subproject did not get removed in revision if os.path.exists(root_dir_local_url): local_url = root_dir_local_url return local_dirname, os.fsencode(local_url) def swh_hash_data_per_revision( self, start_revision: int, end_revision: int ) -> Iterator[ Tuple[ int, Dict, Tuple[List[Content], List[SkippedContent], List[Directory]], DirectoryFromDisk, ], ]: """Compute swh hash data per each revision between start_revision and end_revision. Args: start_revision: starting revision end_revision: ending revision Yields: Tuple (rev, nextrev, commit, objects_per_path): - rev: current revision - commit: commit data (author, date, message) for such revision - objects_per_path: Tuple of list of objects between start_revision and end_revision - complete Directory representation """ # even in incremental loading mode, we need to replay the whole set of # path modifications from first revision to restore possible file states induced # by setting svn properties on those files (end of line style for instance) self.replay_started = True first_revision = 1 if start_revision else 0 # handle empty repository edge case for commit in self.logs(first_revision, end_revision): rev = commit["rev"] objects = self.swhreplay.compute_objects(rev) if rev >= start_revision: # start yielding new data to archive once we reached the revision to # resume the loading from if commit["has_changes"] or start_revision == 0: # yield data only if commit has changes or if repository is empty root_dir_path = self.root_directory.encode()[1:] if not root_dir_path or root_dir_path in self.swhreplay.directory: root_dir = self.swhreplay.directory[root_dir_path] else: # root directory of subproject got removed in revision, return # empty directory for that edge case root_dir = DirectoryFromDisk() yield rev, commit, objects, root_dir def swh_hash_data_at_revision( self, revision: int ) -> Tuple[Dict, DirectoryFromDisk]: """Compute the information at a given svn revision. This is expected to be used for checks only. Yields: The tuple (commit dictionary, targeted directory object). """ # Update disk representation of the repository at revision id local_dirname, local_url = self.export_temporary(revision) # Compute the current hashes on disk directory = DirectoryFromDisk.from_disk( path=local_url, max_content_length=self.max_content_length ) # Retrieve the commit information for revision commit = list(self.logs(revision, revision))[0] # Clean export directory self.clean_fs(local_dirname) return commit, directory def clean_fs(self, local_dirname: Optional[str] = None) -> None: """Clean up the local working copy. Args: local_dirname: Path to remove recursively if provided. Otherwise, remove the temporary upper root tree used for svn repository loading. """ dirname = local_dirname or self.local_dirname if os.path.exists(dirname): logger.debug("cleanup %s", dirname) shutil.rmtree(dirname) diff --git a/swh/loader/svn/svn_retry.py b/swh/loader/svn/svn_retry.py new file mode 100644 index 0000000..5080df5 --- /dev/null +++ b/swh/loader/svn/svn_retry.py @@ -0,0 +1,41 @@ +# Copyright (C) 2022 The Software Heritage developers +# See the AUTHORS file at the top-level directory of this distribution +# License: GNU General Public License version 3, or any later version +# See top-level LICENSE file for more information + + +import logging + +from subvertpy import SubversionException +from tenacity import retry +from tenacity.before_sleep import before_sleep_log +from tenacity.retry import retry_if_exception +from tenacity.stop import stop_after_attempt +from tenacity.wait import wait_exponential + +logger = logging.getLogger(__name__) + +SVN_RETRY_WAIT_EXP_BASE = 10 +SVN_RETRY_MAX_ATTEMPTS = 5 + + +def is_retryable_svn_exception(exception): + if isinstance(exception, SubversionException): + return exception.args[0].startswith( + ( + "Connection timed out", + "Unable to connect to a repository at URL", + "Error running context: The server unexpectedly closed the connection", + ) + ) + return isinstance(exception, (ConnectionResetError, TimeoutError)) + + +def svn_retry(): + return retry( + retry=retry_if_exception(is_retryable_svn_exception), + wait=wait_exponential(exp_base=SVN_RETRY_WAIT_EXP_BASE), + stop=stop_after_attempt(max_attempt_number=SVN_RETRY_MAX_ATTEMPTS), + before_sleep=before_sleep_log(logger, logging.DEBUG), + reraise=True, + ) diff --git a/swh/loader/svn/tests/test_externals.py b/swh/loader/svn/tests/test_externals.py index 3bda76d..a9a4784 100644 --- a/swh/loader/svn/tests/test_externals.py +++ b/swh/loader/svn/tests/test_externals.py @@ -1,1329 +1,1337 @@ # Copyright (C) 2022 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information import pytest -from swh.loader.svn.loader import SvnLoader, SvnLoaderFromRemoteDump +from swh.loader.svn.loader import SvnLoader, SvnLoaderFromRemoteDump, SvnRepo from swh.loader.svn.utils import svn_urljoin from swh.loader.tests import assert_last_visit_matches, check_snapshot from .utils import CommitChange, CommitChangeType, add_commit, create_repo +@pytest.fixture(autouse=True) +def svn_retry_sleep_mocker(mocker): + mocker.patch.object(SvnRepo.export.retry, "sleep") + mocker.patch.object(SvnRepo.checkout.retry, "sleep") + mocker.patch.object(SvnRepo.propget.retry, "sleep") + mocker.patch.object(SvnRepo.remote_access.retry, "sleep") + + @pytest.fixture def external_repo_url(tmpdir_factory): # create a repository return create_repo(tmpdir_factory.mktemp("external")) def test_loader_with_valid_svn_externals( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create some directories and files in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/hello/hello-world", properties={"svn:executable": "*"}, data=b"#!/bin/bash\necho Hello World !", ), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="foo.sh", properties={"svn:executable": "*"}, data=b"#!/bin/bash\necho foo", ), ], ) # first commit add_commit( repo_url, "Create repository structure.", [ CommitChange(change_type=CommitChangeType.AddOrUpdate, path="branches/",), CommitChange(change_type=CommitChangeType.AddOrUpdate, path="tags/",), CommitChange(change_type=CommitChangeType.AddOrUpdate, path="trunk/",), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/bar.sh", properties={"svn:executable": "*"}, data=b"#!/bin/bash\necho bar", ), ], ) # second commit add_commit( repo_url, ( "Set svn:externals property on trunk/externals path of repository to load." "One external targets a remote directory and another one a remote file." ), [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/externals/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'code/hello')} hello\n" f"{svn_urljoin(external_repo_url, 'foo.sh')} foo.sh\n" f"{svn_urljoin(repo_url, 'trunk/bar.sh')} bar.sh" ) }, ), ], ) # first load loader = SvnLoader(swh_storage, repo_url, temp_directory=tmp_path, check_revision=1) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) # third commit add_commit( repo_url, "Unset svn:externals property on trunk/externals path", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/externals/", properties={"svn:externals": None}, ), ], ) # second load loader = SvnLoader(swh_storage, repo_url, temp_directory=tmp_path, check_revision=1) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) -def test_loader_with_invalid_svn_externals(swh_storage, repo_url, tmp_path): +def test_loader_with_invalid_svn_externals(swh_storage, repo_url, tmp_path, mocker): # first commit add_commit( repo_url, "Create repository structure.", [ CommitChange(change_type=CommitChangeType.AddOrUpdate, path="branches/",), CommitChange(change_type=CommitChangeType.AddOrUpdate, path="tags/",), CommitChange(change_type=CommitChangeType.AddOrUpdate, path="trunk/",), ], ) # second commit add_commit( repo_url, ( "Set svn:externals property on trunk/externals path of repository to load." "The externals URLs are not valid." ), [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/externals/", properties={ "svn:externals": ( "file:///tmp/invalid/svn/repo/hello hello\n" "file:///tmp/invalid/svn/repo/foo.sh foo.sh" ) }, ), ], ) loader = SvnLoader(swh_storage, repo_url, temp_directory=tmp_path, check_revision=1) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_with_valid_externals_modification( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create some directories and files in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/hello/hello-world", properties={"svn:executable": "*"}, data=b"#!/bin/bash\necho Hello World !", ), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/bar/bar.sh", properties={"svn:executable": "*"}, data=b"#!/bin/bash\necho bar", ), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="foo.sh", properties={"svn:executable": "*"}, data=b"#!/bin/bash\necho foo", ), ], ) # first commit add_commit( repo_url, ("Set svn:externals property on trunk/externals path of repository to load."), [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/externals/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'code/hello')} src/code/hello\n" # noqa f"{svn_urljoin(external_repo_url, 'foo.sh')} src/foo.sh\n" ) }, ), ], ) # second commit add_commit( repo_url, ( "Modify svn:externals property on trunk/externals path of repository to load." # noqa ), [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/externals/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'code/bar')} src/code/bar\n" # noqa f"{svn_urljoin(external_repo_url, 'foo.sh')} src/foo.sh\n" ) }, ), ], ) loader = SvnLoader(swh_storage, repo_url, temp_directory=tmp_path, check_revision=1) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_with_valid_externals_and_versioned_path( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create a file in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/script.sh", data=b"#!/bin/bash\necho Hello World !", ), ], ) # first commit add_commit( repo_url, "Add file with same name but different content in main repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/script.sh", data=b"#!/bin/bash\necho foo", ), ], ) # second commit add_commit( repo_url, "Add externals targeting the versioned file", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'code/script.sh')} script.sh" # noqa ) }, ), ], ) # third commit add_commit( repo_url, "Modify the versioned file", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/script.sh", data=b"#!/bin/bash\necho bar", ), ], ) loader = SvnLoader(swh_storage, repo_url, temp_directory=tmp_path, check_revision=1) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_with_invalid_externals_and_versioned_path( swh_storage, repo_url, tmp_path ): # first commit add_commit( repo_url, "Add file in main repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/script.sh", data=b"#!/bin/bash\necho foo", ), ], ) # second commit add_commit( repo_url, "Add invalid externals targeting the versioned file", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": ( "file:///tmp/invalid/svn/repo/code/script.sh script.sh" ) }, ), ], ) loader = SvnLoader(swh_storage, repo_url, temp_directory=tmp_path, check_revision=1) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_set_externals_then_remove_and_add_as_local( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create a file in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/script.sh", data=b"#!/bin/bash\necho Hello World !", ), ], ) # first commit add_commit( repo_url, "Add trunk directory and set externals", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": (f"{svn_urljoin(external_repo_url, 'code')} code") }, ), ], ) # second commit add_commit( repo_url, "Unset externals on trunk and add remote path as local path", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={"svn:externals": None}, ), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/code/script.sh", data=b"#!/bin/bash\necho Hello World !", ), ], ) loader = SvnLoader(swh_storage, repo_url, temp_directory=tmp_path, check_revision=1) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_set_invalid_externals_then_remove(swh_storage, repo_url, tmp_path): # first commit add_commit( repo_url, "Add trunk directory and set invalid external", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": "file:///tmp/invalid/svn/repo/code external/code" }, ), ], ) # second commit add_commit( repo_url, "Unset externals on trunk", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={"svn:externals": None}, ), ], ) loader = SvnLoader(swh_storage, repo_url, temp_directory=tmp_path, check_revision=1) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_set_externals_with_versioned_file_overlap( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create a file in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/script.sh", data=b"#!/bin/bash\necho Hello World !", ), ], ) # first commit add_commit( repo_url, "Add file with same name as in the external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/script.sh", data=b"#!/bin/bash\necho foo", ), ], ) # second commit add_commit( repo_url, "Set external on trunk overlapping versioned file", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'code/script.sh')} script.sh" ) }, ), ], ) # third commit add_commit( repo_url, "Unset externals on trunk", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={"svn:externals": None}, ), ], ) loader = SvnLoader(swh_storage, repo_url, temp_directory=tmp_path, check_revision=1) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_dump_loader_relative_externals_detection( swh_storage, repo_url, external_repo_url, tmp_path ): add_commit( external_repo_url, "Create a file in external repository.", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="project1/foo.sh", data=b"#!/bin/bash\necho foo", ), ], ) add_commit( external_repo_url, "Create another file in repository to load.", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="project2/bar.sh", data=b"#!/bin/bash\necho bar", ), ], ) external_url = f"{external_repo_url.replace('file://', '//')}/project2/bar.sh" add_commit( repo_url, "Set external relative to URL scheme in repository to load", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="project1/", properties={"svn:externals": (f"{external_url} bar.sh")}, ), ], ) loader = SvnLoaderFromRemoteDump( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1 ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) assert loader.svnrepo.has_relative_externals add_commit( repo_url, "Unset external in repository to load", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="project1/", properties={"svn:externals": None}, ), ], ) loader = SvnLoaderFromRemoteDump( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1 ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) assert not loader.svnrepo.has_relative_externals def test_loader_externals_cache(swh_storage, repo_url, external_repo_url, tmp_path): # first commit on external add_commit( external_repo_url, "Create some directories and files in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/hello/hello-world", properties={"svn:executable": "*"}, data=b"#!/bin/bash\necho Hello World !", ), ], ) # first commit add_commit( repo_url, "Create repository structure.", [ CommitChange(change_type=CommitChangeType.AddOrUpdate, path="project1/",), CommitChange(change_type=CommitChangeType.AddOrUpdate, path="project2/",), ], ) external_url = svn_urljoin(external_repo_url, "code/hello") # second commit add_commit( repo_url, ( "Set svn:externals property on trunk/externals path of repository to load." "One external targets a remote directory and another one a remote file." ), [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="project1/externals/", properties={"svn:externals": (f"{external_url} hello\n")}, ), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="project2/externals/", properties={"svn:externals": (f"{external_url} hello\n")}, ), ], ) loader = SvnLoader(swh_storage, repo_url, temp_directory=tmp_path, check_revision=1) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) assert ( external_url, None, False, ) in loader.svnrepo.swhreplay.editor.externals_cache def test_loader_remove_versioned_path_with_external_overlap( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create a file in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/hello.sh", data=b"#!/bin/bash\necho Hello World !", ), ], ) # first commit add_commit( repo_url, "Add a file", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/project/script.sh", data=b"#!/bin/bash\necho foo", ), ], ) # second commit add_commit( repo_url, "Set external on trunk overlapping versioned path", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'code')} project/code" ) }, ), ], ) # third commit add_commit( repo_url, "Remove trunk/project/ versioned path", [CommitChange(change_type=CommitChangeType.Delete, path="trunk/project/",),], ) loader = SvnLoader( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1, ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_export_external_path_using_peg_rev( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create a file in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/foo.sh", data=b"#!/bin/bash\necho foo", ), ], ) # second commit on external add_commit( external_repo_url, "Remove previously added file", [CommitChange(change_type=CommitChangeType.Delete, path="code/foo.sh",),], ) # third commit on external add_commit( external_repo_url, "Add file again but with different content", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/foo.sh", data=b"#!/bin/bash\necho bar", ), ], ) # first commit add_commit( repo_url, "Add trunk dir", [CommitChange(change_type=CommitChangeType.AddOrUpdate, path="trunk/",),], ) # second commit add_commit( repo_url, "Set external on trunk targeting first revision of external repo", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'code/foo.sh')}@1 foo.sh" ) }, ), ], ) # third commit add_commit( repo_url, "Modify external on trunk to target third revision of external repo", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'code/foo.sh')}@3 foo.sh" ) }, ), ], ) loader = SvnLoader( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1, ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_remove_external_overlapping_versioned_path( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create files in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/foo.sh", data=b"#!/bin/bash\necho foo", ), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/link", data=b"#!/bin/bash\necho link", ), ], ) # first commit add_commit( repo_url, "Add trunk dir and a link file", [ CommitChange(change_type=CommitChangeType.AddOrUpdate, path="trunk/"), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/link", data=b"link ../test", properties={"svn:special": "*"}, ), ], ) # second commit add_commit( repo_url, "Set external on root dir overlapping versioned trunk path", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="", # repo root dir properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'code/foo.sh')} trunk/code/foo.sh\n" # noqa f"{svn_urljoin(external_repo_url, 'code/link')} trunk/link" ) }, ), ], ) # third commit add_commit( repo_url, "Remove external on root dir", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="", properties={"svn:externals": None}, ), ], ) loader = SvnLoader( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1, ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_modify_external_same_path( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create a file in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/foo.sh", data=b"#!/bin/bash\necho foo", ), ], ) # first commit add_commit( repo_url, "Add trunk dir", [CommitChange(change_type=CommitChangeType.AddOrUpdate, path="trunk/")], ) # second commit add_commit( repo_url, "Set external code on trunk dir", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": (f"{svn_urljoin(external_repo_url, 'code')} code") }, ), ], ) # third commit add_commit( repo_url, "Change code external on trunk targeting an invalid URL", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={"svn:externals": "file:///tmp/invalid/svn/repo/path code"}, ), ], ) loader = SvnLoader( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1, ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_with_recursive_external( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create a file in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="code/foo.sh", data=b"#!/bin/bash\necho foo", ), ], ) # first commit add_commit( repo_url, "Add trunk dir and a file", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/bar.sh", data=b"#!/bin/bash\necho bar", ) ], ) # second commit add_commit( repo_url, "Set externals code on trunk/externals dir, one being recursive", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/externals/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'code')} code\n" f"{repo_url} recursive" ) }, ), ], ) # first load loader = SvnLoader( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1, ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) assert loader.svnrepo.has_recursive_externals # second load on stale repo loader = SvnLoader( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1, ) assert loader.load() == {"status": "uneventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) assert loader.svnrepo.has_recursive_externals # third commit add_commit( repo_url, "Remove recursive external on trunk/externals dir", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/externals/", properties={ "svn:externals": (f"{svn_urljoin(external_repo_url, 'code')} code") }, ), ], ) # third load loader = SvnLoader( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1, ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) assert not loader.svnrepo.has_recursive_externals def test_loader_externals_with_same_target( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create files in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="foo/foo.sh", data=b"#!/bin/bash\necho foo", ), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="bar/bar.sh", data=b"#!/bin/bash\necho bar", ), ], ) # first commit add_commit( repo_url, "Add trunk/src dir", [CommitChange(change_type=CommitChangeType.AddOrUpdate, path="trunk/src/")], ) # second commit add_commit( repo_url, "Add externals on trunk targeting same directory", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'foo')} src\n" f"{svn_urljoin(external_repo_url, 'bar')} src" ) }, ), ], ) loader = SvnLoader( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1, ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_external_in_versioned_path( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create a file in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="src/foo.sh", data=b"#!/bin/bash\necho foo", ), ], ) # first commit add_commit( repo_url, "Add trunk/src dir", [CommitChange(change_type=CommitChangeType.AddOrUpdate, path="trunk/src/")], ) # second commit add_commit( repo_url, "Add a file in trunk/src directory and set external on trunk targeting src", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/src/bar.sh", data=b"#!/bin/bash\necho bar", ), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": (f"{svn_urljoin(external_repo_url, 'src')} src") }, ), ], ) loader = SvnLoader( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1, ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_dump_loader_externals_in_loaded_repository(swh_storage, tmp_path, mocker): repo_url = create_repo(tmp_path, repo_name="foo") externa_url = create_repo(tmp_path, repo_name="foobar") # first commit on external add_commit( externa_url, "Create a file in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/src/foo.sh", data=b"#!/bin/bash\necho foo", ), ], ) add_commit( repo_url, ( "Add a file and set externals on trunk/externals:" "one external located in this repository, the other in a remote one" ), [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/src/bar.sh", data=b"#!/bin/bash\necho bar", ), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/externals/", properties={ "svn:externals": ( f"{svn_urljoin(repo_url, 'trunk/src/bar.sh')} bar.sh\n" f"{svn_urljoin(externa_url, 'trunk/src/foo.sh')} foo.sh" ) }, ), ], ) from swh.loader.svn.svn import client mock_client = mocker.MagicMock() mocker.patch.object(client, "Client", mock_client) class Info: repos_root_url = repo_url mock_client().info.return_value = {"repo": Info()} loader = SvnLoaderFromRemoteDump(swh_storage, repo_url, temp_directory=tmp_path) loader.load() export_call_args = mock_client().export.call_args_list # first external export should use the base URL of the local repository # mounted from the remote dump as it is located in loaded repository assert export_call_args[0][0][0] != svn_urljoin( loader.svnrepo.origin_url, "trunk/src/bar.sh" ) assert export_call_args[0][0][0] == svn_urljoin( loader.svnrepo.remote_url, "trunk/src/bar.sh" ) # second external export should use the remote URL of the external repository assert export_call_args[1][0][0] == svn_urljoin(externa_url, "trunk/src/foo.sh") def test_loader_externals_add_remove_readd_on_subpath( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create files in an external repository", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="src/foo.sh", data=b"#!/bin/bash\necho foo", ), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="src/bar.sh", data=b"#!/bin/bash\necho bar", ), ], ) # first commit add_commit( repo_url, "Set external on two paths targeting the same absolute path", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/src/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'src/foo.sh')} foo.sh" ) }, ), CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'src/foo.sh')} src/foo.sh" ) }, ), ], ) # second commit add_commit( repo_url, "Remove external on a single path", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="trunk/", properties={ "svn:externals": ( f"{svn_urljoin(external_repo_url, 'src/bar.sh')} src/bar.sh" ) }, ), ], ) loader = SvnLoader( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1, ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) def test_loader_directory_symlink_in_external( swh_storage, repo_url, external_repo_url, tmp_path ): # first commit on external add_commit( external_repo_url, "Create dirs in an external repository", [ CommitChange(change_type=CommitChangeType.AddOrUpdate, path="src/apps/",), CommitChange(change_type=CommitChangeType.AddOrUpdate, path="src/deps/",), ], ) # second commit on external add_commit( external_repo_url, "Add symlink to src/deps in src/apps directory", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="src/apps/deps", data=b"link ../deps", properties={"svn:special": "*"}, ), ], ) # first commit add_commit( repo_url, "Add deps dir", [CommitChange(change_type=CommitChangeType.AddOrUpdate, path="deps/")], ) # second commit add_commit( repo_url, "Set external to deps folder", [ CommitChange( change_type=CommitChangeType.AddOrUpdate, path="deps/", properties={"svn:externals": (f"{external_repo_url} external")}, ), ], ) loader = SvnLoader( swh_storage, repo_url, temp_directory=tmp_path, check_revision=1, ) assert loader.load() == {"status": "eventful"} assert_last_visit_matches( loader.storage, repo_url, status="full", type="svn", ) check_snapshot(loader.snapshot, loader.storage) diff --git a/swh/loader/svn/tests/test_svn_retry.py b/swh/loader/svn/tests/test_svn_retry.py new file mode 100644 index 0000000..351c32f --- /dev/null +++ b/swh/loader/svn/tests/test_svn_retry.py @@ -0,0 +1,285 @@ +# Copyright (C) 2022 The Software Heritage developers +# See the AUTHORS file at the top-level directory of this distribution +# License: GNU General Public License version 3, or any later version +# See top-level LICENSE file for more information + +import os + +import pytest +from subvertpy import SubversionException +from subvertpy.ra import Auth, RemoteAccess, get_username_provider + +from swh.loader.svn.svn import SvnRepo +from swh.loader.svn.svn_retry import SVN_RETRY_MAX_ATTEMPTS, SVN_RETRY_WAIT_EXP_BASE +from swh.loader.tests import prepare_repository_from_archive + + +def _get_repo_url(archive_name, datadir, tmp_path): + archive_path = os.path.join(datadir, f"{archive_name}.tgz") + return prepare_repository_from_archive(archive_path, "pkg-gourmet", tmp_path) + + +@pytest.fixture() +def sample_repo_url(datadir, tmp_path): + return _get_repo_url("pkg-gourmet", datadir, tmp_path) + + +@pytest.fixture() +def sample_repo_with_externals_url(datadir, tmp_path): + return _get_repo_url("pkg-gourmet-with-external-id", datadir, tmp_path) + + +class SVNClientWrapper: + """Methods of subvertpy.client.Client cannot be patched by mocker fixture + as they are read only attributes due to subvertpy.client module being + a C extension module. So we use that wrapper class instead to simulate + mocking behavior. + """ + + def __init__(self, client, exception, nb_failed_calls): + self.client = client + self.exception = exception + self.nb_failed_calls = nb_failed_calls + self.nb_calls = 0 + + def _wrapped_svn_cmd(self, svn_cmd, *args, **kwargs): + self.nb_calls = self.nb_calls + 1 + if self.nb_calls <= self.nb_failed_calls: + raise self.exception + else: + return svn_cmd(*args, **kwargs) + + def export(self, *args, **kwargs): + return self._wrapped_svn_cmd(self.client.export, *args, **kwargs) + + def checkout(self, *args, **kwargs): + return self._wrapped_svn_cmd(self.client.checkout, *args, **kwargs) + + def propget(self, *args, **kwargs): + return self._wrapped_svn_cmd(self.client.propget, *args, **kwargs) + + +def assert_sleep_calls(mock_sleep, mocker, nb_failures): + mock_sleep.assert_has_calls( + [ + mocker.call(param) + for param in [SVN_RETRY_WAIT_EXP_BASE ** i for i in range(nb_failures)] + ] + ) + + +RETRYABLE_EXCEPTIONS = [ + SubversionException( + "Error running context: The server unexpectedly closed the connection.", 120108, + ), + SubversionException("Connection timed out", 175012), + SubversionException("Unable to connect to a repository at URL", 170013), + ConnectionResetError(), + TimeoutError(), +] + + +@pytest.mark.parametrize("exception_to_retry", RETRYABLE_EXCEPTIONS) +def test_svn_export_retry_success( + mocker, tmp_path, sample_repo_url, exception_to_retry +): + svnrepo = SvnRepo( + sample_repo_url, sample_repo_url, tmp_path, max_content_length=100000 + ) + + mock_sleep = mocker.patch.object(svnrepo.export.retry, "sleep") + + nb_failed_calls = 2 + svnrepo.client = SVNClientWrapper( + svnrepo.client, exception_to_retry, nb_failed_calls + ) + + export_path = os.path.join(tmp_path, "export") + svnrepo.export(sample_repo_url, export_path) + assert os.path.exists(export_path) + + assert_sleep_calls(mock_sleep, mocker, nb_failed_calls) + + +@pytest.mark.parametrize("exception_to_retry", RETRYABLE_EXCEPTIONS) +def test_svn_export_retry_failure( + mocker, tmp_path, sample_repo_url, exception_to_retry +): + svnrepo = SvnRepo( + sample_repo_url, sample_repo_url, tmp_path, max_content_length=100000 + ) + + mock_sleep = mocker.patch.object(svnrepo.export.retry, "sleep") + + nb_failed_calls = SVN_RETRY_MAX_ATTEMPTS + svnrepo.client = SVNClientWrapper( + svnrepo.client, exception_to_retry, nb_failed_calls + ) + + with pytest.raises(type(exception_to_retry)): + export_path = os.path.join(tmp_path, "export") + svnrepo.export(sample_repo_url, export_path) + + assert not os.path.exists(export_path) + + assert_sleep_calls(mock_sleep, mocker, nb_failed_calls - 1) + + +@pytest.mark.parametrize("exception_to_retry", RETRYABLE_EXCEPTIONS) +def test_svn_checkout_retry_success( + mocker, tmp_path, sample_repo_url, exception_to_retry +): + svnrepo = SvnRepo( + sample_repo_url, sample_repo_url, tmp_path, max_content_length=100000 + ) + + mock_sleep = mocker.patch.object(svnrepo.checkout.retry, "sleep") + + nb_failed_calls = 2 + svnrepo.client = SVNClientWrapper( + svnrepo.client, exception_to_retry, nb_failed_calls + ) + + checkout_path = os.path.join(tmp_path, "checkout") + svnrepo.checkout(sample_repo_url, checkout_path, svnrepo.head_revision()) + assert os.path.exists(checkout_path) + + assert_sleep_calls(mock_sleep, mocker, nb_failed_calls) + + +@pytest.mark.parametrize("exception_to_retry", RETRYABLE_EXCEPTIONS) +def test_svn_checkout_retry_failure( + mocker, tmp_path, sample_repo_url, exception_to_retry +): + svnrepo = SvnRepo( + sample_repo_url, sample_repo_url, tmp_path, max_content_length=100000 + ) + + mock_sleep = mocker.patch.object(svnrepo.checkout.retry, "sleep") + + nb_failed_calls = SVN_RETRY_MAX_ATTEMPTS + svnrepo.client = SVNClientWrapper( + svnrepo.client, exception_to_retry, nb_failed_calls + ) + + checkout_path = os.path.join(tmp_path, "checkout") + with pytest.raises(type(exception_to_retry)): + svnrepo.checkout(sample_repo_url, checkout_path, svnrepo.head_revision()) + + assert not os.path.exists(checkout_path) + + assert_sleep_calls(mock_sleep, mocker, nb_failed_calls - 1) + + +@pytest.mark.parametrize("exception_to_retry", RETRYABLE_EXCEPTIONS) +def test_svn_propget_retry_success( + mocker, tmp_path, sample_repo_with_externals_url, exception_to_retry +): + svnrepo = SvnRepo( + sample_repo_with_externals_url, + sample_repo_with_externals_url, + tmp_path, + max_content_length=100000, + ) + + checkout_path = os.path.join(tmp_path, "checkout") + svnrepo.checkout( + sample_repo_with_externals_url, + checkout_path, + svnrepo.head_revision(), + ignore_externals=True, + ) + + mock_sleep = mocker.patch.object(svnrepo.propget.retry, "sleep") + + nb_failed_calls = 2 + svnrepo.client = SVNClientWrapper( + svnrepo.client, exception_to_retry, nb_failed_calls + ) + + externals = svnrepo.propget("svn:externals", checkout_path, None, None, True) + + assert externals + + assert_sleep_calls(mock_sleep, mocker, nb_failed_calls) + + +@pytest.mark.parametrize("exception_to_retry", RETRYABLE_EXCEPTIONS) +def test_svn_propget_retry_failure( + mocker, tmp_path, sample_repo_with_externals_url, exception_to_retry +): + svnrepo = SvnRepo( + sample_repo_with_externals_url, + sample_repo_with_externals_url, + tmp_path, + max_content_length=100000, + ) + + checkout_path = os.path.join(tmp_path, "checkout") + svnrepo.checkout( + sample_repo_with_externals_url, + checkout_path, + svnrepo.head_revision(), + ignore_externals=True, + ) + + mock_sleep = mocker.patch.object(svnrepo.propget.retry, "sleep") + + nb_failed_calls = SVN_RETRY_MAX_ATTEMPTS + svnrepo.client = SVNClientWrapper( + svnrepo.client, exception_to_retry, nb_failed_calls + ) + + with pytest.raises(type(exception_to_retry)): + svnrepo.propget("svn:externals", checkout_path, None, None, True) + + assert_sleep_calls(mock_sleep, mocker, nb_failed_calls - 1) + + +@pytest.mark.parametrize("exception_to_retry", RETRYABLE_EXCEPTIONS) +def test_remote_access_retry_success( + mocker, tmp_path, sample_repo_url, exception_to_retry +): + + nb_failed_calls = 2 + mock_ra = mocker.patch("swh.loader.svn.svn.RemoteAccess") + remote_access = RemoteAccess(sample_repo_url, auth=Auth([get_username_provider()])) + mock_ra.side_effect = ( + [exception_to_retry] * nb_failed_calls + + [remote_access] + + [exception_to_retry] * nb_failed_calls + + [remote_access] + ) + + mock_sleep = mocker.patch.object(SvnRepo.remote_access.retry, "sleep") + + SvnRepo( + sample_repo_url, sample_repo_url, tmp_path, max_content_length=100000, + ) + + assert_sleep_calls(mock_sleep, mocker, nb_failed_calls) + + +@pytest.mark.parametrize("exception_to_retry", RETRYABLE_EXCEPTIONS) +def test_remote_access_retry_failure( + mocker, tmp_path, sample_repo_url, exception_to_retry +): + + nb_failed_calls = SVN_RETRY_MAX_ATTEMPTS + mock_ra = mocker.patch("swh.loader.svn.svn.RemoteAccess") + remote_access = RemoteAccess(sample_repo_url, auth=Auth([get_username_provider()])) + mock_ra.side_effect = ( + [exception_to_retry] * nb_failed_calls + + [remote_access] + + [exception_to_retry] * nb_failed_calls + + [remote_access] + ) + + mock_sleep = mocker.patch.object(SvnRepo.remote_access.retry, "sleep") + + with pytest.raises(type(exception_to_retry)): + SvnRepo( + sample_repo_url, sample_repo_url, tmp_path, max_content_length=100000, + ) + + assert_sleep_calls(mock_sleep, mocker, nb_failed_calls - 1)