List of usage examples for org.eclipse.jgit.lib RefUpdate setExpectedOldObjectId
public void setExpectedOldObjectId(AnyObjectId id)
From source file:com.google.gerrit.server.git.strategy.CherryPick.java
License:Apache License
private CodeReviewCommit writeCherryPickCommit(CodeReviewCommit mergeTip, CodeReviewCommit n) throws IOException, OrmException, NoSuchChangeException, MergeConflictException, MergeIdenticalTreeException {/*from w w w .jav a 2 s. c o m*/ args.rw.parseBody(n); String cherryPickCmtMsg = args.mergeUtil.createCherryPickCommitMessage(n); PersonIdent committer = args.caller.newCommitterIdent(TimeUtil.nowTs(), args.serverIdent.get().getTimeZone()); CodeReviewCommit newCommit = args.mergeUtil.createCherryPickFromCommit(args.repo, args.inserter, mergeTip, n, committer, cherryPickCmtMsg, args.rw); PatchSet.Id id = ChangeUtil.nextPatchSetId(args.repo, n.change().currentPatchSetId()); PatchSet ps = new PatchSet(id); ps.setCreatedOn(TimeUtil.nowTs()); ps.setUploader(args.caller.getAccountId()); ps.setRevision(new RevId(newCommit.getId().getName())); RefUpdate ru; args.db.changes().beginTransaction(n.change().getId()); try { insertAncestors(args.db, ps.getId(), newCommit); ps.setGroups(GroupCollector.getCurrentGroups(args.db, n.change())); args.db.patchSets().insert(Collections.singleton(ps)); n.change().setCurrentPatchSet(patchSetInfoFactory.get(newCommit, ps.getId())); args.db.changes().update(Collections.singletonList(n.change())); List<PatchSetApproval> approvals = Lists.newArrayList(); for (PatchSetApproval a : args.approvalsUtil.byPatchSet(args.db, n.getControl(), n.getPatchsetId())) { approvals.add(new PatchSetApproval(ps.getId(), a)); } args.db.patchSetApprovals().insert(approvals); ru = args.repo.updateRef(ps.getRefName()); ru.setExpectedOldObjectId(ObjectId.zeroId()); ru.setNewObjectId(newCommit); ru.disableRefLog(); if (ru.update(args.rw) != RefUpdate.Result.NEW) { throw new IOException(String.format("Failed to create ref %s in %s: %s", ps.getRefName(), n.change().getDest().getParentKey().get(), ru.getResult())); } args.db.commit(); } finally { args.db.rollback(); } gitRefUpdated.fire(n.change().getProject(), ru); newCommit.copyFrom(n); newCommit.setStatusCode(CommitMergeStatus.CLEAN_PICK); newCommit.setControl(args.changeControlFactory.controlFor(n.change(), args.caller)); newCommits.put(newCommit.getPatchsetId().getParentKey(), newCommit); setRefLogIdent(); return newCommit; }
From source file:com.google.gerrit.server.git.SubmoduleOp.java
License:Apache License
/** * Update the submodules in one branch of one repository. * * @param subscriber the branch of the repository which should be changed. * @param updates submodule updates which should be updated to. * @throws SubmoduleException/* w w w . ja v a 2 s. co m*/ */ private void updateGitlinks(ReviewDb db, Branch.NameKey subscriber, Collection<SubmoduleSubscription> updates) throws SubmoduleException { PersonIdent author = null; StringBuilder msgbuf = new StringBuilder("Updated git submodules\n\n"); boolean sameAuthorForAll = true; try (Repository pdb = repoManager.openRepository(subscriber.getParentKey())) { if (pdb.getRef(subscriber.get()) == null) { throw new SubmoduleException("The branch was probably deleted from the subscriber repository"); } DirCache dc = readTree(pdb, pdb.getRef(subscriber.get())); DirCacheEditor ed = dc.editor(); for (SubmoduleSubscription s : updates) { try (Repository subrepo = repoManager.openRepository(s.getSubmodule().getParentKey()); RevWalk rw = CodeReviewCommit.newRevWalk(subrepo)) { Ref ref = subrepo.getRefDatabase().exactRef(s.getSubmodule().get()); if (ref == null) { ed.add(new DeletePath(s.getPath())); continue; } final ObjectId updateTo = ref.getObjectId(); RevCommit newCommit = rw.parseCommit(updateTo); if (author == null) { author = newCommit.getAuthorIdent(); } else if (!author.equals(newCommit.getAuthorIdent())) { sameAuthorForAll = false; } DirCacheEntry dce = dc.getEntry(s.getPath()); ObjectId oldId; if (dce != null) { if (!dce.getFileMode().equals(FileMode.GITLINK)) { log.error("Requested to update gitlink " + s.getPath() + " in " + s.getSubmodule().getParentKey().get() + " but entry " + "doesn't have gitlink file mode."); continue; } oldId = dce.getObjectId(); } else { // This submodule did not exist before. We do not want to add // the full submodule history to the commit message, so omit it. oldId = updateTo; } ed.add(new PathEdit(s.getPath()) { @Override public void apply(DirCacheEntry ent) { ent.setFileMode(FileMode.GITLINK); ent.setObjectId(updateTo); } }); if (verboseSuperProject) { msgbuf.append("Project: " + s.getSubmodule().getParentKey().get()); msgbuf.append(" " + s.getSubmodule().getShortName()); msgbuf.append(" " + updateTo.getName()); msgbuf.append("\n\n"); try { rw.markStart(newCommit); rw.markUninteresting(rw.parseCommit(oldId)); for (RevCommit c : rw) { msgbuf.append(c.getFullMessage() + "\n\n"); } } catch (IOException e) { logAndThrowSubmoduleException( "Could not perform a revwalk to " + "create superproject commit message", e); } } } } ed.finish(); if (!sameAuthorForAll || author == null) { author = myIdent; } ObjectInserter oi = pdb.newObjectInserter(); ObjectId tree = dc.writeTree(oi); ObjectId currentCommitId = pdb.getRef(subscriber.get()).getObjectId(); CommitBuilder commit = new CommitBuilder(); commit.setTreeId(tree); commit.setParentIds(new ObjectId[] { currentCommitId }); commit.setAuthor(author); commit.setCommitter(myIdent); commit.setMessage(msgbuf.toString()); oi.insert(commit); oi.flush(); ObjectId commitId = oi.idFor(Constants.OBJ_COMMIT, commit.build()); final RefUpdate rfu = pdb.updateRef(subscriber.get()); rfu.setForceUpdate(false); rfu.setNewObjectId(commitId); rfu.setExpectedOldObjectId(currentCommitId); rfu.setRefLogMessage("Submit to " + subscriber.getParentKey().get(), true); switch (rfu.update()) { case NEW: case FAST_FORWARD: gitRefUpdated.fire(subscriber.getParentKey(), rfu); changeHooks.doRefUpdatedHook(subscriber, rfu, account); // TODO since this is performed "in the background" no mail will be // sent to inform users about the updated branch break; default: throw new IOException(rfu.getResult().name()); } // Recursive call: update subscribers of the subscriber updateSuperProjects(db, Sets.newHashSet(subscriber)); } catch (IOException e) { throw new SubmoduleException("Cannot update gitlinks for " + subscriber.get(), e); } }
From source file:com.google.gerrit.server.git.VersionedMetaData.java
License:Apache License
/** * Open a batch of updates to the same metadata ref. * <p>// w ww .j a va 2 s .c o m * This allows making multiple commits to a single metadata ref, at the end of * which is a single ref update. For batching together updates to multiple * refs (each consisting of one or more commits against their respective * refs), create the {@link MetaDataUpdate} with a {@link BatchRefUpdate}. * <p> * A ref update produced by this {@link BatchMetaDataUpdate} is only committed * if there is no associated {@link BatchRefUpdate}. As a result, the * configured ref updated event is not fired if there is an associated batch. * * @param update helper info about the update. * @throws IOException if the update failed. */ public BatchMetaDataUpdate openUpdate(final MetaDataUpdate update) throws IOException { final Repository db = update.getRepository(); reader = db.newObjectReader(); inserter = db.newObjectInserter(); final RevWalk rw = new RevWalk(reader); final RevTree tree = revision != null ? rw.parseTree(revision) : null; newTree = readTree(tree); return new BatchMetaDataUpdate() { AnyObjectId src = revision; AnyObjectId srcTree = tree; @Override public void write(CommitBuilder commit) throws IOException { write(VersionedMetaData.this, commit); } private boolean doSave(VersionedMetaData config, CommitBuilder commit) throws IOException { DirCache nt = config.newTree; ObjectReader r = config.reader; ObjectInserter i = config.inserter; try { config.newTree = newTree; config.reader = reader; config.inserter = inserter; return config.onSave(commit); } catch (ConfigInvalidException e) { throw new IOException( "Cannot update " + getRefName() + " in " + db.getDirectory() + ": " + e.getMessage(), e); } finally { config.newTree = nt; config.reader = r; config.inserter = i; } } @Override public void write(VersionedMetaData config, CommitBuilder commit) throws IOException { if (!doSave(config, commit)) { return; } // Reuse tree from parent commit unless there are contents in newTree or // there is no tree for a parent commit. ObjectId res = newTree.getEntryCount() != 0 || srcTree == null ? newTree.writeTree(inserter) : srcTree.copy(); if (res.equals(srcTree) && !update.allowEmpty() && (commit.getTreeId() == null)) { // If there are no changes to the content, don't create the commit. return; } // If changes are made to the DirCache and those changes are written as // a commit and then the tree ID is set for the CommitBuilder, then // those previous DirCache changes will be ignored and the commit's // tree will be replaced with the ID in the CommitBuilder. The same is // true if you explicitly set tree ID in a commit and then make changes // to the DirCache; that tree ID will be ignored and replaced by that of // the tree for the updated DirCache. if (commit.getTreeId() == null) { commit.setTreeId(res); } else { // In this case, the caller populated the tree without using DirCache. res = commit.getTreeId(); } if (src != null) { commit.addParentId(src); } if (update.insertChangeId()) { ObjectId id = ChangeIdUtil.computeChangeId(res, getRevision(), commit.getAuthor(), commit.getCommitter(), commit.getMessage()); commit.setMessage(ChangeIdUtil.insertId(commit.getMessage(), id)); } src = inserter.insert(commit); srcTree = res; } @Override public RevCommit createRef(String refName) throws IOException { if (Objects.equals(src, revision)) { return revision; } return updateRef(ObjectId.zeroId(), src, refName); } @Override public void removeRef(String refName) throws IOException { RefUpdate ru = db.updateRef(refName); ru.setForceUpdate(true); if (revision != null) { ru.setExpectedOldObjectId(revision); } RefUpdate.Result result = ru.delete(); switch (result) { case FORCED: update.fireGitRefUpdatedEvent(ru); return; default: throw new IOException( "Cannot delete " + ru.getName() + " in " + db.getDirectory() + ": " + ru.getResult()); } } @Override public RevCommit commit() throws IOException { return commitAt(revision); } @Override public RevCommit commitAt(ObjectId expected) throws IOException { if (Objects.equals(src, expected)) { return revision; } return updateRef(MoreObjects.firstNonNull(expected, ObjectId.zeroId()), src, getRefName()); } @Override public void close() { newTree = null; rw.close(); if (inserter != null) { inserter.close(); inserter = null; } if (reader != null) { reader.close(); reader = null; } } private RevCommit updateRef(AnyObjectId oldId, AnyObjectId newId, String refName) throws IOException { BatchRefUpdate bru = update.getBatch(); if (bru != null) { bru.addCommand(new ReceiveCommand(oldId.toObjectId(), newId.toObjectId(), refName)); inserter.flush(); revision = rw.parseCommit(newId); return revision; } RefUpdate ru = db.updateRef(refName); ru.setExpectedOldObjectId(oldId); ru.setNewObjectId(src); ru.setRefLogIdent(update.getCommitBuilder().getAuthor()); String message = update.getCommitBuilder().getMessage(); if (message == null) { message = "meta data update"; } try (BufferedReader reader = new BufferedReader(new StringReader(message))) { // read the subject line and use it as reflog message ru.setRefLogMessage("commit: " + reader.readLine(), true); } inserter.flush(); RefUpdate.Result result = ru.update(); switch (result) { case NEW: case FAST_FORWARD: revision = rw.parseCommit(ru.getNewObjectId()); update.fireGitRefUpdatedEvent(ru); return revision; default: throw new IOException( "Cannot update " + ru.getName() + " in " + db.getDirectory() + ": " + ru.getResult()); } } }; }
From source file:com.google.gerrit.server.notedb.ChangeDelete.java
License:Apache License
public void delete() throws OrmException, IOException { plcUtil.deleteAllDraftsFromAllUsers(notes.getChangeId()); RefUpdate ru = repo.updateRef(notes.getRefName()); ru.setExpectedOldObjectId(notes.load().getRevision()); ru.setNewObjectId(ObjectId.zeroId()); ru.setForceUpdate(true);/*from w w w.ja va 2s. c om*/ ru.setRefLogMessage("Delete change from NoteDb", false); RefUpdate.Result result = ru.delete(); switch (result) { case FAST_FORWARD: case FORCED: case NO_CHANGE: break; case IO_FAILURE: case LOCK_FAILURE: case NEW: case NOT_ATTEMPTED: case REJECTED: case REJECTED_CURRENT_BRANCH: case RENAMED: default: throw new IOException(String.format("Failed to delete change ref %s at %s: %s", notes.getRefName(), notes.getRevision(), result)); } }
From source file:com.google.gerrit.server.project.CreateBranch.java
License:Apache License
@Override public BranchInfo apply(ProjectResource rsrc, Input input) throws BadRequestException, AuthException, ResourceConflictException, IOException { if (input == null) { input = new Input(); }//from w ww . j a v a 2s. co m if (input.ref != null && !ref.equals(input.ref)) { throw new BadRequestException("ref must match URL"); } if (input.revision == null) { input.revision = Constants.HEAD; } while (ref.startsWith("/")) { ref = ref.substring(1); } ref = RefNames.fullName(ref); if (!Repository.isValidRefName(ref)) { throw new BadRequestException("invalid branch name \"" + ref + "\""); } if (MagicBranch.isMagicBranch(ref)) { throw new BadRequestException( "not allowed to create branches under \"" + MagicBranch.getMagicRefNamePrefix(ref) + "\""); } final Branch.NameKey name = new Branch.NameKey(rsrc.getNameKey(), ref); final RefControl refControl = rsrc.getControl().controlForRef(name); try (Repository repo = repoManager.openRepository(rsrc.getNameKey())) { final ObjectId revid = parseBaseRevision(repo, rsrc.getNameKey(), input.revision); final RevWalk rw = verifyConnected(repo, revid); RevObject object = rw.parseAny(revid); if (ref.startsWith(Constants.R_HEADS)) { // Ensure that what we start the branch from is a commit. If we // were given a tag, deference to the commit instead. // try { object = rw.parseCommit(object); } catch (IncorrectObjectTypeException notCommit) { throw new BadRequestException("\"" + input.revision + "\" not a commit"); } } rw.reset(); if (!refControl.canCreate(db.get(), rw, object)) { throw new AuthException("Cannot create \"" + ref + "\""); } try { final RefUpdate u = repo.updateRef(ref); u.setExpectedOldObjectId(ObjectId.zeroId()); u.setNewObjectId(object.copy()); u.setRefLogIdent(identifiedUser.get().newRefLogIdent()); u.setRefLogMessage("created via REST from " + input.revision, false); final RefUpdate.Result result = u.update(rw); switch (result) { case FAST_FORWARD: case NEW: case NO_CHANGE: referenceUpdated.fire(name.getParentKey(), u, ReceiveCommand.Type.CREATE); hooks.doRefUpdatedHook(name, u, identifiedUser.get().getAccount()); break; case LOCK_FAILURE: if (repo.getRefDatabase().exactRef(ref) != null) { throw new ResourceConflictException("branch \"" + ref + "\" already exists"); } String refPrefix = getRefPrefix(ref); while (!Constants.R_HEADS.equals(refPrefix)) { if (repo.getRefDatabase().exactRef(refPrefix) != null) { throw new ResourceConflictException("Cannot create branch \"" + ref + "\" since it conflicts with branch \"" + refPrefix + "\"."); } refPrefix = getRefPrefix(refPrefix); } //$FALL-THROUGH$ default: { throw new IOException(result.name()); } } BranchInfo info = new BranchInfo(); info.ref = ref; info.revision = revid.getName(); info.canDelete = refControl.canDelete() ? true : null; return info; } catch (IOException err) { log.error("Cannot create branch \"" + name + "\"", err); throw err; } } catch (InvalidRevisionException e) { throw new BadRequestException("invalid revision \"" + input.revision + "\""); } }
From source file:com.google.gerrit.server.project.DeleteRef.java
License:Apache License
private void deleteSingleRef(Repository r) throws IOException, ResourceConflictException { String ref = refsToDelete.get(0); if (prefix != null && !ref.startsWith(prefix)) { ref = prefix + ref;// ww w .j a v a 2 s . c om } RefUpdate.Result result; RefUpdate u = r.updateRef(ref); u.setExpectedOldObjectId(r.exactRef(ref).getObjectId()); u.setNewObjectId(ObjectId.zeroId()); u.setForceUpdate(true); refDeletionValidator.validateRefOperation(resource.getName(), identifiedUser.get(), u); int remainingLockFailureCalls = MAX_LOCK_FAILURE_CALLS; for (;;) { try { result = u.delete(); } catch (LockFailedException e) { result = RefUpdate.Result.LOCK_FAILURE; } catch (IOException e) { log.error("Cannot delete " + ref, e); throw e; } if (result == RefUpdate.Result.LOCK_FAILURE && --remainingLockFailureCalls > 0) { try { Thread.sleep(SLEEP_ON_LOCK_FAILURE_MS); } catch (InterruptedException ie) { // ignore } } else { break; } } switch (result) { case NEW: case NO_CHANGE: case FAST_FORWARD: case FORCED: referenceUpdated.fire(resource.getNameKey(), u, ReceiveCommand.Type.DELETE, identifiedUser.get().getAccount()); break; case REJECTED_CURRENT_BRANCH: log.error("Cannot delete " + ref + ": " + result.name()); throw new ResourceConflictException("cannot delete current branch"); case IO_FAILURE: case LOCK_FAILURE: case NOT_ATTEMPTED: case REJECTED: case RENAMED: default: log.error("Cannot delete " + ref + ": " + result.name()); throw new ResourceConflictException("cannot delete: " + result.name()); } }
From source file:com.google.gerrit.server.project.DeleteRef.java
License:Apache License
private ReceiveCommand createDeleteCommand(ProjectResource project, Repository r, String refName) throws OrmException, IOException, ResourceConflictException { Ref ref = r.getRefDatabase().getRef(refName); ReceiveCommand command;//from www . j av a2 s . co m if (ref == null) { command = new ReceiveCommand(ObjectId.zeroId(), ObjectId.zeroId(), refName); command.setResult(Result.REJECTED_OTHER_REASON, "it doesn't exist or you do not have permission to delete it"); return command; } command = new ReceiveCommand(ref.getObjectId(), ObjectId.zeroId(), ref.getName()); if (!project.getControl().controlForRef(refName).canDelete()) { command.setResult(Result.REJECTED_OTHER_REASON, "it doesn't exist or you do not have permission to delete it"); } if (!refName.startsWith(R_TAGS)) { Branch.NameKey branchKey = new Branch.NameKey(project.getNameKey(), ref.getName()); if (!queryProvider.get().setLimit(1).byBranchOpen(branchKey).isEmpty()) { command.setResult(Result.REJECTED_OTHER_REASON, "it has open changes"); } } RefUpdate u = r.updateRef(refName); u.setForceUpdate(true); u.setExpectedOldObjectId(r.exactRef(refName).getObjectId()); u.setNewObjectId(ObjectId.zeroId()); refDeletionValidator.validateRefOperation(project.getName(), identifiedUser.get(), u); return command; }
From source file:com.google.gerrit.server.schema.Schema_146.java
License:Apache License
private void rewriteUserBranch(Repository repo, RevWalk rw, ObjectInserter oi, ObjectId emptyTree, Ref ref, Account account) throws IOException { ObjectId current = createInitialEmptyCommit(oi, emptyTree, account.getRegisteredOn()); rw.reset();//from www . j ava2s. co m rw.sort(RevSort.TOPO); rw.sort(RevSort.REVERSE, true); rw.markStart(rw.parseCommit(ref.getObjectId())); RevCommit c; while ((c = rw.next()) != null) { if (isInitialEmptyCommit(emptyTree, c)) { return; } CommitBuilder cb = new CommitBuilder(); cb.setParentId(current); cb.setTreeId(c.getTree()); cb.setAuthor(c.getAuthorIdent()); cb.setCommitter(c.getCommitterIdent()); cb.setMessage(c.getFullMessage()); cb.setEncoding(c.getEncoding()); current = oi.insert(cb); } oi.flush(); RefUpdate ru = repo.updateRef(ref.getName()); ru.setExpectedOldObjectId(ref.getObjectId()); ru.setNewObjectId(current); ru.setForceUpdate(true); ru.setRefLogIdent(serverIdent); ru.setRefLogMessage(getClass().getSimpleName(), true); Result result = ru.update(); if (result != Result.FORCED) { throw new IOException(String.format("Failed to update ref %s: %s", ref.getName(), result.name())); } }
From source file:com.google.gerrit.server.StarredChangesUtil.java
License:Apache License
private void updateLabels(Repository repo, String refName, ObjectId oldObjectId, SortedSet<String> labels) throws IOException, OrmException { try (RevWalk rw = new RevWalk(repo)) { RefUpdate u = repo.updateRef(refName); u.setExpectedOldObjectId(oldObjectId); u.setForceUpdate(true);//from w w w. j ava 2s .c o m u.setNewObjectId(writeLabels(repo, labels)); u.setRefLogIdent(serverIdent); u.setRefLogMessage("Update star labels", true); RefUpdate.Result result = u.update(rw); switch (result) { case NEW: case FORCED: case NO_CHANGE: case FAST_FORWARD: return; case IO_FAILURE: case LOCK_FAILURE: case NOT_ATTEMPTED: case REJECTED: case REJECTED_CURRENT_BRANCH: case RENAMED: throw new OrmException( String.format("Update star labels on ref %s failed: %s", refName, result.name())); } } }
From source file:com.googlesource.gerrit.plugins.changefabricator.ChangeFabricator.java
License:Apache License
private Change.Id createNewChange(Repository git, RevWalk revWalk, Change.Key changeKey, Project.NameKey project, Ref destRef, RevCommit emptyCommit, RefControl refControl) throws OrmException, InvalidChangeOperationException, IOException { IdentifiedUser me = (IdentifiedUser) userProvider.get(); Change change = new Change(changeKey, new Change.Id(db.nextChangeId()), me.getAccountId(), new Branch.NameKey(project, destRef.getName()), TimeUtil.nowTs()); ChangeInserter ins = changeInserterFactory.create(refControl, change, emptyCommit); PatchSet newPatchSet = ins.getPatchSet(); CommitValidators commitValidators = commitValidatorsFactory.create(refControl, new NoSshInfo(), git); CommitReceivedEvent commitReceivedEvent = new CommitReceivedEvent( new ReceiveCommand(ObjectId.zeroId(), emptyCommit.getId(), newPatchSet.getRefName()), refControl.getProjectControl().getProject(), refControl.getRefName(), emptyCommit, me); try {/*from w w w.ja va2 s . co m*/ commitValidators.validateForGerritCommits(commitReceivedEvent); } catch (CommitValidationException e) { throw new InvalidChangeOperationException(e.getMessage()); } final RefUpdate ru = git.updateRef(newPatchSet.getRefName()); ru.setExpectedOldObjectId(ObjectId.zeroId()); ru.setNewObjectId(emptyCommit); ru.disableRefLog(); if (ru.update(revWalk) != RefUpdate.Result.NEW) { throw new IOException(String.format("Failed to create ref %s in %s: %s", newPatchSet.getRefName(), change.getDest().getParentKey().get(), ru.getResult())); } ins.insert(); return change.getId(); }