def sync_from_downstream( self, dist_git_branch: str, upstream_branch: str, no_pr: bool = False, fork: bool = True, remote_name: str = None, ): """ Sync content of Fedora dist-git repo back to upstream :param dist_git_branch: branch in dist-git :param upstream_branch: upstream branch :param no_pr: won't create a pull request if set to True :param fork: forks the project if set to True :param remote_name: name of remote where we should push; if None, try to find a ssh_url """ logger.info(f"upstream active branch {self.up.active_branch}") self.dg.update_branch(dist_git_branch) self.dg.checkout_branch(dist_git_branch) local_pr_branch = f"{dist_git_branch}-downstream-sync" logger.info(f'using "{dist_git_branch}" dist-git branch') self.up.create_branch(local_pr_branch) self.up.checkout_branch(local_pr_branch) sync_files( self.package_config.synced_files.raw_files_to_sync, self.dg.local_project.working_dir, self.up.local_project.working_dir, ) if not no_pr: description = ( f"Downstream commit: {self.dg.local_project.git_repo.head.commit}\n" ) commit_msg = f"sync from downstream branch {dist_git_branch!r}" pr_title = f"Update from downstream branch {dist_git_branch!r}" self.up.commit(title=commit_msg, msg=description) # the branch may already be up, let's push forcefully source_branch = self.up.push( self.up.local_project.ref, fork=fork, force=True, remote_name=remote_name, ) self.up.create_pull( pr_title, description, source_branch=source_branch, target_branch=upstream_branch, )
def sync_pr(self, pr_id, dist_git_branch: str, upstream_version: str = None): assert_existence(self.dg.local_project) # do not add anything between distgit clone and saving gpg keys! self.up.allowed_gpg_keys = self.dg.get_allowed_gpg_keys_from_downstream_config( ) self.up.run_action(actions=ActionName.pre_sync) self.up.checkout_pr(pr_id=pr_id) self.dg.check_last_commit() local_pr_branch = f"pull-request-{pr_id}-sync" # fetch and reset --hard upstream/$branch? self.dg.create_branch( dist_git_branch, base=f"remotes/origin/{dist_git_branch}", setup_tracking=True, ) self.dg.update_branch(dist_git_branch) self.dg.checkout_branch(dist_git_branch) self.dg.create_branch(local_pr_branch) self.dg.checkout_branch(local_pr_branch) if self.up.with_action(action=ActionName.create_patches): patches = self.up.create_patches( upstream=upstream_version, destination=str(self.dg.absolute_specfile_dir), ) self.dg.add_patches_to_specfile(patches) description = ( f"Upstream pr: {pr_id}\n" f"Upstream commit: {self.up.local_project.git_repo.head.commit}\n") self._handle_sources(add_new_sources=True, force_new_sources=False) raw_sync_files = self.package_config.synced_files.get_raw_files_to_sync( Path(self.up.local_project.working_dir), Path(self.dg.local_project.working_dir), ) sync_files(raw_sync_files) self.dg.commit(title=f"Sync upstream pr: {pr_id}", msg=description) self.push_and_create_pr( pr_title=f"Upstream pr: {pr_id}", pr_description=description, dist_git_branch="master", )
def sync_pr(self, pr_id, dist_git_branch: str, upstream_version: str = None): self.up.run_action(action=ActionName.pre_sync) self.up.checkout_pr(pr_id=pr_id) local_pr_branch = f"pull-request-{pr_id}-sync" # fetch and reset --hard upstream/$branch? self.dg.create_branch( dist_git_branch, base=f"remotes/origin/{dist_git_branch}", setup_tracking=True, ) self.dg.update_branch(dist_git_branch) self.dg.checkout_branch(dist_git_branch) self.dg.create_branch(local_pr_branch) self.dg.checkout_branch(local_pr_branch) if self.up.with_action(action=ActionName.create_patches): patches = self.up.create_patches( upstream=upstream_version, destination=self.dg.local_project.working_dir) self.dg.add_patches_to_specfile(patches) description = ( f"Upstream pr: {pr_id}\n" f"Upstream commit: {self.up.local_project.git_repo.head.commit}\n") self._handle_sources(add_new_sources=True, force_new_sources=False) sync_files( self.package_config.synced_files.raw_files_to_sync, self.up.local_project.working_dir, self.dg.local_project.working_dir, ) self.dg.commit(title=f"Sync upstream pr: {pr_id}", msg=description) self.push_and_create_pr( pr_title=f"Upstream pr: {pr_id}", pr_description=description, dist_git_branch="master", )
def sync_from_downstream( self, dist_git_branch: str, upstream_branch: str, no_pr: bool = False, fork: bool = True, remote_name: str = None, exclude_files: Iterable[str] = None, force: bool = False, ): """ Sync content of Fedora dist-git repo back to upstream :param exclude_files: files that will be excluded from the sync :param dist_git_branch: branch in dist-git :param upstream_branch: upstream branch :param no_pr: won't create a pull request if set to True :param fork: forks the project if set to True :param remote_name: name of remote where we should push; if None, try to find a ssh_url :param force: ignore changes in the git index """ exclude_files = exclude_files or [] if not dist_git_branch: raise PackitException("Dist-git branch is not set.") if not upstream_branch: raise PackitException("Upstream branch is not set.") logger.info(f"Upstream active branch: {self.up.active_branch}") if not force and self.up.is_dirty(): raise PackitException( "The repository is dirty, will not discard the changes. Use --force to bypass." ) self.dg.update_branch(dist_git_branch) self.dg.checkout_branch(dist_git_branch) logger.info(f"Using {dist_git_branch!r} dist-git branch.") if no_pr: self.up.checkout_branch(upstream_branch) else: local_pr_branch = f"{dist_git_branch}-downstream-sync" self.up.create_branch(local_pr_branch) self.up.checkout_branch(local_pr_branch) raw_sync_files = self.package_config.synced_files.get_raw_files_to_sync( dest_dir=Path(self.dg.local_project.working_dir), src_dir=Path(self.up.local_project.working_dir), ) reverse_raw_sync_files = [ raw_file.reversed() for raw_file in raw_sync_files if Path(raw_file.dest).name not in exclude_files ] sync_files(reverse_raw_sync_files, fail_on_missing=False) if not no_pr: description = f"Downstream commit: {self.dg.local_project.commit_hexsha}\n" commit_msg = f"Sync from downstream branch {dist_git_branch!r}" pr_title = f"Update from downstream branch {dist_git_branch!r}" self.up.commit(title=commit_msg, msg=description) # the branch may already be up, let's push forcefully source_branch, fork_username = self.up.push_to_fork( self.up.local_project.ref, fork=fork, force=True, remote_name=remote_name, ) self.up.create_pull( pr_title, description, source_branch=source_branch, target_branch=upstream_branch, fork_username=fork_username, )
def sync_release( self, dist_git_branch: str, use_local_content=False, version: str = None, force_new_sources=False, upstream_ref: str = None, create_pr: bool = True, force: bool = False, ) -> Optional[PullRequest]: """ Update given package in Fedora :param dist_git_branch: branch in dist-git :param use_local_content: don't check out anything :param version: upstream version to update in Fedora :param force_new_sources: don't check the lookaside cache and perform new-sources :param upstream_ref: for a source-git repo, use this ref as the latest upstream commit :param create_pr: create a pull request if set to True :param force: ignore changes in the git index :return created PullRequest if create_pr is True, else None """ assert_existence(self.up.local_project) assert_existence(self.dg.local_project) if self.dg.is_dirty(): raise PackitException( f"The distgit repository {self.dg.local_project.working_dir} is dirty." f"This is not supported.") if not force and self.up.is_dirty() and not use_local_content: raise PackitException( "The repository is dirty, will not discard the changes. Use --force to bypass." ) # do not add anything between distgit clone and saving gpg keys! self.up.allowed_gpg_keys = self.dg.get_allowed_gpg_keys_from_downstream_config( ) upstream_ref = upstream_ref or self.package_config.upstream_ref create_pr = create_pr and self.package_config.create_pr self.up.run_action(actions=ActionName.post_upstream_clone) full_version = version or self.up.get_version() if not full_version: raise PackitException( "Could not figure out version of latest upstream release.") current_up_branch = self.up.active_branch try: upstream_tag = self.up.package_config.upstream_tag_template.format( version=full_version) if not use_local_content: self.up.local_project.checkout_release(upstream_tag) self.dg.check_last_commit() self.up.run_action(actions=ActionName.pre_sync) self.dg.create_branch( dist_git_branch, base=f"remotes/origin/{dist_git_branch}", setup_tracking=True, ) # fetch and reset --hard upstream/$branch? logger.info(f"Using {dist_git_branch!r} dist-git branch.") self.dg.update_branch(dist_git_branch) self.dg.checkout_branch(dist_git_branch) if create_pr: local_pr_branch = f"{full_version}-{dist_git_branch}-update" self.dg.create_branch(local_pr_branch) self.dg.checkout_branch(local_pr_branch) description = ( f"Upstream tag: {upstream_tag}\n" f"Upstream commit: {self.up.local_project.commit_hexsha}\n") path = os.path.join(self.dg.local_project.working_dir, "README.packit") logger.debug(f"Path of README: {path}") with open(path, "w") as f: f.write( SYNCING_NOTE.format(packit_version=get_packit_version())) files_to_sync = self.package_config.get_all_files_to_sync() if self.up.with_action(action=ActionName.prepare_files): comment = f"- new upstream release: {full_version}" try: self.dg.set_specfile_content(self.up.specfile, full_version, comment) except FileNotFoundError as ex: # no downstream spec file: this is either a mistake or # there is no spec file in dist-git yet, hence warning logger.warning( f"There is not spec file downstream: {ex}, copying the one from upstream." ) shutil.copy2( self.up.absolute_specfile_path, self.dg.get_absolute_specfile_path(), ) raw_sync_files = files_to_sync.get_raw_files_to_sync( Path(self.up.local_project.working_dir), Path(self.dg.local_project.working_dir), ) # exclude spec, we have special plans for it raw_sync_files = [ x for x in raw_sync_files if x.src != self.up.absolute_specfile_path ] sync_files(raw_sync_files) if upstream_ref: if self.up.with_action(action=ActionName.create_patches): patches = self.up.create_patches( upstream=upstream_ref, destination=str(self.dg.absolute_specfile_dir), ) self.dg.specfile_add_patches(patches) self._handle_sources(add_new_sources=True, force_new_sources=force_new_sources) # when the action is defined, we still need to copy the files if self.up.has_action(action=ActionName.prepare_files): raw_sync_files = files_to_sync.get_raw_files_to_sync( Path(self.up.local_project.working_dir), Path(self.dg.local_project.working_dir), ) sync_files(raw_sync_files) self.dg.commit(title=f"{full_version} upstream release", msg=description) new_pr = None if create_pr: new_pr = self.push_and_create_pr( pr_title=f"Update to upstream release {full_version}", pr_description=description, dist_git_branch=dist_git_branch, ) else: self.dg.push(refspec=f"HEAD:{dist_git_branch}") finally: if not use_local_content: self.up.local_project.git_repo.git.checkout(current_up_branch) self.dg.refresh_specfile() return new_pr
def sync_release( self, dist_git_branch: str = None, version: str = None, tag: str = None, use_local_content=False, force_new_sources=False, upstream_ref: str = None, create_pr: bool = True, force: bool = False, ) -> Optional[PullRequest]: """ Update given package in Fedora :param dist_git_branch: branch in dist-git, defaults to repo's default branch :param use_local_content: don't check out anything :param version: upstream version to update in Fedora :param tag: upstream git tag :param force_new_sources: don't check the lookaside cache and perform new-sources :param upstream_ref: for a source-git repo, use this ref as the latest upstream commit :param create_pr: create a pull request if set to True :param force: ignore changes in the git index :return created PullRequest if create_pr is True, else None """ dist_git_branch = ( dist_git_branch or self.dg.local_project.git_project.default_branch ) # process version and tag parameters if version and tag: raise PackitException( "Function parameters version and tag are mutually exclusive." ) elif not tag: version = version or self.up.get_version() if not version: raise PackitException( "Could not figure out version of latest upstream release." ) upstream_tag = self.up.convert_version_to_tag(version) else: upstream_tag = tag version = self.up.get_version_from_tag(tag) assert_existence(self.up.local_project, "Upstream local project") assert_existence(self.dg.local_project, "Dist-git local project") if self.dg.is_dirty(): raise PackitException( f"The distgit repository {self.dg.local_project.working_dir} is dirty." f"This is not supported." ) if not force and self.up.is_dirty() and not use_local_content: raise PackitException( "The repository is dirty, will not discard the changes. Use --force to bypass." ) # do not add anything between distgit clone and saving gpg keys! self.up.allowed_gpg_keys = self.dg.get_allowed_gpg_keys_from_downstream_config() upstream_ref = self.up._expand_git_ref( upstream_ref or self.package_config.upstream_ref ) create_pr = create_pr and self.package_config.create_pr self.up.run_action(actions=ActionName.post_upstream_clone) current_up_branch = self.up.active_branch try: # we want to check out the tag only when local_content is not set # and it's an actual upstream repo and not source-git if upstream_ref: logger.info( "We will not check out the upstream tag " "because this is a source-git repo." ) elif not use_local_content: self.up.local_project.checkout_release(upstream_tag) self.dg.check_last_commit() self.up.run_action(actions=ActionName.pre_sync) self.dg.create_branch( dist_git_branch, base=f"remotes/origin/{dist_git_branch}", setup_tracking=True, ) # fetch and reset --hard upstream/$branch? logger.info(f"Using {dist_git_branch!r} dist-git branch.") self.dg.update_branch(dist_git_branch) self.dg.checkout_branch(dist_git_branch) if create_pr: local_pr_branch = f"{version}-{dist_git_branch}-update" self.dg.create_branch(local_pr_branch) self.dg.checkout_branch(local_pr_branch) description = ( f"Upstream tag: {upstream_tag}\n" f"Upstream commit: {self.up.local_project.commit_hexsha}\n" ) readme_path = self.dg.local_project.working_dir / "README.packit" logger.debug(f"README: {readme_path}") readme_path.write_text( SYNCING_NOTE.format(packit_version=get_packit_version()) ) raw_sync_files = ( self.package_config.get_all_files_to_sync().get_raw_files_to_sync( self.up.local_project.working_dir, self.dg.local_project.working_dir, ) ) if self.up.with_action(action=ActionName.prepare_files): raw_files_to_sync = self._prepare_files_to_sync( raw_sync_files=raw_sync_files, full_version=version, upstream_tag=upstream_tag, ) sync_files(raw_files_to_sync) if upstream_ref and self.up.with_action( action=ActionName.create_patches ): patches = self.up.create_patches( upstream=upstream_ref, destination=str(self.dg.absolute_specfile_dir), ) self.dg.specfile_add_patches(patches) self._handle_sources( add_new_sources=True, force_new_sources=force_new_sources ) # when the action is defined, we still need to copy the files if self.up.has_action(action=ActionName.prepare_files): sync_files(raw_sync_files) self.dg.commit(title=f"{version} upstream release", msg=description) new_pr = None if create_pr: title = f"Update to upstream release {version}" if not self.dg.pr_exists(title, description.rstrip(), dist_git_branch): new_pr = self.push_and_create_pr( pr_title=title, pr_description=description, dist_git_branch=dist_git_branch, ) else: self.dg.push(refspec=f"HEAD:{dist_git_branch}") finally: if not use_local_content and not upstream_ref: self.up.local_project.git_repo.git.checkout(current_up_branch) self.dg.refresh_specfile() self.dg.local_project.git_repo.git.reset("--hard", "HEAD") return new_pr
def sync_release( self, dist_git_branch: str, use_local_content=False, version: str = None, force_new_sources=False, upstream_ref: str = None, ): """ Update given package in Fedora """ assert_existence(self.up.local_project) assert_existence(self.dg.local_project) self.up.run_action(action=ActionName.post_upstream_clone) full_version = version or self.up.get_version() if not full_version: raise PackitException( "Could not figure out version of latest upstream release.") current_up_branch = self.up.active_branch try: # TODO: this is problematic, since we may overwrite stuff in the repo # but the thing is that we need to do it # I feel like the ideal thing to do would be to clone the repo and work in tmpdir # TODO: this is also naive, upstream may use different tagging scheme, e.g. # release = 232, tag = v232 if not use_local_content: self.up.checkout_release(full_version) self.up.run_action(action=ActionName.pre_sync) local_pr_branch = f"{full_version}-{dist_git_branch}-update" # fetch and reset --hard upstream/$branch? logger.info(f"Using {dist_git_branch!r} dist-git branch") self.dg.create_branch( dist_git_branch, base=f"remotes/origin/{dist_git_branch}", setup_tracking=True, ) self.dg.update_branch(dist_git_branch) self.dg.checkout_branch(dist_git_branch) self.dg.create_branch(local_pr_branch) self.dg.checkout_branch(local_pr_branch) description = ( f"Upstream tag: {full_version}\n" f"Upstream commit: {self.up.local_project.git_repo.head.commit}\n" ) if self.up.with_action(action=ActionName.prepare_files): sync_files( self.package_config.synced_files.raw_files_to_sync, self.up.local_project.working_dir, self.dg.local_project.working_dir, ) if upstream_ref: if self.up.with_action(action=ActionName.create_patches): patches = self.up.create_patches( upstream=upstream_ref, destination=self.dg.local_project.working_dir, ) self.dg.add_patches_to_specfile(patches) self._handle_sources(add_new_sources=True, force_new_sources=force_new_sources) if self.up.has_action(action=ActionName.prepare_files): sync_files( self.package_config.synced_files.raw_files_to_sync, self.up.local_project.working_dir, self.dg.local_project.working_dir, ) self.dg.commit(title=f"{full_version} upstream release", msg=description) self.push_and_create_pr( pr_title=f"Update to upstream release {full_version}", pr_description=description, dist_git_branch=dist_git_branch, ) finally: if not use_local_content: self.up.local_project.git_repo.git.checkout(current_up_branch)
def sync_release( self, dist_git_branch: str, use_local_content=False, version: str = None, force_new_sources=False, upstream_ref: str = None, create_pr: bool = True, force: bool = False, ): """ Update given package in Fedora :param dist_git_branch: branch in dist-git :param use_local_content: don't check out anything :param version: upstream version to update in Fedora :param force_new_sources: don't check the lookaside cache and perform new-sources :param upstream_ref: for a source-git repo, use this ref as the latest upstream commit :param create_pr: create a pull request if set to True :param force: ignore changes in the git index """ assert_existence(self.up.local_project) assert_existence(self.dg.local_project) if not force and self.up.is_dirty() and not use_local_content: raise PackitException( "The repository is dirty, will not discard the changes. Use --force to bypass." ) # do not add anything between distgit clone and saving gpg keys! self.up.allowed_gpg_keys = self.dg.get_allowed_gpg_keys_from_downstream_config( ) upstream_ref = upstream_ref or self.package_config.upstream_ref create_pr = create_pr or self.package_config.create_pr self.up.run_action(actions=ActionName.post_upstream_clone) full_version = version or self.up.get_version() if not full_version: raise PackitException( "Could not figure out version of latest upstream release.") current_up_branch = self.up.active_branch try: # TODO: this is problematic, since we may overwrite stuff in the repo # but the thing is that we need to do it # I feel like the ideal thing to do would be to clone the repo and work in tmpdir # TODO: this is also naive, upstream may use different tagging scheme, e.g. # release = 232, tag = v232 if not use_local_content: self.up.checkout_release(full_version) self.dg.check_last_commit() self.up.run_action(actions=ActionName.pre_sync) self.dg.create_branch( dist_git_branch, base=f"remotes/origin/{dist_git_branch}", setup_tracking=True, ) # fetch and reset --hard upstream/$branch? logger.info(f"Using {dist_git_branch!r} dist-git branch") self.dg.update_branch(dist_git_branch) self.dg.checkout_branch(dist_git_branch) if create_pr: local_pr_branch = f"{full_version}-{dist_git_branch}-update" self.dg.create_branch(local_pr_branch) self.dg.checkout_branch(local_pr_branch) description = ( f"Upstream tag: {full_version}\n" f"Upstream commit: {self.up.local_project.git_repo.head.commit}\n" ) path = os.path.join(self.dg.local_project.working_dir, "README.packit") logger.debug(f"Path of README {path}") with open(path, "w") as f: f.write(SYNCING_NOTE) if self.up.with_action(action=ActionName.prepare_files): raw_sync_files = self.package_config.synced_files.get_raw_files_to_sync( Path(self.up.local_project.working_dir), Path(self.dg.local_project.working_dir), ) # exclude spec, we have special plans for it raw_sync_files = [ x for x in raw_sync_files if x.src != self.up.absolute_specfile_path ] comment = f"- new upstream release: {full_version}" self.dg.set_specfile_content(self.up.specfile, full_version, comment) sync_files(raw_sync_files) if upstream_ref: if self.up.with_action(action=ActionName.create_patches): patches = self.up.create_patches( upstream=upstream_ref, destination=str(self.dg.absolute_specfile_dir), ) self.dg.add_patches_to_specfile(patches) self._handle_sources(add_new_sources=True, force_new_sources=force_new_sources) # when the action is defined, we still need to copy the files if self.up.has_action(action=ActionName.prepare_files): raw_sync_files = self.package_config.synced_files.get_raw_files_to_sync( Path(self.up.local_project.working_dir), Path(self.dg.local_project.working_dir), ) sync_files(raw_sync_files) self.dg.commit(title=f"{full_version} upstream release", msg=description) if create_pr: self.push_and_create_pr( pr_title=f"Update to upstream release {full_version}", pr_description=description, dist_git_branch=dist_git_branch, ) else: self.dg.push(refspec=f"HEAD:{dist_git_branch}") finally: if not use_local_content: self.up.local_project.git_repo.git.checkout(current_up_branch)
def sync_from_downstream( self, dist_git_branch: str = None, upstream_branch: str = None, no_pr: bool = False, fork: bool = True, remote_name: str = None, exclude_files: Iterable[str] = None, force: bool = False, sync_only_specfile: bool = False, ): """ Sync content of Fedora dist-git repo back to upstream :param dist_git_branch: branch in dist-git, defaults to repo's default branch :param upstream_branch: upstream branch, defaults to repo's default branch :param no_pr: won't create a pull request if set to True :param fork: forks the project if set to True :param remote_name: name of remote where we should push; if None, try to find a ssh_url :param exclude_files: files that will be excluded from the sync :param force: ignore changes in the git index :param sync_only_specfile: whether to sync only content of specfile """ exclude_files = exclude_files or [] if not dist_git_branch: dist_git_branch = self.dg.local_project.git_project.default_branch logger.info( f"Dist-git branch not set, defaulting to {dist_git_branch!r}.") if not upstream_branch: upstream_branch = self.up.local_project.git_project.default_branch logger.info( f"Upstream branch not set, defaulting to {upstream_branch!r}.") logger.info(f"Upstream active branch: {self.up.active_branch}") if not force and self.up.is_dirty(): raise PackitException( "The repository is dirty, will not discard the changes. Use --force to bypass." ) self.dg.update_branch(dist_git_branch) self.dg.checkout_branch(dist_git_branch) logger.info(f"Using {dist_git_branch!r} dist-git branch.") if no_pr: self.up.checkout_branch(upstream_branch) else: local_pr_branch = f"{dist_git_branch}-downstream-sync" self.up.create_branch(local_pr_branch) self.up.checkout_branch(local_pr_branch) files = ([ self.package_config.get_specfile_sync_files_item( from_downstream=True) ] if sync_only_specfile else self.package_config.files_to_sync) # Drop files to be excluded from the sync. for ef in exclude_files: files = [ f.drop_src(ef, criteria=lambda x, y: Path(x).name == y) for f in files if f is not None ] # Make paths absolute and check if they are within the # working directories. for file in files: file.resolve( src_base=self.dg.local_project.working_dir, dest_base=self.up.local_project.working_dir, ) sync_files(files) if not no_pr: description = f"Downstream commit: {self.dg.local_project.commit_hexsha}\n" commit_msg = f"Sync from downstream branch {dist_git_branch!r}" pr_title = f"Update from downstream branch {dist_git_branch!r}" self.up.commit(title=commit_msg, msg=description) # the branch may already be up, let's push forcefully source_branch, fork_username = self.up.push_to_fork( self.up.local_project.ref, fork=fork, force=True, remote_name=remote_name, ) self.up.create_pull( pr_title, description, source_branch=source_branch, target_branch=upstream_branch, fork_username=fork_username, )
def update_dist_git( self, version: Optional[str], upstream_ref: Optional[str], add_new_sources: bool, force_new_sources: bool, upstream_tag: Optional[str], commit_title: str, commit_msg: str, sync_default_files: bool = True, pkg_tool: str = "", ): """Update a dist-git repo from an upstream (aka source-git) repo - copy files to be synced to dist-git - generate and update patch files and the spec-file - upload source archives to the lookaside cache - commit the changes to dist-git, if a commit title is defined Args: version: Upstream version to update in Fedora. upstream_ref: For a source-git repo, use this ref as the latest upstream commit. add_new_sources: Download and upload source archives. force_new_sources: Download/upload the archive even if it's name is already in the cache or in sources file. upstream_tag: Use the message of the commit referenced by this tag to update the changelog in the spec-file, if requested. commit_title: Commit message title (aka subject-line) in dist-git. Do not commit if this is false-ish. commit_msg: Use this commit message in dist-git. sync_default_files: Whether to sync the default files, that is: packit.yaml and the spec-file. pkg_tool: what tool (fedpkg/centpkg) to use upload to lookaside cache """ if sync_default_files: synced_files = self.package_config.get_all_files_to_sync() else: synced_files = self.package_config.files_to_sync # Make all paths absolute and check that they are within # the working directories of the repositories. for item in synced_files: item.resolve( src_base=self.up.local_project.working_dir, dest_base=self.dg.local_project.working_dir, ) if self.up.with_action(action=ActionName.prepare_files): synced_files = self._prepare_files_to_sync( synced_files=synced_files, full_version=version, upstream_tag=upstream_tag, ) sync_files(synced_files) if upstream_ref and self.up.with_action( action=ActionName.create_patches): patches = self.up.create_patches( upstream=upstream_ref, destination=str(self.dg.absolute_specfile_dir), ) # Undo identical patches, but don't remove them # from the list, so that they are added to the spec-file. PatchGenerator.undo_identical(patches, self.dg.local_project.git_repo) self.dg.specfile_add_patches( patches, self.package_config.patch_generation_patch_id_digits) if add_new_sources or force_new_sources: self._handle_sources( force_new_sources=force_new_sources, pkg_tool=pkg_tool, ) if commit_title: self.dg.commit(title=commit_title, msg=commit_msg, prefix="")