Example usage for org.eclipse.jgit.lib Repository newObjectInserter

List of usage examples for org.eclipse.jgit.lib Repository newObjectInserter

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.lib.*
  5. Repository
  6. newObjectInserter

Introduction

In this page you can find the example usage for org.eclipse.jgit.lib Repository newObjectInserter.

Prototype

@NonNull
public ObjectInserter newObjectInserter()

Source Link

Document

Create a new inserter to create objects in #getObjectDatabase() .

Usage

From source file:com.googlesource.gerrit.plugins.changefabricator.ChangeFabricator.java

License:Apache License

@Override
public Response<String> apply(ProjectResource rsrc, Input input)
        throws AuthException, OrmException, InvalidChangeOperationException, IOException {
    String ref = input.ref;/*from  w ww  .j  a  va 2  s. c o m*/
    String msg = input.msg;
    if (Strings.isNullOrEmpty(ref)) {
        throw new InvalidChangeOperationException("Change baker: Destination branch cannot be null or empty");
    }

    if (Strings.isNullOrEmpty(msg)) {
        throw new InvalidChangeOperationException("Change baker: Commit message cannot be null or empty");
    }

    if (!userProvider.get().isIdentifiedUser()) {
        throw new AuthException("User must be authenticated to create a change");
    }

    RefControl refControl = rsrc.getControl().controlForRef(ref);
    if (!refControl.canUpload()) {
        throw new AuthException(String.format("Not allowed to create a change to %s", ref));
    }

    Project.NameKey project = rsrc.getNameKey();
    final Repository git;
    try {
        git = gitManager.openRepository(project);
    } catch (RepositoryNotFoundException e) {
        throw new InvalidChangeOperationException("Cannot open repo");
    }

    try {
        RevWalk rw = new RevWalk(git);
        try {
            Ref destRef = git.getRef(ref);
            if (destRef == null) {
                throw new InvalidChangeOperationException("Branch " + ref + " does not exist.");
            }

            RevCommit mergeTip = rw.parseCommit(destRef.getObjectId());

            PersonIdent authorIdent = ((IdentifiedUser) userProvider.get()).newCommitterIdent(myIdent.getWhen(),
                    myIdent.getTimeZone());

            ObjectId computedChangeId = ChangeIdUtil.computeChangeId(mergeTip.getTree(), mergeTip,
                    mergeTip.getAuthorIdent(), myIdent, msg);

            String commitMessage = ChangeIdUtil.insertId(msg, computedChangeId);

            RevCommit emptyCommit;
            ObjectInserter oi = git.newObjectInserter();

            try {
                CommitBuilder commit = new CommitBuilder();
                commit.setTreeId(mergeTip.getTree().getId());
                commit.setParentId(mergeTip);
                commit.setAuthor(authorIdent);
                commit.setCommitter(authorIdent);
                commit.setMessage(commitMessage);
                emptyCommit = rw.parseCommit(insert(oi, commit));
            } finally {
                oi.release();
            }

            if (emptyCommit == null) {
                throw new IllegalStateException("Cannot create empty change");
            }
            Preconditions.checkNotNull(emptyCommit);

            Change.Key changeKey;
            final List<String> idList = emptyCommit.getFooterLines(CHANGE_ID);
            if (!idList.isEmpty()) {
                final String idStr = idList.get(idList.size() - 1).trim();
                changeKey = new Change.Key(idStr);
            } else {
                changeKey = new Change.Key("I" + computedChangeId.name());
            }

            Id changeId = createNewChange(git, rw, changeKey, project, destRef, emptyCommit, refControl);
            return Response.ok(String.valueOf(changeId.get()));
        } finally {
            rw.release();
        }
    } finally {
        git.close();
    }
}

From source file:com.microsoft.gittf.core.util.DirectoryUtil.java

License:Open Source License

