3447862ad8c9ceba85857774c526e39fde3a2281 rhodecode-0.0.1.5.4

c15d7b336af58df9f1bbc8f8957464e7ea618d4c rhodecode-0.0.1.6.0rc1

78b53ee0d247f90d51b028307ff5717851b6c265 rhodecode-0.0.1.6.0

351ad34d56321349ff5bd38f537bd768b8efef2e rhodecode-0.0.1.7.0

1f71ef689d2a3c9978cea6591a1f4e9107a5ca83 rhodecode-0.0.1.7.1

cc48c1541c7e2e84114bf92a0f9cd4b8b1341545 0.0

d17e88a1a88a29f6fac948c94498129e405a40d3 0.1

ad0ce803b40cb17fc3988373052943e041030b02 0.2

c6e32714336345403adf76abb6ebf9b8116fcdc7 0.2.1

14f488a5dc4ca6647bc6acf12534fd137e968aa8 0.2.2

9b3e9e242f5c97cc0c7657e5ac93dce7de61ca16 0.3

9bf8eb837e785b6856ccfac264e977ce3ebe1535 0.3.1

a84d40e9481fcea4dafadee86b03f0dd401527d6 0.3.2

64ea7ea0923618a0c117acebb816a6f0d162bfdb 0.3.3

cf635c823ea059cc3a1581b82d8672e46b682384 0.3.4

4cca4cc6a0a97f4c4763317184cd41aca4297630 0.3.5

082c9b8f0f17bd34740eb90c69bdc4c80d4b5b31 0.3.6

a18445b85d407294da0b7f1d8be3bedef5ffdea6 0.3.7

8db761c407685e7b08b800c947890035b0d67025 0.4.0rc1

60f726162fd6c515bd819feb423be73cad01d7d3 0.4.0rc2

19086c5de05f4984d7a90cd31624c45dd893f6bb 0.4.0

da65398a62fff50f3d241796cbf17acdea2092ef 0.4.1

bfa0b0a814644f0af3f492d17a9ed169cc3b89fe 0.5.0

d01a8e92936dbd62c76505432f60efba432e9397 0.5.1

List of contributors to Kallithea project:

    Thomas De Schampheleire <thomas.de_schampheleire@nokia.com> 2014-2020

    Mads Kiilerich <mads@kiilerich.com> 2016-2020

    Andrej Shadura <andrew@shadura.me> 2012 2014-2017 2019

    Étienne Gilli <etienne.gilli@gmail.com> 2015-2017 2019

    Allan Nordhøy <epost@anotheragency.no> 2017-2019

    ssantos <ssantos@web.de> 2018-2019

    Adi Kriegisch <adi@cg.tuwien.ac.at> 2019

    Danni Randeris <danniranderis@gmail.com> 2019

    Edmund Wong <ewong@crazy-cat.org> 2019

    Elizabeth Sherrock <lizzyd710@gmail.com> 2019

    Hüseyin Tunç <huseyin.tunc@bulutfon.com> 2019

    leela <53352@protonmail.com> 2019

    Manuel Jacob <me@manueljacob.de> 2019

    Mateusz Mendel <mendelm9@gmail.com> 2019

    Nathan <bonnemainsnathan@gmail.com> 2019

    Oleksandr Shtalinberg <o.shtalinberg@gmail.com> 2019

    Private <adamantine.sword@gmail.com> 2019

    THANOS SIOURDAKIS <siourdakisthanos@gmail.com> 2019

    Wolfgang Scherer <wolfgang.scherer@gmx.de> 2019

    Христо Станев <hstanev@gmail.com> 2019

    Dominik Ruf <dominikruf@gmail.com> 2012 2014-2018

    Michal Čihař <michal@cihar.com> 2014-2015 2018

    Branko Majic <branko@majic.rs> 2015 2018

    Chris Rule <crule@aegistg.com> 2018

    Jesús Sánchez <jsanchezfdz95@gmail.com> 2018

    Patrick Vane <patrick_vane@lowentry.com> 2018

revision = '4851d15bc437'

down_revision = '151b4a4e8c48'

branch_labels = None

depends_on = None

