@Override public void flush() throws IOException { delegate().flush(); }
/** {@inheritDoc} */ @Override protected void doFetch(final ProgressMonitor monitor, final Collection<Ref> want, final Set<ObjectId> have) throws TransportException { markLocalRefsComplete(have); queueWants(want); while (!monitor.isCancelled() && !workQueue.isEmpty()) { final ObjectId id = workQueue.removeFirst(); if (!(id instanceof RevObject) || !((RevObject) id).has(COMPLETE)) downloadObject(monitor, id); process(id); } try { inserter.flush(); } catch (IOException e) { throw new TransportException(e.getMessage(), e); } }
private ObjectId insertProposals(Repository git, ProposedTimestamp ts) throws IOException, NoOp { ObjectId id; try (ObjectInserter inserter = git.newObjectInserter()) { // TODO(sop) Process signed push certificates. if (queuedTree != null) { id = insertSingleProposal(git, ts, inserter); } else { id = insertMultiProposal(git, ts, inserter); } stageCommands = makeStageList(git, inserter); inserter.flush(); } return id; }
private ObjectId write() throws IOException { if (pending.isEmpty()) { return null; } if (reader == null) { load(); } sortPending(pending); ObjectId curr = commit; DirCache dc = newDirCache(); try (ObjectInserter inserter = db.newObjectInserter()) { for (PendingCert pc : pending) { curr = saveCert(inserter, dc, pc, curr); } inserter.flush(); return curr; } }
@Override void start() throws IOException { ObjectId id; try (Repository git = leader.openRepository(); ProposedTimestamp ts = getSystem().getClock().propose(); ObjectInserter inserter = git.newObjectInserter()) { id = bumpTerm(git, ts, inserter); inserter.flush(); blockUntil(ts); } runAsync(id); }
/** {@inheritDoc} */ @Override protected void doFetch(final ProgressMonitor monitor, final Collection<Ref> want, final Set<ObjectId> have) throws TransportException { verifyPrerequisites(); try { try (ObjectInserter ins = transport.local.newObjectInserter()) { PackParser parser = ins.newPackParser(bin); parser.setAllowThin(true); parser.setObjectChecker(transport.getObjectChecker()); parser.setLockMessage(lockMessage); packLock = parser.parse(NullProgressMonitor.INSTANCE); ins.flush(); } } catch (IOException err) { close(); throw new TransportException(transport.uri, err.getMessage(), err); } catch (RuntimeException err) { close(); throw new TransportException(transport.uri, err.getMessage(), err); } }
/** * Performs the merge. * * @param base * base version of the note tree * @param ours * ours version of the note tree * @param theirs * theirs version of the note tree * @return merge result as a new NoteMap * @throws java.io.IOException */ public NoteMap merge(NoteMap base, NoteMap ours, NoteMap theirs) throws IOException { try { InMemoryNoteBucket mergedBucket = merge(0, base.getRoot(), ours.getRoot(), theirs.getRoot()); inserter.flush(); return NoteMap.newMap(mergedBucket, reader); } finally { reader.close(); inserter.close(); } }
boolean ok = mergeImpl(); if (ok && flush) inserter.flush(); return ok; } finally {
private void receivePack(final ProgressMonitor monitor, OutputStream outputStream) throws IOException { onReceivePack(); InputStream input = in; if (sideband) input = new SideBandInputStream(input, monitor, getMessageWriter(), outputStream); try (ObjectInserter ins = local.newObjectInserter()) { PackParser parser = ins.newPackParser(input); parser.setAllowThin(thinPack); parser.setObjectChecker(transport.getObjectChecker()); parser.setLockMessage(lockMessage); packLock = parser.parse(monitor); ins.flush(); } }
private NonNoteEntry mergeNonNotes(NonNoteEntry baseList, NonNoteEntry oursList, NonNoteEntry theirsList) throws IOException { if (baseList == null && oursList == null && theirsList == null) return null; ObjectId baseId = write(baseList); ObjectId oursId = write(oursList); ObjectId theirsId = write(theirsList); inserter.flush(); Merger m = nonNotesMergeStrategy.newMerger(db, true); if (m instanceof ThreeWayMerger) ((ThreeWayMerger) m).setBase(baseId); if (!m.merge(oursId, theirsId)) throw new NotesMergeConflictException(baseList, oursList, theirsList); ObjectId resultTreeId = m.getResultTreeId(); AbbreviatedObjectId none = AbbreviatedObjectId.fromString(""); //$NON-NLS-1$ return NoteParser.parse(none, resultTreeId, reader).nonNotes; }
ins.flush(); return cmds;
static void commitNoteMap(Repository r, String ref, RevWalk walk, NoteMap map, RevCommit notesCommit, ObjectInserter inserter, String msg) throws IOException { // commit the note CommitBuilder builder = new CommitBuilder(); builder.setTreeId(map.writeTree(inserter)); builder.setAuthor(new PersonIdent(r)); builder.setCommitter(builder.getAuthor()); builder.setMessage(msg); if (notesCommit != null) builder.setParentIds(notesCommit); ObjectId commit = inserter.insert(builder); inserter.flush(); RefUpdate refUpdate = r.updateRef(ref); if (notesCommit != null) refUpdate.setExpectedOldObjectId(notesCommit); else refUpdate.setExpectedOldObjectId(ObjectId.zeroId()); refUpdate.setNewObjectId(commit); refUpdate.update(walk); }
inserter.flush();
packSize = Long.valueOf(parser.getPackSize()); stats = parser.getReceivedPackStatistics(); ins.flush();
builder.setTreeId(cache.writeTree(inserter)); commitId = inserter.insert(builder); inserter.flush();
private boolean apply(List<Command> todo) throws IOException { if (!tree.apply(todo)) { // apply set rejection information on commands. return false; } Repository repo = refdb.getRepository(); try (ObjectInserter ins = repo.newObjectInserter()) { CommitBuilder b = new CommitBuilder(); b.setTreeId(tree.writeTree(ins)); if (parentTreeId.equals(b.getTreeId())) { for (Command c : todo) { c.setResult(OK); } return true; } if (!parentCommitId.equals(ObjectId.zeroId())) { b.setParentId(parentCommitId); } author = getRefLogIdent(); if (author == null) { author = new PersonIdent(repo); } b.setAuthor(author); b.setCommitter(author); b.setMessage(getRefLogMessage()); newCommitId = ins.insert(b); ins.flush(); } return true; }
commit.setTreeId(indexTreeId); ObjectId commitId = odi.insert(commit); odi.flush();
inserter.flush();
ObjectInserter odi = getObjectInserter(); resultTree = cache.writeTree(odi); odi.flush(); return true; } catch (UnmergedPathException upe) {
lastAdded = path; inserter.flush(); builder.commit(); setCallable(false);