webhook: quote URL variables to prevent url errors with special chars like # in pr title.

rhodecode/integrations/types/base.py

@@ -1,355 +1,363 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import colander
 import string
 import collections
 import logging
 import requests
+import urllib
 from requests.adapters import HTTPAdapter
 from requests.packages.urllib3.util.retry import Retry
 
 from mako import exceptions
 
+from rhodecode.lib.utils2 import safe_str
 from rhodecode.translation import _
 
 
 log = logging.getLogger(__name__)
 
 
+class UrlTmpl(string.Template):
+
+    def safe_substitute(self, **kws):
+        # url encode the kw for usage in url
+        kws = {k: urllib.quote(safe_str(v)) for k, v in kws.items()}
+        return super(UrlTmpl, self).safe_substitute(**kws)
+
+
 class IntegrationTypeBase(object):
     """ Base class for IntegrationType plugins """
     is_dummy = False
     description = ''
 
     @classmethod
     def icon(cls):
         return '''
         <?xml version="1.0" encoding="UTF-8" standalone="no"?>
         <svg
            xmlns:dc="http://purl.org/dc/elements/1.1/"
            xmlns:cc="http://creativecommons.org/ns#"
            xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:svg="http://www.w3.org/2000/svg"
            xmlns="http://www.w3.org/2000/svg"
            xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
            xmlns:inkscape="http://setwww.inkscape.org/namespaces/inkscape"
            viewBox="0 -256 1792 1792"
            id="svg3025"
            version="1.1"
            inkscape:version="0.48.3.1 r9886"
            width="100%"
            height="100%"
            sodipodi:docname="cog_font_awesome.svg">
           <metadata
              id="metadata3035">
             <rdf:RDF>
               <cc:Work
                  rdf:about="">
                 <dc:format>image/svg+xml</dc:format>
                 <dc:type
                    rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
               </cc:Work>
             </rdf:RDF>
           </metadata>
           <defs
              id="defs3033" />
           <sodipodi:namedview
              pagecolor="#ffffff"
              bordercolor="#666666"
              borderopacity="1"
              objecttolerance="10"
              gridtolerance="10"
              guidetolerance="10"
              inkscape:pageopacity="0"
              inkscape:pageshadow="2"
              inkscape:window-width="640"
              inkscape:window-height="480"
              id="namedview3031"
              showgrid="false"
              inkscape:zoom="0.13169643"
              inkscape:cx="896"
              inkscape:cy="896"
              inkscape:window-x="0"
              inkscape:window-y="25"
              inkscape:window-maximized="0"
              inkscape:current-layer="svg3025" />
           <g
              transform="matrix(1,0,0,-1,121.49153,1285.4237)"
              id="g3027">
             <path
                d="m 1024,640 q 0,106 -75,181 -75,75 -181,75 -106,0 -181,-75 -75,-75 -75,-181 0,-106 75,-181 75,-75 181,-75 106,0 181,75 75,75 75,181 z m 512,109 V 527 q 0,-12 -8,-23 -8,-11 -20,-13 l -185,-28 q -19,-54 -39,-91 35,-50 107,-138 10,-12 10,-25 0,-13 -9,-23 -27,-37 -99,-108 -72,-71 -94,-71 -12,0 -26,9 l -138,108 q -44,-23 -91,-38 -16,-136 -29,-186 -7,-28 -36,-28 H 657 q -14,0 -24.5,8.5 Q 622,-111 621,-98 L 593,86 q -49,16 -90,37 L 362,16 Q 352,7 337,7 323,7 312,18 186,132 147,186 q -7,10 -7,23 0,12 8,23 15,21 51,66.5 36,45.5 54,70.5 -27,50 -41,99 L 29,495 Q 16,497 8,507.5 0,518 0,531 v 222 q 0,12 8,23 8,11 19,13 l 186,28 q 14,46 39,92 -40,57 -107,138 -10,12 -10,24 0,10 9,23 26,36 98.5,107.5 72.5,71.5 94.5,71.5 13,0 26,-10 l 138,-107 q 44,23 91,38 16,136 29,186 7,28 36,28 h 222 q 14,0 24.5,-8.5 Q 914,1391 915,1378 l 28,-184 q 49,-16 90,-37 l 142,107 q 9,9 24,9 13,0 25,-10 129,-119 165,-170 7,-8 7,-22 0,-12 -8,-23 -15,-21 -51,-66.5 -36,-45.5 -54,-70.5 26,-50 41,-98 l 183,-28 q 13,-2 21,-12.5 8,-10.5 8,-23.5 z"
                id="path3029"
                inkscape:connector-curvature="0"
                style="fill:currentColor" />
           </g>
         </svg>
         '''
 
     def __init__(self, settings):
         """
         :param settings: dict of settings to be used for the integration
         """
         self.settings = settings
 
     def settings_schema(self):
         """
         A colander schema of settings for the integration type
         """
         return colander.Schema()
 
 
 class EEIntegration(IntegrationTypeBase):
     description = 'Integration available in RhodeCode EE edition.'
     is_dummy = True
 
     def __init__(self, name, key, settings=None):
         self.display_name = name
         self.key = key
         super(EEIntegration, self).__init__(settings)
 
 
 # Helpers #
 # updating this required to update the `common_vars` as well.
 WEBHOOK_URL_VARS = [
     ('event_name', 'Unique name of the event type, e.g pullrequest-update'),
     ('repo_name', 'Full name of the repository'),
     ('repo_type', 'VCS type of repository'),
     ('repo_id', 'Unique id of repository'),
     ('repo_url', 'Repository url'),
     # extra repo fields
     ('extra:<extra_key_name>', 'Extra repo variables, read from its settings.'),
 
     # special attrs below that we handle, using multi-call
     ('branch', 'Name of each branch submitted, if any.'),
     ('branch_head', 'Head ID of pushed branch (full sha of last commit), if any.'),
     ('commit_id', 'ID (full sha) of each commit submitted, if any.'),
 
     # pr events vars
     ('pull_request_id', 'Unique ID of the pull request.'),
     ('pull_request_title', 'Title of the pull request.'),
     ('pull_request_url', 'Pull request url.'),
     ('pull_request_shadow_url', 'Pull request shadow repo clone url.'),
     ('pull_request_commits_uid', 'Calculated UID of all commits inside the PR. '
                                  'Changes after PR update'),
 
     # user who triggers the call
     ('username', 'User who triggered the call.'),
     ('user_id', 'User id who triggered the call.'),
 ]
 
 # common vars for url template used for CI plugins. Shared with webhook
 CI_URL_VARS = WEBHOOK_URL_VARS
 
 
 class CommitParsingDataHandler(object):
 
     def aggregate_branch_data(self, branches, commits):
         branch_data = collections.OrderedDict()
         for obj in branches:
             branch_data[obj['name']] = obj
 
         branches_commits = collections.OrderedDict()
         for commit in commits:
             if commit.get('git_ref_change'):
                 # special case for GIT that allows creating tags,
                 # deleting branches without associated commit
                 continue
             commit_branch = commit['branch']
 
             if commit_branch not in branches_commits:
                 _branch = branch_data[commit_branch] \
                     if commit_branch else commit_branch
                 branch_commits = {'branch': _branch,
                                   'branch_head': '',
                                   'commits': []}
                 branches_commits[commit_branch] = branch_commits
 
             branch_commits = branches_commits[commit_branch]
             branch_commits['commits'].append(commit)
             branch_commits['branch_head'] = commit['raw_id']
         return branches_commits
 
 
 class WebhookDataHandler(CommitParsingDataHandler):
     name = 'webhook'
 
     def __init__(self, template_url, headers):
         self.template_url = template_url
         self.headers = headers
 
     def get_base_parsed_template(self, data):
         """
         initially parses the passed in template with some common variables
         available on ALL calls
         """
         # note: make sure to update the `WEBHOOK_URL_VARS` if this changes
         common_vars = {
             'repo_name': data['repo']['repo_name'],
             'repo_type': data['repo']['repo_type'],
             'repo_id': data['repo']['repo_id'],
             'repo_url': data['repo']['url'],
             'username': data['actor']['username'],
             'user_id': data['actor']['user_id'],
             'event_name': data['name']
         }
 
         extra_vars = {}
         for extra_key, extra_val in data['repo']['extra_fields'].items():
             extra_vars['extra__{}'.format(extra_key)] = extra_val
         common_vars.update(extra_vars)
 
         template_url = self.template_url.replace('${extra:', '${extra__')
