Example usage for org.eclipse.jgit.lib TagBuilder getTag

List of usage examples for org.eclipse.jgit.lib TagBuilder getTag

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.lib.*
  5. TagBuilder
  6. getTag

Introduction

In this page you can find the example usage for org.eclipse.jgit.lib TagBuilder getTag.

Prototype

public String getTag()

Source Link

Document

Get short name of the tag (no refs/tags/ prefix).

Usage

From source file:com.googlesource.gerrit.plugins.refprotection.BackupRef.java

License:Open Source License

public void createBackup(RefUpdatedEvent event, ProjectResource project) {
    String refName = event.getRefName();

    try (Repository git = repoManager.openRepository(project.getNameKey())) {
        String backupRef = get(project, refName);

        // No-op if the backup branch name is same as the original
        if (backupRef.equals(refName)) {
            return;
        }/*w ww.ja  v  a  2s. c o  m*/

        try (RevWalk revWalk = new RevWalk(git)) {
            RefUpdateAttribute refUpdate = event.refUpdate.get();
            if (cfg.getFromGerritConfig(pluginName).getBoolean("createTag", false)) {
                TagBuilder tag = new TagBuilder();
                AccountAttribute submitter = event.submitter.get();
                tag.setTagger(new PersonIdent(submitter.name, submitter.email));
                tag.setObjectId(revWalk.parseCommit(ObjectId.fromString(refUpdate.oldRev)));
                String update = "Non-fast-forward update to";
                if (refUpdate.newRev.equals(ObjectId.zeroId().getName())) {
                    update = "Deleted";
                }
                String type = "branch";
                String fullMessage = "";
                if (refUpdate.refName.startsWith(R_TAGS)) {
                    type = "tag";
                    try {
                        RevTag origTag = revWalk.parseTag(ObjectId.fromString(refUpdate.oldRev));
                        SimpleDateFormat format = new SimpleDateFormat("EEE MMM d HH:mm:ss yyyy ZZZZ");
                        PersonIdent taggerIdent = origTag.getTaggerIdent();
                        String tagger = String.format("Tagger: %s <%s>\nDate:   %s", taggerIdent.getName(),
                                taggerIdent.getEmailAddress(), format.format(taggerIdent.getWhen()));
                        fullMessage = "\n\nOriginal tag:\n" + tagger + "\n\n" + origTag.getFullMessage();
                    } catch (MissingObjectException e) {
                        log.warn("Original tag does not exist", e);
                    } catch (IncorrectObjectTypeException e) {
                        log.warn("Original tag was not a tag", e);
                    } catch (IOException e) {
                        log.warn("Unable to read original tag details", e);
                    }
                }
                tag.setMessage(update + " " + type + " " + refUpdate.refName + fullMessage);
                tag.setTag(backupRef);

                ObjectInserter inserter = git.newObjectInserter();
                ObjectId tagId = inserter.insert(tag);
                inserter.flush();
                RefUpdate tagRef = git.updateRef(tag.getTag());
                tagRef.setNewObjectId(tagId);
                tagRef.setRefLogMessage("tagged deleted branch/tag " + tag.getTag(), false);
                tagRef.setForceUpdate(false);
                Result result = tagRef.update();
                switch (result) {
                case NEW:
                case FORCED:
                    log.debug("Successfully created backup tag");
                    break;

                case LOCK_FAILURE:
                    log.error("Failed to lock repository while creating backup tag");
                    break;

                case REJECTED:
                    log.error("Tag already exists while creating backup tag");
                    break;

                default:
                    log.error("Unknown error while creating backup tag");
                }
            } else {
                BranchInput input = new BranchInput();
                input.ref = backupRef;
                // We need to parse the commit to ensure if it's a tag, we get the
                // commit the tag points to!
                input.revision = ObjectId
                        .toString(revWalk.parseCommit(ObjectId.fromString(refUpdate.oldRev)).getId());

                try {
                    createBranchFactory.create(backupRef).apply(project, input);
                } catch (BadRequestException | AuthException | ResourceConflictException | IOException e) {
                    log.error(e.getMessage(), e);
                }
            }
        }
    } catch (RepositoryNotFoundException e) {
        log.error("Repository does not exist", e);
    } catch (IOException e) {
        log.error("Could not open repository", e);
    }
}

From source file:org.commonjava.gitwrap.BareGitRepository.java

License:Open Source License

