# 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 = ['*']

    # Instructs infinitepush to forward all received bundle2 parts to the

    # bundle for storage. Defaults to False.

    storeallparts = True

    # routes each incoming push to the bundlestore. defaults to False

    pushtobundlestore = 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 logging

import os

import random

import re

import socket

import subprocess

import time

from mercurial.node import (

    bin,

    hex,

)

from mercurial.i18n import _

from mercurial.utils import (

    procutil,

    stringutil,

)

from mercurial import (

    bundle2,

    changegroup,

    commands,

    discovery,

    encoding,

    error,

    exchange,

    extensions,

    hg,

    localrepo,

    phases,

    pushkey,

    pycompat,

    registrar,

    util,

    wireprototypes,

    wireprotov1peer,

    wireprotov1server,

)

from . import (

    bundleparts,

    common,

)

# 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 = b'ships-with-hg-core'

configtable = {}

configitem = registrar.configitem(configtable)

configitem(

    b'infinitepush', b'server', default=False,

)

configitem(

    b'infinitepush', b'storetype', default=b'',

)

configitem(

    b'infinitepush', b'indextype', default=b'',

)

configitem(

    b'infinitepush', b'indexpath', default=b'',

)

configitem(

    b'infinitepush', b'storeallparts', default=False,

)

configitem(

    b'infinitepush', b'reponame', default=b'',

)

configitem(

    b'scratchbranch', b'storepath', default=b'',

)

configitem(

    b'infinitepush', b'branchpattern', default=b'',

)

configitem(

    b'infinitepush', b'pushtobundlestore', default=False,

)

configitem(

    b'experimental', b'server-bundlestore-bookmark', default=b'',

)

configitem(

    b'experimental', b'infinitepush-scratchpush', default=False,

)

experimental = b'experimental'

configbookmark = b'server-bundlestore-bookmark'

configscratchpush = b'infinitepush-scratchpush'

scratchbranchparttype = bundleparts.scratchbranchparttype

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(b'infinitepush', b'put_args', [])

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

    if not put_binary:

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

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

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

    if not get_binary:

        raise error.Abort(b'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(b'infinitepush', b'sqlhost')

    if not sqlhost:

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

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

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

    if not reponame:

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

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

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

    locktimeout = ui.configint(b'infinitepush', b'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(b'infinitepush', b'loglevel', b'DEBUG')

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

    if not isinstance(numeric_loglevel, int):

        raise error.Abort(_(b'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(b'remotenames', b'hoistedpeer') + b'/'

        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(b'infinitepush', b'storetype')

        if storetype == b'disk':

            from . import store

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

        elif storetype == b'external':

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

        else:

            raise error.Abort(

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

            )

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

        if indextype == b'disk':

            from . import fileindexapi

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

        elif indextype == b'sql':

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

        else:

            raise error.Abort(

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

            )

def _isserver(ui):

    return ui.configbool(b'infinitepush', b'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):

    wireprotov1server.commands[b'listkeyspatterns'] = (

        wireprotolistkeyspatterns,

        b'namespace patterns',

    )

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

    if scratchbranchpat:

        global _scratchbranchmatcher

        kind, pat, _scratchbranchmatcher = stringutil.stringmatcher(

            scratchbranchpat

        )

def serverextsetup(ui):

    origpushkeyhandler = bundle2.parthandlermapping[b'pushkey']

    def newpushkeyhandler(*args, **kwargs):

        bundle2pushkey(origpushkeyhandler, *args, **kwargs)

    newpushkeyhandler.params = origpushkeyhandler.params

    bundle2.parthandlermapping[b'pushkey'] = newpushkeyhandler

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

    newphaseheadshandler = lambda *args, **kwargs: bundle2handlephases(

        orighandlephasehandler, *args, **kwargs

    )

    newphaseheadshandler.params = orighandlephasehandler.params

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

    extensions.wrapfunction(

        localrepo.localrepository, b'listkeys', localrepolistkeys

    )

    wireprotov1server.commands[b'lookup'] = (

        _lookupwrap(wireprotov1server.commands[b'lookup'][0]),

        b'key',

    )

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

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

def clientextsetup(ui):

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

    entry[1].append(

        (

            b'',

            b'bundle-store',

            None,

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

        )

    )

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

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

    wireprotov1peer.wirepeer.listkeyspatterns = listkeyspatterns

    partorder = exchange.b2partsgenorder

    index = partorder.index(b'changeset')

    partorder.insert(

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

    )

def _checkheads(orig, pushop):

    if pushop.ui.configbool(experimental, configscratchpush, False):

        return

    return orig(pushop)

def wireprotolistkeyspatterns(repo, proto, namespace, patterns):

    patterns = wireprototypes.decodelist(patterns)

    d = repo.listkeys(encoding.tolocal(namespace), patterns).iteritems()

    return pushkey.encodekeys(d)

def localrepolistkeys(orig, self, namespace, patterns=None):

    if namespace == b'bookmarks' and patterns:

        index = self.bundlestore.index

        results = {}

        bookmarks = orig(self, namespace)

        for pattern in patterns:

            results.update(index.getbookmarks(pattern))

            if pattern.endswith(b'*'):

                pattern = b're:^' + pattern[:-1] + b'.*'

            kind, pat, matcher = stringutil.stringmatcher(pattern)

            for bookmark, node in bookmarks.iteritems():

                if matcher(bookmark):

                    results[bookmark] = node

        return results

    else:

        return orig(self, namespace)

@wireprotov1peer.batchable

def listkeyspatterns(self, namespace, patterns):

    if not self.capable(b'pushkey'):

        yield {}, None

    f = wireprotov1peer.future()