Examples with MergeScenarioReport org.locationtech.geogig.api.plumbing.merge.MergeScenarioReport used on opensource projects

Example 16 with MergeScenarioReport

use of org.locationtech.geogig.api.plumbing.merge.MergeScenarioReport in project GeoGig by boundlessgeo.

the class RevertFeatureWebOp method run.

/**
     * Runs the command and builds the appropriate response
     * 
     * @param context - the context to use for this command
     * 
     * @throws CommandSpecException
     */
@Override
public void run(CommandContext context) {
    if (this.getTransactionId() == null) {
        throw new CommandSpecException("No transaction was specified, revert feature requires a transaction to preserve the stability of the repository.");
    }
    final Context geogig = this.getCommandLocator(context);
    Optional<RevTree> newTree = Optional.absent();
    Optional<RevTree> oldTree = Optional.absent();
    // get tree from new commit
    Optional<ObjectId> treeId = geogig.command(ResolveTreeish.class).setTreeish(newCommitId).call();
    Preconditions.checkState(treeId.isPresent(), "New commit id did not resolve to a valid tree.");
    newTree = geogig.command(RevObjectParse.class).setRefSpec(treeId.get().toString()).call(RevTree.class);
    Preconditions.checkState(newTree.isPresent(), "Unable to read the new commit tree.");
    // get tree from old commit
    treeId = geogig.command(ResolveTreeish.class).setTreeish(oldCommitId).call();
    Preconditions.checkState(treeId.isPresent(), "Old commit id did not resolve to a valid tree.");
    oldTree = geogig.command(RevObjectParse.class).setRefSpec(treeId.get().toString()).call(RevTree.class);
    Preconditions.checkState(newTree.isPresent(), "Unable to read the old commit tree.");
    // get feature from old tree
    Optional<NodeRef> node = geogig.command(FindTreeChild.class).setParent(oldTree.get()).setIndex(true).setChildPath(featurePath).call();
    boolean delete = false;
    if (!node.isPresent()) {
        delete = true;
        node = geogig.command(FindTreeChild.class).setParent(newTree.get()).setIndex(true).setChildPath(featurePath).call();
        Preconditions.checkState(node.isPresent(), "The feature was not found in either commit tree.");
    }
    // get the new parent tree
    ObjectId metadataId = ObjectId.NULL;
    Optional<NodeRef> parentNode = geogig.command(FindTreeChild.class).setParent(newTree.get()).setChildPath(node.get().getParentPath()).setIndex(true).call();
    RevTreeBuilder treeBuilder = null;
    if (parentNode.isPresent()) {
        metadataId = parentNode.get().getMetadataId();
        Optional<RevTree> parsed = geogig.command(RevObjectParse.class).setObjectId(parentNode.get().getNode().getObjectId()).call(RevTree.class);
        checkState(parsed.isPresent(), "Parent tree couldn't be found in the repository.");
        treeBuilder = new RevTreeBuilder(geogig.stagingDatabase(), parsed.get());
        treeBuilder.remove(node.get().getNode().getName());
    } else {
        treeBuilder = new RevTreeBuilder(geogig.stagingDatabase());
    }
    // put the old feature into the new tree
    if (!delete) {
        treeBuilder.put(node.get().getNode());
    }
    ObjectId newTreeId = geogig.command(WriteBack.class).setAncestor(newTree.get().builder(geogig.stagingDatabase())).setChildPath(node.get().getParentPath()).setToIndex(true).setTree(treeBuilder.build()).setMetadataId(metadataId).call();
    // build new commit with parent of new commit and the newly built tree
    CommitBuilder builder = new CommitBuilder();
    builder.setParentIds(Lists.newArrayList(newCommitId));
    builder.setTreeId(newTreeId);
    builder.setAuthor(authorName.orNull());
    builder.setAuthorEmail(authorEmail.orNull());
    builder.setMessage(commitMessage.or("Reverted changes made to " + featurePath + " at " + newCommitId.toString()));
    RevCommit mapped = builder.build();
    context.getGeoGIG().getRepository().objectDatabase().put(mapped);
    // merge commit into current branch
    final Optional<Ref> currHead = geogig.command(RefParse.class).setName(Ref.HEAD).call();
    if (!currHead.isPresent()) {
        throw new CommandSpecException("Repository has no HEAD, can't merge.");
    }
    MergeOp merge = geogig.command(MergeOp.class);
    merge.setAuthor(authorName.orNull(), authorEmail.orNull());
    merge.addCommit(Suppliers.ofInstance(mapped.getId()));
    merge.setMessage(mergeMessage.or("Merged revert of " + featurePath));
    try {
        final MergeReport report = merge.call();
        context.setResponseContent(new CommandResponse() {

            @Override
            public void write(ResponseWriter out) throws Exception {
                out.start();
                out.writeMergeResponse(Optional.fromNullable(report.getMergeCommit()), report.getReport().get(), geogig, report.getOurs(), report.getPairs().get(0).getTheirs(), report.getPairs().get(0).getAncestor());
                out.finish();
            }
        });
    } catch (Exception e) {
        final RevCommit ours = context.getGeoGIG().getRepository().getCommit(currHead.get().getObjectId());
        final RevCommit theirs = context.getGeoGIG().getRepository().getCommit(mapped.getId());
        final Optional<ObjectId> ancestor = geogig.command(FindCommonAncestor.class).setLeft(ours).setRight(theirs).call();
        context.setResponseContent(new CommandResponse() {

            final MergeScenarioReport report = geogig.command(ReportMergeScenarioOp.class).setMergeIntoCommit(ours).setToMergeCommit(theirs).call();

            @Override
            public void write(ResponseWriter out) throws Exception {
                out.start();
                Optional<RevCommit> mergeCommit = Optional.absent();
                out.writeMergeResponse(mergeCommit, report, geogig, ours.getId(), theirs.getId(), ancestor.get());
                out.finish();
            }
        });
    }
}

