Example usage for org.eclipse.jgit.revwalk RevTag getTaggerIdent

List of usage examples for org.eclipse.jgit.revwalk RevTag getTaggerIdent

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.revwalk.*
  5. RevTag
  6. getTaggerIdent

Introduction

In this page you can find the example usage for org.eclipse.jgit.revwalk RevTag getTaggerIdent.

Prototype

public final PersonIdent getTaggerIdent()

Source Link

Document

Parse the tagger identity from the raw buffer.

Usage

From source file:br.uff.ic.oceano.core.tools.vcs.RefModel.java

License:Apache License

public Date getDate() {
    Date date = new Date(0);
    if (referencedObject != null) {
        if (referencedObject instanceof RevTag) {
            RevTag tag = (RevTag) referencedObject;
            if (tag.getTaggerIdent() != null) {
                date = tag.getTaggerIdent().getWhen();
            }//  w  w  w . j av a 2 s.  c o  m
        } else if (referencedObject instanceof RevCommit) {
            date = ((RevCommit) referencedObject).getCommitterIdent().getWhen();
        }
    }
    return date;
}

From source file:com.gitblit.models.RefModel.java

License:Apache License

public Date getDate() {
    Date date = new Date(0);
    if (referencedObject != null) {
        if (referencedObject instanceof RevTag) {
            RevTag tag = (RevTag) referencedObject;
            PersonIdent tagger = tag.getTaggerIdent();
            if (tagger != null) {
                date = tagger.getWhen();
            }/* ww  w . jav a  2s.co m*/
        } else if (referencedObject instanceof RevCommit) {
            RevCommit commit = (RevCommit) referencedObject;
            date = JGitUtils.getAuthorDate(commit);
        }
    }
    return date;
}

From source file:com.google.gerrit.acceptance.git.SubmitOnPushIT.java

License:Apache License

private void assertTag(Project.NameKey project, String branch, PushOneCommit.Tag tag) throws IOException {
    try (Repository repo = repoManager.openRepository(project)) {
        Ref tagRef = repo.getRef(tag.name);
        assertThat(tagRef).isNotNull();// w  w  w  .  ja  va2 s . com
        ObjectId taggedCommit = null;
        if (tag instanceof PushOneCommit.AnnotatedTag) {
            PushOneCommit.AnnotatedTag annotatedTag = (PushOneCommit.AnnotatedTag) tag;
            try (RevWalk rw = new RevWalk(repo)) {
                RevObject object = rw.parseAny(tagRef.getObjectId());
                assertThat(object).isInstanceOf(RevTag.class);
                RevTag tagObject = (RevTag) object;
                assertThat(tagObject.getFullMessage()).isEqualTo(annotatedTag.message);
                assertThat(tagObject.getTaggerIdent()).isEqualTo(annotatedTag.tagger);
                taggedCommit = tagObject.getObject();
            }
        } else {
            taggedCommit = tagRef.getObjectId();
        }
        ObjectId headCommit = repo.getRef(branch).getObjectId();
        assertThat(taggedCommit).isNotNull();
        assertThat(taggedCommit).isEqualTo(headCommit);
    }
}

From source file:com.google.gerrit.server.project.ListTags.java

License:Apache License

private static TagInfo createTagInfo(Ref ref, RevWalk rw) throws MissingObjectException, IOException {
    RevObject object = rw.parseAny(ref.getObjectId());
    if (object instanceof RevTag) {
        RevTag tag = (RevTag) object;
        // Annotated or signed tag
        return new TagInfo(Constants.R_TAGS + tag.getTagName(), tag.getName(), tag.getObject().getName(),
                tag.getFullMessage().trim(), CommonConverters.toGitPerson(tag.getTaggerIdent()));
    } else {//from   www . j  ava 2  s  .c  o  m
        // Lightweight tag
        return new TagInfo(ref.getName(), ref.getObjectId().getName());
    }
}

From source file:com.google.gerrit.server.project.RefControl.java

License:Apache License

/**
 * Determines whether the user can create a new Git ref.
 *
 * @param db db for checking change visibility.
 * @param rw revision pool {@code object} was parsed in; must be reset before
 *     calling this method./*from ww w  .  j av a2 s. c  om*/
 * @param object the object the user will start the reference with.
 * @return {@code true} if the user specified can create a new Git ref
 */