private static String getUniqueAbbreviatedFolderName(final Repository repository, GUID guid) {
    ObjectInserter objIns = null;/*from   w  w w  . jav a 2 s. c om*/
    try {
        objIns = repository.newObjectInserter();

        return ObjectIdUtil.abbreviate(repository, objIns.idFor(OBJ_BLOB, guid.getGUIDBytes()));
    } catch (Exception e) {
        return guid.getGUIDString();
    } finally {
        if (objIns != null) {
            objIns.release();
        }
    }

}

From source file:com.palantir.gerrit.gerritci.servlets.JobsServlet.java

License:Apache License

public Map<String, Map<String, String>> parseJobRequest(HttpServletRequest req, String projectName)
        throws JsonSyntaxException, IOException, NoSuchProjectException, NoFilepatternException,
        GitAPIException {/*from   ww  w .  j av  a2s  .co  m*/
    Map<String, Map<String, String>> jobToParams = new HashMap<String, Map<String, String>>();

    File projectConfigDirectory = new File(sitePaths.etc_dir, projectName);
    if (!projectConfigDirectory.exists())
        projectConfigDirectory.mkdir();
    File projectConfigFile = new File(projectConfigDirectory, "created_jobs");
    if (!projectConfigFile.exists())
        projectConfigFile.createNewFile();

    JsonObject requestBody = (JsonObject) (new JsonParser()).parse(CharStreams.toString(req.getReader()));

    // get number of jobs
    // If all jobs are deleted, we must purge jobs
    int numOfJobs = requestBody.get("items").getAsJsonArray().size();

    ArrayList<String> receivedJobNames = new ArrayList<String>();

    if (numOfJobs < 1) {
        ArrayList<String> deletedJobs = updateProjectJobFiles(projectConfigFile, projectConfigDirectory,
                receivedJobNames);
        for (String deleted : deletedJobs) {
            jobToParams.put(deleted, null);
        }
        return jobToParams;
    }

    CurrentUser currentUser = this.projectControlFactory.controlFor(new NameKey(projectName)).getCurrentUser();
    String gitPath = getGitPath(sitePaths);
    File gitDir = new File(gitPath, projectName + ".git");
    Repository repository = new FileRepositoryBuilder().setGitDir(gitDir).build();
    ObjectInserter objectInserter = repository.newObjectInserter();
    HashMap<String, ObjectId> jobsToIds = new HashMap<String, ObjectId>();
    // assign file name and append to tree
    TreeFormatter treeFormatter = new TreeFormatter();
    // for each received job, create or rewrite its config file and add to
    // jobToParams
    for (int i = 0; i < numOfJobs; i++) {
        JsonObject jobObject = requestBody.get("items").getAsJsonArray().get(i).getAsJsonObject();
        String jobName = jobObject.get("jobName").toString();
        //Remove leading and trailing quotations ex. "jobname" becomes jobname
        jobName = jobName.substring(1, jobName.length() - 1);
        receivedJobNames.add(jobName);
        String type = jobObject.get("jobType").toString();
        type = type.substring(1, type.length() - 1);
        int numOfParams = jobObject.get("items").getAsJsonArray().size();
        JsonArray paramsArray = jobObject.get("items").getAsJsonArray();
        FileBasedConfig jobConfig = makeJobConfigFile(projectConfigDirectory, jobName, currentUser);
        Map<String, String> parsedParams = new HashMap<String, String>();
        parsedParams.put("projectName", projectName);
        for (int j = 0; j < numOfParams; j++) {
            String field = paramsArray.get(j).getAsJsonObject().get("field").toString();
            field = field.substring(1, field.length() - 1);
            String value = paramsArray.get(j).getAsJsonObject().get("value").toString();
            value = value.substring(1, value.length() - 1);
            parsedParams.put(field, value);
            // update jobconfig files
            jobConfig.setString("jobType", type, field, value);
        }
        jobConfig.save();
        jobsToIds.put(jobName, createGitFileId(repository, jobConfig, objectInserter, jobName));
        jobToParams.put(jobName, parsedParams);
    }
    for (String jobName : jobsToIds.keySet()) {
        treeFormatter.append(jobName + ".config", FileMode.REGULAR_FILE, jobsToIds.get(jobName));
    }
    ObjectId treeId = objectInserter.insert(treeFormatter);
    objectInserter.flush();
    updateProjectRef(treeId, objectInserter, repository, currentUser);
    // update or create project files for all jobs
    ArrayList<String> deletedJobs = updateProjectJobFiles(projectConfigFile, projectConfigDirectory,
            receivedJobNames);
    for (String deleted : deletedJobs) {
        jobToParams.put(deleted, null);
    }
    // returns map of job name to params
    return jobToParams;
}

