Content: Get rid of GitAPIException "expection"

Author: schnatterer

src/main/groovy/com/cloudogu/gitops/features/Content.groovy

@@ -17,7 +17,9 @@ import jakarta.inject.Singleton
 import org.apache.commons.io.FileUtils
 import org.eclipse.jgit.api.CloneCommand
 import org.eclipse.jgit.api.Git
-import org.eclipse.jgit.api.errors.GitAPIException
+import org.eclipse.jgit.api.ResetCommand
+import org.eclipse.jgit.lib.Ref
+import org.eclipse.jgit.lib.Repository
 import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider
 
 @Slf4j
@@ -168,25 +170,49 @@ class Content extends Feature {
         def cloneCommand = gitClone()
                 .setURI(repo.url)
                 .setDirectory(repoTmpDir)
-                .setCloneAllBranches(true)
 
         if (repo.username != null && repo.password != null) {
             cloneCommand.setCredentialsProvider(
                     new UsernamePasswordCredentialsProvider(repo.username, repo.password))
         }
         def git = cloneCommand.call()
-        try {
-            // switch to used branch.
-            git.checkout().setName(repo.ref).call()
+        
+        def actualRef = findRef(repo, git.repository)
 
-        } catch (GitAPIException e) {
-            // This is a fallback because of branches hosted at github.
-            log.debug("checkout branch ${repo.ref} not working, maybe because of github. Now again with origin/${repo.ref} to checkout remote branch.")
-            var nameWithOrigin = 'origin/'+ repo.ref
-            git.checkout().setName(nameWithOrigin).call()
+        // Avoid jgit removing and staging all files except .git which might lead to CheckoutConflictException during checkout
+        git.reset().setMode(ResetCommand.ResetType.HARD).call()
+        git.checkout().setName(actualRef).call()
+    }
 
+    private String findRef(Config.ContentSchema.ContentRepositorySchema repoConfig, Repository gitRepo) {
+        // Check if it is a commit hash first to avoid InvalidRefNameException
+        if (gitRepo.resolve(repoConfig.ref)) {
+            return repoConfig.ref
+        }
+        
+        // Check tags or branches
+        def remoteCommand = Git.lsRemoteRepository()
+                .setRemote(repoConfig.url)
+                .setHeads(true)
+                .setTags(true)
+
+        if (repoConfig.username != null && repoConfig.password != null) {
+            remoteCommand.setCredentialsProvider(
+                    new UsernamePasswordCredentialsProvider(repoConfig.username, repoConfig.password))
         }
+        Collection<Ref> refs = remoteCommand.call()
+        String potentialRef = refs.find { it.name.endsWith(repoConfig.ref) }?.name
+
+        if (!potentialRef) {
+            // Jgit silently ignores some missing refs and just continues with default branch.
+            // This might lead to unexpected surprises for our users, so better fail explicitly
+            throw new RuntimeException("Reference '${repoConfig.ref}' not found in repository '${repoConfig.url}'")
         }
+        
+        // Jgit only checks out remote branches when they start in origin/ 🙄 
+        return potentialRef.replace('refs/heads/', 'origin/')
+    }
+
 
     protected void pushTargetRepos(List<RepoCoordinate> repoCoordinates) {
         repoCoordinates.each { repoCoordinate ->

src/test/groovy/com/cloudogu/gitops/features/ContentTest.groovy

@@ -6,6 +6,7 @@ import com.cloudogu.gitops.scmm.api.Permission
 import com.cloudogu.gitops.scmm.api.Repository
 import com.cloudogu.gitops.scmm.api.ScmmApiClient
 import com.cloudogu.gitops.utils.*
+import groovy.util.logging.Slf4j
 import groovy.yaml.YamlSlurper
 import org.apache.commons.io.FileUtils
 import org.eclipse.jgit.api.CloneCommand
@@ -16,10 +17,12 @@ import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.Test
 import org.mockito.ArgumentCaptor
 
+import static groovy.test.GroovyAssert.shouldFail
 import static org.assertj.core.api.Assertions.assertThat
 import static org.mockito.ArgumentMatchers.*
 import static org.mockito.Mockito.*
 
+@Slf4j
 class ContentTest {
     // bareRepo
     static List<File> foldersToDelete = new ArrayList<File>()
@@ -191,16 +194,36 @@ class ContentTest {
     }
 
     @Test
-    void 'Checks out commit refs and tags for content repos'() {
+    void 'Checks out commit refs, tags and non-default branches for content repos'() {
         config.content.repos = [
-                new Config.ContentSchema.ContentRepositorySchema(url: createContentRepo('nonFolderBasedRepo1'), ref: 'someTag', folderBased: false, target: 'common/tag'),
-                new Config.ContentSchema.ContentRepositorySchema(url: createContentRepo('nonFolderBasedRepo2'), ref: '56d2e3f4b7c95d5645c823f7be8ea6f8a853ac40', folderBased: false, target: 'common/ref')
+                new Config.ContentSchema.ContentRepositorySchema(url: createContentRepo(), ref: 'someTag', folderBased: false, target: 'common/tag'),
+                new Config.ContentSchema.ContentRepositorySchema(url: createContentRepo(), ref: '8bc1d1165468359b16d9771d4a9a3df26afc03e8', folderBased: false, target: 'common/ref'),
+                new Config.ContentSchema.ContentRepositorySchema(url: createContentRepo(), ref: 'someBranch', folderBased: false, target: 'common/branch')
         ]
 
         def repos = createContent().cloneContentRepos()
 
         assertThat(new File(findRoot(repos), "common/tag/README.md")).exists().isFile()
+        assertThat(new File(findRoot(repos), "common/tag/README.md").text).contains("someTag")
+
         assertThat(new File(findRoot(repos), "common/ref/README.md")).exists().isFile()
+        assertThat(new File(findRoot(repos), "common/ref/README.md").text).contains("main")
+        
+        assertThat(new File(findRoot(repos), "common/branch/README.md")).exists().isFile()
+        assertThat(new File(findRoot(repos), "common/branch/README.md").text).contains("someBranch")
+    }
+
+    @Test
+    void 'Fails if commit refs does not exit'() {
+        config.content.repos = [
+                new Config.ContentSchema.ContentRepositorySchema(url: createContentRepo(), ref: 'someTag', folderBased: false, target: 'common/tag'),
+                new Config.ContentSchema.ContentRepositorySchema(url: createContentRepo(), ref: 'does/not/exist', folderBased: true, target: 'does not matter'),
+        ]
+
+        def exception = shouldFail(RuntimeException) {
+            createContent().cloneContentRepos()
+        }
+        assertThat(exception.message).startsWith("Reference 'does/not/exist' not found in repository")
     }
 
     @Test
@@ -466,36 +489,38 @@ class ContentTest {
     }
 
 
-    static String createContentRepo(String srcPath) {
+    static String createContentRepo(String srcPath = '') {
         // The bare repo works as the "remote"
         def bareRepoDir = File.createTempDir('gitops-playground-test-content-repo')
         bareRepoDir.deleteOnExit()
         foldersToDelete << bareRepoDir
         // init with bare repo
         FileUtils.copyDirectory(new File(System.getProperty("user.dir") + "/src/test/groovy/com/cloudogu/gitops/utils/data/git-repository/"), bareRepoDir)
         def bareRepoUri = 'file://' + bareRepoDir.absolutePath
-        println("Repo $srcPath: bare repo $bareRepoUri")
-
-        // Add srcPath to bare repo
-        def tempRepo = File.createTempDir('gitops-playground-temp-repo')
-        tempRepo.deleteOnExit()
-        foldersToDelete << tempRepo
-        println("Repo $srcPath: cloned bare repo to $tempRepo")
-        def git = Git.cloneRepository()
-                .setURI(bareRepoUri)
-                .setBranch('main')
-                .setDirectory(tempRepo)
-                .call()
-
-        FileUtils.copyDirectory(new File(System.getProperty("user.dir") + '/src/test/groovy/com/cloudogu/gitops/utils/data/contentRepos/' + srcPath), tempRepo)
-
-        git.add().addFilepattern(".").call()
-
-        // Avoid complications with local developer's git config, e.g. when  git config --global commit.gpgSign true
-        SystemReader.getInstance().userConfig.clear()
-        git.commit().setMessage("Initialize with $srcPath").call()
-        git.push().call()
-        tempRepo.delete()
+        log.debug("Repo $srcPath: bare repo $bareRepoUri")
+
+        if (srcPath) {
+            // Add srcPath to bare repo
+            def tempRepo = File.createTempDir('gitops-playground-temp-repo')
+            tempRepo.deleteOnExit()
+            foldersToDelete << tempRepo
+            log.debug("Repo $srcPath: cloned bare repo to $tempRepo")
+            def git = Git.cloneRepository()
+                    .setURI(bareRepoUri)
+                    .setBranch('main')
+                    .setDirectory(tempRepo)
+                    .call()
+
+            FileUtils.copyDirectory(new File(System.getProperty("user.dir") + '/src/test/groovy/com/cloudogu/gitops/utils/data/contentRepos/' + srcPath), tempRepo)
+
+            git.add().addFilepattern(".").call()
+
+            // Avoid complications with local developer's git config, e.g. when  git config --global commit.gpgSign true
+            SystemReader.getInstance().userConfig.clear()
+            git.commit().setMessage("Initialize with $srcPath").call()
+            git.push().call()
+            tempRepo.delete()
+        }
 
         return bareRepoUri
     }