-        return string.Template(template_url).safe_substitute(**common_vars)
+        for k, v in common_vars.items():
+            template_url = UrlTmpl(template_url).safe_substitute(**{k: v})
+        return template_url
 
     def repo_push_event_handler(self, event, data):
         url = self.get_base_parsed_template(data)
         url_calls = []
 
         branches_commits = self.aggregate_branch_data(
             data['push']['branches'], data['push']['commits'])
         if '${branch}' in url or '${branch_head}' in url or '${commit_id}' in url:
             # call it multiple times, for each branch if used in variables
             for branch, commit_ids in branches_commits.items():
-                branch_url = string.Template(url).safe_substitute(branch=branch)
+                branch_url = UrlTmpl(url).safe_substitute(branch=branch)
 
                 if '${branch_head}' in branch_url:
                     # last commit in the aggregate is the head of the branch
                     branch_head = commit_ids['branch_head']
-                    branch_url = string.Template(branch_url).safe_substitute(
-                        branch_head=branch_head)
+                    branch_url = UrlTmpl(branch_url).safe_substitute(branch_head=branch_head)
 
                 # call further down for each commit if used
                 if '${commit_id}' in branch_url:
                     for commit_data in commit_ids['commits']:
                         commit_id = commit_data['raw_id']
-                        commit_url = string.Template(branch_url).safe_substitute(
-                            commit_id=commit_id)
+                        commit_url = UrlTmpl(branch_url).safe_substitute(commit_id=commit_id)
                         # register per-commit call
                         log.debug(
                             'register %s call(%s) to url %s',
                             self.name, event, commit_url)
                         url_calls.append(
                             (commit_url, self.headers, data))
 
                 else:
                     # register per-branch call