public boolean canCreate(ReviewDb db, RevWalk rw, RevObject object) {
    if (!canWrite()) {
        return false;
    }
    boolean owner;
    boolean admin;
    switch (getCurrentUser().getAccessPath()) {
    case REST_API:
    case JSON_RPC:
    case UNKNOWN:
        owner = isOwner();
        admin = getCurrentUser().getCapabilities().canAdministrateServer();
        break;

    default:
        owner = false;
        admin = false;
    }

    if (object instanceof RevCommit) {
        if (admin || (owner && !isBlocked(Permission.CREATE))) {
            // Admin or project owner; bypass visibility check.
            return true;
        } else if (!canPerform(Permission.CREATE)) {
            // No create permissions.
            return false;
        } else if (canUpdate()) {
            // If the user has push permissions, they can create the ref regardless
            // of whether they are pushing any new objects along with the create.
            return true;
        } else if (isMergedIntoBranchOrTag(db, rw, (RevCommit) object)) {
            // If the user has no push permissions, check whether the object is
            // merged into a branch or tag readable by this user. If so, they are
            // not effectively "pushing" more objects, so they can create the ref
            // even if they don't have push permission.
            return true;
        }
        return false;
    } else if (object instanceof RevTag) {
        final RevTag tag = (RevTag) object;
        try {
            rw.parseBody(tag);
        } catch (IOException e) {
            return false;
        }

        // If tagger is present, require it matches the user's email.
        //
        final PersonIdent tagger = tag.getTaggerIdent();
        if (tagger != null) {
            boolean valid;
            if (getCurrentUser().isIdentifiedUser()) {
                final IdentifiedUser user = (IdentifiedUser) getCurrentUser();
                final String addr = tagger.getEmailAddress();
                valid = user.hasEmailAddress(addr);
            } else {
                valid = false;
            }
            if (!valid && !owner && !canForgeCommitter()) {
                return false;
            }
        }

        // If the tag has a PGP signature, allow a lower level of permission
        // than if it doesn't have a PGP signature.
        //
        if (tag.getFullMessage().contains("-----BEGIN PGP SIGNATURE-----\n")) {
            return owner || canPerform(Permission.PUSH_SIGNED_TAG);
        } else {
            return owner || canPerform(Permission.PUSH_TAG);
        }
    } else {
        return false;
    }
}

From source file:com.google.gitiles.TagSoyData.java

License:Open Source License

public Map<String, Object> toSoyData(RevTag tag) {
    Map<String, Object> data = Maps.newHashMapWithExpectedSize(4);
    data.put("sha", ObjectId.toString(tag));
    if (tag.getTaggerIdent() != null) {
        data.put("tagger", CommitSoyData.toSoyData(tag.getTaggerIdent(), dateFormatter));
    }//  w  w  w.ja v  a 2  s  .c o  m
    data.put("object", ObjectId.toString(tag.getObject()));
    data.put("message", linkifier.linkify(req, tag.getFullMessage()));
    return data;
}

From source file:com.google.gitiles.TimeCache.java

License:Open Source License

Long getTime(final RevWalk walk, final ObjectId id) throws IOException {
    try {//from   w  w  w .  jav  a2s. c  o  m
        return cache.get(id, new Callable<Long>() {
            @Override
            public Long call() throws IOException {
                RevObject o = walk.parseAny(id);
                while (o instanceof RevTag) {
                    RevTag tag = (RevTag) o;
                    PersonIdent ident = tag.getTaggerIdent();
                    if (ident != null) {
                        return ident.getWhen().getTime() / 1000;
                    }
                    o = tag.getObject();
                    walk.parseHeaders(o);
                }
                if (o.getType() == Constants.OBJ_COMMIT) {
                    return Long.valueOf(((RevCommit) o).getCommitTime());
                }
                return Long.MIN_VALUE;
            }
        });
    } catch (ExecutionException e) {
        Throwables.propagateIfInstanceOf(e.getCause(), IOException.class);
        throw new IOException(e);
    }
}

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;
        }//ww w  .  jav  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:com.madgag.agit.views.TagSummaryView.java

License:Open Source License

public void setObject(RevTag tag, View view, Repository repo) {
    ((PersonIdentView) view.findViewById(tagger_ident)).setIdent("Tagger", tag.getTaggerIdent());
    ((TextView) view.findViewById(message_text)).setText(tag.getFullMessage());
    try {//  w  ww . j  a  v a 2 s  .c o m
        RevObject taggedObject = new RevWalk(repo).parseAny(tag.getObject());
        ((ObjectSummaryView) view.findViewById(tagged_object)).setObject(taggedObject);
        Log.d(TAG, "Successfully set taggedObject=" + taggedObject);
    } catch (IOException e) {
        Log.e(TAG, "Couldn't set the tagged object...", e);
        e.printStackTrace();
    }
}

From source file:jetbrains.buildServer.buildTriggers.vcs.git.tests.GitLabelingSupportTest.java

License:Apache License

@Test
public void tag_with_specified_username() throws Exception {
    VcsRoot root = vcsRoot().withFetchUrl(GitUtils.toURL(getRemoteRepositoryDir("repo.git")))
            .withUsernameForTags("John Doe <john.doe@some.org>").build();
    buildGit().getLabelingSupport().label("label_with_specified_username",
            "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", root, CheckoutRules.DEFAULT);

    Repository r = new RepositoryBuilder().setGitDir(getRemoteRepositoryDir("repo.git")).build();
    RevWalk revWalk = new RevWalk(r);
    try {//from   w w  w.j  av  a2 s. co m
        Ref tagRef = r.getTags().get("label_with_specified_username");
        RevTag t = revWalk.parseTag(tagRef.getObjectId());
        PersonIdent tagger = t.getTaggerIdent();
        assertEquals(tagger.getName(), "John Doe");
        assertEquals(tagger.getEmailAddress(), "john.doe@some.org");
    } finally {
        revWalk.release();
        r.close();
    }
}