public BareGitRepository createTag(final String tagSource, final String tagName, final String message,
        final boolean force) throws GitWrapException {
    try {//from  ww  w. j  av a 2 s.  co  m
        final ObjectId src = repository.resolve(tagSource);
        if (src == null) {
            throw new GitWrapException("Cannot resolve tag-source: %s", tagSource);
        }

        if (!force && repository.resolve(tagName) != null) {
            throw new GitWrapException("Tag: %s already exists!", tagName);
        }

        String dest = tagName;
        if (!dest.startsWith(Constants.R_TAGS)) {
            dest = Constants.R_TAGS + tagName;
        }

        final String tagShort = dest.substring(Constants.R_TAGS.length());

        final ObjectLoader sourceLoader = repository.open(src);
        final ObjectInserter inserter = repository.newObjectInserter();

        final TagBuilder tag = new TagBuilder();
        tag.setTag(tagShort);
        tag.setTagger(new PersonIdent(repository));
        tag.setObjectId(src, sourceLoader.getType());
        tag.setMessage(message);

        final ObjectId tagId = inserter.insert(tag);
        tag.setTagId(tagId);

        final String refName = Constants.R_TAGS + tag.getTag();

        final RefUpdate tagRef = repository.updateRef(refName);
        tagRef.setNewObjectId(tag.getTagId());
        tagRef.setForceUpdate(force);
        tagRef.setRefLogMessage("Tagging source: " + src.name() + " as " + tagName, false);

        final Result updateResult = tagRef.update();

        switch (updateResult) {
        case NEW:
        case FAST_FORWARD:
        case FORCED: {
            break;
        }
        case REJECTED: {
            throw new GitWrapException("Tag already exists: %s", tagName);
        }
        default: {
            throw new GitWrapException("Cannot lock tag: %s", tagName);
        }
        }
    } catch (final IOException e) {
        throw new GitWrapException("Failed to add tag: %s", e, e.getMessage());
    }

    return this;
}

From source file:org.kuali.student.git.cleaner.AbstractRepositoryCleaner.java

License:Educational Community License

