/*
|
* 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 groovy.lang.Binding;
|
import groovy.util.GroovyScriptEngine;
|
|
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;
|
import org.eclipse.jgit.transport.ReceiveCommand.Result;
|
import org.eclipse.jgit.transport.ReceivePack;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import com.gitblit.Constants;
|
import com.gitblit.Constants.AccessRestrictionType;
|
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;
|
|
|
/**
|
* GitblitReceivePack processes receive commands. It also executes Groovy pre-
|
* and post- receive hooks.
|
*
|
* 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 GitblitReceivePack extends ReceivePack implements PreReceiveHook, PostReceiveHook {
|
|
private static final Logger LOGGER = LoggerFactory.getLogger(GitblitReceivePack.class);
|
|
protected final RepositoryModel repository;
|
|
protected final UserModel user;
|
|
protected final File groovyDir;
|
|
protected String gitblitUrl;
|
|
protected GroovyScriptEngine gse;
|
|
protected final IStoredSettings settings;
|
|
protected final IGitblit gitblit;
|
|
protected final ITicketService ticketService;
|
|
protected final TicketNotifier ticketNotifier;
|
|
|
public GitblitReceivePack(
|
IGitblit gitblit,
|
Repository db,
|
RepositoryModel repository,
|
UserModel user) {
|
|
super(db);
|
this.settings = gitblit.getSettings();
|
this.gitblit = gitblit;
|
this.repository = repository;
|
this.user = user;
|
this.groovyDir = gitblit.getHooksFolder();
|
try {
|
// set Grape root
|
File grapeRoot = gitblit.getGrapesFolder();
|
grapeRoot.mkdirs();
|
System.setProperty("grape.root", grapeRoot.getAbsolutePath());
|
this.gse = new GroovyScriptEngine(groovyDir.getAbsolutePath());
|
} 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);
|
setPostReceiveHook(this);
|
}
|
|
/**
|
* Returns true if the user is permitted to apply the receive commands to
|
* the repository.
|
*
|
* @param commands
|
* @return true if the user may push these commands
|
*/
|
protected boolean canPush(Collection<ReceiveCommand> commands) {
|
// TODO Consider supporting branch permissions here (issue-36)
|
// Not sure if that should be Gerrit-style, refs/meta/config, or
|
// gitolite-style, permissions in users.conf
|
//
|
// How could commands be empty?
|
//
|
// Because a subclass, like PatchsetReceivePack, filters receive
|
// commands before this method is called. This makes it possible for
|
// this method to test an empty list. In this case, we assume that the
|
// subclass receive pack properly enforces push restrictions. for the
|
// ref.
|
//
|
// The empty test is not explicitly required, it's written here to
|
// clarify special-case behavior.
|
|
return commands.isEmpty() ? true : user.canPush(repository);
|
}
|
|
/**
|
* Instrumentation point where the incoming push event has been parsed,
|
* validated, objects created BUT refs have not been updated. You might
|
* use this to enforce a branch-write permissions model.
|
*/
|
@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
|
for (ReceiveCommand cmd : commands) {
|
sendRejection(cmd, "Gitblit does not allow pushes to \"{0}\" because it is a mirror!", repository.name);
|
}
|
return;
|
}
|
|
if (repository.isFrozen) {
|
// repository is frozen/readonly
|
for (ReceiveCommand cmd : commands) {
|
sendRejection(cmd, "Gitblit does not allow pushes to \"{0}\" because it is frozen!", repository.name);
|
}
|
return;
|
}
|
|
if (!repository.isBare) {
|
// repository has a working copy
|
for (ReceiveCommand cmd : commands) {
|
sendRejection(cmd, "Gitblit does not allow pushes to \"{0}\" because it has a working copy!", repository.name);
|
}
|
return;
|
}
|
|
if (!canPush(commands)) {
|
// user does not have push permissions
|
for (ReceiveCommand cmd : commands) {
|
sendRejection(cmd, "User \"{0}\" does not have push permissions for \"{1}\"!", user.username, repository.name);
|
}
|
return;
|
}
|
|
if (repository.accessRestriction.atLeast(AccessRestrictionType.PUSH) && repository.verifyCommitter) {
|
// enforce committer verification
|
if (StringUtils.isEmpty(user.emailAddress)) {
|
// reject the push because the pushing account does not have an email address
|
for (ReceiveCommand cmd : commands) {
|
sendRejection(cmd, "Sorry, the account \"{0}\" does not have an email address set for committer verification!", user.username);
|
}
|
return;
|
}
|
|
// Optionally enforce that the committer of first parent chain
|
// match the account being used to push the commits.
|
//
|
// This requires all merge commits are executed with the "--no-ff"
|
// option to force a merge commit even if fast-forward is possible.
|
// This ensures that the chain first parents has the commit
|
// identity of the merging user.
|
boolean allRejected = false;
|
for (ReceiveCommand cmd : commands) {
|
String firstParent = null;
|
try {
|
List<RevCommit> commits = JGitUtils.getRevLog(rp.getRepository(), cmd.getOldId().name(), cmd.getNewId().name());
|
for (RevCommit commit : commits) {
|
|
if (firstParent != null) {
|
if (!commit.getName().equals(firstParent)) {
|
// ignore: commit is right-descendant of a merge
|
continue;
|
}
|
}
|
|
// update expected next commit id
|
if (commit.getParentCount() == 0) {
|
firstParent = null;
|
} else {
|
firstParent = commit.getParents()[0].getId().getName();
|
}
|
|
PersonIdent committer = commit.getCommitterIdent();
|
if (!user.is(committer.getName(), committer.getEmailAddress())) {
|
// verification failed
|
String reason = MessageFormat.format("{0} by {1} <{2}> was not committed by {3} ({4}) <{5}>",
|
commit.getId().name(), committer.getName(), StringUtils.isEmpty(committer.getEmailAddress()) ? "?":committer.getEmailAddress(), user.getDisplayName(), user.username, user.emailAddress);
|
LOGGER.warn(reason);
|
cmd.setResult(Result.REJECTED_OTHER_REASON, reason);
|
allRejected &= true;
|
break;
|
} else {
|
allRejected = false;
|
}
|
}
|
} catch (Exception e) {
|
LOGGER.error("Failed to verify commits were made by pushing user", e);
|
}
|
}
|
|
if (allRejected) {
|
// all ref updates rejected, abort
|
return;
|
}
|
}
|
|
for (ReceiveCommand cmd : commands) {
|
String ref = cmd.getRefName();
|
if (ref.startsWith(Constants.R_HEADS)) {
|
switch (cmd.getType()) {
|
case UPDATE_NONFASTFORWARD:
|
case DELETE:
|
// reset branch commit cache on REWIND and DELETE
|
CommitCache.instance().clear(repository.name, ref);
|
break;
|
default:
|
break;
|
}
|
} else if (ref.equals(BranchTicketService.BRANCH)) {
|
// ensure pushing user is an administrator OR an owner
|
// i.e. prevent ticket tampering
|
boolean permitted = user.canAdmin() || repository.isOwner(user.username);
|
if (!permitted) {
|
sendRejection(cmd, "{0} is not permitted to push to {1}", user.username, ref);
|
}
|
} else if (ref.startsWith(Constants.R_FOR)) {
|
// prevent accidental push to refs/for
|
sendRejection(cmd, "{0} is not configured to receive patchsets", repository.name);
|
}
|
}
|
|
// 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)) {
|
scripts.addAll(repository.preReceiveScripts);
|
}
|
runGroovy(commands, scripts);
|
for (ReceiveCommand cmd : commands) {
|
if (!Result.NOT_ATTEMPTED.equals(cmd.getResult())) {
|
LOGGER.warn(MessageFormat.format("{0} {1} because \"{2}\"", cmd.getNewId()
|
.getName(), cmd.getResult(), cmd.getMessage()));
|
}
|
}
|
}
|
|
/**
|
* Instrumentation point where the incoming push has been applied to the
|
* repository. This is the point where we would trigger a Jenkins build
|
* or send an email.
|
*/
|
@Override
|
public void onPostReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {
|
if (commands.size() == 0) {
|
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) {
|
|
if (Result.OK.equals(cmd.getResult())) {
|
// add some logging for important ref changes
|
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()));
|
break;
|
case UPDATE_NONFASTFORWARD:
|
LOGGER.info(MessageFormat.format("{0} UPDATED NON-FAST-FORWARD {1} in {2} (from {3} to {4})", user.username, cmd.getRefName(), repository.name, cmd.getOldId().name(), cmd.getNewId().name()));
|
break;
|
default:
|
break;
|
}
|
}
|
}
|
|
if (isRefCreationOrDeletion) {
|
gitblit.resetRepositoryCache(repository.name);
|
}
|
}
|
|
/**
|
* Optionally update the incremental push tags.
|
*
|
* @param commands
|
*/
|
protected void updateIncrementalPushTags(Collection<ReceiveCommand> commands) {
|
if (!repository.useIncrementalPushTags) {
|
return;
|
}
|
|
// tag each pushed branch tip
|
String emailAddress = user.emailAddress == null ? getRefLogIdent().getEmailAddress() : user.emailAddress;
|
PersonIdent userIdent = new PersonIdent(user.getDisplayName(), emailAddress);
|
|
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(
|
getRepository(),
|
objectId,
|
userIdent,
|
prefix,
|
"0",
|
msg);
|
}
|
}
|
}
|
|
/**
|
* 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);
|
}
|
}
|
|
/** Execute commands to update references. */
|
@Override
|
protected void executeCommands() {
|
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);
|
|
for (ReceiveCommand cmd : toApply) {
|
if (Result.NOT_ATTEMPTED != cmd.getResult()) {
|
// Already rejected by the core receive process.
|
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());
|
}
|
}
|
}
|
}
|
|
//
|
// 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;
|
}
|
|
public void sendRejection(final ReceiveCommand cmd, final String why, Object... objects) {
|
String text;
|
if (ArrayUtils.isEmpty(objects)) {
|
text = why;
|
} else {
|
text = MessageFormat.format(why, objects);
|
}
|
cmd.setResult(Result.REJECTED_OTHER_REASON, text);
|
LOGGER.error(text + " (" + user.username + ")");
|
}
|
|
public void sendHeader(String msg, Object... objects) {
|
sendInfo("--> ", msg, objects);
|
}
|
|
public void sendInfo(String msg, Object... objects) {
|
sendInfo(" ", msg, objects);
|
}
|
|
private void sendInfo(String prefix, String msg, Object... objects) {
|
String text;
|
if (ArrayUtils.isEmpty(objects)) {
|
text = msg;
|
super.sendMessage(prefix + msg);
|
} else {
|
text = MessageFormat.format(msg, objects);
|
super.sendMessage(prefix + text);
|
}
|
if (!StringUtils.isEmpty(msg)) {
|
LOGGER.info(text + " (" + user.username + ")");
|
}
|
}
|
|
public void sendError(String msg, Object... objects) {
|
String text;
|
if (ArrayUtils.isEmpty(objects)) {
|
text = msg;
|
super.sendError(msg);
|
} else {
|
text = MessageFormat.format(msg, objects);
|
super.sendError(text);
|
}
|
if (!StringUtils.isEmpty(msg)) {
|
LOGGER.error(text + " (" + user.username + ")");
|
}
|
}
|
|
/**
|
* Runs the specified Groovy hook scripts.
|
*
|
* @param repository
|
* @param user
|
* @param commands
|
* @param scripts
|
*/
|
private void runGroovy(Collection<ReceiveCommand> commands, Set<String> scripts) {
|
if (scripts == null || scripts.size() == 0) {
|
// no Groovy scripts to execute
|
return;
|
}
|
|
Binding binding = new Binding();
|
binding.setVariable("gitblit", gitblit);
|
binding.setVariable("repository", repository);
|
binding.setVariable("receivePack", this);
|
binding.setVariable("user", user);
|
binding.setVariable("commands", commands);
|
binding.setVariable("url", gitblitUrl);
|
binding.setVariable("logger", LOGGER);
|
binding.setVariable("clientLogger", new ClientLogger(this));
|
for (String script : scripts) {
|
if (StringUtils.isEmpty(script)) {
|
continue;
|
}
|
// allow script to be specified without .groovy extension
|
// this is easier to read in the settings
|
File file = new File(groovyDir, script);
|
if (!file.exists() && !script.toLowerCase().endsWith(".groovy")) {
|
file = new File(groovyDir, script + ".groovy");
|
if (file.exists()) {
|
script = file.getName();
|
}
|
}
|
try {
|
Object result = gse.run(script, binding);
|
if (result instanceof Boolean) {
|
if (!((Boolean) result)) {
|
LOGGER.error(MessageFormat.format(
|
"Groovy script {0} has failed! Hook scripts aborted.", script));
|
break;
|
}
|
}
|
} catch (Exception e) {
|
LOGGER.error(
|
MessageFormat.format("Failed to execute Groovy script {0}", script), e);
|
}
|
}
|
}
|
|
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();
|
}
|
}
|