import sqlalchemy as sa

from alembic import op

def upgrade():

    pass

    # The following upgrade step turned out to be a bad idea. A later step

    # "d7ec25b66e47_ssh_drop_usk_public_key_idx_again" will remove the index

    # again if it exists ... but we shouldn't even try to create it.

    #meta = sa.MetaData()

    #meta.reflect(bind=op.get_bind())

    #if not any(i.name == 'usk_public_key_idx' for i in meta.tables['user_ssh_keys'].indexes):

    #    with op.batch_alter_table('user_ssh_keys', schema=None) as batch_op:

    #        batch_op.create_index('usk_public_key_idx', ['public_key'], unique=False)

def downgrade():

    if any(i.name == 'usk_public_key_idx' for i in meta.tables['user_ssh_keys'].indexes):

        with op.batch_alter_table('user_ssh_keys', schema=None) as batch_op:

            batch_op.drop_index('usk_public_key_idx')

            repo_groups_data.append({

                "raw_name": repo_gr.group_name,

                "group_name": repo_group_name(repo_gr.group_name, children_groups),

                "desc": h.escape(repo_gr.group_description),

                "repos": repo_count,

                "owner": h.person(repo_gr.owner),

                "action": repo_group_actions(repo_gr.group_id, repo_gr.group_name,

                                             repo_count)

            })

        c.data = {

            "sort": None,

            "dir": "asc",

            "records": repo_groups_data

        }

        return render('admin/repo_groups/repo_groups.html')

    def create(self):

        self.__load_defaults()

        # permissions for can create group based on parent_id are checked

        # here in the Form

        repo_group_form = RepoGroupForm(repo_groups=c.repo_groups)

        try:

            form_result = repo_group_form.to_python(dict(request.POST))

            gr = RepoGroupModel().create(

                group_name=form_result['group_name'],

                group_description=form_result['group_description'],

                parent=form_result['parent_group_id'],

                owner=request.authuser.user_id, # TODO: make editable

                copy_permissions=form_result['group_copy_permissions']

            )

            Session().commit()

            # TODO: in future action_logger(, '', '', '')

        except formencode.Invalid as errors:

            return htmlfill.render(

                render('admin/repo_groups/repo_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during creation of repository group %s')

                    % request.POST.get('group_name'), category='error')

            parent_group_id = form_result['parent_group_id']

            # TODO: maybe we should get back to the main view, not the admin one

            raise HTTPFound(location=url('repos_groups', parent_group=parent_group_id))

        h.flash(_('Created repository group %s') % gr.group_name,

                category='success')

        raise HTTPFound(location=url('repos_group_home', group_name=gr.group_name))

    def new(self):

        if HasPermissionAny('hg.admin')('group create'):

            # we're global admin, we're ok and we can create TOP level groups

            pass

        else:

            # we pass in parent group into creation form, thus we know

            # what would be the group, we can check perms here !

            group_id = safe_int(request.GET.get('parent_group'))

            group = RepoGroup.get(group_id) if group_id else None

            group_name = group.group_name if group else None

            if HasRepoGroupPermissionLevel('admin')(group_name, 'group create'):

                pass

            else:

                raise HTTPForbidden()

        self.__load_defaults()

        return render('admin/repo_groups/repo_group_add.html')

    @HasRepoPermissionLevelDecorator('read')

    def show(self, repo_name, pull_request_id, extra=None):

        c.pull_request = PullRequest.get_or_404(pull_request_id)

        c.allowed_to_change_status = self._is_allowed_to_change_status(c.pull_request)

        cc_model = ChangesetCommentsModel()

        cs_model = ChangesetStatusModel()

        # pull_requests repo_name we opened it against

        # ie. other_repo must match

        if repo_name != c.pull_request.other_repo.repo_name:

            raise HTTPNotFound

        # load compare data into template context

        c.cs_repo = c.pull_request.org_repo

        (c.cs_ref_type,

         c.cs_ref_name,

         c.cs_rev) = c.pull_request.org_ref.split(':')

        c.a_repo = c.pull_request.other_repo

        (c.a_ref_type,

         c.a_ref_name,

         c.a_rev) = c.pull_request.other_ref.split(':') # a_rev is ancestor

        org_scm_instance = c.cs_repo.scm_instance # property with expensive cache invalidation check!!!

                c.cs_ranges.append(org_scm_instance.get_changeset(x))

        c.cs_ranges_org = None # not stored and not important and moving target - could be calculated ...

        revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

        c.jsdata = graph_data(org_scm_instance, revs)

        c.is_range = False

        try:

            if c.a_ref_type == 'rev': # this looks like a free range where target is ancestor

                cs_a = org_scm_instance.get_changeset(c.a_rev)

                root_parents = c.cs_ranges[0].parents

                c.is_range = cs_a in root_parents

                #c.merge_root = len(root_parents) > 1 # a range starting with a merge might deserve a warning

        except ChangesetDoesNotExistError: # probably because c.a_rev not found

            pass

        except IndexError: # probably because c.cs_ranges is empty, probably because revisions are missing

            pass

        avail_revs = set()

        avail_show = []

        c.cs_branch_name = c.cs_ref_name

        c.a_branch_name = None

        other_scm_instance = c.a_repo.scm_instance

        c.update_msg = ""

        c.update_msg_other = ""

        try:

    elif vcs == 'hg':

        match = _hg_header_re.match(diff_chunk)

    if match is None:

        raise Exception('diff not recognized as valid %s diff' % vcs)

    meta_info = match.groupdict()

    rest = diff_chunk[match.end():]

    if rest and _header_next_check.match(rest):

        raise Exception('cannot parse %s diff header: %r followed by %r' % (vcs, diff_chunk[:match.end()], rest[:1000]))

    diff_lines = (_escaper(m.group(0)) for m in re.finditer(br'.*\n|.+$', rest)) # don't split on \r as str.splitlines do

    return meta_info, diff_lines

