chore: reference lifecycle

app/server/appsmith-interfaces/src/main/java/com/appsmith/external/dtos/ce/GitStatusCE_DTO.java

@@ -8,6 +8,7 @@
 /**
  * DTO to convey the status local git repo
  */
+// TODO: @Manish modify git status DTO accordingly
 @Data
 public class GitStatusCE_DTO {
 

app/server/appsmith-server/src/main/java/com/appsmith/server/constants/ce/FieldNameCE.java

@@ -102,6 +102,7 @@ public class FieldNameCE {
     public static final String IS_REQUIRED = "isRequired";
     public static final String UNUSED_DATASOURCE = "UNUSED_DATASOURCE";
     public static final String BRANCH_NAME = "branchName";
+    public static final String REF_NAME = "refName";
     public static final String SOURCE_BRANCH = "sourceBranch";
     public static final String DESTINATION_BRANCH = "destinationBranch";
     public static final String DEFAULT = "default";

app/server/appsmith-server/src/main/java/com/appsmith/server/git/central/CentralGitServiceCE.java

@@ -1,5 +1,6 @@
 package com.appsmith.server.git.central;
 
+import com.appsmith.external.dtos.GitStatusDTO;
 import com.appsmith.git.dto.CommitDTO;
 import com.appsmith.server.constants.ArtifactType;
 import com.appsmith.server.constants.ce.RefType;
@@ -33,4 +34,15 @@ Mono<String> fetchRemoteChanges(
             RefType refType);
 
     Mono<? extends Artifact> discardChanges(String branchedArtifactId, ArtifactType artifactType, GitType gitType);
+
+    Mono<GitStatusDTO> getStatus(
+            String branchedArtifactId, boolean compareRemote, ArtifactType artifactType, GitType gitType);
+
+    Mono<? extends Artifact> checkoutReference(
+            String referenceArtifactId,
+            String referenceToBeCheckedOut,
+            boolean addFileLock,
+            ArtifactType artifactType,
+            GitType gitType,
+            RefType refType);
 }

app/server/appsmith-server/src/main/java/com/appsmith/server/git/central/CentralGitServiceCEImpl.java

@@ -1,6 +1,7 @@
 package com.appsmith.server.git.central;
 
 import com.appsmith.external.constants.AnalyticsEvents;
+import com.appsmith.external.dtos.GitStatusDTO;
 import com.appsmith.external.git.constants.GitConstants;
 import com.appsmith.external.git.constants.GitSpan;
 import com.appsmith.external.models.Datasource;
@@ -67,6 +68,7 @@
 import static com.appsmith.external.git.constants.ce.GitConstantsCE.GIT_CONFIG_ERROR;
 import static com.appsmith.external.git.constants.ce.GitConstantsCE.GIT_PROFILE_ERROR;
 import static com.appsmith.external.git.constants.ce.GitSpanCE.OPS_COMMIT;
+import static com.appsmith.external.git.constants.ce.GitSpanCE.OPS_STATUS;
 import static com.appsmith.external.helpers.AppsmithBeanUtils.copyNestedNonNullProperties;
 import static com.appsmith.server.constants.FieldName.BRANCH_NAME;
 import static com.appsmith.server.constants.FieldName.DEFAULT;
@@ -102,6 +104,9 @@ public class CentralGitServiceCEImpl implements CentralGitServiceCE {
     private final GitRedisUtils gitRedisUtils;
     private final ObservationRegistry observationRegistry;
 
+    protected static final String ORIGIN = "origin/";
+    protected static final String REMOTE_NAME_REPLACEMENT = "";
+
     protected Mono<Boolean> isRepositoryLimitReachedForWorkspace(String workspaceId, Boolean isRepositoryPrivate) {
         if (!isRepositoryPrivate) {
             return Mono.just(FALSE);
@@ -331,6 +336,107 @@ private boolean checkIsDatasourceNameConflict(
         return false;
     }
 
+    @Override
+    public Mono<? extends Artifact> checkoutReference(
+            String referenceArtifactId,
+            String referenceToBeCheckedOut,
+            boolean addFileLock,
+            ArtifactType artifactType,
+            GitType gitType,
+            RefType refType) {
+
+        if (!hasText(referenceToBeCheckedOut)) {
+            return Mono.error(new AppsmithException(AppsmithError.INVALID_PARAMETER, FieldName.REF_NAME));
+        }
+
+        Mono<Tuple2<? extends Artifact, ? extends Artifact>> baseAndBranchedArtifactMono =
+                getBaseAndBranchedArtifacts(referenceArtifactId, artifactType);
+
+        return baseAndBranchedArtifactMono.flatMap(artifactTuples -> {
+            Artifact sourceArtifact = artifactTuples.getT1();
+            return checkoutReference(sourceArtifact, referenceToBeCheckedOut, addFileLock, gitType, refType);
+        });
+    }
+
+    protected Mono<? extends Artifact> checkoutReference(
+            Artifact baseArtifact,
+            String referenceToBeCheckedOut,
+            boolean addFileLock,
+            GitType gitType,
+            RefType refType) {
+
+        if (!hasText(referenceToBeCheckedOut)) {
+            return Mono.error(new AppsmithException(AppsmithError.INVALID_PARAMETER, FieldName.REF_NAME));
+        }
+
+        GitArtifactMetadata baseGitMetadata = baseArtifact.getGitArtifactMetadata();
+
+        if (isBaseGitMetadataInvalid(baseGitMetadata, gitType)) {
+            return Mono.error(new AppsmithException(AppsmithError.INVALID_GIT_SSH_CONFIGURATION));
+        }
+
+        String baseArtifactId = baseGitMetadata.getDefaultArtifactId();
+        final String finalRefName = referenceToBeCheckedOut.replaceFirst(ORIGIN, REMOTE_NAME_REPLACEMENT);
+
+        GitArtifactHelper<?> gitArtifactHelper =
+                gitArtifactHelperResolver.getArtifactHelper(baseArtifact.getArtifactType());
+        GitHandlingService gitHandlingService = gitHandlingServiceResolver.getGitHandlingService(gitType);
+
+        Mono<Boolean> acquireFileLock = gitRedisUtils.acquireGitLock(
+                baseArtifactId, GitConstants.GitCommandConstants.CHECKOUT_BRANCH, addFileLock);
+
+        Mono<? extends Artifact> checkedOutArtifactMono;
+        // If the user is trying to check out remote reference, create a new reference if it does not exist already
+
+        ArtifactJsonTransformationDTO jsonTransformationDTO = new ArtifactJsonTransformationDTO();
+        jsonTransformationDTO.setWorkspaceId(baseArtifact.getWorkspaceId());
+        jsonTransformationDTO.setBaseArtifactId(baseGitMetadata.getDefaultArtifactId());
+        jsonTransformationDTO.setRefType(refType);
+        jsonTransformationDTO.setArtifactType(baseArtifact.getArtifactType());
+        jsonTransformationDTO.setRepoName(baseGitMetadata.getRepoName());
+
+        if (referenceToBeCheckedOut.startsWith(ORIGIN)) {
+
+            checkedOutArtifactMono = gitHandlingService
+                    .listReferences(jsonTransformationDTO, refType)
+                    .flatMap(gitRefs -> {
+                        long branchMatchCount = gitRefs.stream()
+                                .filter(gitRef -> gitRef.equals(finalRefName))
+                                .count();
+
+                        if (branchMatchCount == 0) {
+                            return checkoutRemoteBranch(baseArtifact, finalRefName);
+                        }
+
+                        return Mono.error(new AppsmithException(
+                                AppsmithError.GIT_ACTION_FAILED,
+                                "checkout",
+                                referenceToBeCheckedOut + " already exists in local - " + finalRefName));
+                    });
+        } else {
+            // TODO refactor method to account for RefName as well
+            checkedOutArtifactMono = Mono.defer(() -> gitArtifactHelper
+                    .getArtifactByBaseIdAndBranchName(
+                            baseArtifactId, finalRefName, gitArtifactHelper.getArtifactReadPermission())
+                    .flatMap(artifact -> gitAnalyticsUtils.addAnalyticsForGitOperation(
+                            AnalyticsEvents.GIT_CHECKOUT_BRANCH,
+                            artifact,
+                            artifact.getGitArtifactMetadata().getIsRepoPrivate())));
+        }
+
+        return checkedOutArtifactMono
+                .doFinally(signalType -> gitRedisUtils.releaseFileLock(baseArtifactId, addFileLock))
+                .tag(GitConstants.GitMetricConstants.CHECKOUT_REMOTE, FALSE.toString())
+                .name(GitSpan.OPS_CHECKOUT_BRANCH)
+                .tap(Micrometer.observation(observationRegistry))
+                .onErrorResume(Mono::error);
+    }
+
+    // TODO @Manish: add checkout Remote Branch
+    protected Mono<? extends Artifact> checkoutRemoteBranch(Artifact baseArtifact, String finalRefName) {
+        return null;
+    }
+
     /**
      * Connect the artifact from Appsmith to a git repo
      * This is the prerequisite step needed to perform all the git operation for an artifact
@@ -929,6 +1035,137 @@ private boolean isBaseGitMetadataInvalid(GitArtifactMetadata gitArtifactMetadata
                         .isGitAuthInvalid(gitArtifactMetadata.getGitAuth());
     }
 
+    private Mono<GitStatusDTO> getStatusAfterComparingWithRemote(
+            String baseArtifactId, boolean isFileLock, ArtifactType artifactType, GitType gitType) {
+        return getStatus(baseArtifactId, isFileLock, true, artifactType, gitType);
+    }
+
+    @Override
+    public Mono<GitStatusDTO> getStatus(
+            String branchedArtifactId, boolean compareRemote, ArtifactType artifactType, GitType gitType) {
+        return getStatus(branchedArtifactId, true, compareRemote, artifactType, gitType);
+    }
+
+    /**
+     * Get the status of the artifact for given branched id
+     *
+     * @param branchedArtifactId branched id of the artifact
+     * @param isFileLock         if the locking is required, since the status API is used in the other flows of git
+     *                           Only for the direct hits from the client the locking will be added
+     * @param artifactType       Type of artifact in context
+     * @param gitType            Type of the service
+     * @return Map of json file names which are added, modified, conflicting, removed and the working tree if this is clean
+     */
+    private Mono<GitStatusDTO> getStatus(
+            String branchedArtifactId,
+            boolean isFileLock,
+            boolean compareRemote,
+            ArtifactType artifactType,
+            GitType gitType) {
+
+        Mono<Tuple2<? extends Artifact, ? extends Artifact>> baseAndBranchedArtifacts =
+                getBaseAndBranchedArtifacts(branchedArtifactId, artifactType);
+
+        return baseAndBranchedArtifacts.flatMap(artifactTuple -> {
+            Artifact baseArtifact = artifactTuple.getT1();
+            Artifact branchedArtifact = artifactTuple.getT2();
+            return getStatus(baseArtifact, branchedArtifact, isFileLock, compareRemote, gitType);
+        });
+    }
+
+    protected Mono<GitStatusDTO> getStatus(
+            Artifact baseArtifact,
+            Artifact branchedArtifact,
+            boolean isFileLock,
+            boolean compareRemote,
+            GitType gitType) {
+
+        ArtifactType artifactType = baseArtifact.getArtifactType();
+        GitArtifactHelper<?> gitArtifactHelper = gitArtifactHelperResolver.getArtifactHelper(artifactType);
+        GitHandlingService gitHandlingService = gitHandlingServiceResolver.getGitHandlingService(gitType);
+
+        GitArtifactMetadata baseGitMetadata = baseArtifact.getGitArtifactMetadata();
+        final String baseArtifactId = baseGitMetadata.getDefaultArtifactId();
+
+        GitArtifactMetadata branchedGitMetadata = branchedArtifact.getGitArtifactMetadata();
+        branchedGitMetadata.setGitAuth(baseGitMetadata.getGitAuth());
+
+        final String finalBranchName = branchedGitMetadata.getBranchName();
+
+        if (!StringUtils.hasText(finalBranchName)) {
+            return Mono.error(new AppsmithException(AppsmithError.INVALID_PARAMETER, FieldName.BRANCH_NAME));
+        }
+
+        Mono<? extends ArtifactExchangeJson> exportedArtifactJsonMono =
+                exportService.exportByArtifactId(branchedArtifact.getId(), VERSION_CONTROL, artifactType);
+
+        Mono<GitStatusDTO> statusMono = exportedArtifactJsonMono
+                .flatMap(artifactExchangeJson -> {
+                    return gitRedisUtils
+                            .acquireGitLock(baseArtifactId, GitConstants.GitCommandConstants.STATUS, isFileLock)
+                            .thenReturn(artifactExchangeJson);
+                })
+                .flatMap(artifactExchangeJson -> {
+                    ArtifactJsonTransformationDTO jsonTransformationDTO = new ArtifactJsonTransformationDTO();
+                    jsonTransformationDTO.setRefType(RefType.BRANCH);
+                    jsonTransformationDTO.setWorkspaceId(baseArtifact.getWorkspaceId());
+                    jsonTransformationDTO.setBaseArtifactId(baseArtifact.getId());
+                    jsonTransformationDTO.setRepoName(
+                            branchedArtifact.getGitArtifactMetadata().getRepoName());
+                    jsonTransformationDTO.setArtifactType(artifactExchangeJson.getArtifactJsonType());
+                    jsonTransformationDTO.setRefName(finalBranchName);
+
+                    Mono<Boolean> prepareForStatus =
+                            gitHandlingService.prepareChangesToBeCommitted(jsonTransformationDTO, artifactExchangeJson);
+                    Mono<String> fetchRemoteMono;
+
+                    if (compareRemote) {
+                        fetchRemoteMono = Mono.defer(
+                                () -> fetchRemoteChanges(baseArtifact, branchedArtifact, FALSE, gitType, RefType.BRANCH)
+                                        .onErrorResume(error -> Mono.error(new AppsmithException(
+                                                AppsmithError.GIT_GENERIC_ERROR, error.getMessage()))));
+                    } else {
+                        fetchRemoteMono = Mono.just("ignored");
+                    }
+
+                    return Mono.zip(prepareForStatus, fetchRemoteMono)
+                            .then(gitHandlingService.getStatus(jsonTransformationDTO));
+                })
+                .doFinally(signalType -> gitRedisUtils.releaseFileLock(baseArtifactId, isFileLock))
+                .onErrorResume(throwable -> {
+                    /*
+                     in case of any error, the global exception handler will release the lock
+                     hence we don't need to do that manually
+                    */
+                    log.error(
+                            "Error to get status for application: {}, branch: {}",
+                            baseArtifactId,
+                            finalBranchName,
+                            throwable);
+                    return Mono.error(new AppsmithException(AppsmithError.GIT_GENERIC_ERROR, throwable.getMessage()));
+                });
+
+        return Mono.zip(statusMono, sessionUserService.getCurrentUser())
+                .elapsed()
+                .flatMap(objects -> {
+                    Long elapsedTime = objects.getT1();
+                    GitStatusDTO gitStatusDTO = objects.getT2().getT1();
+                    User currentUser = objects.getT2().getT2();
+                    String flowName;
+                    if (compareRemote) {
+                        flowName = AnalyticsEvents.GIT_STATUS.getEventName();
+                    } else {
+                        flowName = AnalyticsEvents.GIT_STATUS_WITHOUT_FETCH.getEventName();
+                    }
+
+                    return gitAnalyticsUtils
+                            .sendUnitExecutionTimeAnalyticsEvent(flowName, elapsedTime, currentUser, branchedArtifact)
+                            .thenReturn(gitStatusDTO);
+                })
+                .name(OPS_STATUS)
+                .tap(Micrometer.observation(observationRegistry));
+    }
+
     public Mono<String> fetchRemoteChanges(
             Artifact baseArtifact, Artifact refArtifact, boolean isFileLock, GitType gitType, RefType refType) {
 
@@ -967,7 +1204,9 @@ public Mono<String> fetchRemoteChanges(
                 .then(Mono.defer(() ->
                         gitHandlingService.fetchRemoteChanges(jsonTransformationDTO, baseArtifactGitData.getGitAuth())))
                 .flatMap(fetchedRemoteStatusString -> {
-                    return gitRedisUtils.releaseFileLock(baseArtifactId).thenReturn(fetchedRemoteStatusString);
+                    return gitRedisUtils
+                            .releaseFileLock(baseArtifactId, isFileLock)
+                            .thenReturn(fetchedRemoteStatusString);
                 })
                 .onErrorResume(throwable -> {
                     /*

app/server/appsmith-server/src/main/java/com/appsmith/server/git/central/GitHandlingServiceCE.java

@@ -1,6 +1,8 @@
 package com.appsmith.server.git.central;
 
+import com.appsmith.external.dtos.GitStatusDTO;
 import com.appsmith.git.dto.CommitDTO;
+import com.appsmith.server.constants.ce.RefType;
 import com.appsmith.server.domains.Artifact;
 import com.appsmith.server.domains.GitArtifactMetadata;
 import com.appsmith.server.domains.GitAuth;
@@ -41,6 +43,8 @@ void setRepositoryDetailsInGitArtifactMetadata(
 
     Mono<List<String>> listBranches(ArtifactJsonTransformationDTO artifactJsonTransformationDTO);
 
+    Mono<List<String>> listReferences(ArtifactJsonTransformationDTO artifactJsonTransformationDTO, RefType refType);
+
     Mono<Boolean> validateEmptyRepository(ArtifactJsonTransformationDTO artifactJsonTransformationDTO);
 
     Mono<Boolean> initialiseReadMe(
@@ -51,6 +55,7 @@ Mono<Boolean> initialiseReadMe(
 
     Mono<String> createFirstCommit(ArtifactJsonTransformationDTO jsonTransformationDTO, CommitDTO commitDTO);
 
+    // TODO: provide a proper name
     Mono<Boolean> prepareChangesToBeCommitted(
             ArtifactJsonTransformationDTO jsonTransformationDTO, ArtifactExchangeJson artifactExchangeJson);
 
@@ -61,4 +66,6 @@ Mono<Tuple2<? extends Artifact, String>> commitArtifact(
 
     Mono<? extends ArtifactExchangeJson> recreateArtifactJsonFromLastCommit(
             ArtifactJsonTransformationDTO jsonTransformationDTO);
+
+    Mono<GitStatusDTO> getStatus(ArtifactJsonTransformationDTO jsonTransformationDTO);
 }