Example 17 with MergeScenarioReport

use of org.locationtech.geogig.api.plumbing.merge.MergeScenarioReport in project GeoGig by boundlessgeo.

the class MergeOp method _call.

/**
     * Executes the merge operation.
     * 
     * @return always {@code true}
     */
@Override
protected MergeReport _call() throws RuntimeException {
    Preconditions.checkArgument(commits.size() > 0, "No commits specified for merge.");
    Preconditions.checkArgument(!(ours && theirs), "Cannot use both --ours and --theirs.");
    final Optional<Ref> currHead = command(RefParse.class).setName(Ref.HEAD).call();
    Preconditions.checkState(currHead.isPresent(), "Repository has no HEAD, can't rebase.");
    Ref headRef = currHead.get();
    ObjectId oursId = headRef.getObjectId();
    // Preconditions.checkState(currHead.get() instanceof SymRef,
    // "Can't rebase from detached HEAD");
    // SymRef headRef = (SymRef) currHead.get();
    // final String currentBranch = headRef.getTarget();
    getProgressListener().started();
    boolean fastForward = true;
    boolean changed = false;
    Optional<MergeScenarioReport> mergeScenario = Optional.absent();
    List<CommitAncestorPair> pairs = Lists.newArrayList();
    boolean hasConflictsOrAutomerge;
    List<RevCommit> revCommits = Lists.newArrayList();
    if (!ObjectId.NULL.equals(headRef.getObjectId())) {
        revCommits.add(repository().getCommit(headRef.getObjectId()));
    }
    for (ObjectId commitId : commits) {
        revCommits.add(repository().getCommit(commitId));
    }
    hasConflictsOrAutomerge = command(CheckMergeScenarioOp.class).setCommits(revCommits).call().booleanValue();
    if (hasConflictsOrAutomerge && !theirs) {
        Preconditions.checkState(commits.size() < 2, "Conflicted merge.\nCannot merge more than two commits when conflicts exist" + " or features have been modified in several histories");
        RevCommit headCommit = repository().getCommit(headRef.getObjectId());
        ObjectId commitId = commits.get(0);
        Preconditions.checkArgument(!ObjectId.NULL.equals(commitId), "Cannot merge a NULL commit.");
        Preconditions.checkArgument(repository().commitExists(commitId), "Not a valid commit: " + commitId.toString());
        final RevCommit targetCommit = repository().getCommit(commitId);
        Optional<ObjectId> ancestorCommit = command(FindCommonAncestor.class).setLeft(headCommit).setRight(targetCommit).call();
        pairs.add(new CommitAncestorPair(commitId, ancestorCommit.get()));
        mergeScenario = Optional.of(command(ReportMergeScenarioOp.class).setMergeIntoCommit(headCommit).setToMergeCommit(targetCommit).call());
        List<FeatureInfo> merged = mergeScenario.get().getMerged();
        for (FeatureInfo feature : merged) {
            this.workingTree().insert(NodeRef.parentPath(feature.getPath()), feature.getFeature());
            Iterator<DiffEntry> unstaged = workingTree().getUnstaged(null);
            index().stage(getProgressListener(), unstaged, 0);
            changed = true;
            fastForward = false;
        }
        List<DiffEntry> unconflicting = mergeScenario.get().getUnconflicted();
        if (!unconflicting.isEmpty()) {
            index().stage(getProgressListener(), unconflicting.iterator(), 0);
            changed = true;
            fastForward = false;
        }
        workingTree().updateWorkHead(index().getTree().getId());
        List<Conflict> conflicts = mergeScenario.get().getConflicts();
        if (!ours && !conflicts.isEmpty()) {
            // In case we use the "ours" strategy, we do nothing. We ignore conflicting
            // changes and leave the current elements
            command(UpdateRef.class).setName(Ref.MERGE_HEAD).setNewValue(commitId).call();
            command(UpdateRef.class).setName(Ref.ORIG_HEAD).setNewValue(headCommit.getId()).call();
            command(ConflictsWriteOp.class).setConflicts(conflicts).call();
            StringBuilder msg = new StringBuilder();
            Optional<Ref> ref = command(ResolveBranchId.class).setObjectId(commitId).call();
            if (ref.isPresent()) {
                msg.append("Merge branch " + ref.get().getName());
            } else {
                msg.append("Merge commit '" + commitId.toString() + "'. ");
            }
            msg.append("\n\nConflicts:\n");
            for (Conflict conflict : mergeScenario.get().getConflicts()) {
                msg.append("\t" + conflict.getPath() + "\n");
            }
            command(SaveMergeCommitMessageOp.class).setMessage(msg.toString()).call();
            StringBuilder sb = new StringBuilder();
            for (Conflict conflict : conflicts) {
                sb.append("CONFLICT: Merge conflict in " + conflict.getPath() + "\n");
            }
            sb.append("Automatic merge failed. Fix conflicts and then commit the result.\n");
            throw new MergeConflictsException(sb.toString(), headCommit.getId(), commitId);
        }
    } else {
        Preconditions.checkState(!hasConflictsOrAutomerge || commits.size() < 2, "Conflicted merge.\nCannot merge more than two commits when conflicts exist" + " or features have been modified in several histories");
        for (ObjectId commitId : commits) {
            ProgressListener subProgress = subProgress(100.f / commits.size());
            Preconditions.checkArgument(!ObjectId.NULL.equals(commitId), "Cannot merge a NULL commit.");
            Preconditions.checkArgument(repository().commitExists(commitId), "Not a valid commit: " + commitId.toString());
            subProgress.started();
            if (ObjectId.NULL.equals(headRef.getObjectId())) {
                // Fast-forward
                if (headRef instanceof SymRef) {
                    final String currentBranch = ((SymRef) headRef).getTarget();
                    command(UpdateRef.class).setName(currentBranch).setNewValue(commitId).call();
                    headRef = (SymRef) command(UpdateSymRef.class).setName(Ref.HEAD).setNewValue(currentBranch).call().get();
                } else {
                    headRef = command(UpdateRef.class).setName(headRef.getName()).setNewValue(commitId).call().get();
                }
                workingTree().updateWorkHead(commitId);
                index().updateStageHead(commitId);
                subProgress.complete();
                changed = true;
                continue;
            }
            RevCommit headCommit = repository().getCommit(headRef.getObjectId());
            final RevCommit targetCommit = repository().getCommit(commitId);
            Optional<ObjectId> ancestorCommit = command(FindCommonAncestor.class).setLeft(headCommit).setRight(targetCommit).call();
            pairs.add(new CommitAncestorPair(commitId, ancestorCommit.get()));
            subProgress.setProgress(10.f);
            Preconditions.checkState(ancestorCommit.isPresent(), "No ancestor commit could be found.");
            if (commits.size() == 1) {
                mergeScenario = Optional.of(command(ReportMergeScenarioOp.class).setMergeIntoCommit(headCommit).setToMergeCommit(targetCommit).call());
                if (ancestorCommit.get().equals(headCommit.getId())) {
                    // Fast-forward
                    if (headRef instanceof SymRef) {
                        final String currentBranch = ((SymRef) headRef).getTarget();
                        command(UpdateRef.class).setName(currentBranch).setNewValue(commitId).call();
                        headRef = (SymRef) command(UpdateSymRef.class).setName(Ref.HEAD).setNewValue(currentBranch).call().get();
                    } else {
                        headRef = command(UpdateRef.class).setName(headRef.getName()).setNewValue(commitId).call().get();
                    }
                    workingTree().updateWorkHead(commitId);
                    index().updateStageHead(commitId);
                    subProgress.complete();
                    changed = true;
                    continue;
                } else if (ancestorCommit.get().equals(commitId)) {
                    continue;
                }
            }
            // get changes
            Iterator<DiffEntry> diff = command(DiffTree.class).setOldTree(ancestorCommit.get()).setNewTree(targetCommit.getId()).setReportTrees(true).call();
            // stage changes
            index().stage(new SubProgressListener(subProgress, 100.f), diff, 0);
            changed = true;
            fastForward = false;
            workingTree().updateWorkHead(index().getTree().getId());
            subProgress.complete();
        }
    }
    if (!changed) {
        throw new NothingToCommitException("The branch has already been merged.");
    }
    RevCommit mergeCommit = commit(fastForward);
    MergeReport result = new MergeReport(mergeCommit, mergeScenario, oursId, pairs);
    return result;
}

