# Infinite push

#

# Copyright 2016 Facebook, Inc.

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

""" store some pushes in a remote blob store on the server (EXPERIMENTAL)

    [infinitepush]

    # Server-side and client-side option. Pattern of the infinitepush bookmark

    branchpattern = PATTERN

    # Server or client

    server = False

    # Server-side option. Possible values: 'disk' or 'sql'. Fails if not set

    indextype = disk

    # Server-side option. Used only if indextype=sql.

    # Format: 'IP:PORT:DB_NAME:USER:PASSWORD'

    sqlhost = IP:PORT:DB_NAME:USER:PASSWORD

    # Server-side option. Used only if indextype=disk.

    # Filesystem path to the index store

    indexpath = PATH

    # Server-side option. Possible values: 'disk' or 'external'

    # Fails if not set

    storetype = disk

    # Server-side option.

    # Path to the binary that will save bundle to the bundlestore

    # Formatted cmd line will be passed to it (see `put_args`)

    put_binary = put

    # Serser-side option. Used only if storetype=external.

    # Format cmd-line string for put binary. Placeholder: {filename}

    put_args = {filename}

    # Server-side option.

    # Path to the binary that get bundle from the bundlestore.

    # Formatted cmd line will be passed to it (see `get_args`)

    get_binary = get

    # Serser-side option. Used only if storetype=external.

    # Format cmd-line string for get binary. Placeholders: {filename} {handle}

    get_args = {filename} {handle}

    # Server-side option

    logfile = FIlE

    # Server-side option

    loglevel = DEBUG

    # Server-side option. Used only if indextype=sql.

    # Sets mysql wait_timeout option.

    waittimeout = 300

    # Server-side option. Used only if indextype=sql.

    # Sets mysql innodb_lock_wait_timeout option.

    locktimeout = 120

    # Server-side option. Used only if indextype=sql.

    # Name of the repository

    reponame = ''

    # Client-side option. Used by --list-remote option. List of remote scratch

    # patterns to list if no patterns are specified.

    defaultremotepatterns = ['*']

    # Server-side option. If bookmark that was pushed matches

    # `fillmetadatabranchpattern` then background

    # `hg debugfillinfinitepushmetadata` process will save metadata

    # in infinitepush index for nodes that are ancestor of the bookmark.

    fillmetadatabranchpattern = ''

    # Instructs infinitepush to forward all received bundle2 parts to the

    # bundle for storage. Defaults to False.

    storeallparts = True

    [remotenames]

    # Client-side option

    # This option should be set only if remotenames extension is enabled.

    # Whether remote bookmarks are tracked by remotenames extension.

    bookmarks = True

"""

from __future__ import absolute_import

import collections

import contextlib

import errno

import functools

import json

import logging

import os

import random

import re

import socket

import struct

import subprocess

import sys

import tempfile

import time

from mercurial.node import (

    bin,

    hex,

)

from mercurial.i18n import _

from mercurial import (

    bundle2,

    changegroup,

    commands,

    discovery,

    encoding,

    error,

    exchange,

    extensions,

    hg,

    localrepo,

    peer,

    phases,

    pushkey,

    registrar,

    util,

    wireproto,

)

from . import (

    bundleparts,

    common,

    infinitepushcommands,

)

# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for

# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should

# be specifying the version(s) of Mercurial they are tested with, or

# leave the attribute unspecified.

testedwith = 'ships-with-hg-core'

configtable = {}

configitem = registrar.configitem(configtable)

configitem('infinitepush', 'server',

    default=False,

)

configitem('infinitepush', 'storetype',

    default='',

)

configitem('infinitepush', 'indextype',

    default='',

)

configitem('infinitepush', 'indexpath',

    default='',

)

configitem('infinitepush', 'fillmetadatabranchpattern',

    default='',

)

configitem('infinitepush', 'storeallparts',

    default=False,

)

configitem('infinitepush', 'reponame',

    default='',

)

configitem('infinitepush', 'bundle-stream',

    default=False,

)

configitem('scratchbranch', 'storepath',

    default='',

)

configitem('infinitepush', 'branchpattern',

    default='',

)

configitem('infinitepush', 'metadatafilelimit',

    default=100,

)

configitem('experimental', 'server-bundlestore-bookmark',

    default='',

)

configitem('experimental', 'server-bundlestore-create',

    default='',

)

configitem('experimental', 'infinitepush-scratchpush',

    default=False,

)

configitem('experimental', 'non-forward-move',

    default=False,

)

experimental = 'experimental'