_chunk_re = re.compile(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)')

_newline_marker = re.compile(r'^\\ No newline at end of file')

def _parse_lines(diff_lines):

    """

    Given an iterator of diff body lines, parse them and return a dict per

    line and added/removed totals.

    """

    added = deleted = 0

    old_line = old_end = new_line = new_end = None

    try:

        line = diff_lines.next()

        while True:

            lines = []

            chunks.append(lines)

            match = _chunk_re.match(line)

            if not match:

                raise Exception('error parsing diff @@ line %r' % line)

            gr = match.groups()

            (old_line, old_end,

             new_line, new_end) = [int(x or 1) for x in gr[:-1]]

            old_line -= 1

            new_line -= 1

            context = len(gr) == 5

            old_end += old_line

            new_end += new_line

            if context:

                # skip context only if it's first line

                if int(gr[0]) > 1:

        if sub_value == 0 or show_short_version:

            if future:

                return _('in %s') % fmt_funcs[part](value)

            else:

                return _('%s ago') % fmt_funcs[part](value)

        if future:

            return _('in %s and %s') % (fmt_funcs[part](value),

                fmt_funcs[sub_part](sub_value))

        else:

            return _('%s and %s ago') % (fmt_funcs[part](value),

                fmt_funcs[sub_part](sub_value))

    return _('just now')

def uri_filter(uri):

    """

    Removes user:password from given url string

    :param uri:

    :rtype: unicode

    :returns: filtered list of strings

    """

    if not uri:

    proto = ''

    for pat in ('https://', 'http://', 'git://'):

        if uri.startswith(pat):

            uri = uri[len(pat):]

            proto = pat

            break

    # remove passwords and username

    uri = uri[uri.find('@') + 1:]

    # get the port

    cred_pos = uri.find(':')

    if cred_pos == -1:

        host, port = uri, None

    else:

        host, port = uri[:cred_pos], uri[cred_pos + 1:]

    return [_f for _f in [proto, host, port] if _f]