Example 18 with MergeScenarioReport

use of org.locationtech.geogig.api.plumbing.merge.MergeScenarioReport in project GeoGig by boundlessgeo.

the class RebaseOp method applyCommit.

/**
     * Applies the passed command.
     * 
     * @param commitToApply the commit to apply
     * @param useCommitChanges if true, applies the command completely, staging its changes before
     *        committing. If false, it commits the currently staged changes, ignoring the changes in
     *        the commit and using just its author and message
     */
private void applyCommit(RevCommit commitToApply, boolean useCommitChanges) {
    Repository repository = repository();
    Platform platform = platform();
    if (useCommitChanges) {
        ObjectId parentTreeId;
        ObjectId parentCommitId = ObjectId.NULL;
        if (commitToApply.getParentIds().size() > 0) {
            parentCommitId = commitToApply.getParentIds().get(0);
        }
        parentTreeId = ObjectId.NULL;
        if (repository.commitExists(parentCommitId)) {
            parentTreeId = repository.getCommit(parentCommitId).getTreeId();
        }
        // get changes
        Iterator<DiffEntry> diff = command(DiffTree.class).setOldTree(parentTreeId).setNewTree(commitToApply.getTreeId()).setReportTrees(true).call();
        // see if there are conflicts
        MergeScenarioReport report = command(ReportCommitConflictsOp.class).setCommit(commitToApply).call();
        if (report.getConflicts().isEmpty()) {
            // stage changes
            index().stage(getProgressListener(), diff, 0);
            // write new tree
            ObjectId newTreeId = command(WriteTree2.class).call();
            long timestamp = platform.currentTimeMillis();
            // Create new commit
            CommitBuilder builder = new CommitBuilder(commitToApply);
            builder.setParentIds(Arrays.asList(rebaseHead));
            builder.setTreeId(newTreeId);
            builder.setCommitterTimestamp(timestamp);
            builder.setCommitterTimeZoneOffset(platform.timeZoneOffset(timestamp));
            RevCommit newCommit = builder.build();
            repository.objectDatabase().put(newCommit);
            rebaseHead = newCommit.getId();
            command(UpdateRef.class).setName(currentBranch).setNewValue(rebaseHead).call();
            command(UpdateSymRef.class).setName(Ref.HEAD).setNewValue(currentBranch).call();
            workingTree().updateWorkHead(newTreeId);
            index().updateStageHead(newTreeId);
        } else {
            Iterator<DiffEntry> unconflicted = report.getUnconflicted().iterator();
            // stage unconflicted changes
            index().stage(getProgressListener(), unconflicted, 0);
            workingTree().updateWorkHead(index().getTree().getId());
            // mark conflicted elements
            command(ConflictsWriteOp.class).setConflicts(report.getConflicts()).call();
            // created exception message
            StringBuilder msg = new StringBuilder();
            msg.append("error: could not apply ");
            msg.append(commitToApply.getId().toString().substring(0, 7));
            msg.append(" " + commitToApply.getMessage() + "\n");
            for (Conflict conflict : report.getConflicts()) {
                msg.append("CONFLICT: conflict in " + conflict.getPath() + "\n");
            }
            File branchFile = new File(getRebaseFolder(), "branch");
            try {
                Files.write(currentBranch, branchFile, Charsets.UTF_8);
            } catch (IOException e) {
                throw new IllegalStateException("Cannot create current branch info file");
            }
            throw new RebaseConflictsException(msg.toString());
        }
    } else {
        // write new tree
        ObjectId newTreeId = command(WriteTree2.class).call();
        long timestamp = platform.currentTimeMillis();
        // Create new commit
        CommitBuilder builder = new CommitBuilder(commitToApply);
        builder.setParentIds(Arrays.asList(rebaseHead));
        builder.setTreeId(newTreeId);
        builder.setCommitterTimestamp(timestamp);
        builder.setCommitterTimeZoneOffset(platform.timeZoneOffset(timestamp));
        RevCommit newCommit = builder.build();
        repository.objectDatabase().put(newCommit);
        rebaseHead = newCommit.getId();
        command(UpdateRef.class).setName(currentBranch).setNewValue(rebaseHead).call();
        command(UpdateSymRef.class).setName(Ref.HEAD).setNewValue(currentBranch).call();
        workingTree().updateWorkHead(newTreeId);
        index().updateStageHead(newTreeId);
    }
}