From source file:jetbrains.buildServer.buildTriggers.vcs.git.GitMergeSupport.java

License:Apache License

@NotNull
private ObjectId mergeCommits(@NotNull GitVcsRoot gitRoot, @NotNull Repository db, @NotNull RevCommit srcCommit,
        @NotNull RevCommit dstCommit, @NotNull String message, @NotNull MergeOptions options)
        throws IOException, MergeFailedException {
    if (!alwaysCreateMergeCommit(options)) {
        RevWalk walk = new RevWalk(db);
        try {/*  w  ww .j a  v  a  2 s . c o m*/
            if (walk.isMergedInto(walk.parseCommit(dstCommit), walk.parseCommit(srcCommit))) {
                LOG.debug("Commit " + srcCommit.name() + " already merged into " + dstCommit
                        + ", skip the merge");
                return srcCommit;
            }
        } finally {
            walk.release();
        }
    }

    if (tryRebase(options)) {
        LOG.debug("Run rebase, root " + gitRoot + ", revision " + srcCommit.name() + ", destination "
                + dstCommit.name());
        try {
            return rebase(gitRoot, db, srcCommit, dstCommit);
        } catch (MergeFailedException e) {
            if (enforceLinearHistory(options)) {
                LOG.debug("Rebase failed, root " + gitRoot + ", revision " + srcCommit.name() + ", destination "
                        + dstCommit.name(), e);
                throw e;
            }
        } catch (IOException e) {
            if (enforceLinearHistory(options)) {
                LOG.debug("Rebase failed, root " + gitRoot + ", revision " + srcCommit.name() + ", destination "
                        + dstCommit.name(), e);
                throw e;
            }
        }
    }

    ResolveMerger merger = (ResolveMerger) MergeStrategy.RECURSIVE.newMerger(db, true);
    boolean mergeSuccessful = merger.merge(dstCommit, srcCommit);
    if (!mergeSuccessful) {
        List<String> conflicts = merger.getUnmergedPaths();
        Collections.sort(conflicts);
        LOG.debug("Merge failed with conflicts, root " + gitRoot + ", revision " + srcCommit.name()
                + ", destination " + dstCommit.name() + ", conflicts " + conflicts);
        throw new MergeFailedException(conflicts);
    }

    ObjectInserter inserter = db.newObjectInserter();
    DirCache dc = DirCache.newInCore();
    DirCacheBuilder dcb = dc.builder();

    dcb.addTree(new byte[] {}, 0, db.getObjectDatabase().newReader(), merger.getResultTreeId());
    inserter.flush();
    dcb.finish();

    ObjectId writtenTreeId = dc.writeTree(inserter);

    CommitBuilder commitBuilder = new CommitBuilder();
    commitBuilder.setCommitter(gitRoot.getTagger(db));
    commitBuilder.setAuthor(gitRoot.getTagger(db));
    commitBuilder.setMessage(message);
    commitBuilder.addParentId(dstCommit);
    commitBuilder.addParentId(srcCommit);
    commitBuilder.setTreeId(writtenTreeId);

    ObjectId commitId = inserter.insert(commitBuilder);
    inserter.flush();
    return commitId;
}

From source file:jetbrains.buildServer.buildTriggers.vcs.git.GitMergeSupport.java