def credentials_filter(uri):

    """

    if _url.password:

        _url.password = 'XXXXX'

    return str(_url)

class HookEnvironmentError(Exception): pass

def get_hook_environment():

    """

    Get hook context by deserializing the global KALLITHEA_EXTRAS environment

    variable.

    Called early in Git out-of-process hooks to get .ini config path so the

    basic environment can be configured properly. Also used in all hooks to get

    information about the action that triggered it.

    """

    try:

        kallithea_extras = os.environ['KALLITHEA_EXTRAS']

    except KeyError:

        raise HookEnvironmentError("Environment variable KALLITHEA_EXTRAS not found")

    extras = json.loads(kallithea_extras)

            extras[k]

    return AttributeDict(extras)

def set_hook_environment(username, ip_addr, repo_name, repo_alias, action=None):

    """Prepare global context for running hooks by serializing data in the

    global KALLITHEA_EXTRAS environment variable.

    Most importantly, this allow Git hooks to do proper logging and updating of

    caches after pushes.

    Must always be called before anything with hooks are invoked.

    """

    from kallithea import CONFIG

    extras = {

        'ip': ip_addr, # used in log_push/pull_action action_logger

        'username': username,

        'action': action or 'push_local', # used in log_push_action_raw_ids action_logger

        'repository': repo_name,

        'scm': repo_alias, # used to pick hack in log_push_action_raw_ids

        'config': CONFIG['__file__'], # used by git hook to read config

    }

    os.environ['KALLITHEA_EXTRAS'] = json.dumps(extras)

        u'bl\xe5b\xe6rgr\xf8d'

        >>> GitSshHandler.make(shlex.split('''git-upload-pack "/foo'bar"''')).repo_name

        u"foo'bar"

        >>> GitSshHandler.make(shlex.split("git-receive-pack '/foo'")).repo_name

        u'foo'

        >>> GitSshHandler.make(shlex.split("git-receive-pack '/foo'")).verb

        'git-receive-pack'

        >>> GitSshHandler.make(shlex.split("/bin/git-upload-pack '/foo'")) # ssh-serve will report 'SSH command %r is not supported'

        >>> GitSshHandler.make(shlex.split('''git-upload-pack /foo bar''')) # ssh-serve will report 'SSH command %r is not supported'

        >>> shlex.split("git-upload-pack '/foo'bar' x") # ssh-serve will report: Error parsing SSH command "...": No closing quotation

        Traceback (most recent call last):

        ValueError: No closing quotation

        >>> GitSshHandler.make(shlex.split('hg -R foo serve --stdio')) # not handled here

        """

        if (len(ssh_command_parts) == 2 and

            ssh_command_parts[0] in ['git-upload-pack', 'git-receive-pack'] and

            ssh_command_parts[1].startswith('/')

        ):

            return cls(safe_unicode(ssh_command_parts[1][1:]), ssh_command_parts[0])

        return None

    def __init__(self, repo_name, verb):

        self.verb = verb

    def _serve(self):

        if self.verb == 'git-upload-pack': # action 'pull'

            # base class called set_hook_environment - action is hardcoded to 'pull'

            log_pull_action(ui=make_ui(), repo=self.db_repo.scm_instance._repo)

        else: # probably verb 'git-receive-pack', action 'push'

            if not self.allow_push:

                self.exit('Push access to %r denied' % safe_str(self.repo_name))

            # Note: push logging is handled by Git post-receive hook

        # git shell is not a real shell but use shell inspired quoting *inside* the argument.

        # Per https://github.com/git/git/blob/v2.22.0/quote.c#L12 :

        # The path must be "'" quoted, but "'" and "!" must exit the quoting and be "\" escaped

        quoted_abspath = "'%s'" % self.db_repo.repo_full_path.replace("'", r"'\''").replace("!", r"'\!'")

        newcmd = ['git', 'shell', '-c', "%s %s" % (self.verb, quoted_abspath)]

        log.debug('Serving: %s', newcmd)

        os.execvp(newcmd[0], newcmd)

        self.exit("Failed to exec 'git' as %s" % newcmd)

    @classmethod

    def make(cls, ssh_command_parts):

        r"""

        >>> import shlex

        >>> MercurialSshHandler.make(shlex.split('hg -R "foo bar" serve --stdio')).repo_name

        u'foo bar'

        >>> MercurialSshHandler.make(shlex.split(' hg -R blåbærgrød serve --stdio ')).repo_name

        u'bl\xe5b\xe6rgr\xf8d'

        >>> MercurialSshHandler.make(shlex.split('''hg -R 'foo"bar' serve --stdio''')).repo_name

        u'foo"bar'

        >>> MercurialSshHandler.make(shlex.split('/bin/hg -R "foo" serve --stdio'))

        >>> MercurialSshHandler.make(shlex.split('''hg -R "foo"bar" serve --stdio''')) # ssh-serve will report: Error parsing SSH command "...": invalid syntax

        Traceback (most recent call last):

        ValueError: No closing quotation

        >>> MercurialSshHandler.make(shlex.split('git-upload-pack "/foo"')) # not handled here

        """

        if ssh_command_parts[:2] == ['hg', '-R'] and ssh_command_parts[3:] == ['serve', '--stdio']:

            return cls(safe_unicode(ssh_command_parts[2]))

        return None

    def _serve(self):

        # Note: we want a repo with config based on .hg/hgrc and can thus not use self.db_repo.scm_instance._repo.ui

        baseui = make_ui(repo_path=self.db_repo.repo_full_path)

        if not self.allow_push:

            baseui.setconfig(b'hooks', b'pretxnopen._ssh_reject', b'python:kallithea.lib.hooks.rejectpush')

            baseui.setconfig(b'hooks', b'prepushkey._ssh_reject', b'python:kallithea.lib.hooks.rejectpush')

        repo = mercurial.hg.repository(baseui, safe_bytes(self.db_repo.repo_full_path))

        log.debug("Starting Mercurial sshserver for %s", self.db_repo.repo_full_path)

        mercurial.wireprotoserver.sshserver(baseui, repo).serve_forever()

