Nemcio/SCM-Manager
1
0
Fork 0
mirror of https://github.com/scm-manager/scm-manager.git synced 2025-11-12 00:15:44 +01:00
Code Issues Packages Projects Releases Activity

fix wrong handling of git file hooks

Browse Source
This commit is contained in:
Sebastian Sdorra
2013-02-27 11:49:49 +01:00
parent 2e54ff171d
commit 9aa3a05cab
3 changed files with 534 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files

278
scm-plugins/scm-git-plugin/src/main/java/sonia/scm/web/GitReceiveHook.java
View File

@@ -35,9 +35,6 @@ package sonia.scm.web;
//~--- non-JDK imports --------------------------------------------------------
import com.google.common.collect.Lists;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.transport.PostReceiveHook;
import org.eclipse.jgit.transport.PreReceiveHook;
@@ -47,23 +44,14 @@ import org.eclipse.jgit.transport.ReceivePack;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import sonia.scm.io.Command;
import sonia.scm.io.CommandResult;
import sonia.scm.io.SimpleCommand;
import sonia.scm.repository.GitRepositoryHandler;
import sonia.scm.repository.GitRepositoryHookEvent;
import sonia.scm.repository.GitUtil;
import sonia.scm.repository.RepositoryHookType;
import sonia.scm.repository.RepositoryManager;
import sonia.scm.repository.RepositoryUtil;
import sonia.scm.util.IOUtil;
import sonia.scm.util.Util;
//~--- JDK imports ------------------------------------------------------------
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
@@ -74,18 +62,6 @@ import java.util.List;
public class GitReceiveHook implements PreReceiveHook, PostReceiveHook
{
/** Field description */
public static final String FILE_HOOKDIRECTORY = "hooks";
/** Field description */
public static final String FILE_HOOK_POST_RECEIVE = "post-receive";
/** Field description */
public static final String FILE_HOOK_PRE_RECEIVE = "pre-receive";
/** Field description */
public static final String PREFIX_MSG = "[SCM] ";
/** the logger for GitReceiveHook */
private static final Logger logger =
LoggerFactory.getLogger(GitReceiveHook.class);
@@ -137,131 +113,6 @@ public class GitReceiveHook implements PreReceiveHook, PostReceiveHook
onReceive(rpack, receiveCommands, RepositoryHookType.PRE_RECEIVE);
}
/**
* Method description
*
* @param rpack
* @param rc
* @param repositoryDirectory
* @param hook
* @param oldId
* @param newId
* @param refName
*/
private void executeFileHook(ReceivePack rpack, ReceiveCommand rc,
File repositoryDirectory, File hook, ObjectId oldId, ObjectId newId,
String refName)
{
if (logger.isDebugEnabled())
{
logger.debug("execute file hook '{}' in directoy '{}'");
}
final Command cmd = new SimpleCommand(hook.getAbsolutePath(),
GitUtil.getId(oldId), GitUtil.getId(newId),
Util.nonNull(refName));
// issue-99
cmd.setWorkDirectory(repositoryDirectory);
try
{
CommandResult result = cmd.execute();
if (result.isSuccessfull())
{
if (logger.isDebugEnabled())
{
logger.debug("executed file hook successfull");
if (logger.isTraceEnabled())
{
String out = result.getOutput();
if (Util.isNotEmpty(out))
{
logger.trace(out);
}
}
}
}
else
{
if (logger.isErrorEnabled())
{
logger.error("failed to execute file hook");
}
String out = result.getOutput();
if (Util.isNotEmpty(out))
{
logger.error(out);
}
sendError(rpack, rc, out);
}
}
catch (IOException ex)
{
logger.error("could not execute file hook", ex);
}
}
/**
* Method description
*
*
* @param rpack
* @param rc
* @param newId
* @param type
*/
private void handleFileHooks(ReceivePack rpack, ReceiveCommand rc,
RepositoryHookType type)
{
ObjectId newId = rc.getNewId();
ObjectId oldId = null;
if (isUpdateCommand(rc))
{
oldId = rc.getOldId();
if (logger.isTraceEnabled())
{
logger.trace("handle update receive command from commit '{}' to '{}'",
oldId.getName(), newId.getName());
}
}
else if (logger.isTraceEnabled())
{
logger.trace("handle receive command for commit '{}'", newId.getName());
}
File directory = rpack.getRepository().getDirectory();
String scriptName = null;
if (type == RepositoryHookType.POST_RECEIVE)
{
scriptName = FILE_HOOK_POST_RECEIVE;
}
else if (type == RepositoryHookType.PRE_RECEIVE)
{
scriptName = FILE_HOOK_PRE_RECEIVE;
}
if (scriptName != null)
{
File hookScript = getHookScript(directory, scriptName);
if (hookScript != null)
{
executeFileHook(rpack, rc, directory, hookScript, oldId, newId,
rc.getRefName());
}
}
}
/**
* Method description
*
@@ -287,10 +138,7 @@ public class GitReceiveHook implements PreReceiveHook, PostReceiveHook
{
logger.error("could not handle receive commands", ex);
if (type == RepositoryHookType.PRE_RECEIVE)
{
sendError(rpack, receiveCommands, ex.getMessage());
}
GitHooks.abortIfPossible(type, rpack, receiveCommands, ex.getMessage());
}
}
@@ -300,140 +148,32 @@ public class GitReceiveHook implements PreReceiveHook, PostReceiveHook
*
* @param rpack
* @param receiveCommands
* @param commands
* @param type
*/
private void onReceive(ReceivePack rpack,
Collection<ReceiveCommand> receiveCommands, RepositoryHookType type)
Collection<ReceiveCommand> commands, RepositoryHookType type)
{
if (logger.isTraceEnabled())
{
logger.trace("received git hook, type={}", type);
}
List<ReceiveCommand> commands = Lists.newArrayList();
List<ReceiveCommand> receiveCommands = GitHooks.filterReceiveable(type,
commands);
for (ReceiveCommand rc : receiveCommands)
{
if (isReceiveable(rc, type))
{
commands.add(rc);
handleFileHooks(rpack, rc, type);
}
else if (logger.isTraceEnabled())
{
//J-
logger.trace("skip receive command, type={}, ref={}, result={}",
new Object[] {
rc.getType(),
rc.getRefName(),
rc.getResult()
}
);
//J+
}
}
GitFileHook.execute(type, rpack, commands);
if (!commands.isEmpty())
if (!receiveCommands.isEmpty())
{
handleReceiveCommands(rpack, commands, type);
handleReceiveCommands(rpack, receiveCommands, type);
}
else if (logger.isDebugEnabled())
{
logger.debug("no receive command found to process");
logger.debug("no receive commands found to process");
}
}
/**
* Method description
*
*
* @param rpack
* @param commands
* @param message
*/
private void sendError(ReceivePack rpack, Iterable<ReceiveCommand> commands,
String message)
{
if (logger.isWarnEnabled())
{
logger.warn("abort git push request with msg: {}", message);
}
for (ReceiveCommand rc : commands)
{
rc.setResult(ReceiveCommand.Result.REJECTED_OTHER_REASON);
}
rpack.sendError(PREFIX_MSG.concat(Util.nonNull(message)));
}
/**
* Method description
*
*
*
* @param rpack
* @param rc
* @param message
*/
private void sendError(ReceivePack rpack, ReceiveCommand rc, String message)
{
rc.setResult(ReceiveCommand.Result.REJECTED_OTHER_REASON);
rpack.sendError(PREFIX_MSG.concat(Util.nonNull(message)));
}
//~--- get methods ----------------------------------------------------------
/**
* Method description
*
*
* @param directory
* @param name
*
* @return
*/
private File getHookScript(File directory, String name)
{
File baseFile = new File(directory,
FILE_HOOKDIRECTORY.concat(File.separator).concat(name));
return IOUtil.getScript(baseFile);
}
/**
* Method description
*
*
* @param rc
* @param type
*
* @return
*/
private boolean isReceiveable(ReceiveCommand rc, RepositoryHookType type)
{
//J-
return ((RepositoryHookType.PRE_RECEIVE == type) &&
(rc.getResult() == ReceiveCommand.Result.NOT_ATTEMPTED)) ||
((RepositoryHookType.POST_RECEIVE == type) &&
(rc.getResult() == ReceiveCommand.Result.OK));
//J+
}
/**
* Method description
*
*
* @param rc
*
* @return
*/
private boolean isUpdateCommand(ReceiveCommand rc)
{
return (rc.getType() == ReceiveCommand.Type.UPDATE)
|| (rc.getType() == ReceiveCommand.Type.UPDATE_NONFASTFORWARD);
}
//~--- fields ---------------------------------------------------------------
/** Field description */