License:Apache License

@NotNull
private ObjectId rebase(@NotNull GitVcsRoot gitRoot, @NotNull Repository db, @NotNull RevCommit srcCommit,
        @NotNull RevCommit dstCommit) throws IOException, MergeFailedException {
    RevWalk walk = new RevWalk(db);
    try {/*w  ww.ja v a 2 s  .  c  o  m*/
        RevCommit src = walk.parseCommit(srcCommit);
        RevCommit dst = walk.parseCommit(dstCommit);
        walk.markStart(src);
        walk.markStart(dst);
        walk.setRevFilter(RevFilter.MERGE_BASE);
        RevCommit base = walk.next();

        Map<ObjectId, RevCommit> tree2commit = new HashMap<ObjectId, RevCommit>();
        RevCommit c;

        if (base != null) {
            walk.reset();
            walk.setRevFilter(RevFilter.ALL);
            walk.markStart(dst);
            walk.markUninteresting(base);
            while ((c = walk.next()) != null) {
                tree2commit.put(c.getTree().getId(), c);
            }
        }

        walk.reset();
        walk.markStart(src);
        walk.markUninteresting(dst);
        walk.sort(RevSort.TOPO);
        walk.sort(RevSort.REVERSE);

        Map<RevCommit, RevCommit> orig2rebased = new HashMap<RevCommit, RevCommit>();
        List<RevCommit> toRebase = new ArrayList<RevCommit>();
        while ((c = walk.next()) != null) {
            ObjectId treeId = c.getTree().getId();
            RevCommit existing = tree2commit.get(treeId);
            if (existing != null) {
                orig2rebased.put(c, existing);
            } else {
                if (c.getParentCount() > 1) {
                    throw new MergeFailedException(asList("Rebase of merge commits is not supported"));
                } else {
                    toRebase.add(c);
                }
            }
        }

        orig2rebased.put(toRebase.get(0).getParent(0), dstCommit);
        ObjectInserter inserter = db.newObjectInserter();
        for (RevCommit commit : toRebase) {
            RevCommit p = commit.getParent(0);
            RevCommit b = orig2rebased.get(p);
            ObjectId rebased = rebaseCommit(gitRoot, db, inserter, commit, b);
            orig2rebased.put(commit, walk.parseCommit(rebased));
        }

        return orig2rebased.get(toRebase.get(toRebase.size() - 1));
    } finally {
        walk.release();
    }
}

From source file:net.polydawn.mdm.Plumbing.java

License:Open Source License

/**
 * Create a new "empty" commit in a new branch. If the branch name already exists,
 * a forced update will be performed./*from   w  w  w .  j  a  va2  s  . c  o  m*/
 *
 * @return result of the branch update.
 * @throws IOException
 */
public static RefUpdate.Result createOrphanBranch(Repository repo, String branchName) throws IOException {
    ObjectInserter odi = repo.newObjectInserter();
    try {
        // Create an (empty) tree object to reference from a commit.
        TreeFormatter tree = new TreeFormatter();
        ObjectId treeId = odi.insert(tree);

        // Create a commit object... most data is nulls or silly placeholders; I expect you'll amend this commit.
        CommitBuilder commit = new CommitBuilder();
        PersonIdent author = new PersonIdent("mdm", "");
        commit.setAuthor(author);
        commit.setCommitter(author);
        commit.setMessage("");
        commit.setTreeId(treeId);

        // Insert the commit into the repository.
        ObjectId commitId = odi.insert(commit);
        odi.flush();

        // (Re)extract the commit we just flushed, and update a new branch ref to point to it.
        RevWalk revWalk = new RevWalk(repo);
        try {
            RevCommit revCommit = revWalk.parseCommit(commitId);
            if (!branchName.startsWith("refs/"))
                branchName = "refs/heads/" + branchName;
            RefUpdate ru = repo.updateRef(branchName);
            ru.setNewObjectId(commitId);
            ru.setRefLogMessage("commit: " + revCommit.getShortMessage(), false);
            return ru.forceUpdate();
        } finally {
            revWalk.release();
        }
    } finally {
        odi.release();
    }
}