configbookmark = 'server-bundlestore-bookmark'

configcreate = 'server-bundlestore-create'

configscratchpush = 'infinitepush-scratchpush'

confignonforwardmove = 'non-forward-move'

scratchbranchparttype = bundleparts.scratchbranchparttype

cmdtable = infinitepushcommands.cmdtable

revsetpredicate = registrar.revsetpredicate()

templatekeyword = registrar.templatekeyword()

_scratchbranchmatcher = lambda x: False

_maybehash = re.compile(r'^[a-f0-9]+$').search

def _buildexternalbundlestore(ui):

    put_args = ui.configlist('infinitepush', 'put_args', [])

    put_binary = ui.config('infinitepush', 'put_binary')

    if not put_binary:

        raise error.Abort('put binary is not specified')

    get_args = ui.configlist('infinitepush', 'get_args', [])

    get_binary = ui.config('infinitepush', 'get_binary')

    if not get_binary:

        raise error.Abort('get binary is not specified')

    from . import store

    return store.externalbundlestore(put_binary, put_args, get_binary, get_args)

def _buildsqlindex(ui):

    sqlhost = ui.config('infinitepush', 'sqlhost')

    if not sqlhost:

        raise error.Abort(_('please set infinitepush.sqlhost'))

    host, port, db, user, password = sqlhost.split(':')

    reponame = ui.config('infinitepush', 'reponame')

    if not reponame:

        raise error.Abort(_('please set infinitepush.reponame'))

    logfile = ui.config('infinitepush', 'logfile', '')

    waittimeout = ui.configint('infinitepush', 'waittimeout', 300)

    locktimeout = ui.configint('infinitepush', 'locktimeout', 120)

    from . import sqlindexapi

    return sqlindexapi.sqlindexapi(

        reponame, host, port, db, user, password,

        logfile, _getloglevel(ui), waittimeout=waittimeout,

        locktimeout=locktimeout)

def _getloglevel(ui):

    loglevel = ui.config('infinitepush', 'loglevel', 'DEBUG')

    numeric_loglevel = getattr(logging, loglevel.upper(), None)

    if not isinstance(numeric_loglevel, int):

        raise error.Abort(_('invalid log level %s') % loglevel)

    return numeric_loglevel

def _tryhoist(ui, remotebookmark):

    '''returns a bookmarks with hoisted part removed

    Remotenames extension has a 'hoist' config that allows to use remote

    bookmarks without specifying remote path. For example, 'hg update master'

    works as well as 'hg update remote/master'. We want to allow the same in

    infinitepush.

    '''

    if common.isremotebooksenabled(ui):

        hoist = ui.config('remotenames', 'hoist') + '/'

        if remotebookmark.startswith(hoist):

            return remotebookmark[len(hoist):]

    return remotebookmark

class bundlestore(object):

    def __init__(self, repo):

        self._repo = repo

        storetype = self._repo.ui.config('infinitepush', 'storetype', '')

        if storetype == 'disk':

            from . import store

            self.store = store.filebundlestore(self._repo.ui, self._repo)

        elif storetype == 'external':

            self.store = _buildexternalbundlestore(self._repo.ui)

        else:

            raise error.Abort(

                _('unknown infinitepush store type specified %s') % storetype)

        indextype = self._repo.ui.config('infinitepush', 'indextype', '')

        if indextype == 'disk':

            from . import fileindexapi

            self.index = fileindexapi.fileindexapi(self._repo)

        elif indextype == 'sql':

            self.index = _buildsqlindex(self._repo.ui)

        else:

            raise error.Abort(

                _('unknown infinitepush index type specified %s') % indextype)

def _isserver(ui):

    return ui.configbool('infinitepush', 'server')

def reposetup(ui, repo):

    if _isserver(ui) and repo.local():

        repo.bundlestore = bundlestore(repo)

def extsetup(ui):

    commonsetup(ui)

    if _isserver(ui):

        serverextsetup(ui)

    else:

        clientextsetup(ui)

def commonsetup(ui):

    wireproto.commands['listkeyspatterns'] = (

        wireprotolistkeyspatterns, 'namespace patterns')

    scratchbranchpat = ui.config('infinitepush', 'branchpattern')

    if scratchbranchpat:

        global _scratchbranchmatcher

        kind, pat, _scratchbranchmatcher = util.stringmatcher(scratchbranchpat)