-                    log.debug(
-                        'register %s call(%s) to url %s',
+                    log.debug('register %s call(%s) to url %s',
                         self.name, event, branch_url)
-                    url_calls.append(
-                        (branch_url, self.headers, data))
+                    url_calls.append((branch_url, self.headers, data))
 
         else:
-            log.debug(
-                'register %s call(%s) to url %s', self.name, event, url)
+            log.debug('register %s call(%s) to url %s', self.name, event, url)
             url_calls.append((url, self.headers, data))
 
         return url_calls
 
     def repo_create_event_handler(self, event, data):
         url = self.get_base_parsed_template(data)
-        log.debug(
-            'register %s call(%s) to url %s', self.name, event, url)
+        log.debug('register %s call(%s) to url %s', self.name, event, url)
         return [(url, self.headers, data)]
 
     def pull_request_event_handler(self, event, data):
         url = self.get_base_parsed_template(data)
-        log.debug(
-            'register %s call(%s) to url %s', self.name, event, url)
-        url = string.Template(url).safe_substitute(
-            pull_request_id=data['pullrequest']['pull_request_id'],
-            pull_request_title=data['pullrequest']['title'],
-            pull_request_url=data['pullrequest']['url'],
-            pull_request_shadow_url=data['pullrequest']['shadow_url'],
-            pull_request_commits_uid=data['pullrequest']['commits_uid'],
-        )
+        log.debug('register %s call(%s) to url %s', self.name, event, url)
+        pr_vars = [
+            ('pull_request_id', data['pullrequest']['pull_request_id']),
+            ('pull_request_title', data['pullrequest']['title']),
+            ('pull_request_url', data['pullrequest']['url']),
+            ('pull_request_shadow_url', data['pullrequest']['shadow_url']),
+            ('pull_request_commits_uid', data['pullrequest']['commits_uid']),
+        ]
+        for k, v in pr_vars:
+            url = UrlTmpl(url).safe_substitute(**{k: v})
+
         return [(url, self.headers, data)]
 
     def __call__(self, event, data):
         from rhodecode import events
 
         if isinstance(event, events.RepoPushEvent):
             return self.repo_push_event_handler(event, data)
         elif isinstance(event, events.RepoCreateEvent):
             return self.repo_create_event_handler(event, data)
         elif isinstance(event, events.PullRequestEvent):
             return self.pull_request_event_handler(event, data)
         else:
             raise ValueError(
                 'event type `%s` not in supported list: %s' % (
                     event.__class__, events))
 
 
 def get_auth(settings):
     from requests.auth import HTTPBasicAuth
     username = settings.get('username')
     password = settings.get('password')
     if username and password:
         return HTTPBasicAuth(username, password)
     return None
 
 
 def get_web_token(settings):
     return settings['secret_token']
 
 
 def get_url_vars(url_vars):
     return '\n'.join(
         '{} - {}'.format('${' + key + '}', explanation)
         for key, explanation in url_vars)
 
 
 def render_with_traceback(template, *args, **kwargs):
     try:
         return template.render(*args, **kwargs)
     except Exception:
         log.error(exceptions.text_error_template().render())
         raise
 
 
 STATUS_400 = (400, 401, 403)
 STATUS_500 = (500, 502, 504)
 
 
 def requests_retry_call(
         retries=3, backoff_factor=0.3, status_forcelist=STATUS_400+STATUS_500,
         session=None):
     """
     session = requests_retry_session()
     response = session.get('http://example.com')
 
     :param retries:
     :param backoff_factor:
     :param status_forcelist:
     :param session:
     """
     session = session or requests.Session()
     retry = Retry(
         total=retries,
         read=retries,
         connect=retries,
         backoff_factor=backoff_factor,
         status_forcelist=status_forcelist,
     )
     adapter = HTTPAdapter(max_retries=retry)
     session.mount('http://', adapter)
     session.mount('https://', adapter)
     return session

rhodecode/integrations/types/webhook.py

@@ -1,265 +1,265 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 from __future__ import unicode_literals
 
 import deform
 import deform.widget
 import logging
 import colander
 
 import rhodecode
 from rhodecode import events
 from rhodecode.translation import _
 from rhodecode.integrations.types.base import (
     IntegrationTypeBase, get_auth, get_web_token, get_url_vars,
     WebhookDataHandler, WEBHOOK_URL_VARS, requests_retry_call)
 from rhodecode.lib.celerylib import run_task, async_task, RequestContextTask
 from rhodecode.model.validation_schema import widgets
 
 log = logging.getLogger(__name__)
 
 
 # updating this required to update the `common_vars` passed in url calling func
 
 URL_VARS = get_url_vars(WEBHOOK_URL_VARS)
 
 
 class WebhookSettingsSchema(colander.Schema):
     url = colander.SchemaNode(
         colander.String(),
         title=_('Webhook URL'),
         description=
             _('URL to which Webhook should submit data. If used some of the '
               'variables would trigger multiple calls, like ${branch} or '
               '${commit_id}. Webhook will be called as many times as unique '
               'objects in data in such cases.'),
         missing=colander.required,
         required=True,
         validator=colander.url,
         widget=widgets.CodeMirrorWidget(
             help_block_collapsable_name='Show url variables',
             help_block_collapsable=(
                 'E.g http://my-serv/trigger_job/${{event_name}}'
                 '?PR_ID=${{pull_request_id}}'
                 '\nFull list of vars:\n{}'.format(URL_VARS)),
             codemirror_mode='text',
             codemirror_options='{"lineNumbers": false, "lineWrapping": true}'),
     )
     secret_token = colander.SchemaNode(
         colander.String(),
         title=_('Secret Token'),
         description=_('Optional string used to validate received payloads. '
                       'It will be sent together with event data in JSON'),
         default='',
         missing='',
         widget=deform.widget.TextInputWidget(
             placeholder='e.g. secret_token'
         ),
     )
     username = colander.SchemaNode(
         colander.String(),
         title=_('Username'),
         description=_('Optional username to authenticate the call.'),
         default='',
         missing='',
         widget=deform.widget.TextInputWidget(
             placeholder='e.g. admin'
         ),
     )
     password = colander.SchemaNode(
         colander.String(),
         title=_('Password'),
         description=_('Optional password to authenticate the call.'),
         default='',
         missing='',
         widget=deform.widget.PasswordWidget(
             placeholder='e.g. secret.',
             redisplay=True,
         ),
     )
     custom_header_key = colander.SchemaNode(
         colander.String(),
         title=_('Custom Header Key'),
         description=_('Custom Header name to be set when calling endpoint.'),
         default='',
         missing='',
         widget=deform.widget.TextInputWidget(
             placeholder='e.g: Authorization'
         ),
     )
     custom_header_val = colander.SchemaNode(
         colander.String(),
         title=_('Custom Header Value'),
         description=_('Custom Header value to be set when calling endpoint.'),
         default='',
         missing='',
         widget=deform.widget.TextInputWidget(
             placeholder='e.g. Basic XxXxXx'
         ),
     )
     method_type = colander.SchemaNode(
         colander.String(),
         title=_('Call Method'),
         description=_('Select a HTTP method to use when calling the Webhook.'),
         default='post',
         missing='',
         widget=deform.widget.RadioChoiceWidget(
             values=[('get', 'GET'), ('post', 'POST'), ('put', 'PUT')],
             inline=True
         ),
     )
 
 
 class WebhookIntegrationType(IntegrationTypeBase):
     key = 'webhook'
     display_name = _('Webhook')
     description = _('send JSON data to a url endpoint')
 
     @classmethod
     def icon(cls):
         return '''<?xml version="1.0" encoding="UTF-8" standalone="no"?><svg viewBox="0 0 256 239" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid"><g><path d="M119.540432,100.502743 C108.930124,118.338815 98.7646301,135.611455 88.3876025,152.753617 C85.7226696,157.154315 84.4040417,160.738531 86.5332204,166.333309 C92.4107024,181.787152 84.1193605,196.825836 68.5350381,200.908244 C53.8383677,204.759349 39.5192953,195.099955 36.6032893,179.365384 C34.0194114,165.437749 44.8274148,151.78491 60.1824106,149.608284 C61.4694072,149.424428 62.7821041,149.402681 64.944891,149.240571 C72.469175,136.623655 80.1773157,123.700312 88.3025935,110.073173 C73.611854,95.4654658 64.8677898,78.3885437 66.803227,57.2292132 C68.1712787,42.2715849 74.0527146,29.3462646 84.8033863,18.7517722 C105.393354,-1.53572199 136.805164,-4.82141828 161.048542,10.7510424 C184.333097,25.7086706 194.996783,54.8450075 185.906752,79.7822957 C179.052655,77.9239597 172.151111,76.049808 164.563565,73.9917997 C167.418285,60.1274266 165.306899,47.6765751 155.95591,37.0109123 C149.777932,29.9690049 141.850349,26.2780332 132.835442,24.9178894 C114.764113,22.1877169 97.0209573,33.7983633 91.7563309,51.5355878 C85.7800012,71.6669027 94.8245623,88.1111998 119.540432,100.502743 L119.540432,100.502743 Z" fill="#C73A63"></path><path d="M149.841194,79.4106285 C157.316054,92.5969067 164.905578,105.982857 172.427885,119.246236 C210.44865,107.483365 239.114472,128.530009 249.398582,151.063322 C261.81978,178.282014 253.328765,210.520191 228.933162,227.312431 C203.893073,244.551464 172.226236,241.605803 150.040866,219.46195 C155.694953,214.729124 161.376716,209.974552 167.44794,204.895759 C189.360489,219.088306 208.525074,218.420096 222.753207,201.614016 C234.885769,187.277151 234.622834,165.900356 222.138374,151.863988 C207.730339,135.66681 188.431321,135.172572 165.103273,150.721309 C155.426087,133.553447 145.58086,116.521995 136.210101,99.2295848 C133.05093,93.4015266 129.561608,90.0209366 122.440622,88.7873178 C110.547271,86.7253555 102.868785,76.5124151 102.408155,65.0698097 C101.955433,53.7537294 108.621719,43.5249733 119.04224,39.5394355 C129.363912,35.5914599 141.476705,38.7783085 148.419765,47.554004 C154.093621,54.7244134 155.896602,62.7943365 152.911402,71.6372484 C152.081082,74.1025091 151.00562,76.4886916 149.841194,79.4106285 L149.841194,79.4106285 Z" fill="#4B4B4B"></path><path d="M167.706921,187.209935 L121.936499,187.209935 C117.54964,205.253587 108.074103,219.821756 91.7464461,229.085759 C79.0544063,236.285822 65.3738898,238.72736 50.8136292,236.376762 C24.0061432,232.053165 2.08568567,207.920497 0.156179306,180.745298 C-2.02835403,149.962159 19.1309765,122.599149 47.3341915,116.452801 C49.2814904,123.524363 51.2485589,130.663141 53.1958579,137.716911 C27.3195169,150.919004 18.3639187,167.553089 25.6054984,188.352614 C31.9811726,206.657224 50.0900643,216.690262 69.7528413,212.809503 C89.8327554,208.847688 99.9567329,192.160226 98.7211371,165.37844 C117.75722,165.37844 136.809118,165.180745 155.847178,165.475311 C163.280522,165.591951 169.019617,164.820939 174.620326,158.267339 C183.840836,147.48306 200.811003,148.455721 210.741239,158.640984 C220.88894,169.049642 220.402609,185.79839 209.663799,195.768166 C199.302587,205.38802 182.933414,204.874012 173.240413,194.508846 C171.247644,192.37176 169.677943,189.835329 167.706921,187.209935 L167.706921,187.209935 Z" fill="#4A4A4A"></path></g></svg>'''
 
     valid_events = [
         events.PullRequestCloseEvent,
         events.PullRequestMergeEvent,
         events.PullRequestUpdateEvent,
         events.PullRequestCommentEvent,
         events.PullRequestReviewEvent,
         events.PullRequestCreateEvent,
         events.RepoPushEvent,
         events.RepoCreateEvent,
     ]
 
     def settings_schema(self):
         schema = WebhookSettingsSchema()
         schema.add(colander.SchemaNode(
             colander.Set(),
             widget=deform.widget.CheckboxChoiceWidget(
                 values=sorted(
                     [(e.name, e.display_name) for e in self.valid_events]
                 )
             ),
             description="Events activated for this integration",
             name='events'
         ))
         return schema
 
     def send_event(self, event):
         log.debug(
             'handling event %s with Webhook integration %s', event.name, self)
 
         if event.__class__ not in self.valid_events:
             log.debug('event not valid: %r', event)
             return
 
         allowed_events = self.settings['events']
         if event.name not in allowed_events:
             log.debug('event ignored: %r event %s not in allowed events %s',
                       event, event.name, allowed_events)
             return
 
         data = event.as_dict()
         template_url = self.settings['url']
 
         headers = {}
         head_key = self.settings.get('custom_header_key')
         head_val = self.settings.get('custom_header_val')
         if head_key and head_val:
             headers = {head_key: head_val}
 
         handler = WebhookDataHandler(template_url, headers)
 
         url_calls = handler(event, data)
-        log.debug('webhook: calling following urls: %s', [x[0] for x in url_calls])
+        log.debug('Webhook: calling following urls: %s', [x[0] for x in url_calls])
 
         run_task(post_to_webhook, url_calls, self.settings)
 
 
 @async_task(ignore_result=True, base=RequestContextTask)
 def post_to_webhook(url_calls, settings):
     """
     Example data::
 
         {'actor': {'user_id': 2, 'username': u'admin'},
          'actor_ip': u'192.168.157.1',
          'name': 'repo-push',
          'push': {'branches': [{'name': u'default',
                                 'url': 'http://rc.local:8080/hg-repo/changelog?branch=default'}],
                   'commits': [{'author': u'Marcin Kuzminski <[e-mail]>',
                                'branch': u'default',
                                'date': datetime.datetime(2017, 11, 30, 12, 59, 48),
                                'issues': [],
                                'mentions': [],
                                'message': u'commit Thu 30 Nov 2017 13:59:48 CET',
                                'message_html': u'commit Thu 30 Nov 2017 13:59:48 CET',
                                'message_html_title': u'commit Thu 30 Nov 2017 13:59:48 CET',
                                'parents': [{'raw_id': '431b772a5353dad9974b810dd3707d79e3a7f6e0'}],
                                'permalink_url': u'http://rc.local:8080/_7/changeset/a815cc738b9651eb5ffbcfb1ce6ccd7c701a5ddf',
                                'raw_id': 'a815cc738b9651eb5ffbcfb1ce6ccd7c701a5ddf',
                                'refs': {'bookmarks': [],
                                         'branches': [u'default'],
                                         'tags': [u'tip']},
                                'reviewers': [],
                                'revision': 9L,
                                'short_id': 'a815cc738b96',
                                'url': u'http://rc.local:8080/hg-repo/changeset/a815cc738b9651eb5ffbcfb1ce6ccd7c701a5ddf'}],
                   'issues': {}},
          'repo': {'extra_fields': '',
                   'permalink_url': u'http://rc.local:8080/_7',
                   'repo_id': 7,
                   'repo_name': u'hg-repo',
                   'repo_type': u'hg',
                   'url': u'http://rc.local:8080/hg-repo'},
          'server_url': u'http://rc.local:8080',
          'utc_timestamp': datetime.datetime(2017, 11, 30, 13, 0, 1, 569276)
          }
     """
 
     call_headers = {
         'User-Agent': 'RhodeCode-webhook-caller/{}'.format(rhodecode.__version__)
     }  # updated below with custom ones, allows override
 
     auth = get_auth(settings)
     token = get_web_token(settings)
 
     for url, headers, data in url_calls:
         req_session = requests_retry_call()
 
         method = settings.get('method_type') or 'post'
         call_method = getattr(req_session, method)
 
         headers = headers or {}
         call_headers.update(headers)
 
         log.debug('calling Webhook with method: %s, and auth:%s', call_method, auth)
         if settings.get('log_data'):
             log.debug('calling webhook with data: %s', data)
         resp = call_method(url, json={
             'token': token,
             'event': data
         }, headers=call_headers, auth=auth, timeout=60)
         log.debug('Got Webhook response: %s', resp)
 
         try:
             resp.raise_for_status()  # raise exception on a failed request
         except Exception:
             log.error(resp.text)
             raise

rhodecode/tests/integrations/test_webhook.py

@@ -1,132 +1,135 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
 
 from rhodecode import events
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.integrations.types.webhook import WebhookDataHandler
 
 
 @pytest.fixture
 def base_data():
     return {
         'name': 'event',
         'repo': {
             'repo_name': 'foo',
             'repo_type': 'hg',
             'repo_id': '12',
             'url': 'http://repo.url/foo',
             'extra_fields': {},
         },
         'actor': {
             'username': 'actor_name',
             'user_id': 1
         }
     }
 
 
 def test_webhook_parse_url_invalid_event():
     template_url = 'http://server.com/${repo_name}/build'
     handler = WebhookDataHandler(
         template_url, {'exmaple-header': 'header-values'})
     event = events.RepoDeleteEvent('')
     with pytest.raises(ValueError) as err:
         handler(event, {})
 
     err = str(err.value)
     assert err.startswith(
         'event type `%s` not in supported list' % event.__class__)
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${repo_name}/build',
      ['http://server.com/foo/build']),
     ('http://server.com/${repo_name}/${repo_type}',
      ['http://server.com/foo/hg']),
     ('http://${server}.com/${repo_name}/${repo_id}',
      ['http://${server}.com/foo/12']),
     ('http://server.com/${branch}/build',
      ['http://server.com/${branch}/build']),
 ])
 def test_webook_parse_url_for_create_event(base_data, template, expected_urls):
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(events.RepoCreateEvent(''), base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${repo_name}/${pull_request_id}',
      ['http://server.com/foo/999']),
     ('http://server.com/${repo_name}/${pull_request_url}',
-     ['http://server.com/foo/http://pr-url.com']),
+     ['http://server.com/foo/http%3A//pr-url.com']),
+    ('http://server.com/${repo_name}/${pull_request_url}/?TITLE=${pull_request_title}',
+     ['http://server.com/foo/http%3A//pr-url.com/?TITLE=example-pr-title%20Ticket%20%23123']),
+    ('http://server.com/${repo_name}/?SHADOW_URL=${pull_request_shadow_url}',
+     ['http://server.com/foo/?SHADOW_URL=http%3A//pr-url.com/repository']),
 ])