Example 19 with MergeScenarioReport

use of org.locationtech.geogig.api.plumbing.merge.MergeScenarioReport in project GeoGig by boundlessgeo.

the class CherryPickOp method _call.

/**
     * Executes the cherry pick operation.
     * 
     * @return RevCommit the new commit with the changes from the cherry-picked commit
     */
@Override
protected RevCommit _call() {
    final Repository repository = repository();
    final Optional<Ref> currHead = command(RefParse.class).setName(Ref.HEAD).call();
    Preconditions.checkState(currHead.isPresent(), "Repository has no HEAD, can't cherry pick.");
    Preconditions.checkState(currHead.get() instanceof SymRef, "Can't cherry pick from detached HEAD");
    final SymRef headRef = (SymRef) currHead.get();
    Preconditions.checkState(index().isClean() && workingTree().isClean(), "You must have a clean working tree and index to perform a cherry pick.");
    getProgressListener().started();
    Preconditions.checkArgument(repository.commitExists(commit), "Commit could not be resolved: %s.", commit);
    RevCommit commitToApply = repository.getCommit(commit);
    ObjectId headId = headRef.getObjectId();
    ObjectId parentCommitId = ObjectId.NULL;
    if (commitToApply.getParentIds().size() > 0) {
        parentCommitId = commitToApply.getParentIds().get(0);
    }
    ObjectId parentTreeId = ObjectId.NULL;
    if (repository.commitExists(parentCommitId)) {
        parentTreeId = repository.getCommit(parentCommitId).getTreeId();
    }
    // get changes
    Iterator<DiffEntry> diff = command(DiffTree.class).setOldTree(parentTreeId).setNewTree(commitToApply.getTreeId()).setReportTrees(true).call();
    // see if there are conflicts
    MergeScenarioReport report = command(ReportCommitConflictsOp.class).setCommit(commitToApply).call();
    if (report.getConflicts().isEmpty()) {
        // stage changes
        index().stage(getProgressListener(), diff, 0);
        // write new tree
        ObjectId newTreeId = command(WriteTree2.class).call();
        RevCommit newCommit = command(CommitOp.class).setCommit(commitToApply).call();
        repository.workingTree().updateWorkHead(newTreeId);
        repository.index().updateStageHead(newTreeId);
        getProgressListener().complete();
        return newCommit;
    } else {
        Iterator<DiffEntry> unconflicted = report.getUnconflicted().iterator();
        // stage changes
        index().stage(getProgressListener(), unconflicted, 0);
        workingTree().updateWorkHead(index().getTree().getId());
        command(UpdateRef.class).setName(Ref.CHERRY_PICK_HEAD).setNewValue(commit).call();
        command(UpdateRef.class).setName(Ref.ORIG_HEAD).setNewValue(headId).call();
        command(ConflictsWriteOp.class).setConflicts(report.getConflicts()).call();
        StringBuilder msg = new StringBuilder();
        msg.append("error: could not apply ");
        msg.append(commitToApply.getId().toString().substring(0, 7));
        msg.append(" " + commitToApply.getMessage());
        for (Conflict conflict : report.getConflicts()) {
            msg.append("\t" + conflict.getPath() + "\n");
        }
        StringBuilder sb = new StringBuilder();
        for (Conflict conflict : report.getConflicts()) {
            sb.append("CONFLICT: conflict in " + conflict.getPath() + "\n");
        }
        sb.append("Fix conflicts and then commit the result using 'geogig commit -c " + commitToApply.getId().toString().substring(0, 7) + "\n");
        throw new IllegalStateException(sb.toString());
    }
}

Example 20 with MergeScenarioReport

use of org.locationtech.geogig.api.plumbing.merge.MergeScenarioReport in project GeoGig by boundlessgeo.

the class ReportMergeConflictsOpTest method testRemovedSameFeature.

@Test
public void testRemovedSameFeature() throws Exception {
    insertAndAdd(points1);
    geogig.command(CommitOp.class).call();
    geogig.command(BranchCreateOp.class).setName("TestBranch").call();
    deleteAndAdd(points1);
    RevCommit masterCommit = geogig.command(CommitOp.class).call();
    geogig.command(CheckoutOp.class).setSource("TestBranch").call();
    deleteAndAdd(points1);
    RevCommit branchCommit = geogig.command(CommitOp.class).call();
    MergeScenarioReport conflicts = geogig.command(ReportMergeScenarioOp.class).setMergeIntoCommit(masterCommit).setToMergeCommit(branchCommit).call();
    assertEquals(0, conflicts.getConflicts().size());
    assertEquals(0, conflicts.getUnconflicted().size());
    Boolean hasConflicts = geogig.command(CheckMergeScenarioOp.class).setCommits(Lists.newArrayList(masterCommit, branchCommit)).call();
    assertFalse(hasConflicts.booleanValue());
}