Ticket Reference handling #1048

Paul Martin

2016-04-27 c2188a840bc4153ae92112b04b2e06a90d3944aa

 src/main/java/com/gitblit/git/GitblitReceivePack.java

@@ -22,18 +22,28 @@
import java.io.File;

import java.io.IOException;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Collection;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.SortedMap;

import java.util.TreeMap;

import java.util.concurrent.TimeUnit;



import org.eclipse.jgit.lib.AnyObjectId;

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.RevWalk;

import org.eclipse.jgit.transport.PostReceiveHook;

import org.eclipse.jgit.transport.PreReceiveHook;

import org.eclipse.jgit.transport.ReceiveCommand;

@@ -47,16 +57,27 @@
import com.gitblit.IStoredSettings;

import com.gitblit.Keys;

import com.gitblit.client.Translation;

import com.gitblit.extensions.ReceiveHook;

import com.gitblit.manager.IGitblit;

import com.gitblit.models.RepositoryModel;

import com.gitblit.models.TicketModel;

import com.gitblit.models.UserModel;

import com.gitblit.models.TicketModel.Change;

import com.gitblit.models.TicketModel.Field;

import com.gitblit.models.TicketModel.Patchset;

import com.gitblit.models.TicketModel.Status;

import com.gitblit.models.TicketModel.TicketAction;

import com.gitblit.models.TicketModel.TicketLink;

import com.gitblit.tickets.BranchTicketService;

import com.gitblit.tickets.ITicketService;

import com.gitblit.tickets.TicketNotifier;

import com.gitblit.utils.ArrayUtils;

import com.gitblit.utils.ClientLogger;

import com.gitblit.utils.CommitCache;

import com.gitblit.utils.JGitUtils;

import com.gitblit.utils.RefLogUtils;

import com.gitblit.utils.StringUtils;

import com.google.common.collect.Lists;