class BaseSshHandler(object):

    # Protocol for setting properties:

    # Set by sub class:

    #   vcs_type: 'hg' or 'git'

    # Set by make() / __init__():

    #   repo_name: requested repo name - only validated by serve()

    # Set by serve() - must not be accessed before:

    #   db_repo: repository db object

    #   authuser: user that has been authenticated - like request.authuser ... which isn't used here

    #   allow_push: false for read-only access to the repo

    # Set defaults, in case .exit should be called early

    vcs_type = None

    repo_name = None

    @staticmethod

    def make(ssh_command):

        """Factory function. Given a command as invoked over SSH (and preserved

        in SSH_ORIGINAL_COMMAND when run as authorized_keys command), return a

        handler if the command looks ok, else return None.

        """

        raise NotImplementedError

    def serve(self, user_id, key_id, client_ip):

        """Verify basic sanity of the repository, and that the user is

        valid and has access - then serve the native VCS protocol for

        repository access."""

        dbuser = User.get(user_id)

        if dbuser is None:

            self.exit('User %r not found' % user_id)

        self.authuser = AuthUser.make(dbuser=dbuser, ip_addr=client_ip)

        log.info('Authorized user %s from SSH %s trusting user id %s and key id %s for %r', dbuser, client_ip, user_id, key_id, self.repo_name)

        if self.authuser is None: # not ok ... but already kind of authenticated by SSH ... but not really not authorized ...

            self.exit('User %s from %s cannot be authorized' % (dbuser.username, client_ip))

        ssh_key = UserSshKeys.get(key_id)

        if ssh_key is None:

            self.exit('SSH key %r not found' % key_id)

        ssh_key.last_seen = datetime.datetime.now()

        Session().commit()

        if HasPermissionAnyMiddleware('repository.write',

                                      'repository.admin')(self.authuser, self.repo_name):

            self.allow_push = True

        elif HasPermissionAnyMiddleware('repository.read')(self.authuser, self.repo_name):

            self.allow_push = False

        else:

    @LazyProperty

    def last_changeset(self):

        if self.changeset:

            return self.changeset.get_file_changeset(self.path)

        raise NodeError("Cannot retrieve last changeset of the file without "

            "related changeset attribute")

    def get_mimetype(self):

        """

        Mimetype is calculated based on the file's content.

        """

        mtype, encoding = mimetypes.guess_type(self.name)

        if mtype is None:

            if self.is_binary:

                mtype = 'application/octet-stream'

                encoding = None

            else:

                mtype = 'text/plain'

                encoding = None

                # try with pygments

                try:

                    mt = lexers.get_lexer_for_filename(self.name).mimetypes

                except lexers.ClassNotFound:

                    mt = None

                if mt:

                    mtype = mt[0]

        return mtype, encoding

    @LazyProperty

    def mimetype(self):

        """

        Wrapper around full mimetype info. It returns only type of fetched

        mimetype without the encoding part. use get_mimetype function to fetch

        full set of (type,encoding)

        """

        return self.get_mimetype()[0]

    @LazyProperty

    def mimetype_main(self):

        return self.mimetype.split('/')[0]

    @LazyProperty

    def lexer(self):

