Examples of org.eclipse.jgit.lib.ObjectInserter

org.eclipse.jgit.lib.ObjectInserter
Inserts objects into an existing {@code ObjectDatabase}.
An inserter is not thread-safe. Individual threads should each obtain their own unique inserter instance, or must arrange for locking at a higher level to ensure the inserter is in use by no more than one thread at a time.
Objects written by an inserter may not be immediately visible for reading after the insert method completes. Callers must invoke either {@link #release()} or {@link #flush()} prior to updating references orotherwise making the returned ObjectIds visible to other code.

   * @throws FileNotFoundException
   * @throws IOException
   */
  protected void resetIndex(FileTreeIterator treeItr)
      throws FileNotFoundException, IOException {
    ObjectInserter inserter = db.newObjectInserter();
    DirCacheBuilder builder = db.lockDirCache().builder();
    DirCacheEntry dce;


    while (!treeItr.eof()) {
      long len = treeItr.getEntryLength();


      dce = new DirCacheEntry(treeItr.getEntryPathString());
      dce.setFileMode(treeItr.getEntryFileMode());
      dce.setLastModified(treeItr.getEntryLastModified());
      dce.setLength((int) len);
      FileInputStream in = new FileInputStream(treeItr.getEntryFile());
      dce.setObjectId(inserter.insert(Constants.OBJ_BLOB, len, in));
      in.close();
      builder.add(dce);
      treeItr.next(1);
    }
    builder.commit();
    inserter.flush();
    inserter.release();
  }

View Full Code Here

  private int indexVersion = -1;


  @Override
  protected void run() throws Exception {
    BufferedInputStream in = new BufferedInputStream(ins);
    ObjectInserter inserter = db.newObjectInserter();
    try {
      PackParser p = inserter.newPackParser(in);
      p.setAllowThin(fixThin);
      if (indexVersion != -1 && p instanceof ObjectDirectoryPackParser) {
        ObjectDirectoryPackParser imp = (ObjectDirectoryPackParser) p;
        imp.setIndexVersion(indexVersion);
      }
      p.parse(new TextProgressMonitor());
      inserter.flush();
    } finally {
      inserter.release();
    }
  }

View Full Code Here

@SuppressWarnings("deprecation")
public class TreeWalkBasicDiffTest extends RepositoryTestCase {
  @Test
  public void testMissingSubtree_DetectFileAdded_FileModified()
      throws Exception {
    final ObjectInserter inserter = db.newObjectInserter();
    final ObjectId aFileId = inserter.insert(OBJ_BLOB, encode("a"));
    final ObjectId bFileId = inserter.insert(OBJ_BLOB, encode("b"));
    final ObjectId cFileId1 = inserter.insert(OBJ_BLOB, encode("c-1"));
    final ObjectId cFileId2 = inserter.insert(OBJ_BLOB, encode("c-2"));


    // Create sub-a/empty, sub-c/empty = hello.
    final ObjectId oldTree;
    {
      final Tree root = new Tree(db);
      {
        final Tree subA = root.addTree("sub-a");
        subA.addFile("empty").setId(aFileId);
        subA.setId(inserter.insert(OBJ_TREE, subA.format()));
      }
      {
        final Tree subC = root.addTree("sub-c");
        subC.addFile("empty").setId(cFileId1);
        subC.setId(inserter.insert(OBJ_TREE, subC.format()));
      }
      oldTree = inserter.insert(OBJ_TREE, root.format());
    }


    // Create sub-a/empty, sub-b/empty, sub-c/empty.
    final ObjectId newTree;
    {
      final Tree root = new Tree(db);
      {
        final Tree subA = root.addTree("sub-a");
        subA.addFile("empty").setId(aFileId);
        subA.setId(inserter.insert(OBJ_TREE, subA.format()));
      }
      {
        final Tree subB = root.addTree("sub-b");
        subB.addFile("empty").setId(bFileId);
        subB.setId(inserter.insert(OBJ_TREE, subB.format()));
      }
      {
        final Tree subC = root.addTree("sub-c");
        subC.addFile("empty").setId(cFileId2);
        subC.setId(inserter.insert(OBJ_TREE, subC.format()));
      }
      newTree = inserter.insert(OBJ_TREE, root.format());
    }
    inserter.flush();
    inserter.release();


    final TreeWalk tw = new TreeWalk(db);
    tw.reset(oldTree, newTree);
    tw.setRecursive(true);
    tw.setFilter(TreeFilter.ANY_DIFF);

View Full Code Here

    assertEquals(Arrays.asList("abcd", "bcd"), getMatchingPaths("bcd", treeId));
    assertEquals(Arrays.asList("abc", "c"), getMatchingPaths("c", treeId));
  }


  private ObjectId createTree(String... paths) throws IOException {
    final ObjectInserter odi = db.newObjectInserter();
    final DirCache dc = db.readDirCache();
    final DirCacheBuilder builder = dc.builder();
    for (String path : paths) {
      DirCacheEntry entry = createEntry(path, FileMode.REGULAR_FILE);
      builder.add(entry);
    }
    builder.finish();
    final ObjectId treeId = dc.writeTree(odi);
    odi.flush();
    return treeId;
  }

View Full Code Here

  }


  public Note call() throws GitAPIException {
    checkCallable();
    RevWalk walk = new RevWalk(repo);
    ObjectInserter inserter = repo.newObjectInserter();
    NoteMap map = NoteMap.newEmptyMap();
    RevCommit notesCommit = null;
    try {
      Ref ref = repo.getRef(notesRef);
      // if we have a notes ref, use it
      if (ref != null) {
        notesCommit = walk.parseCommit(ref.getObjectId());
        map = NoteMap.read(walk.getObjectReader(), notesCommit);
      }
      map.set(id, null, inserter);
      commitNoteMap(walk, map, notesCommit, inserter,
          "Notes removed by 'git notes remove'");
      return map.getNote(id);
    } catch (IOException e) {
      throw new JGitInternalException(e.getMessage(), e);
    } finally {
      inserter.release();
      walk.release();
    }
  }

View Full Code Here

    Ref head = getHead();
    ObjectReader reader = repo.newObjectReader();
    try {
      RevCommit headCommit = parseCommit(reader, head.getObjectId());
      DirCache cache = repo.lockDirCache();
      ObjectInserter inserter = repo.newObjectInserter();
      ObjectId commitId;
      try {
        TreeWalk treeWalk = new TreeWalk(reader);
        treeWalk.setRecursive(true);
        treeWalk.addTree(headCommit.getTree());
        treeWalk.addTree(new DirCacheIterator(cache));
        treeWalk.addTree(new FileTreeIterator(repo));
        treeWalk.setFilter(AndTreeFilter.create(new SkipWorkTreeFilter(
            1), new IndexDiffFilter(1, 2)));


        // Return null if no local changes to stash
        if (!treeWalk.next())
          return null;


        MutableObjectId id = new MutableObjectId();
        List<PathEdit> wtEdits = new ArrayList<PathEdit>();
        List<String> wtDeletes = new ArrayList<String>();
        List<DirCacheEntry> untracked = new ArrayList<DirCacheEntry>();
        boolean hasChanges = false;
        do {
          AbstractTreeIterator headIter = treeWalk.getTree(0,
              AbstractTreeIterator.class);
          DirCacheIterator indexIter = treeWalk.getTree(1,
              DirCacheIterator.class);
          WorkingTreeIterator wtIter = treeWalk.getTree(2,
              WorkingTreeIterator.class);
          if (indexIter != null
              && !indexIter.getDirCacheEntry().isMerged())
            throw new UnmergedPathsException(
                new UnmergedPathException(
                    indexIter.getDirCacheEntry()));
          if (wtIter != null) {
            if (indexIter == null && headIter == null
                && !includeUntracked)
              continue;
            hasChanges = true;
            if (indexIter != null && wtIter.idEqual(indexIter))
              continue;
            if (headIter != null && wtIter.idEqual(headIter))
              continue;
            treeWalk.getObjectId(id, 0);
            final DirCacheEntry entry = new DirCacheEntry(
                treeWalk.getRawPath());
            entry.setLength(wtIter.getEntryLength());
            entry.setLastModified(wtIter.getEntryLastModified());
            entry.setFileMode(wtIter.getEntryFileMode());
            long contentLength = wtIter.getEntryContentLength();
            InputStream in = wtIter.openEntryStream();
            try {
              entry.setObjectId(inserter.insert(
                  Constants.OBJ_BLOB, contentLength, in));
            } finally {
              in.close();
            }


            if (indexIter == null && headIter == null)
              untracked.add(entry);
            else
              wtEdits.add(new PathEdit(entry) {
                public void apply(DirCacheEntry ent) {
                  ent.copyMetaData(entry);
                }
              });
          }
          hasChanges = true;
          if (wtIter == null && headIter != null)
            wtDeletes.add(treeWalk.getPathString());
        } while (treeWalk.next());


        if (!hasChanges)
          return null;


        String branch = Repository.shortenRefName(head.getTarget()
            .getName());


        // Commit index changes
        CommitBuilder builder = createBuilder();
        builder.setParentId(headCommit);
        builder.setTreeId(cache.writeTree(inserter));
        builder.setMessage(MessageFormat.format(indexMessage, branch,
            headCommit.abbreviate(7).name(),
            headCommit.getShortMessage()));
        ObjectId indexCommit = inserter.insert(builder);


        // Commit untracked changes
        ObjectId untrackedCommit = null;
        if (!untracked.isEmpty()) {
          DirCache untrackedDirCache = DirCache.newInCore();
          DirCacheBuilder untrackedBuilder = untrackedDirCache
              .builder();
          for (DirCacheEntry entry : untracked)
            untrackedBuilder.add(entry);
          untrackedBuilder.finish();


          builder.setParentIds(new ObjectId[0]);
          builder.setTreeId(untrackedDirCache.writeTree(inserter));
          builder.setMessage(MessageFormat.format(MSG_UNTRACKED,
              branch, headCommit.abbreviate(7).name(),
              headCommit.getShortMessage()));
          untrackedCommit = inserter.insert(builder);
        }


        // Commit working tree changes
        if (!wtEdits.isEmpty() || !wtDeletes.isEmpty()) {
          DirCacheEditor editor = cache.editor();
          for (PathEdit edit : wtEdits)
            editor.add(edit);
          for (String path : wtDeletes)
            editor.add(new DeletePath(path));
          editor.finish();
        }
        builder.setParentId(headCommit);
        builder.addParentId(indexCommit);
        if (untrackedCommit != null)
          builder.addParentId(untrackedCommit);
        builder.setMessage(MessageFormat.format(
            workingDirectoryMessage, branch,
            headCommit.abbreviate(7).name(),
            headCommit.getShortMessage()));
        builder.setTreeId(cache.writeTree(inserter));
        commitId = inserter.insert(builder);
        inserter.flush();


        updateStashRef(commitId, builder.getAuthor(),
            builder.getMessage());


        // Remove untracked files
        if (includeUntracked) {
          for (DirCacheEntry entry : untracked) {
            File file = new File(repo.getWorkTree(),
                entry.getPathString());
            FileUtils.delete(file);
          }
        }


      } finally {
        inserter.release();
        cache.unlock();
      }


      // Hard reset to HEAD
      new ResetCommand(repo).setMode(ResetType.HARD).call();

View Full Code Here

  }


  public Note call() throws GitAPIException {
    checkCallable();
    RevWalk walk = new RevWalk(repo);
    ObjectInserter inserter = repo.newObjectInserter();
    NoteMap map = NoteMap.newEmptyMap();
    RevCommit notesCommit = null;
    try {
      Ref ref = repo.getRef(notesRef);
      // if we have a notes ref, use it
      if (ref != null) {
        notesCommit = walk.parseCommit(ref.getObjectId());
        map = NoteMap.read(walk.getObjectReader(), notesCommit);
      }
      map.set(id, message, inserter);
      commitNoteMap(walk, map, notesCommit, inserter,
          "Notes added by 'git notes add'");
      return map.getNote(id);
    } catch (IOException e) {
      throw new JGitInternalException(e.getMessage(), e);
    } finally {
      inserter.release();
      walk.release();
    }
  }

View Full Code Here

    DirCache dc = null;
    boolean addAll = false;
    if (filepatterns.contains(".")) //$NON-NLS-1$
      addAll = true;


    ObjectInserter inserter = repo.newObjectInserter();
    try {
      dc = repo.lockDirCache();
      DirCacheIterator c;


      DirCacheBuilder builder = dc.builder();
      final TreeWalk tw = new TreeWalk(repo);
      tw.addTree(new DirCacheBuildIterator(builder));
      if (workingTreeIterator == null)
        workingTreeIterator = new FileTreeIterator(repo);
      tw.addTree(workingTreeIterator);
      tw.setRecursive(true);
      if (!addAll)
        tw.setFilter(PathFilterGroup.createFromStrings(filepatterns));


      String lastAddedFile = null;


      while (tw.next()) {
        String path = tw.getPathString();


        WorkingTreeIterator f = tw.getTree(1, WorkingTreeIterator.class);
        if (tw.getTree(0, DirCacheIterator.class) == null &&
            f != null && f.isEntryIgnored()) {
          // file is not in index but is ignored, do nothing
        }
        // In case of an existing merge conflict the
        // DirCacheBuildIterator iterates over all stages of
        // this path, we however want to add only one
        // new DirCacheEntry per path.
        else if (!(path.equals(lastAddedFile))) {
          if (!(update && tw.getTree(0, DirCacheIterator.class) == null)) {
            c = tw.getTree(0, DirCacheIterator.class);
            if (f != null) { // the file exists
              long sz = f.getEntryLength();
              DirCacheEntry entry = new DirCacheEntry(path);
              if (c == null || c.getDirCacheEntry() == null
                  || !c.getDirCacheEntry().isAssumeValid()) {
                FileMode mode = f.getIndexFileMode(c);
                entry.setFileMode(mode);


                if (FileMode.GITLINK != mode) {
                  entry.setLength(sz);
                  entry.setLastModified(f
                      .getEntryLastModified());
                  long contentSize = f
                      .getEntryContentLength();
                  InputStream in = f.openEntryStream();
                  try {
                    entry.setObjectId(inserter.insert(
                        Constants.OBJ_BLOB, contentSize, in));
                  } finally {
                    in.close();
                  }
                } else
                  entry.setObjectId(f.getEntryObjectId());
                builder.add(entry);
                lastAddedFile = path;
              } else {
                builder.add(c.getDirCacheEntry());
              }


            } else if (c != null
                && (!update || FileMode.GITLINK == c
                    .getEntryFileMode()))
              builder.add(c.getDirCacheEntry());
          }
        }
      }
      inserter.flush();
      builder.commit();
      setCallable(false);
    } catch (IOException e) {
      throw new JGitInternalException(
          JGitText.get().exceptionCaughtDuringExecutionOfAddCommand, e);
    } finally {
      inserter.release();
      if (dc != null)
        dc.unlock();
    }


    return dc;

View Full Code Here

      DirCache index = repo.lockDirCache();
      try {
        if (!only.isEmpty())
          index = createTemporaryIndex(headId, index, rw);


        ObjectInserter odi = repo.newObjectInserter();
        try {
          // Write the index as tree to the object database. This may
          // fail for example when the index contains unmerged paths
          // (unresolved conflicts)
          ObjectId indexTreeId = index.writeTree(odi);


          if (insertChangeId)
            insertChangeId(indexTreeId);


          // Create a Commit object, populate it and write it
          CommitBuilder commit = new CommitBuilder();
          commit.setCommitter(committer);
          commit.setAuthor(author);
          commit.setMessage(message);


          commit.setParentIds(parents);
          commit.setTreeId(indexTreeId);
          ObjectId commitId = odi.insert(commit);
          odi.flush();


          RevCommit revCommit = rw.parseCommit(commitId);
          RefUpdate ru = repo.updateRef(Constants.HEAD);
          ru.setNewObjectId(commitId);
          if (reflogComment != null) {
            ru.setRefLogMessage(reflogComment, false);
          } else {
            String prefix = amend ? "commit (amend): " //$NON-NLS-1$
                : parents.size() == 0 ? "commit (initial): " //$NON-NLS-1$
                    : "commit: "; //$NON-NLS-1$
            ru.setRefLogMessage(
                prefix + revCommit.getShortMessage(), false);
          }
          if (headId != null)
            ru.setExpectedOldObjectId(headId);
          else
            ru.setExpectedOldObjectId(ObjectId.zeroId());
          Result rc = ru.forceUpdate();
          switch (rc) {
          case NEW:
          case FORCED:
          case FAST_FORWARD: {
            setCallable(false);
            if (state == RepositoryState.MERGING_RESOLVED
                || isMergeDuringRebase(state)) {
              // Commit was successful. Now delete the files
              // used for merge commits
              repo.writeMergeCommitMsg(null);
              repo.writeMergeHeads(null);
            } else if (state == RepositoryState.CHERRY_PICKING_RESOLVED) {
              repo.writeMergeCommitMsg(null);
              repo.writeCherryPickHead(null);
            } else if (state == RepositoryState.REVERTING_RESOLVED) {
              repo.writeMergeCommitMsg(null);
              repo.writeRevertHead(null);
            }
            return revCommit;
          }
          case REJECTED:
          case LOCK_FAILURE:
            throw new ConcurrentRefUpdateException(
                JGitText.get().couldNotLockHEAD, ru.getRef(),
                rc);
          default:
            throw new JGitInternalException(MessageFormat.format(
                JGitText.get().updatingRefFailed,
                Constants.HEAD, commitId.toString(), rc));
          }
        } finally {
          odi.release();
        }
      } finally {
        index.unlock();
      }
    } catch (UnmergedPathException e) {

View Full Code Here

  }


  private DirCache createTemporaryIndex(ObjectId headId, DirCache index,
      RevWalk rw)
      throws IOException {
    ObjectInserter inserter = null;


    // get DirCacheBuilder for existing index
    DirCacheBuilder existingBuilder = index.builder();


    // get DirCacheBuilder for newly created in-core index to build a
    // temporary index for this commit
    DirCache inCoreIndex = DirCache.newInCore();
    DirCacheBuilder tempBuilder = inCoreIndex.builder();


    onlyProcessed = new boolean[only.size()];
    boolean emptyCommit = true;


    TreeWalk treeWalk = new TreeWalk(repo);
    int dcIdx = treeWalk.addTree(new DirCacheBuildIterator(existingBuilder));
    int fIdx = treeWalk.addTree(new FileTreeIterator(repo));
    int hIdx = -1;
    if (headId != null)
      hIdx = treeWalk.addTree(rw.parseTree(headId));
    treeWalk.setRecursive(true);


    String lastAddedFile = null;
    while (treeWalk.next()) {
      String path = treeWalk.getPathString();
      // check if current entry's path matches a specified path
      int pos = lookupOnly(path);


      CanonicalTreeParser hTree = null;
      if (hIdx != -1)
        hTree = treeWalk.getTree(hIdx, CanonicalTreeParser.class);


      DirCacheIterator dcTree = treeWalk.getTree(dcIdx,
          DirCacheIterator.class);


      if (pos >= 0) {
        // include entry in commit


        FileTreeIterator fTree = treeWalk.getTree(fIdx,
            FileTreeIterator.class);


        // check if entry refers to a tracked file
        boolean tracked = dcTree != null || hTree != null;
        if (!tracked)
          break;


        // for an unmerged path, DirCacheBuildIterator will yield 3
        // entries, we only want to add one
        if (path.equals(lastAddedFile))
          continue;


        lastAddedFile = path;


        if (fTree != null) {
          // create a new DirCacheEntry with data retrieved from disk
          final DirCacheEntry dcEntry = new DirCacheEntry(path);
          long entryLength = fTree.getEntryLength();
          dcEntry.setLength(entryLength);
          dcEntry.setLastModified(fTree.getEntryLastModified());
          dcEntry.setFileMode(fTree.getIndexFileMode(dcTree));


          boolean objectExists = (dcTree != null && fTree
              .idEqual(dcTree))
              || (hTree != null && fTree.idEqual(hTree));
          if (objectExists) {
            dcEntry.setObjectId(fTree.getEntryObjectId());
          } else {
            if (FileMode.GITLINK.equals(dcEntry.getFileMode()))
              dcEntry.setObjectId(fTree.getEntryObjectId());
            else {
              // insert object
              if (inserter == null)
                inserter = repo.newObjectInserter();
              long contentLength = fTree.getEntryContentLength();
              InputStream inputStream = fTree.openEntryStream();
              try {
                dcEntry.setObjectId(inserter.insert(
                    Constants.OBJ_BLOB, contentLength,
                    inputStream));
              } finally {
                inputStream.close();
              }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.eclipse.jgit.lib.ObjectInserter

com.gitblit.tickets.BranchTicketService

com.gitblit.utils.JGitUtils

com.gitblit.utils.RefLogUtils

com.gitblit.wicket.pages.NewRepositoryPage

com.google.gerrit.server.ChangeUtil

com.google.gerrit.server.git.BanCommit

com.google.gerrit.server.git.SubmoduleOp

com.google.gerrit.server.git.SubmoduleOpTest

com.google.gerrit.server.git.VersionedMetaData

com.google.gerrit.server.patch.PatchListLoader

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.