|
|
"""
|
|
|
rcextensions module.
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
import os
|
|
|
import imp
|
|
|
import string
|
|
|
import functools
|
|
|
|
|
|
here = os.path.dirname(os.path.abspath(__file__))
|
|
|
registered_extensions = dict()
|
|
|
|
|
|
class DotDict(dict):
|
|
|
|
|
|
def __contains__(self, k):
|
|
|
try:
|
|
|
return dict.__contains__(self, k) or hasattr(self, k)
|
|
|
except:
|
|
|
return False
|
|
|
|
|
|
# only called if k not found in normal places
|
|
|
def __getattr__(self, k):
|
|
|
try:
|
|
|
return object.__getattribute__(self, k)
|
|
|
except AttributeError:
|
|
|
try:
|
|
|
return self[k]
|
|
|
except KeyError:
|
|
|
raise AttributeError(k)
|
|
|
|
|
|
def __setattr__(self, k, v):
|
|
|
try:
|
|
|
object.__getattribute__(self, k)
|
|
|
except AttributeError:
|
|
|
try:
|
|
|
self[k] = v
|
|
|
except:
|
|
|
raise AttributeError(k)
|
|
|
else:
|
|
|
object.__setattr__(self, k, v)
|
|
|
|
|
|
def __delattr__(self, k):
|
|
|
try:
|
|
|
object.__getattribute__(self, k)
|
|
|
except AttributeError:
|
|
|
try:
|
|
|
del self[k]
|
|
|
except KeyError:
|
|
|
raise AttributeError(k)
|
|
|
else:
|
|
|
object.__delattr__(self, k)
|
|
|
|
|
|
def toDict(self):
|
|
|
return unserialize(self)
|
|
|
|
|
|
def __repr__(self):
|
|
|
keys = list(self.iterkeys())
|
|
|
keys.sort()
|
|
|
args = ', '.join(['%s=%r' % (key, self[key]) for key in keys])
|
|
|
return '%s(%s)' % (self.__class__.__name__, args)
|
|
|
|
|
|
@staticmethod
|
|
|
def fromDict(d):
|
|
|
return serialize(d)
|
|
|
|
|
|
|
|
|
def serialize(x):
|
|
|
if isinstance(x, dict):
|
|
|
return DotDict((k, serialize(v)) for k, v in x.iteritems())
|
|
|
elif isinstance(x, (list, tuple)):
|
|
|
return type(x)(serialize(v) for v in x)
|
|
|
else:
|
|
|
return x
|
|
|
|
|
|
|
|
|
def unserialize(x):
|
|
|
if isinstance(x, dict):
|
|
|
return dict((k, unserialize(v)) for k, v in x.iteritems())
|
|
|
elif isinstance(x, (list, tuple)):
|
|
|
return type(x)(unserialize(v) for v in x)
|
|
|
else:
|
|
|
return x
|
|
|
|
|
|
|
|
|
def load_extension(filename, async=False):
|
|
|
"""
|
|
|
use to load extensions inside rcextension folder.
|
|
|
for example::
|
|
|
|
|
|
callback = load_extension('email.py', async=False)
|
|
|
if callback:
|
|
|
callback('foobar')
|
|
|
|
|
|
put file named email.py inside rcextensions folder to load it. Changing
|
|
|
async=True will make the call of the plugin async, it's useful for
|
|
|
blocking calls like sending an email or notification with APIs.
|
|
|
"""
|
|
|
mod = ''.join(filename.split('.')[:-1])
|
|
|
loaded = imp.load_source(mod, os.path.join(here, filename))
|
|
|
|
|
|
callback = getattr(loaded, 'run', None)
|
|
|
if not callback:
|
|
|
raise Exception('Plugin missing `run` method')
|
|
|
if async:
|
|
|
# modify callback so it's actually an async call
|
|
|
def _async_callback(*args, **kwargs):
|
|
|
import threading
|
|
|
thr = threading.Thread(target=callback, args=args, kwargs=kwargs)
|
|
|
thr.start()
|
|
|
if kwargs.get('_async_block'):
|
|
|
del kwargs['_async_block']
|
|
|
thr.join()
|
|
|
|
|
|
return _async_callback
|
|
|
return callback
|
|
|
|
|
|
|
|
|
def _verify_kwargs(expected_parameters, kwargs):
|
|
|
"""
|
|
|
Verify that exactly `expected_parameters` are passed in as `kwargs`.
|
|
|
"""
|
|
|
expected_parameters = set(expected_parameters)
|
|
|
kwargs_keys = set(kwargs.keys())
|
|
|
if kwargs_keys != expected_parameters:
|
|
|
missing_kwargs = expected_parameters - kwargs_keys
|
|
|
unexpected_kwargs = kwargs_keys - expected_parameters
|
|
|
raise AssertionError(
|
|
|
"Missing parameters: %r, unexpected parameters: %s" %
|
|
|
(missing_kwargs, unexpected_kwargs))
|
|
|
|
|
|
|
|
|
def verify_kwargs(required_args):
|
|
|
"""
|
|
|
decorator to verify extension calls arguments.
|
|
|
|
|
|
:param required_args:
|
|
|
"""
|
|
|
def wrap(func):
|
|
|
def wrapper(*args, **kwargs):
|
|
|
_verify_kwargs(required_args, kwargs)
|
|
|
return func(*args, **kwargs)
|
|
|
return wrapper
|
|
|
return wrap
|
|
|
|
|
|
|
|
|
def register(name=None):
|
|
|
def wrap(func):
|
|
|
@functools.wraps(func)
|
|
|
def wrapper(*args, **kwargs):
|
|
|
# register load_extensions in kwargs, so we can chain plugins
|
|
|
kwargs['_load_extension'] = load_extension
|
|
|
# append this path for us to use added plugins or modules
|
|
|
import sys
|
|
|
_cur_path = os.path.dirname(os.path.abspath(__file__))
|
|
|
if _cur_path not in sys.path:
|
|
|
sys.path.append(_cur_path)
|
|
|
|
|
|
registered_extensions[func.__name__] = func
|
|
|
return func(*args, **kwargs)
|
|
|
return wrapper
|
|
|
return wrap
|
|
|
|
|
|
# =============================================================================
|
|
|
# END OF UTILITY FUNCTIONS HERE
|
|
|
# =============================================================================
|
|
|
|
|
|
# Additional mappings that are not present in the pygments lexers
|
|
|
# used for building stats
|
|
|
# format is {'ext':['Names']} eg. {'py':['Python']} note: there can be
|
|
|
# more than one name for extension
|
|
|
# NOTE: that this will override any mappings in LANGUAGES_EXTENSIONS_MAP
|
|
|
# build by pygments
|
|
|
EXTRA_MAPPINGS = {}
|
|
|
|
|
|
# additional lexer definitions for custom files it's overrides pygments lexers,
|
|
|
# and uses defined name of lexer to colorize the files. Format is {'ext':
|
|
|
# 'lexer_name'} List of lexers can be printed running:
|
|
|
# >> python -c "import pprint;from pygments import lexers;
|
|
|
# pprint.pprint([(x[0], x[1]) for x in lexers.get_all_lexers()]);"
|
|
|
|
|
|
EXTRA_LEXERS = {}
|
|
|
|
|
|
|
|
|
CONFIG = DotDict(
|
|
|
slack=DotDict(
|
|
|
api_key='api-key',
|
|
|
api_url='slack-incoming-hook-url',
|
|
|
default_room='#slack-channel',
|
|
|
default_plugin_config={},
|
|
|
),
|
|
|
redmine=DotDict(
|
|
|
api_key='api-key',
|
|
|
default_tracker_url='https://redmine.tracker.url',
|
|
|
default_project_id=None,
|
|
|
default_status_resolved_id=3
|
|
|
),
|
|
|
)
|
|
|
|
|
|
# slack conf
|
|
|
CONFIG.slack.default_plugin_config = {
|
|
|
'INCOMING_WEBHOOK_URL': CONFIG.slack.api_url,
|
|
|
'SLACK_TOKEN': CONFIG.slack.api_key,
|
|
|
'SLACK_ROOM': CONFIG.slack.default_room,
|
|
|
'SLACK_FROM': 'RhodeCode',
|
|
|
'SLACK_FROM_ICON_EMOJI': ':rhodecode:',
|
|
|
}
|
|
|
|
|
|
# redmine smart_pr configuration
|
|
|
def configure_redmine_smart_pr(issues, kwargs):
|
|
|
kwargs['REDMINE_ISSUES'] = issues
|
|
|
kwargs['redmine_tracker_url'] = kwargs.pop(
|
|
|
'redmine_tracker_url', '') or CONFIG.redmine.default_tracker_url
|
|
|
kwargs['redmine_api_key'] = kwargs.pop(
|
|
|
'redmine_api_key', '') or CONFIG.redmine.api_key
|
|
|
kwargs['redmine_project_id'] = kwargs.pop(
|
|
|
'redmine_project_id', '') or CONFIG.redmine.default_project_id
|
|
|
|
|
|
|
|
|
@register('CREATE_REPO_HOOK')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'repo_name', 'repo_type', 'description', 'private',
|
|
|
'created_on', 'enable_downloads', 'repo_id', 'user_id', 'enable_statistics',
|
|
|
'clone_uri', 'fork_id', 'group_id', 'created_by'])
|
|
|
def _create_repo_hook(*args, **kwargs):
|
|
|
"""
|
|
|
POST CREATE REPOSITORY HOOK. This function will be executed after
|
|
|
each repository is created. kwargs available:
|
|
|
|
|
|
:param repo_name:
|
|
|
:param repo_type:
|
|
|
:param description:
|
|
|
:param private:
|
|
|
:param created_on:
|
|
|
:param enable_downloads:
|
|
|
:param repo_id:
|
|
|
:param user_id:
|
|
|
:param enable_statistics:
|
|
|
:param clone_uri:
|
|
|
:param fork_id:
|
|
|
:param group_id:
|
|
|
:param created_by:
|
|
|
"""
|
|
|
return 0
|
|
|
CREATE_REPO_HOOK = _create_repo_hook
|
|
|
|
|
|
|
|
|
@register('CREATE_REPO_GROUP_HOOK')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'group_name', 'group_parent_id', 'group_description',
|
|
|
'group_id', 'user_id', 'created_by', 'created_on', 'enable_locking'])
|
|
|
def _create_repo_group_hook(*args, **kwargs):
|
|
|
"""
|
|
|
POST CREATE REPOSITORY GROUP HOOK, this function will be
|
|
|
executed after each repository group is created. kwargs available:
|
|
|
|
|
|
:param group_name:
|
|
|
:param group_parent_id:
|
|
|
:param group_description:
|
|
|
:param group_id:
|
|
|
:param user_id:
|
|
|
:param created_by:
|
|
|
:param created_on:
|
|
|
:param enable_locking:
|
|
|
"""
|
|
|
return 0
|
|
|
CREATE_REPO_GROUP_HOOK = _create_repo_group_hook
|
|
|
|
|
|
|
|
|
@register('PRE_CREATE_USER_HOOK')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'username', 'password', 'email', 'firstname',
|
|
|
'lastname', 'active', 'admin', 'created_by'])
|
|
|
def _pre_create_user_hook(*args, **kwargs):
|
|
|
"""
|
|
|
PRE CREATE USER HOOK, this function will be executed before each
|
|
|
user is created, it returns a tuple of bool, reason.
|
|
|
If bool is False the user creation will be stopped and reason
|
|
|
will be displayed to the user. kwargs available:
|
|
|
|
|
|
:param username:
|
|
|
:param password:
|
|
|
:param email:
|
|
|
:param firstname:
|
|
|
:param lastname:
|
|
|
:param active:
|
|
|
:param admin:
|
|
|
:param created_by:
|
|
|
"""
|
|
|
|
|
|
reason = 'allowed'
|
|
|
return True, reason
|
|
|
PRE_CREATE_USER_HOOK = _pre_create_user_hook
|
|
|
|
|
|
|
|
|
@register('CREATE_USER_HOOK')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'username', 'full_name_or_username', 'full_contact',
|
|
|
'user_id', 'name', 'firstname', 'short_contact', 'admin', 'lastname',
|
|
|
'ip_addresses', 'extern_type', 'extern_name', 'email', 'api_key',
|
|
|
'api_keys', 'last_login', 'full_name', 'active', 'password', 'emails',
|
|
|
'inherit_default_permissions', 'created_by', 'created_on'])
|
|
|
def _create_user_hook(*args, **kwargs):
|
|
|
"""
|
|
|
POST CREATE USER HOOK, this function will be executed after each user is created
|
|
|
kwargs available:
|
|
|
|
|
|
:param username:
|
|
|
:param full_name_or_username:
|
|
|
:param full_contact:
|
|
|
:param user_id:
|
|
|
:param name:
|
|
|
:param firstname:
|
|
|
:param short_contact:
|
|
|
:param admin:
|
|
|
:param lastname:
|
|
|
:param ip_addresses:
|
|
|
:param extern_type:
|
|
|
:param extern_name:
|
|
|
:param email:
|
|
|
:param api_key:
|
|
|
:param api_keys:
|
|
|
:param last_login:
|
|
|
:param full_name:
|
|
|
:param active:
|
|
|
:param password:
|
|
|
:param emails:
|
|
|
:param inherit_default_permissions:
|
|
|
:param created_by:
|
|
|
:param created_on:
|
|
|
"""
|
|
|
return 0
|
|
|
CREATE_USER_HOOK = _create_user_hook
|
|
|
|
|
|
|
|
|
@register('DELETE_REPO_HOOK')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'repo_name', 'repo_type', 'description', 'private',
|
|
|
'created_on', 'enable_downloads', 'repo_id', 'user_id', 'enable_statistics',
|
|
|
'clone_uri', 'fork_id', 'group_id', 'deleted_by', 'deleted_on'])
|
|
|
def _delete_repo_hook(*args, **kwargs):
|
|
|
"""
|
|
|
POST DELETE REPOSITORY HOOK, this function will be executed after
|
|
|
each repository deletion kwargs available:
|
|
|
|
|
|
:param repo_name:
|
|
|
:param repo_type:
|
|
|
:param description:
|
|
|
:param private:
|
|
|
:param created_on:
|
|
|
:param enable_downloads:
|
|
|
:param repo_id:
|
|
|
:param user_id:
|
|
|
:param enable_statistics:
|
|
|
:param clone_uri:
|
|
|
:param fork_id:
|
|
|
:param group_id:
|
|
|
:param deleted_by:
|
|
|
:param deleted_on:
|
|
|
"""
|
|
|
return 0
|
|
|
DELETE_REPO_HOOK = _delete_repo_hook
|
|
|
|
|
|
|
|
|
@register('DELETE_USER_HOOK')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'username', 'full_name_or_username', 'full_contact',
|
|
|
'user_id', 'name', 'firstname', 'short_contact', 'admin', 'lastname',
|
|
|
'ip_addresses', 'email', 'api_key', 'last_login', 'full_name', 'active',
|
|
|
'password', 'emails', 'inherit_default_permissions', 'deleted_by'
|
|
|
])
|
|
|
def _delete_user_hook(*args, **kwargs):
|
|
|
"""
|
|
|
POST DELETE USER HOOK, this function will be executed after each
|
|
|
user is deleted kwargs available:
|
|
|
|
|
|
:param username:
|
|
|
:param full_name_or_username:
|
|
|
:param full_contact:
|
|
|
:param user_id:
|
|
|
:param name:
|
|
|
:param firstname:
|
|
|
:param short_contact:
|
|
|
:param admin:
|
|
|
:param lastname:
|
|
|
:param ip_addresses:
|
|
|
:param ldap_dn:
|
|
|
:param email:
|
|
|
:param api_key:
|
|
|
:param last_login:
|
|
|
:param full_name:
|
|
|
:param active:
|
|
|
:param password:
|
|
|
:param emails:
|
|
|
:param inherit_default_permissions:
|
|
|
:param deleted_by:
|
|
|
"""
|
|
|
return 0
|
|
|
DELETE_USER_HOOK = _delete_user_hook
|
|
|
|
|
|
|
|
|
@register('PRE_PUSH_HOOK')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'server_url', 'config', 'scm', 'username',
|
|
|
'ip', 'action', 'repository', 'repo_store_path'])
|
|
|
def _pre_push_hook(*args, **kwargs):
|
|
|
"""
|
|
|
Post push hook
|
|
|
kwargs available:
|
|
|
|
|
|
:param server_url: url of instance that triggered this hook
|
|
|
:param config: path to .ini config used
|
|
|
:param scm: type of VS 'git' or 'hg'
|
|
|
:param username: name of user who pushed
|
|
|
:param ip: ip of who pushed
|
|
|
:param action: push
|
|
|
:param repository: repository name
|
|
|
:param repo_store_path: full path to where repositories are stored
|
|
|
"""
|
|
|
return 0
|
|
|
PRE_PUSH_HOOK = _pre_push_hook
|
|
|
|
|
|
|
|
|
@register('PUSH_HOOK')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'server_url', 'config', 'scm', 'username',
|
|
|
'ip', 'action', 'repository', 'repo_store_path', 'pushed_revs'])
|
|
|
def _push_hook(*args, **kwargs):
|
|
|
"""
|
|
|
POST PUSH HOOK, this function will be executed after each push it's
|
|
|
executed after the build-in hook that RhodeCode uses for logging pushes
|
|
|
kwargs available:
|
|
|
|
|
|
:param server_url: url of instance that triggered this hook
|
|
|
:param config: path to .ini config used
|
|
|
:param scm: type of VS 'git' or 'hg'
|
|
|
:param username: name of user who pushed
|
|
|
:param ip: ip of who pushed
|
|
|
:param action: push
|
|
|
:param repository: repository name
|
|
|
:param repo_store_path: full path to where repositories are stored
|
|
|
:param pushed_revs: list of pushed commit ids
|
|
|
"""
|
|
|
# backward compat
|
|
|
kwargs['commit_ids'] = kwargs['pushed_revs']
|
|
|
|
|
|
# fetch extra fields from repository
|
|
|
call = load_extension('extra_fields.py')
|
|
|
_extra_fields = {}
|
|
|
if call:
|
|
|
repo_extra_fields = call(**kwargs)
|
|
|
# now update if we have extra fields, they have precedence
|
|
|
# this way users can store any configuration inside the database per
|
|
|
# repo
|
|
|
for key, data in repo_extra_fields.items():
|
|
|
kwargs[key] = data['field_value']
|
|
|
_extra_fields[key] = data['field_value']
|
|
|
|
|
|
# fetch pushed commits, from commit_ids list
|
|
|
call = load_extension('extract_commits.py')
|
|
|
extracted_commits = {}
|
|
|
if call:
|
|
|
extracted_commits = call(**kwargs)
|
|
|
# store the commits for the next call chain
|
|
|
kwargs['COMMITS'] = extracted_commits
|
|
|
|
|
|
# slack !
|
|
|
call = load_extension('slack_push_notify.py')
|
|
|
if call:
|
|
|
kwargs.update(CONFIG.slack.default_plugin_config)
|
|
|
call(**kwargs)
|
|
|
|
|
|
# fetch redmine issues from given commits
|
|
|
call = load_extension('extract_redmine_issues.py')
|
|
|
issues = {}
|
|
|
if call:
|
|
|
issues = call(**kwargs)
|
|
|
|
|
|
# redmine smart commits
|
|
|
call = load_extension('redmine_smart_commits.py')
|
|
|
if call:
|
|
|
kwargs['REDMINE_ISSUES'] = issues
|
|
|
|
|
|
kwargs['redmine_tracker_url'] = kwargs.pop(
|
|
|
'redmine_tracker_url', '') or CONFIG.redmine.default_tracker_url
|
|
|
kwargs['redmine_api_key'] = kwargs.pop(
|
|
|
'redmine_api_key', '') or CONFIG.redmine.api_key
|
|
|
kwargs['redmine_status_resolved_id'] = kwargs.pop(
|
|
|
'redmine_status_resolved_id', '') or CONFIG.redmine.default_status_resolved_id
|
|
|
kwargs['redmine_project_id'] = kwargs.pop(
|
|
|
'redmine_project_id', '') or CONFIG.redmine.default_project_id
|
|
|
call(**kwargs)
|
|
|
|
|
|
return 0
|
|
|
PUSH_HOOK = _push_hook
|
|
|
|
|
|
|
|
|
@register('PRE_PULL_HOOK')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'server_url', 'config', 'scm', 'username', 'ip',
|
|
|
'action', 'repository'])
|
|
|
def _pre_pull_hook(*args, **kwargs):
|
|
|
"""
|
|
|
Post pull hook
|
|
|
kwargs available::
|
|
|
|
|
|
:param server_url: url of instance that triggered this hook
|
|
|
:param config: path to .ini config used
|
|
|
:param scm: type of VS 'git' or 'hg'
|
|
|
:param username: name of user who pulled
|
|
|
:param ip: ip of who pulled
|
|
|
:param action: pull
|
|
|
:param repository: repository name
|
|
|
"""
|
|
|
return 0
|
|
|
PRE_PULL_HOOK = _pre_pull_hook
|
|
|
|
|
|
|
|
|
@register('PULL_HOOK')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'server_url', 'config', 'scm', 'username', 'ip',
|
|
|
'action', 'repository'])
|
|
|
def _pull_hook(*args, **kwargs):
|
|
|
"""
|
|
|
POST PULL HOOK, this function will be executed after each push it's
|
|
|
executed after the build-in hook that RhodeCode uses for logging pulls
|
|
|
|
|
|
kwargs available:
|
|
|
|
|
|
:param server_url: url of instance that triggered this hook
|
|
|
:param config: path to .ini config used
|
|
|
:param scm: type of VS 'git' or 'hg'
|
|
|
:param username: name of user who pulled
|
|
|
:param ip: ip of who pulled
|
|
|
:param action: pull
|
|
|
:param repository: repository name
|
|
|
"""
|
|
|
return 0
|
|
|
PULL_HOOK = _pull_hook
|
|
|
|
|
|
|
|
|
# =============================================================================
|
|
|
# PULL REQUEST RELATED HOOKS
|
|
|
# =============================================================================
|
|
|
@register('CREATE_PULL_REQUEST')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'server_url', 'config', 'scm', 'username', 'ip',
|
|
|
'action', 'repository', 'pull_request_id', 'url', 'title', 'description',
|
|
|
'status', 'created_on', 'updated_on', 'commit_ids', 'review_status',
|
|
|
'mergeable', 'source', 'target', 'author', 'reviewers'])
|
|
|
def _create_pull_request_hook(*args, **kwargs):
|
|
|
"""
|
|
|
|
|
|
"""
|
|
|
# extract extra fields and default reviewers from target
|
|
|
kwargs['REPOSITORY'] = kwargs['target']['repository']
|
|
|
|
|
|
call = load_extension('extra_fields.py')
|
|
|
if call:
|
|
|
repo_extra_fields = call(**kwargs)
|
|
|
# now update if we have extra fields, they have precedence
|
|
|
# this way users can store any configuration inside the database per
|
|
|
# repo
|
|
|
for key, data in repo_extra_fields.items():
|
|
|
kwargs[key] = data['field_value']
|
|
|
|
|
|
call = load_extension('default_reviewers.py')
|
|
|
if call:
|
|
|
# read default_reviewers key propagated from extra fields
|
|
|
kwargs['default_reviewers'] = map(string.strip, kwargs.pop(
|
|
|
'default_reviewers', '').split(','))
|
|
|
call(**kwargs)
|
|
|
|
|
|
# extract below from source repo as commits are there
|
|
|
kwargs['REPOSITORY'] = kwargs['source']['repository']
|
|
|
|
|
|
# # fetch pushed commits, from commit_ids list
|
|
|
# call = load_extension('extract_commits.py')
|
|
|
# extracted_commits = {}
|
|
|
# if call:
|
|
|
# extracted_commits = call(**kwargs)
|
|
|
# # store the commits for the next call chain
|
|
|
# kwargs['COMMITS'] = extracted_commits
|
|
|
#
|
|
|
# # fetch issues from given commits
|
|
|
# call = load_extension('extract_redmine_issues.py')
|
|
|
# issues = {}
|
|
|
# if call:
|
|
|
# issues = call(**kwargs)
|
|
|
#
|
|
|
# # redmine smart pr update
|
|
|
# call = load_extension('redmine_pr_flow.py')
|
|
|
# if call:
|
|
|
# # updates kwargs on the fly
|
|
|
# configure_redmine_smart_pr(issues=issues, kwargs=kwargs)
|
|
|
# call(**kwargs)
|
|
|
#
|
|
|
# # slack notification on merging PR
|
|
|
# call = load_extension('slack_message.py')
|
|
|
# if call:
|
|
|
# kwargs.update(CONFIG.slack.default_plugin_config)
|
|
|
# kwargs['SLACK_ROOM'] = '#develop'
|
|
|
# kwargs['SLACK_MESSAGE'] = 'Pull request <%s|#%s> (%s) was created.' % (
|
|
|
# kwargs.get('url'), kwargs.get('pull_request_id'), kwargs.get('title'))
|
|
|
#
|
|
|
# call(**kwargs)
|
|
|
|
|
|
return 0
|
|
|
CREATE_PULL_REQUEST = _create_pull_request_hook
|
|
|
|
|
|
|
|
|
@register('REVIEW_PULL_REQUEST')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'server_url', 'config', 'scm', 'username', 'ip',
|
|
|
'action', 'repository', 'pull_request_id', 'url', 'title', 'description',
|
|
|
'status', 'created_on', 'updated_on', 'commit_ids', 'review_status',
|
|
|
'mergeable', 'source', 'target', 'author', 'reviewers'])
|
|
|
def _review_pull_request_hook(*args, **kwargs):
|
|
|
"""
|
|
|
|
|
|
"""
|
|
|
# extract extra fields and default reviewers from target
|
|
|
kwargs['REPOSITORY'] = kwargs['target']['repository']
|
|
|
|
|
|
# fetch extra fields
|
|
|
call = load_extension('extra_fields.py')
|
|
|
if call:
|
|
|
repo_extra_fields = call(**kwargs)
|
|
|
# now update if we have extra fields, they have precedence
|
|
|
# this way users can store any configuration inside the database per
|
|
|
# repo
|
|
|
for key, data in repo_extra_fields.items():
|
|
|
kwargs[key] = data['field_value']
|
|
|
|
|
|
# extract below from source repo as commits are there
|
|
|
kwargs['REPOSITORY'] = kwargs['source']['repository']
|
|
|
|
|
|
# fetch pushed commits, from commit_ids list
|
|
|
call = load_extension('extract_commits.py')
|
|
|
extracted_commits = {}
|
|
|
if call:
|
|
|
extracted_commits = call(**kwargs)
|
|
|
# store the commits for the next call chain
|
|
|
kwargs['COMMITS'] = extracted_commits
|
|
|
|
|
|
# fetch issues from given commits
|
|
|
call = load_extension('extract_redmine_issues.py')
|
|
|
issues = {}
|
|
|
if call:
|
|
|
issues = call(**kwargs)
|
|
|
|
|
|
# redmine smart pr update
|
|
|
call = load_extension('redmine_pr_flow.py')
|
|
|
if call:
|
|
|
# updates kwargs on the fly
|
|
|
configure_redmine_smart_pr(issues=issues, kwargs=kwargs)
|
|
|
call(**kwargs)
|
|
|
|
|
|
return 0
|
|
|
REVIEW_PULL_REQUEST = _review_pull_request_hook
|
|
|
|
|
|
|
|
|
@register('UPDATE_PULL_REQUEST')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'server_url', 'config', 'scm', 'username', 'ip',
|
|
|
'action', 'repository', 'pull_request_id', 'url', 'title', 'description',
|
|
|
'status', 'created_on', 'updated_on', 'commit_ids', 'review_status',
|
|
|
'mergeable', 'source', 'target', 'author', 'reviewers'])
|
|
|
def _update_pull_request_hook(*args, **kwargs):
|
|
|
"""
|
|
|
|
|
|
"""
|
|
|
# extract extra fields and default reviewers from target
|
|
|
kwargs['REPOSITORY'] = kwargs['target']['repository']
|
|
|
|
|
|
# fetch extra fields
|
|
|
call = load_extension('extra_fields.py')
|
|
|
if call:
|
|
|
repo_extra_fields = call(**kwargs)
|
|
|
# now update if we have extra fields, they have precedence
|
|
|
# this way users can store any configuration inside the database per
|
|
|
# repo
|
|
|
for key, data in repo_extra_fields.items():
|
|
|
kwargs[key] = data['field_value']
|
|
|
|
|
|
# extract below from source repo as commits are there
|
|
|
kwargs['REPOSITORY'] = kwargs['source']['repository']
|
|
|
|
|
|
# fetch pushed commits, from commit_ids list
|
|
|
call = load_extension('extract_commits.py')
|
|
|
extracted_commits = {}
|
|
|
if call:
|
|
|
extracted_commits = call(**kwargs)
|
|
|
# store the commits for the next call chain
|
|
|
kwargs['COMMITS'] = extracted_commits
|
|
|
|
|
|
# fetch issues from given commits
|
|
|
call = load_extension('extract_redmine_issues.py')
|
|
|
issues = {}
|
|
|
if call:
|
|
|
issues = call(**kwargs)
|
|
|
|
|
|
# redmine smart pr updated
|
|
|
call = load_extension('redmine_pr_flow.py')
|
|
|
if call:
|
|
|
# updates kwargs on the fly
|
|
|
configure_redmine_smart_pr(issues=issues, kwargs=kwargs)
|
|
|
call(**kwargs)
|
|
|
|
|
|
return 0
|
|
|
UPDATE_PULL_REQUEST = _update_pull_request_hook
|
|
|
|
|
|
|
|
|
@register('MERGE_PULL_REQUEST')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'server_url', 'config', 'scm', 'username', 'ip',
|
|
|
'action', 'repository', 'pull_request_id', 'url', 'title', 'description',
|
|
|
'status', 'created_on', 'updated_on', 'commit_ids', 'review_status',
|
|
|
'mergeable', 'source', 'target', 'author', 'reviewers'])
|
|
|
def _merge_pull_request_hook(*args, **kwargs):
|
|
|
"""
|
|
|
|
|
|
"""
|
|
|
# extract extra fields and default reviewers from target
|
|
|
kwargs['REPOSITORY'] = kwargs['target']['repository']
|
|
|
|
|
|
# fetch extra fields
|
|
|
call = load_extension('extra_fields.py')
|
|
|
if call:
|
|
|
repo_extra_fields = call(**kwargs)
|
|
|
# now update if we have extra fields, they have precedence
|
|
|
# this way users can store any configuration inside the database per
|
|
|
# repo
|
|
|
for key, data in repo_extra_fields.items():
|
|
|
kwargs[key] = data['field_value']
|
|
|
|
|
|
# extract below from source repo as commits are there
|
|
|
kwargs['REPOSITORY'] = kwargs['source']['repository']
|
|
|
|
|
|
# fetch pushed commits, from commit_ids list
|
|
|
call = load_extension('extract_commits.py')
|
|
|
extracted_commits = {}
|
|
|
if call:
|
|
|
extracted_commits = call(**kwargs)
|
|
|
# store the commits for the next call chain
|
|
|
kwargs['COMMITS'] = extracted_commits
|
|
|
|
|
|
# fetch issues from given commits
|
|
|
call = load_extension('extract_redmine_issues.py')
|
|
|
issues = {}
|
|
|
if call:
|
|
|
issues = call(**kwargs)
|
|
|
|
|
|
# redmine smart pr update
|
|
|
call = load_extension('redmine_pr_flow.py')
|
|
|
if call:
|
|
|
# updates kwargs on the fly
|
|
|
configure_redmine_smart_pr(issues=issues, kwargs=kwargs)
|
|
|
call(**kwargs)
|
|
|
|
|
|
# slack notification on merging PR
|
|
|
call = load_extension('slack_message.py')
|
|
|
if call:
|
|
|
kwargs.update(CONFIG.slack.default_plugin_config)
|
|
|
kwargs['SLACK_ROOM'] = '#develop'
|
|
|
kwargs['SLACK_MESSAGE'] = 'Pull request <%s|#%s> (%s) was merged.' % (
|
|
|
kwargs.get('url'), kwargs.get('pull_request_id'), kwargs.get('title'))
|
|
|
call(**kwargs)
|
|
|
|
|
|
return 0
|
|
|
MERGE_PULL_REQUEST = _merge_pull_request_hook
|
|
|
|
|
|
|
|
|
@register('CLOSE_PULL_REQUEST')
|
|
|
@verify_kwargs(
|
|
|
['_load_extension', 'server_url', 'config', 'scm', 'username', 'ip',
|
|
|
'action', 'repository', 'pull_request_id', 'url', 'title', 'description',
|
|
|
'status', 'created_on', 'updated_on', 'commit_ids', 'review_status',
|
|
|
'mergeable', 'source', 'target', 'author', 'reviewers'])
|
|
|
def _close_pull_request_hook(*args, **kwargs):
|
|
|
"""
|
|
|
|
|
|
"""
|
|
|
# extract extra fields and default reviewers from target
|
|
|
kwargs['REPOSITORY'] = kwargs['target']['repository']
|
|
|
|
|
|
# fetch extra fields
|
|
|
call = load_extension('extra_fields.py')
|
|
|
if call:
|
|
|
repo_extra_fields = call(**kwargs)
|
|
|
# now update if we have extra fields, they have precedence
|
|
|
# this way users can store any configuration inside the database per
|
|
|
# repo
|
|
|
for key, data in repo_extra_fields.items():
|
|
|
kwargs[key] = data['field_value']
|
|
|
|
|
|
# extract below from source repo as commits are there
|
|
|
kwargs['REPOSITORY'] = kwargs['source']['repository']
|
|
|
|
|
|
# fetch pushed commits, from commit_ids list
|
|
|
call = load_extension('extract_commits.py')
|
|
|
extracted_commits = {}
|
|
|
if call:
|
|
|
extracted_commits = call(**kwargs)
|
|
|
# store the commits for the next call chain
|
|
|
kwargs['COMMITS'] = extracted_commits
|
|
|
|
|
|
# fetch issues from given commits
|
|
|
call = load_extension('extract_redmine_issues.py')
|
|
|
issues = {}
|
|
|
if call:
|
|
|
issues = call(**kwargs)
|
|
|
|
|
|
# redmine smart pr update
|
|
|
call = load_extension('redmine_pr_flow.py')
|
|
|
if call:
|
|
|
# updates kwargs on the fly
|
|
|
configure_redmine_smart_pr(issues=issues, kwargs=kwargs)
|
|
|
call(**kwargs)
|
|
|
|
|
|
return 0
|
|
|
CLOSE_PULL_REQUEST = _close_pull_request_hook
|
|
|
|