From source file:org.eclipse.egit.core.op.CommitOperation.java

License:Open Source License

private void doCommits(String actMessage, HashMap<Repository, Tree> treeMap) throws IOException, TeamException {

    String commitMessage = actMessage;
    final Date commitDate = new Date();
    final TimeZone timeZone = TimeZone.getDefault();

    final PersonIdent authorIdent = RawParseUtils.parsePersonIdent(author);
    final PersonIdent committerIdent = RawParseUtils.parsePersonIdent(committer);

    for (java.util.Map.Entry<Repository, Tree> entry : treeMap.entrySet()) {
        Tree tree = entry.getValue();/*w  w w  . java 2 s  .c om*/
        Repository repo = tree.getRepository();
        repo.getIndex().write();
        writeTreeWithSubTrees(tree);

        ObjectId currentHeadId = repo.resolve(Constants.HEAD);
        ObjectId[] parentIds;
        if (amending) {
            RevCommit[] parents = previousCommit.getParents();
            parentIds = new ObjectId[parents.length];
            for (int i = 0; i < parents.length; i++)
                parentIds[i] = parents[i].getId();
        } else {
            if (currentHeadId != null)
                parentIds = new ObjectId[] { currentHeadId };
            else
                parentIds = new ObjectId[0];
        }
        if (createChangeId) {
            ObjectId parentId;
            if (parentIds.length > 0)
                parentId = parentIds[0];
            else
                parentId = null;
            ObjectId changeId = ChangeIdUtil.computeChangeId(tree.getId(), parentId, authorIdent,
                    committerIdent, commitMessage);
            commitMessage = ChangeIdUtil.insertId(commitMessage, changeId);
            if (changeId != null)
                commitMessage = commitMessage.replaceAll(
                        "\nChange-Id: I0000000000000000000000000000000000000000\n", //$NON-NLS-1$
                        "\nChange-Id: I" + changeId.getName() + "\n"); //$NON-NLS-1$ //$NON-NLS-2$
        }
        CommitBuilder commit = new CommitBuilder();
        commit.setTreeId(tree.getTreeId());
        commit.setParentIds(parentIds);
        commit.setMessage(commitMessage);
        commit.setAuthor(new PersonIdent(authorIdent, commitDate, timeZone));
        commit.setCommitter(new PersonIdent(committerIdent, commitDate, timeZone));

        ObjectInserter inserter = repo.newObjectInserter();
        ObjectId commitId;
        try {
            commitId = inserter.insert(commit);
            inserter.flush();
        } finally {
            inserter.release();
        }

        final RefUpdate ru = repo.updateRef(Constants.HEAD);
        ru.setNewObjectId(commitId);
        ru.setRefLogMessage(buildReflogMessage(commitMessage), false);
        if (ru.forceUpdate() == RefUpdate.Result.LOCK_FAILURE) {
            throw new TeamException(NLS.bind(CoreText.CommitOperation_failedToUpdate, ru.getName(), commitId));
        }
    }
}

From source file:org.eclipse.egit.core.test.GitTestCase.java

License:Open Source License

protected ObjectId createFile(Repository repository, IProject actProject, String name, String content)
        throws IOException {
    File file = new File(actProject.getProject().getLocation().toFile(), name);
    FileWriter fileWriter = new FileWriter(file);
    fileWriter.write(content);/*from   ww w .j av  a 2 s .c om*/
    fileWriter.close();
    byte[] fileContents = IO.readFully(file);
    ObjectInserter inserter = repository.newObjectInserter();
    try {
        ObjectId objectId = inserter.insert(Constants.OBJ_BLOB, fileContents);
        inserter.flush();
        return objectId;
    } finally {
        inserter.release();
    }
}