-def test_webook_parse_url_for_pull_request_event(
-        base_data, template, expected_urls):
+def test_webook_parse_url_for_pull_request_event(base_data, template, expected_urls):
 
     base_data['pullrequest'] = {
         'pull_request_id': 999,
         'url': 'http://pr-url.com',
-        'title': 'example-pr-title',
+        'title': 'example-pr-title Ticket #123',
         'commits_uid': 'abcdefg1234',
         'shadow_url': 'http://pr-url.com/repository'
     }
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(events.PullRequestCreateEvent(
         AttributeDict({'target_repo': 'foo'})), base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${branch}/build',
         ['http://server.com/stable/build',
          'http://server.com/dev/build']),
     ('http://server.com/${branch}/${commit_id}',
         ['http://server.com/stable/stable-xxx',
          'http://server.com/stable/stable-yyy',
          'http://server.com/dev/dev-xxx',
          'http://server.com/dev/dev-yyy']),
     ('http://server.com/${branch_head}',
      ['http://server.com/stable-yyy',
       'http://server.com/dev-yyy']),
     ('http://server.com/${commit_id}',
      ['http://server.com/stable-xxx',
       'http://server.com/stable-yyy',
       'http://server.com/dev-xxx',
       'http://server.com/dev-yyy']),
 ])
 def test_webook_parse_url_for_push_event(
         baseapp, repo_push_event, base_data, template, expected_urls):
     base_data['push'] = {
         'branches': [{'name': 'stable'}, {'name': 'dev'}],
         'commits': [{'branch': 'stable', 'raw_id': 'stable-xxx'},
                     {'branch': 'stable', 'raw_id': 'stable-yyy'},
                     {'branch': 'dev', 'raw_id': 'dev-xxx'},
                     {'branch': 'dev', 'raw_id': 'dev-yyy'}]
     }
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(repo_push_event, base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]