/**

@@ -91,6 +112,11 @@
   protected final IStoredSettings settings;



   protected final IGitblit gitblit;

	
   protected final ITicketService ticketService;



   protected final TicketNotifier ticketNotifier;

	


   public GitblitReceivePack(

         IGitblit gitblit,

@@ -113,10 +139,29 @@
      } catch (IOException e) {

      }



      if (gitblit.getTicketService().isAcceptingTicketUpdates(repository)) {

         this.ticketService = gitblit.getTicketService();

         this.ticketNotifier = this.ticketService.createNotifier();

      } else {

         this.ticketService = null;

         this.ticketNotifier = null;

      }

		
      // set advanced ref permissions

      setAllowCreates(user.canCreateRef(repository));

      setAllowDeletes(user.canDeleteRef(repository));

      setAllowNonFastForwards(user.canRewindRef(repository));



      int maxObjectSz = settings.getInteger(Keys.git.maxObjectSizeLimit, -1);

      if (maxObjectSz >= 0) {

         setMaxObjectSizeLimit(maxObjectSz);

      }

      int maxPackSz = settings.getInteger(Keys.git.maxPackSizeLimit, -1);

      if (maxPackSz >= 0) {

         setMaxPackSizeLimit(maxPackSz);

      }

      setCheckReceivedObjects(settings.getBoolean(Keys.git.checkReceivedObjects, true));

      setCheckReferencedObjectsAreReachable(settings.getBoolean(Keys.git.checkReferencedObjectsAreReachable, true));



      // setup pre and post receive hook

      setPreReceiveHook(this);

@@ -156,6 +201,14 @@
    */

   @Override

   public void onPreReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {



      if (commands.size() == 0) {

         // no receive commands to process

         // this can happen if receive pack subclasses intercept and filter

         // the commands

         LOGGER.debug("skipping pre-receive processing, no refs created, updated, or removed");

         return;

      }



      if (repository.isMirror) {

         // repository is a mirror

@@ -276,6 +329,15 @@
         }

      }



      // call pre-receive plugins

      for (ReceiveHook hook : gitblit.getExtensions(ReceiveHook.class)) {

         try {

            hook.onPreReceive(this, commands);

         } catch (Exception e) {

            LOGGER.error("Failed to execute extension", e);

         }

      }



      Set<String> scripts = new LinkedHashSet<String>();

      scripts.addAll(gitblit.getPreReceiveScriptsInherited(repository));

      if (!ArrayUtils.isEmpty(repository.preReceiveScripts)) {

@@ -298,9 +360,48 @@
   @Override

   public void onPostReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {

      if (commands.size() == 0) {

         LOGGER.debug("skipping post-receive hooks, no refs created, updated, or removed");

         LOGGER.debug("skipping post-receive processing, no refs created, updated, or removed");

         return;

      }



      logRefChange(commands);

      updateIncrementalPushTags(commands);

      updateGitblitRefLog(commands);



      // check for updates pushed to the BranchTicketService branch

      // if the BranchTicketService is active it will reindex, as appropriate

      for (ReceiveCommand cmd : commands) {

         if (Result.OK.equals(cmd.getResult())

               && BranchTicketService.BRANCH.equals(cmd.getRefName())) {

            rp.getRepository().fireEvent(new ReceiveCommandEvent(repository, cmd));

         }

      }



      // call post-receive plugins

      for (ReceiveHook hook : gitblit.getExtensions(ReceiveHook.class)) {

         try {

            hook.onPostReceive(this, commands);

         } catch (Exception e) {

            LOGGER.error("Failed to execute extension", e);

         }

      }



      // run Groovy hook scripts

      Set<String> scripts = new LinkedHashSet<String>();

      scripts.addAll(gitblit.getPostReceiveScriptsInherited(repository));

      if (!ArrayUtils.isEmpty(repository.postReceiveScripts)) {

         scripts.addAll(repository.postReceiveScripts);

      }

      runGroovy(commands, scripts);

   }



   /**

    * Log the ref changes in the container log.

    *

    * @param commands

    */

   protected void logRefChange(Collection<ReceiveCommand> commands) {

      boolean isRefCreationOrDeletion = false;



      // log ref changes

      for (ReceiveCommand cmd : commands) {

@@ -310,9 +411,11 @@
            switch (cmd.getType()) {

            case DELETE:

               LOGGER.info(MessageFormat.format("{0} DELETED {1} in {2} ({3})", user.username, cmd.getRefName(), repository.name, cmd.getOldId().name()));

               isRefCreationOrDeletion = true;

               break;

            case CREATE:

               LOGGER.info(MessageFormat.format("{0} CREATED {1} in {2}", user.username, cmd.getRefName(), repository.name));

               isRefCreationOrDeletion = true;

               break;

            case UPDATE:

               LOGGER.info(MessageFormat.format("{0} UPDATED {1} in {2} (from {3} to {4})", user.username, cmd.getRefName(), repository.name, cmd.getOldId().name(), cmd.getNewId().name()));

@@ -326,66 +429,68 @@
         }

      }



      if (repository.useIncrementalPushTags) {

         // tag each pushed branch tip

         String emailAddress = user.emailAddress == null ? rp.getRefLogIdent().getEmailAddress() : user.emailAddress;

         PersonIdent userIdent = new PersonIdent(user.getDisplayName(), emailAddress);

      if (isRefCreationOrDeletion) {

         gitblit.resetRepositoryCache(repository.name);

      }

   }



         for (ReceiveCommand cmd : commands) {

            if (!cmd.getRefName().startsWith(Constants.R_HEADS)) {

               // only tag branch ref changes

               continue;

            }



            if (!ReceiveCommand.Type.DELETE.equals(cmd.getType())

                  && ReceiveCommand.Result.OK.equals(cmd.getResult())) {

               String objectId = cmd.getNewId().getName();

               String branch = cmd.getRefName().substring(Constants.R_HEADS.length());

               // get translation based on the server's locale setting

               String template = Translation.get("gb.incrementalPushTagMessage");

               String msg = MessageFormat.format(template, branch);

               String prefix;

               if (StringUtils.isEmpty(repository.incrementalPushTagPrefix)) {

                  prefix = settings.getString(Keys.git.defaultIncrementalPushTagPrefix, "r");

               } else {

                  prefix = repository.incrementalPushTagPrefix;

               }



               JGitUtils.createIncrementalRevisionTag(

                     rp.getRepository(),

                     objectId,

                     userIdent,

                     prefix,

                     "0",

                     msg);

            }

         }

   /**

    * Optionally update the incremental push tags.

    *

    * @param commands

    */

   protected void updateIncrementalPushTags(Collection<ReceiveCommand> commands) {

      if (!repository.useIncrementalPushTags) {

         return;

      }



      // update push log

      try {

         RefLogUtils.updateRefLog(user, rp.getRepository(), commands);

         LOGGER.debug(MessageFormat.format("{0} push log updated", repository.name));

      } catch (Exception e) {

         LOGGER.error(MessageFormat.format("Failed to update {0} pushlog", repository.name), e);

      }

      // tag each pushed branch tip

      String emailAddress = user.emailAddress == null ? getRefLogIdent().getEmailAddress() : user.emailAddress;

      PersonIdent userIdent = new PersonIdent(user.getDisplayName(), emailAddress);



      // check for updates pushed to the BranchTicketService branch

      // if the BranchTicketService is active it will reindex, as appropriate

      for (ReceiveCommand cmd : commands) {

         if (Result.OK.equals(cmd.getResult())

               && BranchTicketService.BRANCH.equals(cmd.getRefName())) {

            rp.getRepository().fireEvent(new ReceiveCommandEvent(repository, cmd));

         if (!cmd.getRefName().startsWith(Constants.R_HEADS)) {

            // only tag branch ref changes

            continue;

         }



         if (!ReceiveCommand.Type.DELETE.equals(cmd.getType())

               && ReceiveCommand.Result.OK.equals(cmd.getResult())) {

            String objectId = cmd.getNewId().getName();

            String branch = cmd.getRefName().substring(Constants.R_HEADS.length());

            // get translation based on the server's locale setting

            String template = Translation.get("gb.incrementalPushTagMessage");

            String msg = MessageFormat.format(template, branch);

            String prefix;

            if (StringUtils.isEmpty(repository.incrementalPushTagPrefix)) {

               prefix = settings.getString(Keys.git.defaultIncrementalPushTagPrefix, "r");

            } else {

               prefix = repository.incrementalPushTagPrefix;

            }



            JGitUtils.createIncrementalRevisionTag(

                  getRepository(),

                  objectId,

                  userIdent,

                  prefix,

                  "0",

                  msg);

         }

      }

   }



      // run Groovy hook scripts

      Set<String> scripts = new LinkedHashSet<String>();

      scripts.addAll(gitblit.getPostReceiveScriptsInherited(repository));

      if (!ArrayUtils.isEmpty(repository.postReceiveScripts)) {

         scripts.addAll(repository.postReceiveScripts);

   /**

    * Update Gitblit's internal reflog.

    *

    * @param commands

    */

   protected void updateGitblitRefLog(Collection<ReceiveCommand> commands) {

      try {

         RefLogUtils.updateRefLog(user, getRepository(), commands);

         LOGGER.debug(MessageFormat.format("{0} reflog updated", repository.name));

      } catch (Exception e) {

         LOGGER.error(MessageFormat.format("Failed to update {0} reflog", repository.name), e);

      }

      runGroovy(commands, scripts);

   }



   /** Execute commands to update references. */

@@ -428,13 +533,111 @@
            }

         }

      }

		
      //

      // if there are ref update receive commands that were

      // successfully processed and there is an active ticket service for the repository

      // then process any referenced tickets

      //

      if (ticketService != null) {

         List<ReceiveCommand> allUpdates = ReceiveCommand.filter(batch.getCommands(), Result.OK);

         if (!allUpdates.isEmpty()) {

            int ticketsProcessed = 0;

            for (ReceiveCommand cmd : allUpdates) {

               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;

               case DELETE:

                  //Identify if the branch has been merged 
                  SortedMap<Integer, String> bases =  new TreeMap<Integer, String>();

                  try {

                     ObjectId dObj = cmd.getOldId();

                     Collection<Ref> tips = getRepository().getRefDatabase().getRefs(Constants.R_HEADS).values();

                     for (Ref ref : tips) {

                        ObjectId iObj = ref.getObjectId();

                        String mergeBase = JGitUtils.getMergeBase(getRepository(), dObj, iObj);

                        if (mergeBase != null) {

                           int d = JGitUtils.countCommits(getRepository(), getRevWalk(), mergeBase, dObj.name());

                           bases.put(d, mergeBase);

                           //All commits have been merged into some other branch

                           if (d == 0) {

                              break;

                           }

                        }

                     }

							
                     if (bases.isEmpty()) {

                        //TODO: Handle orphan branch case

                     } else {

                        if (bases.firstKey() > 0) {

                           //Delete references from the remaining commits that haven't been merged

                           String mergeBase = bases.get(bases.firstKey());

                           List<TicketLink> deletedRefs = JGitUtils.identifyTicketsBetweenCommits(getRepository(),

                                 settings, mergeBase, dObj.name());

									
                           for (TicketLink link : deletedRefs) {

                              link.isDelete = true;

                           }

                           Change deletion = new Change(user.username);

                           deletion.pendingLinks = deletedRefs;

                           ticketService.updateTicket(repository, 0, deletion);

                        }

                     }

							
                  } catch (IOException e) {

                     LOGGER.error(null, e);

                  }

                  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);

      }

   }



   protected void setGitblitUrl(String url) {

      this.gitblitUrl = url;

   }



   protected void sendRejection(final ReceiveCommand cmd, final String why, Object... objects) {

   public void sendRejection(final ReceiveCommand cmd, final String why, Object... objects) {

      String text;

      if (ArrayUtils.isEmpty(objects)) {

         text = why;

@@ -445,15 +648,15 @@
      LOGGER.error(text + " (" + user.username + ")");

   }



   protected void sendHeader(String msg, Object... objects) {

   public void sendHeader(String msg, Object... objects) {

      sendInfo("--> ", msg, objects);

   }



   protected void sendInfo(String msg, Object... objects) {

   public void sendInfo(String msg, Object... objects) {

      sendInfo("    ", msg, objects);

   }



   protected void sendInfo(String prefix, String msg, Object... objects) {

   private void sendInfo(String prefix, String msg, Object... objects) {

      String text;

      if (ArrayUtils.isEmpty(objects)) {

         text = msg;

@@ -467,7 +670,7 @@
      }

   }



   protected void sendError(String msg, Object... objects) {

   public void sendError(String msg, Object... objects) {

      String text;

      if (ArrayUtils.isEmpty(objects)) {

         text = msg;

@@ -532,4 +735,128 @@
         }

      }

   }



   public IGitblit getGitblit() {

      return gitblit;

   }



   public RepositoryModel getRepositoryModel() {

      return repository;

   }



   public UserModel getUserModel() {

      return user;

   }

	
   /**

    * Automatically closes open tickets and adds references to tickets if made in the commit message.

    *

    * @param cmd

    */

   private Collection<TicketModel> processReferencedTickets(ReceiveCommand cmd) {

      Map<Long, TicketModel> changedTickets = 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) {

					
               TicketModel ticket = ticketService.getTicket(repository, link.targetTicketId);

               if (ticket == null) {

                  continue;

               }

					
               Change change = null;

               String commitSha = c.getName();

               String branchName = Repository.shortenRefName(cmd.getRefName());

					
               switch (link.action) {

                  case 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(commitSha);

                  } break;

						
                  case Close: {

                     // As this isn't a patchset theres no merging taking place when closing a ticket

                     if (ticket.isClosed()) {

                        continue;

                     }

							
                     change = new Change(user.username);

                     change.setField(Field.status, Status.Fixed);

							
                     if (StringUtils.isEmpty(ticket.responsible)) {

                        // unassigned tickets are assigned to the closer

                        change.setField(Field.responsible, user.username);

                     }

                  }

						
                  default: {

                     //No action

                  } break;

               }

					
               if (change != null) {

                  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}", commitSha, branchName);

                        changedTickets.put(ticket.number, ticket);

                     } break;



                     case Close: {

                        sendInfo("closed by push of {0} to {1}", commitSha, branchName);

                        changedTickets.put(ticket.number, ticket);

                     } break;



                     default: { }

                  }



                  sendInfo(ticketService.getTicketUrl(ticket));

                  sendInfo("");

               } else {

                  switch (link.action) {

                     case Commit: {

                        sendError("FAILED to reference ticket {0} by push of {1}", link.targetTicketId, commitSha);

                     } break;

							
                     case Close: {

                        sendError("FAILED to close ticket {0} by push of {1}", link.targetTicketId, commitSha);	
                     } break;

							
                     default: { }

                  }

               }

            }

         }

				
      } catch (IOException e) {

         LOGGER.error("Can't scan for changes to reference or close", e);

      } finally {

         rw.reset();

      }



      return changedTickets.values();

   }

}