From source file:org.eclipse.egit.ui.internal.actions.CompareWithIndexActionHandler.java

License:Open Source License

private ITypedElement getHeadTypedElement(final IFile baseFile) throws IOException {
    final RepositoryMapping mapping = RepositoryMapping.getMapping(baseFile.getProject());
    final Repository repository = mapping.getRepository();
    final String gitPath = mapping.getRepoRelativePath(baseFile);

    DirCache dc = repository.lockDirCache();
    final DirCacheEntry entry = dc.getEntry(gitPath);
    dc.unlock();//from ww w . j  a v a 2  s.c  o  m
    if (entry == null) {
        // the file cannot be found in the index
        return new GitCompareFileRevisionEditorInput.EmptyTypedElement(
                NLS.bind(UIText.CompareWithIndexAction_FileNotInIndex, baseFile.getName()));
    }

    IFileRevision nextFile = GitFileRevision.inIndex(repository, gitPath);
    final EditableRevision next = new EditableRevision(nextFile);

    IContentChangeListener listener = new IContentChangeListener() {
        public void contentChanged(IContentChangeNotifier source) {
            final byte[] newContent = next.getModifiedContent();
            DirCache cache = null;
            try {
                cache = repository.lockDirCache();
                DirCacheEditor editor = cache.editor();
                editor.add(new PathEdit(gitPath) {
                    @Override
                    public void apply(DirCacheEntry ent) {
                        ent.copyMetaData(entry);

                        ObjectInserter inserter = repository.newObjectInserter();
                        ent.copyMetaData(entry);
                        ent.setLength(newContent.length);
                        ent.setLastModified(System.currentTimeMillis());
                        InputStream in = new ByteArrayInputStream(newContent);
                        try {
                            ent.setObjectId(inserter.insert(Constants.OBJ_BLOB, newContent.length, in));
                            inserter.flush();
                        } catch (IOException ex) {
                            throw new RuntimeException(ex);
                        } finally {
                            try {
                                in.close();
                            } catch (IOException e) {
                                // ignore here
                            }
                        }
                    }
                });
                try {
                    editor.commit();
                } catch (RuntimeException e) {
                    if (e.getCause() instanceof IOException)
                        throw (IOException) e.getCause();
                    else
                        throw e;
                }

            } catch (IOException e) {
                Activator.handleError(UIText.CompareWithIndexAction_errorOnAddToIndex, e, true);
            } finally {
                if (cache != null)
                    cache.unlock();
            }
        }
    };

    next.addContentChangeListener(listener);
    return next;
}

From source file:org.eclipse.mylyn.internal.gerrit.ui.egit.GitFileRevisionUtils.java

License:Open Source License

public static IFileRevision getFileRevision(final Repository repository, final IFileVersion reviewFileVersion) {
    IFileRevision gitFileRevision = null;

    if (reviewFileVersion != null && reviewFileVersion.getPath() != null) {
        //Get SHA-1 for the file revision to look for the correct file revision in the Git repository
        ObjectInserter inserter = repository.newObjectInserter();
        String id = inserter.idFor(Constants.OBJ_BLOB, CompareUtil.getContent(reviewFileVersion)).getName();
        inserter.release();//ww w  .  j a v a2s.com
        if (id != null) {
            final ObjectId objId = ObjectId.fromString(id);
            if (objId != null) {
                final IPath path = Path.fromPortableString(reviewFileVersion.getPath());
                gitFileRevision = new org.eclipse.team.core.history.provider.FileRevision() {

                    public IFileRevision withAllProperties(IProgressMonitor monitor) throws CoreException {
                        return this;
                    }

                    public boolean isPropertyMissing() {
                        return false;
                    }

                    public IStorage getStorage(IProgressMonitor monitor) throws CoreException {
                        return getFileRevisionStorage(null, repository, path, objId);
                    }

                    public String getName() {
                        return path.lastSegment();
                    }
                };
            }
        }
    }
    return gitFileRevision;
}