def serverextsetup(ui):

    origpushkeyhandler = bundle2.parthandlermapping['pushkey']

    def newpushkeyhandler(*args, **kwargs):

        bundle2pushkey(origpushkeyhandler, *args, **kwargs)

    newpushkeyhandler.params = origpushkeyhandler.params

    bundle2.parthandlermapping['pushkey'] = newpushkeyhandler

    orighandlephasehandler = bundle2.parthandlermapping['phase-heads']

    newphaseheadshandler = lambda *args, **kwargs: \

        bundle2handlephases(orighandlephasehandler, *args, **kwargs)

    newphaseheadshandler.params = orighandlephasehandler.params

    bundle2.parthandlermapping['phase-heads'] = newphaseheadshandler

    extensions.wrapfunction(localrepo.localrepository, 'listkeys',

                            localrepolistkeys)

    wireproto.commands['lookup'] = (

        _lookupwrap(wireproto.commands['lookup'][0]), 'key')

    extensions.wrapfunction(exchange, 'getbundlechunks', getbundlechunks)

    extensions.wrapfunction(bundle2, 'processparts', processparts)

def clientextsetup(ui):

    entry = extensions.wrapcommand(commands.table, 'push', _push)

    # Don't add the 'to' arg if it already exists

    if not any(a for a in entry[1] if a[1] == 'to'):

        entry[1].append(('', 'to', '', _('push revs to this bookmark')))

    if not any(a for a in entry[1] if a[1] == 'non-forward-move'):

        entry[1].append(('', 'non-forward-move', None,

                         _('allows moving a remote bookmark to an '

                           'arbitrary place')))

    if not any(a for a in entry[1] if a[1] == 'create'):

        entry[1].append(

            ('', 'create', None, _('create a new remote bookmark')))

    entry[1].append(

        ('', 'bundle-store', None,

         _('force push to go to bundle store (EXPERIMENTAL)')))

    bookcmd = extensions.wrapcommand(commands.table, 'bookmarks', exbookmarks)

    bookcmd[1].append(

        ('', 'list-remote', None,

         'list remote bookmarks. '

         'Positional arguments are interpreted as wildcard patterns. '

         'Only allowed wildcard is \'*\' in the end of the pattern. '

         'If no positional arguments are specified then it will list '

         'the most "important" remote bookmarks. '

         'Otherwise it will list remote bookmarks '

         'that match at least one pattern '

         ''))

    bookcmd[1].append(

        ('', 'remote-path', '',

         'name of the remote path to list the bookmarks'))

    extensions.wrapcommand(commands.table, 'pull', _pull)

    extensions.wrapcommand(commands.table, 'update', _update)

    extensions.wrapfunction(discovery, 'checkheads', _checkheads)

    extensions.wrapfunction(bundle2, '_addpartsfromopts', _addpartsfromopts)

    wireproto.wirepeer.listkeyspatterns = listkeyspatterns

    partorder = exchange.b2partsgenorder

    index = partorder.index('changeset')

    partorder.insert(

        index, partorder.pop(partorder.index(scratchbranchparttype)))

def _showbookmarks(ui, bookmarks, **opts):

    # Copy-paste from commands.py

    fm = ui.formatter('bookmarks', opts)

    for bmark, n in sorted(bookmarks.iteritems()):

        fm.startitem()

        if not ui.quiet:

            fm.plain('   ')

        fm.write('bookmark', '%s', bmark)

        pad = ' ' * (25 - encoding.colwidth(bmark))

        fm.condwrite(not ui.quiet, 'node', pad + ' %s', n)

        fm.plain('\n')

    fm.end()

def exbookmarks(orig, ui, repo, *names, **opts):

    pattern = opts.get('list_remote')

    delete = opts.get('delete')

    remotepath = opts.get('remote_path')

    path = ui.paths.getpath(remotepath or None, default=('default'))

    if pattern:

        destpath = path.pushloc or path.loc

        other = hg.peer(repo, opts, destpath)

        if not names:

            raise error.Abort(

                '--list-remote requires a bookmark pattern',

                hint='use "hg book" to get a list of your local bookmarks')

        else:

            fetchedbookmarks = other.listkeyspatterns('bookmarks',

                                                      patterns=names)

        _showbookmarks(ui, fetchedbookmarks, **opts)

        return

    elif delete and 'remotenames' in extensions._extensions:

        existing_local_bms = set(repo._bookmarks.keys())

        scratch_bms = []

        other_bms = []

        for name in names:

            if _scratchbranchmatcher(name) and name not in existing_local_bms:

                scratch_bms.append(name)

            else:

                other_bms.append(name)

        if len(scratch_bms) > 0:

            if remotepath == '':

                remotepath = 'default'