#! /usr/bin/env python3.3
"""Support for admin-supplied custom "commit rejection hook" called during
preflight check time, once per commit x branch.
"""
import logging
import re
import shlex
import sys
import p4gf_config
from p4gf_l10n import _, NTR
import p4gf_path
import p4gf_preflight_checker
import p4gf_proc
import p4gf_protect
import p4gf_tempfile
import p4gf_util
LOG = logging.getLogger(__name__)
class PreflightHook:
"""An object that knows how to call a custom "commit rejection hook"
that can say whether a Git commit is permitted into Perforce.
"""
def __init__(self):
self.action = None
self.msg = None
self.cmds = None
self._spec_file = None
self._spec_file_path = None
self._p4_spec = None
def __str__(self):
if self.action is None:
return 'None'
elif self.action == ACTION_NONE:
return 'none'
elif self.action in [ACTION_PASS, ACTION_FAIL]:
return '{}: {}'.format(self.action, self.msg)
else:
# format list of lists
cmdstr = ''
for c in self.cmds:
if isinstance(c, list):
c = ' '.join(c)
cmdstr += str(c) + '\n'
return '{0}: {1}'.format(self.action, cmdstr)
def is_callable(self):
"""Are we worth calling?
Return True if we've got something to call, False if not.
Returning False allows calling code to avoid wasting time calculating
parameters for our __call__ function.
"""
return ACTION_NONE != self.action
def needs_spec_file(self):
"""Is it worth writing a fake spec to a temp file for each __call__()?
Only if we're calling an external tool, not if we're just PASS/FAIL.
"""
return ACTION_RUN == self.action
@staticmethod
def from_context(ctx):
"""Search for a preflight-hook configuration in the current config.
Can be specified in repo config or inherited from global config.
We neither know nor care.
"""
hook = PreflightHook()
value = ctx.repo_config.get(p4gf_config.SECTION_GIT_TO_PERFORCE,
p4gf_config.KEY_PREFLIGHT_COMMIT)
value_lower = str(value).strip().lower()
LOG.debug2('from_context() config {} = {}'
.format(p4gf_config.KEY_PREFLIGHT_COMMIT, value))
if re.search(r'none\b', value_lower) or not value_lower:
hook.action = ACTION_NONE
LOG.debug('from_context() none')
return hook
elif re.search(r'pass\b', value_lower):
hook.action = ACTION_PASS
hook.msg = value[4:].strip()
LOG.debug('from_context() pass: {}'.format(hook.msg))
return hook
elif re.search(r'fail\b', value_lower):
hook.action = ACTION_FAIL
hook.msg = value[4:].strip()
LOG.debug('from_context() fail: {}'.format(hook.msg))
return hook
else:
hook.action = ACTION_RUN
hook.cmds = []
for line in value.splitlines():
hook.cmds.append(PreflightCommand.from_line(line))
LOG.debug('from_context() cmd : {}'.format(hook.cmds))
return hook
def __call__( self
, ctx
, fe_commit
, branch_id
, jobs ):
"""If preflight hook configured, invoke it (or PASS/FAIL it).
If fail, raise exception detailing why.
Route hook's stdout and stderr to our stderr.
"""
_debug3('call() {} {} {}'
, p4gf_util.abbrev(fe_commit['sha1'])
, p4gf_util.abbrev(branch_id)
, self )
if self.action is ACTION_NONE:
return
elif self.action is ACTION_PASS:
if self.msg:
sys.stderr.write(self.msg + '\n')
return
elif self.action is ACTION_FAIL:
raise_rejection(fe_commit['sha1'], self.msg)
else: # self.action is ACTION_RUN:
cmd_line_vars = calc_cmd_line_vars(
ctx = ctx
, fe_commit = fe_commit
, branch_id = branch_id
, jobs = jobs
, spec_file_path = self.spec_file_path()
)
d = (ctx.gwt_to_depot_path(fe_file['path'])
for fe_file in fe_commit['files'])
depot_file_list = (dd for dd in d if dd)
self._write_spec_file(
ctx = ctx
, fe_commit = fe_commit
, depot_file_list = depot_file_list
, jobs = jobs
, spec_file_path = self.spec_file_path()
, cmd_line_vars = cmd_line_vars )
for cmd in self.cmds:
if cmd.matches(fe_commit):
cmd.run(fe_commit, cmd_line_vars)
def spec_file_path(self):
"""Lazy-create, then reuse over and over, a single temp file to hold
our fake changelist spec.
"""
if self._spec_file_path:
return self._spec_file_path
# Don't bother if we're just PASS/FAIL/None
if not self.needs_spec_file():
self._spec_file_path = ''
return self._spec_file_path
self._spec_file = p4gf_tempfile.new_temp_file(
prefix = 'preflight-commit-'
, delete = False)
self._spec_file_path = self._spec_file.name
return self._spec_file_path
def p4_spec(self, ctx):
"""Return a 'p4 change -o' spec suitable for use with
p4.format_change(spec).
NOT the same as a Python dict, although it behaves as one
most of the time.
"""
if self._p4_spec:
return self._p4_spec
self._p4_spec = ctx.p4.fetch_change()
return self._p4_spec
def _write_spec_file( self
, ctx
, fe_commit
, depot_file_list
, jobs
, spec_file_path
, cmd_line_vars ):
"""Write our fake change description spec to a temp file.
File is a combination 'p4 change -o' and 'p4 describe'.
Also includes Git Fusion fields such as 'repo' and 'sha1'.
Note that any Jobs will appear in BOTH the Description and Jobs fields.
This is correct.
Change: new
Date: 2013/09/16 16:17:03
Client: git-fusion-p4gf_repo
User: myron
Status: pending
Description:
Description text
Jobs:
job01234
Jobs:
job01234
Files:
//depot/main/foo#4 edit
repo: my_repo
sha1: 719172d6e978b132aeaac134947191ba7978626d
"""
# pylint:disable=too-many-arguments
if not self.needs_spec_file():
return
# Let P4Python do most of our formatting, including
# all multi-line stuff like description and jobs.
spec = self.p4_spec(ctx)
spec.clear()
spec['Change'] = NTR('new')
spec['Client'] = cmd_line_vars['%client%']
spec['User' ] = cmd_line_vars['%user%']
spec['Status'] = NTR('pending')
spec['Description'] = fe_commit['data']
if jobs:
spec['Jobs'] = jobs
if depot_file_list:
spec['Files'] = list(depot_file_list)
spec_text = ctx.p4.format_change(spec)
# Append our custom Git Fusion fields.
# P4.format_change() will fail with error if
# ask it to format these.
l = []
_tabpend(l, NTR('repo'), cmd_line_vars['%repo%'])
_tabpend(l, NTR('sha1'), cmd_line_vars['%sha1%'])
_tabpend(l, NTR('branch-id'), cmd_line_vars['%branch_id%'])
_tabpend(l, NTR('git-branch-name'), cmd_line_vars['%git-branch-name%'])
spec_text = spec_text + '\n' + '\n\n'.join(l) + '\n'
with open(spec_file_path, "w") as out:
_debug3('writing {}', spec_file_path)
out.write(spec_text)
class PreflightCommand:
"""PreflightCommand represents a command to run."""
def __init__(self, cmd, path=None):
"""Initialize an instance of PreflightCommand."""
self.cmd = cmd
self.path = path
if path:
# convert Perforce-style wildcards to regular expressions
self.regex = re.compile(path.replace('*', '[^/]+').replace('...', '.*'))
else:
self.regex = None
@staticmethod
def from_line(line):
"""Create a PreflightCommand from the given configuration value."""
if line[0] == '[':
# find the next unescaped ] in the line
offset = 0
while True:
path_end = line.find(']', offset)
if path_end == -1:
raise RuntimeError(_('malformed hook command: {line}').format(line=line))
if line[path_end-1] == '\\':
offset = path_end + 1
else:
break
path = line[1:path_end]
cmd = shlex.split(line[path_end+1:].strip())
return PreflightCommand(cmd, path)
return PreflightCommand(shlex.split(line.strip()))
def matches(self, fe_commit):
"""Indicate if this command is appropriate for the given commit."""
if self.regex:
for entry in fe_commit['files']:
if self.regex.match(entry['path']):
return True
return False
return True
def run(self, fe_commit, cmd_line_vars):
"""Run the command for the given commit."""
cmd = [substitute_cmd_line_vars(cmd_line_vars, word) for word in self.cmd]
_debug3('cmd {}', cmd)
d = p4gf_proc.popen_no_throw(cmd)
_debug3('{}', d)
msg = p4gf_path.join_non_empty('\n', d['out'], d['err'])
if d['ec']:
raise_rejection(fe_commit['sha1'], msg)
sys.stderr.write(msg)
def __repr__(self):
"""Return a debug representation of this."""
return "PreflightCommand[path={}, cmd={}]".format(self.path, self.cmd)
def __str__(self):
"""Return a string representation of this."""
return "[{}] {}".format(self.path, self.cmd)
def raise_rejection(sha1, msg):
"""preflight-commit hook rejected. Tell the Git pusher."""
raise p4gf_preflight_checker.PreflightException(
_('preflight-commit rejected: {sha1} {msg}\n')
.format( sha1 = p4gf_util.abbrev(sha1)
, msg = msg))
def substitute_cmd_line_vars(cmd_line_vars, word):
"""Change '%user' into 'myron'.
'p4 trigger'-like variable substitution.
"""
result = word
for k, v in cmd_line_vars.items():
result = result.replace(k, v)
return result
def calc_cmd_line_vars( ctx
, fe_commit
, branch_id
, jobs
, spec_file_path
):
"""Return our mapping of command-line variable substitutions,
populating if necessary.
DANGER: Little Bobby Tables! Sanitize your shell inputs!
These become strings in a command. Watch out for any input
that a user can control such as repo name or jobs list.
"""
branch = ctx.branch_dict()[branch_id]
git_branch_name = _or_space(branch.git_branch_name)
client_host = _or_space(p4gf_protect.get_remote_client_addr())
r = {
# Git Fusion specific variables
'%repo%' : _sanitize(ctx.config.repo_name)
, '%sha1%' : fe_commit['sha1']
, '%branch_id%' : branch_id
, '%git-branch-name%' : _sanitize(git_branch_name)
# Common Perforce trigger variables
, '%client%' : ctx.p4.client
, '%clienthost%' : client_host
, '%command%' : 'user-submit'
, '%quote%' : '"'
, '%serverport%' : ctx.p4.port
, '%user%' : fe_commit['owner']
, '%formfile%' : spec_file_path
, '%formname%' : NTR('new')
, '%formtype%' : NTR('change')
, '%jobs%' : _sanitize(' '.join(jobs)) if jobs else ''
}
return r
def _tabpend(l, key, val):
"""Append key: <tab> val to a list."""
l.append(NTR('{key}:\t{val}').format(key=key, val=val))
ACTION_NONE = NTR('none')
ACTION_PASS = NTR('pass')
ACTION_FAIL = NTR('fail')
ACTION_RUN = NTR('run')
def _or_space(w):
"""Convert None to ''."""
if not w:
return ''
return w
def _sanitize(w):
"""Prohibit characters that could escape the shell.
Even though WE don't invoke the shell, any customer-supplied hooks
are almost surely running their own shell, and thus vulnerable
to Little Bobby Tables.
"""
ww = w
# Seems like shlex.quote() would be a better choice.
ww = ww.replace(';', '')
return ww
def _debug3(msg, *arg, **kwarg):
"""If logging at DEBUG3, do so. If not, do nothing."""
if LOG.isEnabledFor(logging.DEBUG3):
LOG.debug3(msg.format(*arg, **kwarg))