Java tutorial
/* * Copyright 2013 gitblit.com. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.gitblit.git; import static org.eclipse.jgit.transport.BasePackPushConnection.CAPABILITY_SIDE_BAND_64K; import java.io.IOException; import java.text.MessageFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUnit; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.eclipse.jgit.lib.BatchRefUpdate; import org.eclipse.jgit.lib.NullProgressMonitor; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.ProgressMonitor; import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.RefUpdate; import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.revwalk.RevSort; import org.eclipse.jgit.revwalk.RevWalk; import org.eclipse.jgit.transport.ReceiveCommand; import org.eclipse.jgit.transport.ReceiveCommand.Result; import org.eclipse.jgit.transport.ReceiveCommand.Type; import org.eclipse.jgit.transport.ReceivePack; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.gitblit.Constants; import com.gitblit.Keys; import com.gitblit.extensions.PatchsetHook; import com.gitblit.manager.IGitblit; import com.gitblit.models.RepositoryModel; import com.gitblit.models.TicketModel; import com.gitblit.models.TicketModel.Change; import com.gitblit.models.TicketModel.Field; import com.gitblit.models.TicketModel.Patchset; import com.gitblit.models.TicketModel.PatchsetType; import com.gitblit.models.TicketModel.Status; import com.gitblit.models.TicketModel.TicketAction; import com.gitblit.models.TicketModel.TicketLink; import com.gitblit.models.UserModel; import com.gitblit.tickets.BranchTicketService; import com.gitblit.tickets.ITicketService; import com.gitblit.tickets.TicketMilestone; import com.gitblit.tickets.TicketNotifier; import com.gitblit.utils.ArrayUtils; import com.gitblit.utils.DiffUtils; import com.gitblit.utils.DiffUtils.DiffStat; import com.gitblit.utils.JGitUtils; import com.gitblit.utils.JGitUtils.MergeResult; import com.gitblit.utils.JGitUtils.MergeStatus; import com.gitblit.utils.RefLogUtils; import com.gitblit.utils.StringUtils; import com.google.common.collect.Lists; /** * PatchsetReceivePack processes receive commands and allows for creating, updating, * and closing Gitblit tickets. It also executes Groovy pre- and post- receive * hooks. * * The patchset mechanism defined in this class is based on the ReceiveCommits class * from the Gerrit code review server. * * The general execution flow is: * <ol> * <li>onPreReceive()</li> * <li>executeCommands()</li> * <li>onPostReceive()</li> * </ol> * * @author Android Open Source Project * @author James Moger * */ public class PatchsetReceivePack extends GitblitReceivePack { protected static final List<String> MAGIC_REFS = Arrays.asList(Constants.R_FOR, Constants.R_TICKET); protected static final Pattern NEW_PATCHSET = Pattern .compile("^refs/tickets/(?:[0-9a-zA-Z][0-9a-zA-Z]/)?([1-9][0-9]*)(?:/new)?$"); private static final Logger LOGGER = LoggerFactory.getLogger(PatchsetReceivePack.class); protected final ITicketService ticketService; protected final TicketNotifier ticketNotifier; private boolean requireMergeablePatchset; public PatchsetReceivePack(IGitblit gitblit, Repository db, RepositoryModel repository, UserModel user) { super(gitblit, db, repository, user); this.ticketService = gitblit.getTicketService(); this.ticketNotifier = ticketService.createNotifier(); } /** Returns the patchset ref root from the ref */ private String getPatchsetRef(String refName) { for (String patchRef : MAGIC_REFS) { if (refName.startsWith(patchRef)) { return patchRef; } } return null; } /** Checks if the supplied ref name is a patchset ref */ private boolean isPatchsetRef(String refName) { return !StringUtils.isEmpty(getPatchsetRef(refName)); } /** Checks if the supplied ref name is a change ref */ private boolean isTicketRef(String refName) { return refName.startsWith(Constants.R_TICKETS_PATCHSETS); } /** Extracts the integration branch from the ref name */ private String getIntegrationBranch(String refName) { String patchsetRef = getPatchsetRef(refName); String branch = refName.substring(patchsetRef.length()); if (branch.indexOf('%') > -1) { branch = branch.substring(0, branch.indexOf('%')); } String defaultBranch = "master"; try { defaultBranch = getRepository().getBranch(); } catch (Exception e) { LOGGER.error("failed to determine default branch for " + repository.name, e); } if (!StringUtils.isEmpty(getRepositoryModel().mergeTo)) { // repository settings specifies a default integration branch defaultBranch = Repository.shortenRefName(getRepositoryModel().mergeTo); } long ticketId = 0L; try { ticketId = Long.parseLong(branch); } catch (Exception e) { // not a number } if (ticketId > 0 || branch.equalsIgnoreCase("default") || branch.equalsIgnoreCase("new")) { return defaultBranch; } return branch; } /** Extracts the ticket id from the ref name */ private long getTicketId(String refName) { if (refName.indexOf('%') > -1) { refName = refName.substring(0, refName.indexOf('%')); } if (refName.startsWith(Constants.R_FOR)) { String ref = refName.substring(Constants.R_FOR.length()); try { return Long.parseLong(ref); } catch (Exception e) { // not a number } } else if (refName.startsWith(Constants.R_TICKET) || refName.startsWith(Constants.R_TICKETS_PATCHSETS)) { return PatchsetCommand.getTicketNumber(refName); } return 0L; } /** Returns true if the ref namespace exists */ private boolean hasRefNamespace(String ref) { Map<String, Ref> blockingFors; try { blockingFors = getRepository().getRefDatabase().getRefs(ref); } catch (IOException err) { sendError("Cannot scan refs in {0}", repository.name); LOGGER.error("Error!", err); return true; } if (!blockingFors.isEmpty()) { sendError("{0} needs the following refs removed to receive patchsets: {1}", repository.name, blockingFors.keySet()); return true; } return false; } /** Removes change ref receive commands */ private List<ReceiveCommand> excludeTicketCommands(Collection<ReceiveCommand> commands) { List<ReceiveCommand> filtered = new ArrayList<ReceiveCommand>(); for (ReceiveCommand cmd : commands) { if (!isTicketRef(cmd.getRefName())) { // this is not a ticket ref update filtered.add(cmd); } } return filtered; } /** Removes patchset receive commands for pre- and post- hook integrations */ private List<ReceiveCommand> excludePatchsetCommands(Collection<ReceiveCommand> commands) { List<ReceiveCommand> filtered = new ArrayList<ReceiveCommand>(); for (ReceiveCommand cmd : commands) { if (!isPatchsetRef(cmd.getRefName())) { // this is a non-patchset ref update filtered.add(cmd); } } return filtered; } /** Process receive commands EXCEPT for Patchset commands. */ @Override public void onPreReceive(ReceivePack rp, Collection<ReceiveCommand> commands) { Collection<ReceiveCommand> filtered = excludePatchsetCommands(commands); super.onPreReceive(rp, filtered); } /** Process receive commands EXCEPT for Patchset commands. */ @Override public void onPostReceive(ReceivePack rp, Collection<ReceiveCommand> commands) { Collection<ReceiveCommand> filtered = excludePatchsetCommands(commands); super.onPostReceive(rp, filtered); // send all queued ticket notifications after processing all patchsets ticketNotifier.sendAll(); } @Override protected void validateCommands() { // workaround for JGit's awful scoping choices // // set the patchset refs to OK to bypass checks in the super implementation for (final ReceiveCommand cmd : filterCommands(Result.NOT_ATTEMPTED)) { if (isPatchsetRef(cmd.getRefName())) { if (cmd.getType() == ReceiveCommand.Type.CREATE) { cmd.setResult(Result.OK); } } } super.validateCommands(); } /** Execute commands to update references. */ @Override protected void executeCommands() { // we process patchsets unless the user is pushing something special boolean processPatchsets = true; for (ReceiveCommand cmd : filterCommands(Result.NOT_ATTEMPTED)) { if (ticketService instanceof BranchTicketService && BranchTicketService.BRANCH.equals(cmd.getRefName())) { // the user is pushing an update to the BranchTicketService data processPatchsets = false; } } // workaround for JGit's awful scoping choices // // reset the patchset refs to NOT_ATTEMPTED (see validateCommands) for (ReceiveCommand cmd : filterCommands(Result.OK)) { if (isPatchsetRef(cmd.getRefName())) { cmd.setResult(Result.NOT_ATTEMPTED); } else if (ticketService instanceof BranchTicketService && BranchTicketService.BRANCH.equals(cmd.getRefName())) { // the user is pushing an update to the BranchTicketService data processPatchsets = false; } } List<ReceiveCommand> toApply = filterCommands(Result.NOT_ATTEMPTED); if (toApply.isEmpty()) { return; } ProgressMonitor updating = NullProgressMonitor.INSTANCE; boolean sideBand = isCapabilityEnabled(CAPABILITY_SIDE_BAND_64K); if (sideBand) { SideBandProgressMonitor pm = new SideBandProgressMonitor(msgOut); pm.setDelayStart(250, TimeUnit.MILLISECONDS); updating = pm; } BatchRefUpdate batch = getRepository().getRefDatabase().newBatchUpdate(); batch.setAllowNonFastForwards(isAllowNonFastForwards()); batch.setRefLogIdent(getRefLogIdent()); batch.setRefLogMessage("push", true); ReceiveCommand patchsetRefCmd = null; PatchsetCommand patchsetCmd = null; for (ReceiveCommand cmd : toApply) { if (Result.NOT_ATTEMPTED != cmd.getResult()) { // Already rejected by the core receive process. continue; } if (isPatchsetRef(cmd.getRefName()) && processPatchsets) { if (ticketService == null) { sendRejection(cmd, "Sorry, the ticket service is unavailable and can not accept patchsets at this time."); continue; } if (!ticketService.isReady()) { sendRejection(cmd, "Sorry, the ticket service can not accept patchsets at this time."); continue; } if (UserModel.ANONYMOUS.equals(user)) { // server allows anonymous pushes, but anonymous patchset // contributions are prohibited by design sendRejection(cmd, "Sorry, anonymous patchset contributions are prohibited."); continue; } final Matcher m = NEW_PATCHSET.matcher(cmd.getRefName()); if (m.matches()) { // prohibit pushing directly to a patchset ref long id = getTicketId(cmd.getRefName()); sendError("You may not directly push directly to a patchset ref!"); sendError("Instead, please push to one the following:"); sendError(" - {0}{1,number,0}", Constants.R_FOR, id); sendError(" - {0}{1,number,0}", Constants.R_TICKET, id); sendRejection(cmd, "protected ref"); continue; } if (hasRefNamespace(Constants.R_FOR)) { // the refs/for/ namespace exists and it must not LOGGER.error("{} already has refs in the {} namespace", repository.name, Constants.R_FOR); sendRejection(cmd, "Sorry, a repository administrator will have to remove the {} namespace", Constants.R_FOR); continue; } if (cmd.getNewId().equals(ObjectId.zeroId())) { // ref deletion request if (cmd.getRefName().startsWith(Constants.R_TICKET)) { if (user.canDeleteRef(repository)) { batch.addCommand(cmd); } else { sendRejection(cmd, "Sorry, you do not have permission to delete {}", cmd.getRefName()); } } else { sendRejection(cmd, "Sorry, you can not delete {}", cmd.getRefName()); } continue; } if (patchsetRefCmd != null) { sendRejection(cmd, "You may only push one patchset at a time."); continue; } LOGGER.info(MessageFormat.format("Verifying {0} push ref \"{1}\" received from {2}", repository.name, cmd.getRefName(), user.username)); // responsible verification String responsible = PatchsetCommand.getSingleOption(cmd, PatchsetCommand.RESPONSIBLE); if (!StringUtils.isEmpty(responsible)) { UserModel assignee = gitblit.getUserModel(responsible); if (assignee == null) { // no account by this name sendRejection(cmd, "{0} can not be assigned any tickets because there is no user account by that name", responsible); continue; } else if (!assignee.canPush(repository)) { // account does not have RW permissions sendRejection(cmd, "{0} ({1}) can not be assigned any tickets because the user does not have RW permissions for {2}", assignee.getDisplayName(), assignee.username, repository.name); continue; } } // milestone verification String milestone = PatchsetCommand.getSingleOption(cmd, PatchsetCommand.MILESTONE); if (!StringUtils.isEmpty(milestone)) { TicketMilestone milestoneModel = ticketService.getMilestone(repository, milestone); if (milestoneModel == null) { // milestone does not exist sendRejection(cmd, "Sorry, \"{0}\" is not a valid milestone!", milestone); continue; } } // watcher verification List<String> watchers = PatchsetCommand.getOptions(cmd, PatchsetCommand.WATCH); if (!ArrayUtils.isEmpty(watchers)) { boolean verified = true; for (String watcher : watchers) { UserModel user = gitblit.getUserModel(watcher); if (user == null) { // watcher does not exist sendRejection(cmd, "Sorry, \"{0}\" is not a valid username for the watch list!", watcher); verified = false; break; } } if (!verified) { continue; } } patchsetRefCmd = cmd; patchsetCmd = preparePatchset(cmd); if (patchsetCmd != null) { batch.addCommand(patchsetCmd); } continue; } batch.addCommand(cmd); } if (!batch.getCommands().isEmpty()) { try { batch.execute(getRevWalk(), updating); } catch (IOException err) { for (ReceiveCommand cmd : toApply) { if (cmd.getResult() == Result.NOT_ATTEMPTED) { sendRejection(cmd, "lock error: {0}", err.getMessage()); LOGGER.error( MessageFormat.format("failed to lock {0}:{1}", repository.name, cmd.getRefName()), err); } } } } // // set the results into the patchset ref receive command // if (patchsetRefCmd != null && patchsetCmd != null) { if (!patchsetCmd.getResult().equals(Result.OK)) { // patchset command failed! LOGGER.error( patchsetCmd.getType() + " " + patchsetCmd.getRefName() + " " + patchsetCmd.getResult()); patchsetRefCmd.setResult(patchsetCmd.getResult(), patchsetCmd.getMessage()); } else { // all patchset commands were applied patchsetRefCmd.setResult(Result.OK); // update the ticket branch ref RefUpdate ru = updateRef(patchsetCmd.getTicketBranch(), patchsetCmd.getNewId(), patchsetCmd.getPatchsetType()); updateReflog(ru); TicketModel ticket = processPatchset(patchsetCmd); if (ticket != null) { ticketNotifier.queueMailing(ticket); } } } // // if there are standard ref update receive commands that were // successfully processed, process referenced tickets, if any // List<ReceiveCommand> allUpdates = ReceiveCommand.filter(batch.getCommands(), Result.OK); List<ReceiveCommand> refUpdates = excludePatchsetCommands(allUpdates); List<ReceiveCommand> stdUpdates = excludeTicketCommands(refUpdates); if (!stdUpdates.isEmpty()) { int ticketsProcessed = 0; for (ReceiveCommand cmd : stdUpdates) { switch (cmd.getType()) { case CREATE: case UPDATE: if (cmd.getRefName().startsWith(Constants.R_HEADS)) { Collection<TicketModel> tickets = processReferencedTickets(cmd); ticketsProcessed += tickets.size(); for (TicketModel ticket : tickets) { ticketNotifier.queueMailing(ticket); } } break; case UPDATE_NONFASTFORWARD: if (cmd.getRefName().startsWith(Constants.R_HEADS)) { String base = JGitUtils.getMergeBase(getRepository(), cmd.getOldId(), cmd.getNewId()); List<TicketLink> deletedRefs = JGitUtils.identifyTicketsBetweenCommits(getRepository(), settings, base, cmd.getOldId().name()); for (TicketLink link : deletedRefs) { link.isDelete = true; } Change deletion = new Change(user.username); deletion.pendingLinks = deletedRefs; ticketService.updateTicket(repository, 0, deletion); Collection<TicketModel> tickets = processReferencedTickets(cmd); ticketsProcessed += tickets.size(); for (TicketModel ticket : tickets) { ticketNotifier.queueMailing(ticket); } } break; default: break; } } if (ticketsProcessed == 1) { sendInfo("1 ticket updated"); } else if (ticketsProcessed > 1) { sendInfo("{0} tickets updated", ticketsProcessed); } } // reset the ticket caches for the repository ticketService.resetCaches(repository); } /** * Prepares a patchset command. * * @param cmd * @return the patchset command */ private PatchsetCommand preparePatchset(ReceiveCommand cmd) { String branch = getIntegrationBranch(cmd.getRefName()); long number = getTicketId(cmd.getRefName()); TicketModel ticket = null; if (number > 0 && ticketService.hasTicket(repository, number)) { ticket = ticketService.getTicket(repository, number); } if (ticket == null) { if (number > 0) { // requested ticket does not exist sendError("Sorry, {0} does not have ticket {1,number,0}!", repository.name, number); sendRejection(cmd, "Invalid ticket number"); return null; } } else { if (ticket.isMerged()) { // ticket already merged & resolved Change mergeChange = null; for (Change change : ticket.changes) { if (change.isMerge()) { mergeChange = change; break; } } if (mergeChange != null) { sendError("Sorry, {0} already merged {1} from ticket {2,number,0} to {3}!", mergeChange.author, mergeChange.patchset, number, ticket.mergeTo); } sendRejection(cmd, "Ticket {0,number,0} already resolved", number); return null; } else if (!StringUtils.isEmpty(ticket.mergeTo)) { // ticket specifies integration branch branch = ticket.mergeTo; } } final int shortCommitIdLen = settings.getInteger(Keys.web.shortCommitIdLength, 6); final String shortTipId = cmd.getNewId().getName().substring(0, shortCommitIdLen); final RevCommit tipCommit = JGitUtils.getCommit(getRepository(), cmd.getNewId().getName()); final String forBranch = branch; RevCommit mergeBase = null; Ref forBranchRef = getAdvertisedRefs().get(Constants.R_HEADS + forBranch); if (forBranchRef == null || forBranchRef.getObjectId() == null) { // unknown integration branch sendError("Sorry, there is no integration branch named ''{0}''.", forBranch); sendRejection(cmd, "Invalid integration branch specified"); return null; } else { // determine the merge base for the patchset on the integration branch String base = JGitUtils.getMergeBase(getRepository(), forBranchRef.getObjectId(), tipCommit.getId()); if (StringUtils.isEmpty(base)) { sendError(""); sendError("There is no common ancestry between {0} and {1}.", forBranch, shortTipId); sendError("Please reconsider your proposed integration branch, {0}.", forBranch); sendError(""); sendRejection(cmd, "no merge base for patchset and {0}", forBranch); return null; } mergeBase = JGitUtils.getCommit(getRepository(), base); } // ensure that the patchset can be cleanly merged right now MergeStatus status = JGitUtils.canMerge(getRepository(), tipCommit.getName(), forBranch, repository.mergeType); switch (status) { case ALREADY_MERGED: sendError(""); sendError("You have already merged this patchset.", forBranch); sendError(""); sendRejection(cmd, "everything up-to-date"); return null; case MERGEABLE: break; default: if (ticket == null || requireMergeablePatchset) { sendError(""); sendError("Your patchset can not be cleanly merged into {0}.", forBranch); sendError("Please rebase your patchset and push again."); sendError("NOTE:", number); sendError("You should push your rebase to refs/for/{0,number,0}", number); sendError(""); sendError(" git push origin HEAD:refs/for/{0,number,0}", number); sendError(""); sendRejection(cmd, "patchset not mergeable"); return null; } } // check to see if this commit is already linked to a ticket if (ticket != null && JGitUtils.getTicketNumberFromCommitBranch(getRepository(), tipCommit) == ticket.number) { sendError("{0} has already been pushed to ticket {1,number,0}.", shortTipId, ticket.number); sendRejection(cmd, "everything up-to-date"); return null; } List<TicketLink> ticketLinks = JGitUtils.identifyTicketsFromCommitMessage(getRepository(), settings, tipCommit); PatchsetCommand psCmd; if (ticket == null) { /* * NEW TICKET */ Patchset patchset = newPatchset(null, mergeBase.getName(), tipCommit.getName()); int minLength = 10; int maxLength = 100; String minTitle = MessageFormat.format(" minimum length of a title is {0} characters.", minLength); String maxTitle = MessageFormat.format(" maximum length of a title is {0} characters.", maxLength); if (patchset.commits > 1) { sendError(""); sendError("You may not create a ''{0}'' branch proposal ticket from {1} commits!", forBranch, patchset.commits); sendError(""); // display an ellipsized log of the commits being pushed RevWalk walk = getRevWalk(); walk.reset(); walk.sort(RevSort.TOPO); int boundary = 3; int count = 0; try { walk.markStart(tipCommit); walk.markUninteresting(mergeBase); for (;;) { RevCommit c = walk.next(); if (c == null) { break; } if (count < boundary || count >= (patchset.commits - boundary)) { walk.parseBody(c); sendError(" {0} {1}", c.getName().substring(0, shortCommitIdLen), StringUtils.trimString(c.getShortMessage(), 60)); } else if (count == boundary) { sendError(" ... more commits ..."); } count++; } } catch (IOException e) { // Should never happen, the core receive process would have // identified the missing object earlier before we got control. LOGGER.error("failed to get commit count", e); } finally { walk.close(); } sendError(""); sendError("Possible Solutions:"); sendError(""); int solution = 1; String forSpec = cmd.getRefName().substring(Constants.R_FOR.length()); if (forSpec.equals("default") || forSpec.equals("new")) { try { // determine other possible integration targets List<String> bases = Lists.newArrayList(); for (Ref ref : getRepository().getRefDatabase().getRefs(Constants.R_HEADS).values()) { if (!ref.getName().startsWith(Constants.R_TICKET) && !ref.getName().equals(forBranchRef.getName())) { if (JGitUtils.isMergedInto(getRepository(), ref.getObjectId(), tipCommit)) { bases.add(Repository.shortenRefName(ref.getName())); } } } if (!bases.isEmpty()) { if (bases.size() == 1) { // suggest possible integration targets String base = bases.get(0); sendError("{0}. Propose this change for the ''{1}'' branch.", solution++, base); sendError(""); sendError(" git push origin HEAD:refs/for/{0}", base); sendError(" pt propose {0}", base); sendError(""); } else { // suggest possible integration targets sendError("{0}. Propose this change for a different branch.", solution++); sendError(""); for (String base : bases) { sendError(" git push origin HEAD:refs/for/{0}", base); sendError(" pt propose {0}", base); sendError(""); } } } } catch (IOException e) { LOGGER.error(null, e); } } sendError("{0}. Squash your changes into a single commit with a meaningful message.", solution++); sendError(""); sendError("{0}. Open a ticket for your changes and then push your {1} commits to the ticket.", solution++, patchset.commits); sendError(""); sendError(" git push origin HEAD:refs/for/{id}"); sendError(" pt propose {id}"); sendError(""); sendRejection(cmd, "too many commits"); return null; } // require a reasonable title/subject String title = tipCommit.getFullMessage().trim().split("\n")[0]; if (title.length() < minLength) { // reject, title too short sendError(""); sendError("Please supply a longer title in your commit message!"); sendError(""); sendError(minTitle); sendError(maxTitle); sendError(""); sendRejection(cmd, "ticket title is too short [{0}/{1}]", title.length(), maxLength); return null; } if (title.length() > maxLength) { // reject, title too long sendError(""); sendError("Please supply a more concise title in your commit message!"); sendError(""); sendError(minTitle); sendError(maxTitle); sendError(""); sendRejection(cmd, "ticket title is too long [{0}/{1}]", title.length(), maxLength); return null; } // assign new id long ticketId = ticketService.assignNewId(repository); // create the patchset command psCmd = new PatchsetCommand(user.username, patchset); psCmd.newTicket(tipCommit, forBranch, ticketId, cmd.getRefName()); } else { /* * EXISTING TICKET */ Patchset patchset = newPatchset(ticket, mergeBase.getName(), tipCommit.getName()); psCmd = new PatchsetCommand(user.username, patchset); psCmd.updateTicket(tipCommit, forBranch, ticket, cmd.getRefName()); } // confirm user can push the patchset boolean pushPermitted = ticket == null || !ticket.hasPatchsets() || ticket.isAuthor(user.username) || ticket.isPatchsetAuthor(user.username) || ticket.isResponsible(user.username) || user.canPush(repository); switch (psCmd.getPatchsetType()) { case Proposal: // proposals (first patchset) are always acceptable break; case FastForward: // patchset updates must be permitted if (!pushPermitted) { // reject sendError(""); sendError("To push a patchset to this ticket one of the following must be true:"); sendError(" 1. you created the ticket"); sendError(" 2. you created the first patchset"); sendError(" 3. you are specified as responsible for the ticket"); sendError(" 4. you have push (RW) permissions to {0}", repository.name); sendError(""); sendRejection(cmd, "not permitted to push to ticket {0,number,0}", ticket.number); return null; } break; default: // non-fast-forward push if (!pushPermitted) { // reject sendRejection(cmd, "non-fast-forward ({0})", psCmd.getPatchsetType()); return null; } break; } Change change = psCmd.getChange(); change.pendingLinks = ticketLinks; return psCmd; } /** * Creates or updates an ticket with the specified patchset. * * @param cmd * @return a ticket if the creation or update was successful */ private TicketModel processPatchset(PatchsetCommand cmd) { Change change = cmd.getChange(); if (cmd.isNewTicket()) { // create the ticket object TicketModel ticket = ticketService.createTicket(repository, cmd.getTicketId(), change); if (ticket != null) { sendInfo(""); sendHeader("#{0,number,0}: {1}", ticket.number, StringUtils.trimString(ticket.title, Constants.LEN_SHORTLOG)); sendInfo("created proposal ticket from patchset"); sendInfo(ticketService.getTicketUrl(ticket)); sendInfo(""); // log the new patch ref RefLogUtils.updateRefLog(user, getRepository(), Arrays.asList(new ReceiveCommand(cmd.getOldId(), cmd.getNewId(), cmd.getRefName()))); // call any patchset hooks for (PatchsetHook hook : gitblit.getExtensions(PatchsetHook.class)) { try { hook.onNewPatchset(ticket); } catch (Exception e) { LOGGER.error("Failed to execute extension", e); } } return ticket; } else { sendError("FAILED to create ticket"); } } else { // update an existing ticket TicketModel ticket = ticketService.updateTicket(repository, cmd.getTicketId(), change); if (ticket != null) { sendInfo(""); sendHeader("#{0,number,0}: {1}", ticket.number, StringUtils.trimString(ticket.title, Constants.LEN_SHORTLOG)); if (change.patchset.rev == 1) { // new patchset sendInfo("uploaded patchset {0} ({1})", change.patchset.number, change.patchset.type.toString()); } else { // updated patchset sendInfo("added {0} {1} to patchset {2}", change.patchset.added, change.patchset.added == 1 ? "commit" : "commits", change.patchset.number); } sendInfo(ticketService.getTicketUrl(ticket)); sendInfo(""); // log the new patchset ref RefLogUtils.updateRefLog(user, getRepository(), Arrays.asList(new ReceiveCommand(cmd.getOldId(), cmd.getNewId(), cmd.getRefName()))); // call any patchset hooks final boolean isNewPatchset = change.patchset.rev == 1; for (PatchsetHook hook : gitblit.getExtensions(PatchsetHook.class)) { try { if (isNewPatchset) { hook.onNewPatchset(ticket); } else { hook.onUpdatePatchset(ticket); } } catch (Exception e) { LOGGER.error("Failed to execute extension", e); } } // return the updated ticket return ticket; } else { sendError("FAILED to upload {0} for ticket {1,number,0}", change.patchset, cmd.getTicketId()); } } return null; } /** * Automatically closes open tickets that have been merged to their integration * branch by a client and adds references to tickets if made in the commit message. * * @param cmd */ private Collection<TicketModel> processReferencedTickets(ReceiveCommand cmd) { Map<Long, TicketModel> mergedTickets = new LinkedHashMap<Long, TicketModel>(); final RevWalk rw = getRevWalk(); try { rw.reset(); rw.markStart(rw.parseCommit(cmd.getNewId())); if (!ObjectId.zeroId().equals(cmd.getOldId())) { rw.markUninteresting(rw.parseCommit(cmd.getOldId())); } RevCommit c; while ((c = rw.next()) != null) { rw.parseBody(c); List<TicketLink> ticketLinks = JGitUtils.identifyTicketsFromCommitMessage(getRepository(), settings, c); if (ticketLinks == null) { continue; } for (TicketLink link : ticketLinks) { if (mergedTickets.containsKey(link.targetTicketId)) { continue; } TicketModel ticket = ticketService.getTicket(repository, link.targetTicketId); if (ticket == null) { continue; } String integrationBranch; if (StringUtils.isEmpty(ticket.mergeTo)) { // unspecified integration branch integrationBranch = null; } else { // specified integration branch integrationBranch = Constants.R_HEADS + ticket.mergeTo; } Change change; Patchset patchset = null; String mergeSha = c.getName(); String mergeTo = Repository.shortenRefName(cmd.getRefName()); if (link.action == TicketAction.Commit) { //A commit can reference a ticket in any branch even if the ticket is closed. //This allows developers to identify and communicate related issues change = new Change(user.username); change.referenceCommit(mergeSha); } else { // ticket must be open and, if specified, the ref must match the integration branch if (ticket.isClosed() || (integrationBranch != null && !integrationBranch.equals(cmd.getRefName()))) { continue; } String baseRef = PatchsetCommand.getBasePatchsetBranch(ticket.number); boolean knownPatchset = false; Set<Ref> refs = getRepository().getAllRefsByPeeledObjectId().get(c.getId()); if (refs != null) { for (Ref ref : refs) { if (ref.getName().startsWith(baseRef)) { knownPatchset = true; break; } } } if (knownPatchset) { // identify merged patchset by the patchset tip for (Patchset ps : ticket.getPatchsets()) { if (ps.tip.equals(mergeSha)) { patchset = ps; break; } } if (patchset == null) { // should not happen - unless ticket has been hacked sendError("Failed to find the patchset for {0} in ticket {1,number,0}?!", mergeSha, ticket.number); continue; } // create a new change change = new Change(user.username); } else { // new patchset pushed by user String base = cmd.getOldId().getName(); patchset = newPatchset(ticket, base, mergeSha); PatchsetCommand psCmd = new PatchsetCommand(user.username, patchset); psCmd.updateTicket(c, mergeTo, ticket, null); // create a ticket patchset ref updateRef(psCmd.getPatchsetBranch(), c.getId(), patchset.type); RefUpdate ru = updateRef(psCmd.getTicketBranch(), c.getId(), patchset.type); updateReflog(ru); // create a change from the patchset command change = psCmd.getChange(); } // set the common change data about the merge change.setField(Field.status, Status.Merged); change.setField(Field.mergeSha, mergeSha); change.setField(Field.mergeTo, mergeTo); if (StringUtils.isEmpty(ticket.responsible)) { // unassigned tickets are assigned to the closer change.setField(Field.responsible, user.username); } } ticket = ticketService.updateTicket(repository, ticket.number, change); if (ticket != null) { sendInfo(""); sendHeader("#{0,number,0}: {1}", ticket.number, StringUtils.trimString(ticket.title, Constants.LEN_SHORTLOG)); switch (link.action) { case Commit: { sendInfo("referenced by push of {0} to {1}", c.getName(), mergeTo); } break; case Close: { sendInfo("closed by push of {0} to {1}", patchset, mergeTo); mergedTickets.put(ticket.number, ticket); } break; default: { } } sendInfo(ticketService.getTicketUrl(ticket)); sendInfo(""); } else { String shortid = mergeSha.substring(0, settings.getInteger(Keys.web.shortCommitIdLength, 6)); switch (link.action) { case Commit: { sendError("FAILED to reference ticket {0,number,0} by push of {1}", link.targetTicketId, shortid); } break; case Close: { sendError("FAILED to close ticket {0,number,0} by push of {1}", link.targetTicketId, shortid); } break; default: { } } } } } } catch (IOException e) { LOGGER.error("Can't scan for changes to reference or close", e); } finally { rw.reset(); } return mergedTickets.values(); } /** * Creates a new patchset with metadata. * * @param ticket * @param mergeBase * @param tip */ private Patchset newPatchset(TicketModel ticket, String mergeBase, String tip) { int totalCommits = JGitUtils.countCommits(getRepository(), getRevWalk(), mergeBase, tip); Patchset newPatchset = new Patchset(); newPatchset.tip = tip; newPatchset.base = mergeBase; newPatchset.commits = totalCommits; Patchset currPatchset = ticket == null ? null : ticket.getCurrentPatchset(); if (currPatchset == null) { /* * PROPOSAL PATCHSET * patchset 1, rev 1 */ newPatchset.number = 1; newPatchset.rev = 1; newPatchset.type = PatchsetType.Proposal; // diffstat from merge base DiffStat diffStat = DiffUtils.getDiffStat(getRepository(), mergeBase, tip); newPatchset.insertions = diffStat.getInsertions(); newPatchset.deletions = diffStat.getDeletions(); } else { /* * PATCHSET UPDATE */ int added = totalCommits - currPatchset.commits; boolean ff = JGitUtils.isMergedInto(getRepository(), currPatchset.tip, tip); boolean squash = added < 0; boolean rebase = !currPatchset.base.equals(mergeBase); // determine type, number and rev of the patchset if (ff) { /* * FAST-FORWARD * patchset number preserved, rev incremented */ boolean merged = JGitUtils.isMergedInto(getRepository(), currPatchset.tip, ticket.mergeTo); if (merged) { // current patchset was already merged // new patchset, mark as rebase newPatchset.type = PatchsetType.Rebase; newPatchset.number = currPatchset.number + 1; newPatchset.rev = 1; // diffstat from parent DiffStat diffStat = DiffUtils.getDiffStat(getRepository(), mergeBase, tip); newPatchset.insertions = diffStat.getInsertions(); newPatchset.deletions = diffStat.getDeletions(); } else { // FF update to patchset newPatchset.type = PatchsetType.FastForward; newPatchset.number = currPatchset.number; newPatchset.rev = currPatchset.rev + 1; newPatchset.parent = currPatchset.tip; // diffstat from parent DiffStat diffStat = DiffUtils.getDiffStat(getRepository(), currPatchset.tip, tip); newPatchset.insertions = diffStat.getInsertions(); newPatchset.deletions = diffStat.getDeletions(); } } else { /* * NON-FAST-FORWARD * new patchset, rev 1 */ if (rebase && squash) { newPatchset.type = PatchsetType.Rebase_Squash; newPatchset.number = currPatchset.number + 1; newPatchset.rev = 1; } else if (squash) { newPatchset.type = PatchsetType.Squash; newPatchset.number = currPatchset.number + 1; newPatchset.rev = 1; } else if (rebase) { newPatchset.type = PatchsetType.Rebase; newPatchset.number = currPatchset.number + 1; newPatchset.rev = 1; } else { newPatchset.type = PatchsetType.Amend; newPatchset.number = currPatchset.number + 1; newPatchset.rev = 1; } // diffstat from merge base DiffStat diffStat = DiffUtils.getDiffStat(getRepository(), mergeBase, tip); newPatchset.insertions = diffStat.getInsertions(); newPatchset.deletions = diffStat.getDeletions(); } if (added > 0) { // ignore squash (negative add) newPatchset.added = added; } } return newPatchset; } private RefUpdate updateRef(String ref, ObjectId newId, PatchsetType type) { ObjectId ticketRefId = ObjectId.zeroId(); try { ticketRefId = getRepository().resolve(ref); } catch (Exception e) { // ignore } try { RefUpdate ru = getRepository().updateRef(ref, false); ru.setRefLogIdent(getRefLogIdent()); switch (type) { case Amend: case Rebase: case Rebase_Squash: case Squash: ru.setForceUpdate(true); break; default: break; } ru.setExpectedOldObjectId(ticketRefId); ru.setNewObjectId(newId); RefUpdate.Result result = ru.update(getRevWalk()); if (result == RefUpdate.Result.LOCK_FAILURE) { sendError("Failed to obtain lock when updating {0}:{1}", repository.name, ref); sendError("Perhaps an administrator should remove {0}/{1}.lock?", getRepository().getDirectory(), ref); return null; } return ru; } catch (IOException e) { LOGGER.error("failed to update ref " + ref, e); sendError("There was an error updating ref {0}:{1}", repository.name, ref); } return null; } private void updateReflog(RefUpdate ru) { if (ru == null) { return; } ReceiveCommand.Type type = null; switch (ru.getResult()) { case NEW: type = Type.CREATE; break; case FAST_FORWARD: type = Type.UPDATE; break; case FORCED: type = Type.UPDATE_NONFASTFORWARD; break; default: LOGGER.error( MessageFormat.format("unexpected ref update type {0} for {1}", ru.getResult(), ru.getName())); return; } ReceiveCommand cmd = new ReceiveCommand(ru.getOldObjectId(), ru.getNewObjectId(), ru.getName(), type); RefLogUtils.updateRefLog(user, getRepository(), Arrays.asList(cmd)); } /** * Merge the specified patchset to the integration branch. * * @param ticket * @param patchset * @return true, if successful */ public MergeStatus merge(TicketModel ticket) { PersonIdent committer = new PersonIdent(user.getDisplayName(), StringUtils.isEmpty(user.emailAddress) ? (user.username + "@gitblit") : user.emailAddress); Patchset patchset = ticket.getCurrentPatchset(); String message = MessageFormat.format("Merged #{0,number,0} \"{1}\"", ticket.number, ticket.title); Ref oldRef = null; try { oldRef = getRepository().findRef(ticket.mergeTo); } catch (IOException e) { LOGGER.error("failed to get ref for " + ticket.mergeTo, e); } MergeResult mergeResult = JGitUtils.merge(getRepository(), patchset.tip, ticket.mergeTo, getRepositoryModel().mergeType, committer, message); if (StringUtils.isEmpty(mergeResult.sha)) { LOGGER.error("FAILED to merge {} to {} ({})", new Object[] { patchset, ticket.mergeTo, mergeResult.status.name() }); return mergeResult.status; } Change change = new Change(user.username); change.setField(Field.status, Status.Merged); change.setField(Field.mergeSha, mergeResult.sha); change.setField(Field.mergeTo, ticket.mergeTo); if (StringUtils.isEmpty(ticket.responsible)) { // unassigned tickets are assigned to the closer change.setField(Field.responsible, user.username); } long ticketId = ticket.number; ticket = ticketService.updateTicket(repository, ticket.number, change); if (ticket != null) { ticketNotifier.queueMailing(ticket); if (oldRef != null) { ReceiveCommand cmd = new ReceiveCommand(oldRef.getObjectId(), ObjectId.fromString(mergeResult.sha), oldRef.getName()); cmd.setResult(Result.OK); List<ReceiveCommand> commands = Arrays.asList(cmd); logRefChange(commands); updateIncrementalPushTags(commands); updateGitblitRefLog(commands); } // call patchset hooks for (PatchsetHook hook : gitblit.getExtensions(PatchsetHook.class)) { try { hook.onMergePatchset(ticket); } catch (Exception e) { LOGGER.error("Failed to execute extension", e); } } return mergeResult.status; } else { LOGGER.error("FAILED to resolve ticket {} by merge from web ui", ticketId); } return mergeResult.status; } public void sendAll() { ticketNotifier.sendAll(); } }