@Override
public final void execute() throws IOException {

    onBeforeExecute();/*www. j  av  a  2  s  .c  o  m*/

    inserter = getRepo().newObjectInserter();

    boolean localBranchSource = true;

    if (!getBranchRefSpec().equals(Constants.R_HEADS))
        localBranchSource = false;

    dateString = formatter.print(new DateTime());

    /*
     * Track the commits that are rewritten.
     * 
     * This is important so that we can update the grafts file to relate to
     * the current parent object ids.
     */
    PrintWriter objectTranslationWriter = new PrintWriter(
            "object-translations-" + getFileNameSuffix() + "-" + dateString + ".txt");

    branchHeads = getRepo().getRefDatabase().getRefs(getBranchRefSpec());

    commitToBranchMap = new HashMap<ObjectId, Set<Ref>>();

    walkRepo = new RevWalk(getRepo());

    for (Ref branchRef : branchHeads.values()) {

        ObjectId branchObjectId = branchRef.getObjectId();

        Set<Ref> refs = commitToBranchMap.get(branchObjectId);

        if (refs == null) {
            refs = new HashSet<>();
            commitToBranchMap.put(branchObjectId, refs);
        }

        refs.add(branchRef);

        walkRepo.markStart(walkRepo.parseCommit(branchObjectId));

        onBranchHead(branchRef, branchObjectId);

    }

    if (includeTagsInRevWalk()) {

        tagHeads = getRepo().getRefDatabase().getRefs(Constants.R_TAGS);
    } else {
        tagHeads = new HashMap<String, Ref>();
    }

    commitToTagMap = new HashMap<ObjectId, Set<Ref>>();

    for (Ref tagRef : tagHeads.values()) {

        RevTag tag = walkRepo.parseTag(tagRef.getObjectId());

        ObjectId commitId = tag.getObject().getId();

        Set<Ref> refs = commitToTagMap.get(commitId);

        if (refs == null) {
            refs = new HashSet<>();
            commitToTagMap.put(commitId, refs);
        }

        refs.add(tagRef);

        walkRepo.markStart(walkRepo.parseCommit(commitId));

        onTag(tag.getId(), commitId);
    }

    onBeforeRevWalk();

    walkRepo.sort(RevSort.TOPO, true);
    walkRepo.sort(RevSort.REVERSE, true);

    Iterator<RevCommit> it = provideRevCommitIterator(walkRepo.iterator());

    deferredReferenceDeletes = new LinkedList<>();
    deferredReferenceCreates = new LinkedList<>();

    objectTranslationWriter.println("# new-object-id <space> original-object-id");

    originalCommitIdToNewCommitIdMap = new HashMap<>();

    GitTreeProcessor treeProcessor = new GitTreeProcessor(getRepo());

    processedCommits = new HashSet<ObjectId>();

    while (it.hasNext()) {

        RevCommit commit = it.next();

        boolean recreateCommitByTranslatedParent = determineIfRecreateByTranslatedParent(commit);

        GitTreeData tree = treeProcessor.extractExistingTreeDataFromCommit(commit.getId());

        boolean recreate = processCommitTree(commit, tree);

        if (!recreateCommitByTranslatedParent && !recreate) {
            processedCommits.add(commit.getId());
            continue;
        }

        /*
         * Process in reverse order from old to new.
         */
        CommitBuilder builder = new CommitBuilder();

        builder.setAuthor(commit.getAuthorIdent());
        builder.setMessage(commit.getFullMessage());

        builder.setCommitter(commit.getCommitterIdent());

        if (tree.isTreeDirty()) {

            ObjectId newTreeId = tree.buildTree(inserter);

            builder.setTreeId(newTreeId);
        } else {
            builder.setTreeId(commit.getTree().getId());
        }

        builder.setEncoding("UTF-8");

        Set<ObjectId> newParents = processParents(commit);

        builder.setParentIds(new ArrayList<>(newParents));

        ObjectId newCommitId = inserter.insert(builder);

        onNewCommit(commit, newCommitId);

        originalCommitIdToNewCommitIdMap.put(commit.getId(), newCommitId);

        objectTranslationWriter.println(newCommitId.name() + " " + commit.getId().getName());

        RevWalk commitWalk = new RevWalk(getRepo());

        RevCommit newCommit = commitWalk.parseCommit(newCommitId);

        processedCommits.add(newCommitId);

        // check if any tags need to be moved
        if (commitToTagMap.containsKey(commit.getId())) {

            Set<Ref> tags = commitToTagMap.get(commit.getId());

            Set<TagBuilder> newTagSet = new HashSet<>();

            for (Ref tagRef : tags) {

                RevTag tag = commitWalk.parseTag(tagRef.getObjectId());

                TagBuilder tb = new TagBuilder();

                tb.setMessage(tag.getFullMessage());
                tb.setObjectId(newCommit);
                tb.setTag(tag.getTagName());
                tb.setTagger(tag.getTaggerIdent());

                newTagSet.add(tb);

                deferDelete(tagRef.getName(), tagRef.getObjectId());

            }

            for (TagBuilder tagBuilder : newTagSet) {

                ObjectId tagId = inserter.insert(tagBuilder);

                String tagName = Constants.R_TAGS + tagBuilder.getTag();

                deferCreate(tagName, tagId);

                onTagRefCreate(tagName, tagId);

            }

        }

        // check if any branches need to be moved
        if (commitToBranchMap.containsKey(commit.getId())) {

            Set<Ref> refs = commitToBranchMap.get(commit.getId());

            for (Ref branchRef : refs) {

                if (localBranchSource) {

                    deferDelete(branchRef.getName(), branchRef.getObjectId());

                }

                String adjustedBranchName = Constants.R_HEADS
                        + branchRef.getName().substring(getBranchRefSpec().length());

                deferCreate(adjustedBranchName, newCommitId);

                onBranchRefCreate(adjustedBranchName, newCommitId);

            }

        }

        commitWalk.release();
    }

    inserter.flush();

    getRepo().getRefDatabase().refresh();

    log.info("Applying updates: " + deferredReferenceDeletes.size() + " deletes, "
            + deferredReferenceCreates.size() + " creates.");

    if (getExternalGitCommandPath() != null) {
        ExternalGitUtils.batchRefUpdate(getExternalGitCommandPath(), getRepo(), deferredReferenceDeletes,
                System.out);
    } else {
        GitRefUtils.batchRefUpdate(getRepo(), deferredReferenceDeletes, NullProgressMonitor.INSTANCE);
    }

    getRepo().getRefDatabase().refresh();

    if (getExternalGitCommandPath() != null) {
        ExternalGitUtils.batchRefUpdate(getExternalGitCommandPath(), getRepo(), deferredReferenceCreates,
                System.out);
    } else {

        GitRefUtils.batchRefUpdate(getRepo(), deferredReferenceCreates, NullProgressMonitor.INSTANCE);

    }

    log.info("Completed.");

    walkRepo.release();

    inserter.release();

    close();

    objectTranslationWriter.close();

}