</%block>

<%block name="header_menu">

    ${self.menu('about')}

</%block>

<%def name="main()">

<div class="panel panel-primary">

  <div class="panel-heading">

    <h5 class="panel-title">${_('About')} Kallithea</h5>

  </div>

  <div class="panel-body panel-about">

  <p><a href="https://kallithea-scm.org/">Kallithea</a> is a project of the

  <a href="http://sfconservancy.org/">Software Freedom Conservancy, Inc.</a>

  and is released under the terms of the

  <a href="http://www.gnu.org/copyleft/gpl.html">GNU General Public License,

  v 3.0 (GPLv3)</a>.</p>

  <p>Kallithea is copyrighted by various authors, including but not

  necessarily limited to the following:</p>

  <ul>

  <li>Copyright &copy; 2012&ndash;2020, Mads Kiilerich</li>

  <li>Copyright &copy; 2014&ndash;2020, Thomas De Schampheleire</li>

  <li>Copyright &copy; 2012, 2014&ndash;2017, 2019, Andrej Shadura</li>

  <li>Copyright &copy; 2015&ndash;2017, 2019, Étienne Gilli</li>

  <li>Copyright &copy; 2017&ndash;2019, Allan Nordhøy</li>

  <li>Copyright &copy; 2018&ndash;2019, ssantos</li>

  <li>Copyright &copy; 2019, Adi Kriegisch</li>

  <li>Copyright &copy; 2019, Danni Randeris</li>

  <li>Copyright &copy; 2019, Edmund Wong</li>

  <li>Copyright &copy; 2019, Elizabeth Sherrock</li>

  <li>Copyright &copy; 2019, Hüseyin Tunç</li>

  <li>Copyright &copy; 2019, leela</li>

  <li>Copyright &copy; 2019, Manuel Jacob</li>

  <li>Copyright &copy; 2019, Mateusz Mendel</li>

  <li>Copyright &copy; 2019, Nathan</li>

  <li>Copyright &copy; 2019, Oleksandr Shtalinberg</li>

  <li>Copyright &copy; 2019, Private</li>

  <li>Copyright &copy; 2019, THANOS SIOURDAKIS</li>

  <li>Copyright &copy; 2019, Wolfgang Scherer</li>

  <li>Copyright &copy; 2019, Христо Станев</li>

  <li>Copyright &copy; 2012, 2014&ndash;2018, Dominik Ruf</li>

  <li>Copyright &copy; 2014&ndash;2015, 2018, Michal Čihař</li>

  <li>Copyright &copy; 2015, 2018, Branko Majic</li>

  <li>Copyright &copy; 2018, Chris Rule</li>

  <li>Copyright &copy; 2018, Jesús Sánchez</li>

  <li>Copyright &copy; 2018, Patrick Vane</li>

        username = 'test_password_reset_1'

        password = 'qweqwe'

        email = 'username@example.com'

        name = u'passwd'

        lastname = u'reset'

        timestamp = int(time.time())

        new = User()

        new.username = username

        new.password = password

        new.email = email

        new.name = name

        new.lastname = lastname

        new.api_key = generate_api_key()

        Session().add(new)

        Session().commit()

        token = UserModel().get_reset_password_token(

            User.get_by_username(username), timestamp, self.session_csrf_secret_token())

        collected = []

        def mock_send_email(recipients, subject, body='', html_body='', headers=None, author=None):

            collected.append((recipients, subject, body, html_body))

            response = self.app.post(base.url(controller='login',

                                         action='password_reset'),

                                     {'email': email,

                                      '_session_csrf_secret_token': self.session_csrf_secret_token()})

        self.checkSessionFlash(response, 'A password reset confirmation code has been sent')

        ((recipients, subject, body, html_body),) = collected

        assert recipients == ['username@example.com']

        assert subject == 'Password reset link'

        assert '\n%s\n' % token in body

        (confirmation_url,) = (line for line in body.splitlines() if line.startswith('http://'))

        assert ' href="%s"' % confirmation_url.replace('&', '&').replace('@', '%40') in html_body

        d = urlparse.parse_qs(urlparse.urlparse(confirmation_url).query)

        assert d['token'] == [token]

        assert d['timestamp'] == [str(timestamp)]

        assert d['email'] == [email]

        response = response.follow()

        # BAD TOKEN

        bad_token = "bad"

        action_parts = [ul.action.split(':', 1) for ul in UserLog.query().order_by(UserLog.user_log_id)]

        assert [(t[0], (t[1].count(',') + 1) if len(t) == 2 else 0) for t in action_parts] == \

            [(u'pull', 0), (u'push', 3)]

    @parametrize_vcs_test

    def test_pull(self, webserver, testfork, vt):

        UserLog.query().delete()

        Session().commit()

        dest_dir = _get_tmp_dir()

        stdout, stderr = Command(base.TESTS_TMP_PATH).execute(vt.repo_type, 'init', dest_dir)

        clone_url = vt.repo_url_param(webserver, vt.repo_name)

        stdout, stderr = Command(dest_dir).execute(vt.repo_type, 'pull', clone_url)

        if vt.repo_type == 'git':

            assert 'FETCH_HEAD' in stderr

        elif vt.repo_type == 'hg':

            assert 'new changesets' in stdout

        action_parts = [ul.action for ul in UserLog.query().order_by(UserLog.user_log_id)]

        assert action_parts == [u'pull']

    @parametrize_vcs_test

    def test_push_invalidates_cache(self, webserver, testfork, vt):

        pre_cached_tip = [repo.get_api_data()['last_changeset']['short_id'] for repo in Repository.query().filter(Repository.repo_name == testfork[vt.repo_type])]

        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

                                               == testfork[vt.repo_type]).scalar()

        if not key:

            key = CacheInvalidation(testfork[vt.repo_type], testfork[vt.repo_type])

            Session().add(key)

        key.cache_active = True

        Session().commit()

        dest_dir = _get_tmp_dir()

        clone_url = vt.repo_url_param(webserver, testfork[vt.repo_type])

        stdout, stderr = Command(base.TESTS_TMP_PATH).execute(vt.repo_type, 'clone', clone_url, dest_dir)

        stdout, stderr = _add_files_and_push(webserver, vt, dest_dir, files_no=1, clone_url=clone_url)

        if vt.repo_type == 'git':

            _check_proper_git_push(stdout, stderr)

        post_cached_tip = [repo.get_api_data()['last_changeset']['short_id'] for repo in Repository.query().filter(Repository.repo_name == testfork[vt.repo_type])]

        assert pre_cached_tip != post_cached_tip

echo "Shortlog for inclusion in the release announcement"

scripts/shortlog.py "only('.', branch('stable') & tagged() & public() & not '.')"

cat - << EOT

Now, make sure

* all tests are passing

* release note is ready

* announcement is ready

* source has been pushed to https://kallithea-scm.org/repos/kallithea

EOT

echo "Verify current revision is tagged for $version"

hg log -r "'$version'&." | grep .

echo -n "Enter \"pypi\" to upload Kallithea $version to pypi: "

read answer

[ "$answer" = "pypi" ]

echo "Rebuild readthedocs for docs.kallithea-scm.org"

xdg-open https://readthedocs.org/projects/kallithea/

curl -X POST http://readthedocs.org/build/kallithea

xdg-open http://docs.kallithea-scm.org/en/latest/ # or whatever the branch is

twine upload dist/*

xdg-open https://pypi.python.org/pypi/Kallithea