mercurial/localrepo.py
author Sean Farley <sean.michael.farley@gmail.com>
Fri, 22 Nov 2013 14:58:41 -0500
changeset 20129 da8fb88bd757
parent 20091 abfe6a8e619b
child 20176 4c96c50ef937
permissions -rw-r--r--
bash_completion: add completion for deleting a shelve
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1089
142b5d5ec9cc Break apart hg.py
mpm@selenic.com
parents: 1072
diff changeset
     1
# localrepo.py - read/write repository class for mercurial
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
     2
#
4635
63b9d2deed48 Updated copyright notices and add "and others" to "hg version"
Thomas Arendsen Hein <thomas@intevation.de>
parents: 4633
diff changeset
     3
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
     4
#
8225
46293a0c7e9f updated license to be explicit about GPL version 2
Martin Geisler <mg@lazybytes.net>
parents: 8210
diff changeset
     5
# This software may be used and distributed according to the terms of the
10263
25e572394f5c Update license to GPLv2+
Matt Mackall <mpm@selenic.com>
parents: 9954
diff changeset
     6
# GNU General Public License version 2 or any later version.
18118
e70ff1e599f4 branchmap: extract read logic from repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18117
diff changeset
     7
from node import hex, nullid, short
3891
6b4127c7d52a Simplify i18n imports
Matt Mackall <mpm@selenic.com>
parents: 3877
diff changeset
     8
from i18n import _
18100
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
     9
import peer, changegroup, subrepo, discovery, pushkey, obsolete, repoview
15418
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15403
diff changeset
    10
import changelog, dirstate, filelog, manifest, context, bookmarks, phases
20088
7cbb79bddee7 localrepo: import "lock" module as "lockmod" for readability
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20087
diff changeset
    11
import lock as lockmod
7cbb79bddee7 localrepo: import "lock" module as "lockmod" for readability
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20087
diff changeset
    12
import transaction, store, encoding
14902
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
    13
import scmutil, util, extensions, hook, error, revset
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
    14
import match as matchmod
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
    15
import merge as mergemod
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
    16
import tags as tagsmod
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
    17
from lock import release
11303
a1aad8333864 move working dir/dirstate methods from localrepo to workingctx
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 11301
diff changeset
    18
import weakref, errno, os, time, inspect
20033
f962870712da pathutil: tease out a new library to break an import cycle from canonpath use
Augie Fackler <raf@durin42.com>
parents: 20027
diff changeset
    19
import branchmap, pathutil
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
    20
propertycache = util.propertycache
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
    21
filecache = scmutil.filecache
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
    22
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    23
class repofilecache(filecache):
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    24
    """All filecache usage on repo are done for logic that should be unfiltered
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    25
    """
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    26
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    27
    def __get__(self, repo, type=None):
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    28
        return super(repofilecache, self).__get__(repo.unfiltered(), type)
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    29
    def __set__(self, repo, value):
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    30
        return super(repofilecache, self).__set__(repo.unfiltered(), value)
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    31
    def __delete__(self, repo):
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    32
        return super(repofilecache, self).__delete__(repo.unfiltered())
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    33
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    34
class storecache(repofilecache):
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    35
    """filecache for files in the store"""
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    36
    def join(self, obj, fname):
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    37
        return obj.sjoin(fname)
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    38
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    39
class unfilteredpropertycache(propertycache):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    40
    """propertycache that apply to unfiltered repo only"""
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    41
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    42
    def __get__(self, repo, type=None):
19846
9789670992d6 repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 19515
diff changeset
    43
        unfi = repo.unfiltered()
9789670992d6 repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 19515
diff changeset
    44
        if unfi is repo:
9789670992d6 repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 19515
diff changeset
    45
            return super(unfilteredpropertycache, self).__get__(unfi)
9789670992d6 repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 19515
diff changeset
    46
        return getattr(unfi, self.name)
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    47
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    48
class filteredpropertycache(propertycache):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    49
    """propertycache that must take filtering in account"""
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    50
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    51
    def cachevalue(self, obj, value):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    52
        object.__setattr__(obj, self.name, value)
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    53
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    54
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    55
def hasunfilteredcache(repo, name):
18644
3e92772d5383 spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents: 18520
diff changeset
    56
    """check if a repo has an unfilteredpropertycache value for <name>"""
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    57
    return name in vars(repo.unfiltered())
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    58
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
    59
def unfilteredmethod(orig):
17994
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    60
    """decorate method that always need to be run on unfiltered version"""
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    61
    def wrapper(repo, *args, **kwargs):
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    62
        return orig(repo.unfiltered(), *args, **kwargs)
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    63
    return wrapper
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    64
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    65
MODERNCAPS = set(('lookup', 'branchmap', 'pushkey', 'known', 'getbundle'))
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    66
LEGACYCAPS = MODERNCAPS.union(set(['changegroupsubset']))
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    67
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    68
class localpeer(peer.peerrepository):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    69
    '''peer for a local repo; reflects only the most recent API'''
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    70
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    71
    def __init__(self, repo, caps=MODERNCAPS):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    72
        peer.peerrepository.__init__(self)
18382
f3b21beb9802 filtering: rename filters to their antonyms
Kevin Bullock <kbullock@ringworld.org>
parents: 18364
diff changeset
    73
        self._repo = repo.filtered('served')
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    74
        self.ui = repo.ui
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    75
        self._caps = repo._restrictcapabilities(caps)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    76
        self.requirements = repo.requirements
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    77
        self.supportedformats = repo.supportedformats
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    78
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    79
    def close(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    80
        self._repo.close()
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    81
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    82
    def _capabilities(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    83
        return self._caps
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    84
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    85
    def local(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    86
        return self._repo
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    87
17193
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
    88
    def canpush(self):
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
    89
        return True
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
    90
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    91
    def url(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    92
        return self._repo.url()
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    93
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    94
    def lookup(self, key):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    95
        return self._repo.lookup(key)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    96
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    97
    def branchmap(self):
18279
679767c38cb5 clfilter: drop extra filtering in localpeer
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18278
diff changeset
    98
        return self._repo.branchmap()
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    99
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   100
    def heads(self):
18279
679767c38cb5 clfilter: drop extra filtering in localpeer
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18278
diff changeset
   101
        return self._repo.heads()
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   102
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   103
    def known(self, nodes):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   104
        return self._repo.known(nodes)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   105
19201
309c439cdbaa bundle-ng: add bundlecaps argument to getbundle() command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19200
diff changeset
   106
    def getbundle(self, source, heads=None, common=None, bundlecaps=None):
309c439cdbaa bundle-ng: add bundlecaps argument to getbundle() command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19200
diff changeset
   107
        return self._repo.getbundle(source, heads=heads, common=common,
309c439cdbaa bundle-ng: add bundlecaps argument to getbundle() command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19200
diff changeset
   108
                                    bundlecaps=None)
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   109
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   110
    # TODO We might want to move the next two calls into legacypeer and add
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   111
    # unbundle instead.
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   112
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   113
    def lock(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   114
        return self._repo.lock()
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   115
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   116
    def addchangegroup(self, cg, source, url):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   117
        return self._repo.addchangegroup(cg, source, url)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   118
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   119
    def pushkey(self, namespace, key, old, new):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   120
        return self._repo.pushkey(namespace, key, old, new)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   121
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   122
    def listkeys(self, namespace):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   123
        return self._repo.listkeys(namespace)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   124
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   125
    def debugwireargs(self, one, two, three=None, four=None, five=None):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   126
        '''used to test argument passing over the wire'''
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   127
        return "%s %s %s %s %s" % (one, two, three, four, five)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   128
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   129
class locallegacypeer(localpeer):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   130
    '''peer extension which implements legacy methods too; used for tests with
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   131
    restricted capabilities'''
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   132
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   133
    def __init__(self, repo):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   134
        localpeer.__init__(self, repo, caps=LEGACYCAPS)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   135
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   136
    def branches(self, nodes):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   137
        return self._repo.branches(nodes)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   138
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   139
    def between(self, pairs):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   140
        return self._repo.between(pairs)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   141
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   142
    def changegroup(self, basenodes, source):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   143
        return self._repo.changegroup(basenodes, source)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   144
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   145
    def changegroupsubset(self, bases, heads, source):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   146
        return self._repo.changegroupsubset(bases, heads, source)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   147
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   148
class localrepository(object):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   149
14270
d6907a5674a2 revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14232
diff changeset
   150
    supportedformats = set(('revlogv1', 'generaldelta'))
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   151
    _basesupported = supportedformats | set(('store', 'fncache', 'shared',
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   152
                                             'dotencode'))
17137
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   153
    openerreqs = set(('revlogv1', 'generaldelta'))
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   154
    requirements = ['revlogv1']
18186
d336f53cb2e3 clfilter: ensure unfiltered repo have a filtername attribute too
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18162
diff changeset
   155
    filtername = None
17137
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   156
19928
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   157
    # a list of (ui, featureset) functions.
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   158
    # only functions defined in module of enabled extensions are invoked
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   159
    featuresetupfuncs = set()
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   160
17137
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   161
    def _baserequirements(self, create):
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   162
        return self.requirements[:]
2439
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
   163
14363
82f3b0f3f0a5 localrepo, sshrepo: use Boolean create argument in __init__
Martin Geisler <mg@lazybytes.net>
parents: 14333
diff changeset
   164
    def __init__(self, baseui, path=None, create=False):
18945
e75b72fffdfe vfs: split "expand" into "realpath"/"expandpath" to apply each separately
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18811
diff changeset
   165
        self.wvfs = scmutil.vfs(path, expandpath=True, realpath=True)
17650
bf2eb3a126d2 localrepo: use "vfs" constructor instead of "opener" one
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17550
diff changeset
   166
        self.wopener = self.wvfs
17157
87e8440964a0 localrepo: use path expansion API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17156
diff changeset
   167
        self.root = self.wvfs.base
17158
60338880d265 localrepo: use "self.wvfs.join()" instead of "os.path.join()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17157
diff changeset
   168
        self.path = self.wvfs.join(".hg")
3850
a4457828ca1a move code around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3803
diff changeset
   169
        self.origroot = path
20033
f962870712da pathutil: tease out a new library to break an import cycle from canonpath use
Augie Fackler <raf@durin42.com>
parents: 20027
diff changeset
   170
        self.auditor = pathutil.pathauditor(self.root, self._checknested)
17650
bf2eb3a126d2 localrepo: use "vfs" constructor instead of "opener" one
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17550
diff changeset
   171
        self.vfs = scmutil.vfs(self.path)
bf2eb3a126d2 localrepo: use "vfs" constructor instead of "opener" one
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17550
diff changeset
   172
        self.opener = self.vfs
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   173
        self.baseui = baseui
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   174
        self.ui = baseui.copy()
20082
b04cc8651a63 localrepo: prevent to copy repo local config, copy baseui instead
Simon Heimberg <simohe@besonet.ch>
parents: 20033
diff changeset
   175
        self.ui.copy = baseui.copy # prevent copying repo configuration
15922
23921c17299a phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15892
diff changeset
   176
        # A list of callback to shape the phase if no data were found.
23921c17299a phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15892
diff changeset
   177
        # Callback are in the form: func(repo, roots) --> processed root.
23921c17299a phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15892
diff changeset
   178
        # This list it to be filled by extension during repo setup
23921c17299a phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15892
diff changeset
   179
        self._phasedefaults = []
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   180
        try:
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   181
            self.ui.readconfig(self.join("hgrc"), self.root)
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   182
            extensions.loadall(self.ui)
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   183
        except IOError:
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   184
            pass
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   185
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   186
        if self.featuresetupfuncs:
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   187
            self.supported = set(self._basesupported) # use private copy
19928
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   188
            extmods = set(m.__name__ for n, m
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   189
                          in extensions.extensions(self.ui))
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   190
            for setupfunc in self.featuresetupfuncs:
19928
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   191
                if setupfunc.__module__ in extmods:
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   192
                    setupfunc(self.ui, self.supported)
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   193
        else:
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   194
            self.supported = self._basesupported
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   195
17161
be016e96117a localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17160
diff changeset
   196
        if not self.vfs.isdir():
3035
4d0e0f149581 localrepo: move the repo creation code, fail if the repo exists
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3019
diff changeset
   197
            if create:
17161
be016e96117a localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17160
diff changeset
   198
                if not self.wvfs.exists():
be016e96117a localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17160
diff changeset
   199
                    self.wvfs.makedirs()
be016e96117a localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17160
diff changeset
   200
                self.vfs.makedir(notindexed=True)
17137
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   201
                requirements = self._baserequirements(create)
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   202
                if self.ui.configbool('format', 'usestore', True):
17161
be016e96117a localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17160
diff changeset
   203
                    self.vfs.mkdir("store")
4166
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   204
                    requirements.append("store")
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   205
                    if self.ui.configbool('format', 'usefncache', True):
7234
ae70fe6143fc add format.usefncache config option (default is true)
Adrian Buehlmann <adrian@cadifra.com>
parents: 7233
diff changeset
   206
                        requirements.append("fncache")
12687
34d8247a4595 store: encode first period or space in filenames (issue1713)
Adrian Buehlmann <adrian@cadifra.com>
parents: 12622
diff changeset
   207
                        if self.ui.configbool('format', 'dotencode', True):
34d8247a4595 store: encode first period or space in filenames (issue1713)
Adrian Buehlmann <adrian@cadifra.com>
parents: 12622
diff changeset
   208
                            requirements.append('dotencode')
4166
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   209
                    # create an invalid changelog
17160
22b9b1d2f5d4 localrepo: use "vfs" intead of "opener" while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17159
diff changeset
   210
                    self.vfs.append(
14168
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   211
                        "00changelog.i",
4166
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   212
                        '\0\0\0\2' # represents revlogv2
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   213
                        ' dummy changelog to prevent using the old repo layout'
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   214
                    )
14270
d6907a5674a2 revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14232
diff changeset
   215
                if self.ui.configbool('format', 'generaldelta', False):
d6907a5674a2 revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14232
diff changeset
   216
                    requirements.append("generaldelta")
14905
207935cda6dc localrepo: make requirements attribute of newly-created repos contain a set
Andrew Pritchard <andrewp@fogcreek.com>
parents: 14904
diff changeset
   217
                requirements = set(requirements)
3035
4d0e0f149581 localrepo: move the repo creation code, fail if the repo exists
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3019
diff changeset
   218
            else:
7637
1d54e2f6c0b7 error: move repo errors
Matt Mackall <mpm@selenic.com>
parents: 7633
diff changeset
   219
                raise error.RepoError(_("repository %s not found") % path)
3035
4d0e0f149581 localrepo: move the repo creation code, fail if the repo exists
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3019
diff changeset
   220
        elif create:
7637
1d54e2f6c0b7 error: move repo errors
Matt Mackall <mpm@selenic.com>
parents: 7633
diff changeset
   221
            raise error.RepoError(_("repository %s already exists") % path)
3851
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   222
        else:
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   223
            try:
17160
22b9b1d2f5d4 localrepo: use "vfs" intead of "opener" while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17159
diff changeset
   224
                requirements = scmutil.readrequires(self.vfs, self.supported)
3851
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   225
            except IOError, inst:
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   226
                if inst.errno != errno.ENOENT:
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   227
                    raise
14482
58b36e9ea783 introduce new function scmutil.readrequires
Adrian Buehlmann <adrian@cadifra.com>
parents: 14434
diff changeset
   228
                requirements = set()
405
99470ae6b424 Check if repository exists
mpm@selenic.com
parents: 402
diff changeset
   229
8799
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   230
        self.sharedpath = self.path
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   231
        try:
18946
3d4f41eaae67 localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18945
diff changeset
   232
            vfs = scmutil.vfs(self.vfs.read("sharedpath").rstrip('\n'),
3d4f41eaae67 localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18945
diff changeset
   233
                              realpath=True)
3d4f41eaae67 localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18945
diff changeset
   234
            s = vfs.base
3d4f41eaae67 localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18945
diff changeset
   235
            if not vfs.exists():
8799
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   236
                raise error.RepoError(
8908
105343f9f744 Fix warning: Seen unexpected token "%"
Dongsheng Song <dongsheng.song@gmail.com>
parents: 8813
diff changeset
   237
                    _('.hg/sharedpath points to nonexistent directory %s') % s)
8799
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   238
            self.sharedpath = s
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   239
        except IOError, inst:
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   240
            if inst.errno != errno.ENOENT:
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   241
                raise
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   242
17654
1dc37491e9fb localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17650
diff changeset
   243
        self.store = store.store(requirements, self.sharedpath, scmutil.vfs)
6840
80e51429cb9a introduce store classes
Adrian Buehlmann <adrian@cadifra.com>
parents: 6839
diff changeset
   244
        self.spath = self.store.path
17654
1dc37491e9fb localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17650
diff changeset
   245
        self.svfs = self.store.vfs
1dc37491e9fb localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17650
diff changeset
   246
        self.sopener = self.svfs
6840
80e51429cb9a introduce store classes
Adrian Buehlmann <adrian@cadifra.com>
parents: 6839
diff changeset
   247
        self.sjoin = self.store.join
17654
1dc37491e9fb localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17650
diff changeset
   248
        self.vfs.createmode = self.store.createmode
12295
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   249
        self._applyrequirements(requirements)
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   250
        if create:
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   251
            self._writerequirements()
3850
a4457828ca1a move code around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3803
diff changeset
   252
9146
5614a628d173 localrepo: rename in-memory tag cache instance attributes (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9145
diff changeset
   253
18189
b9026ba002f6 branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18186
diff changeset
   254
        self._branchcaches = {}
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   255
        self.filterpats = {}
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   256
        self._datafilters = {}
4916
5c5d23d93447 Use a weakref for recursive transactions
Matt Mackall <mpm@selenic.com>
parents: 4915
diff changeset
   257
        self._transref = self._lockref = self._wlockref = None
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   258
14929
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   259
        # A cache for various files under .hg/ that tracks file changes,
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   260
        # (used by the filecache decorator)
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   261
        #
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   262
        # Maps a property name to its util.filecacheentry
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   263
        self._filecache = {}
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   264
18101
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   265
        # hold sets of revision to be filtered
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   266
        # should be cleared when something might have changed the filter value:
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   267
        # - new changesets,
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   268
        # - phase change,
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   269
        # - new obsolescence marker,
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   270
        # - working directory parent change,
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   271
        # - bookmark changes
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   272
        self.filteredrevcache = {}
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   273
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   274
    def close(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   275
        pass
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   276
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   277
    def _restrictcapabilities(self, caps):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   278
        return caps
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   279
12295
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   280
    def _applyrequirements(self, requirements):
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   281
        self.requirements = requirements
14333
31a5973fcf96 revlog: get rid of defversion
Sune Foldager <cryo@cyanite.org>
parents: 14274
diff changeset
   282
        self.sopener.options = dict((r, 1) for r in requirements
17137
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   283
                                           if r in self.openerreqs)
12295
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   284
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   285
    def _writerequirements(self):
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   286
        reqfile = self.opener("requires", "w")
18356
752f77ef7202 localrepo: store requirements sorted
Mads Kiilerich <mads@kiilerich.com>
parents: 18318
diff changeset
   287
        for r in sorted(self.requirements):
12295
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   288
            reqfile.write("%s\n" % r)
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   289
        reqfile.close()
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   290
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   291
    def _checknested(self, path):
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   292
        """Determine if path is a legal nested repository."""
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   293
        if not path.startswith(self.root):
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   294
            return False
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   295
        subpath = path[len(self.root) + 1:]
15722
417127af3996 windows: use normalized path to check repository nesting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15604
diff changeset
   296
        normsubpath = util.pconvert(subpath)
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   297
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   298
        # XXX: Checking against the current working copy is wrong in
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   299
        # the sense that it can reject things like
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   300
        #
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   301
        #   $ hg cat -r 10 sub/x.txt
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   302
        #
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   303
        # if sub/ is no longer a subrepository in the working copy
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   304
        # parent revision.
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   305
        #
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   306
        # However, it can of course also allow things that would have
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   307
        # been rejected before, such as the above cat command if sub/
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   308
        # is a subrepository now, but was a normal directory before.
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   309
        # The old path auditor would have rejected by mistake since it
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   310
        # panics when it sees sub/.hg/.
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   311
        #
12174
7bccd04292a2 localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents: 12166
diff changeset
   312
        # All in all, checking against the working copy seems sensible
7bccd04292a2 localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents: 12166
diff changeset
   313
        # since we want to prevent access to nested repositories on
7bccd04292a2 localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents: 12166
diff changeset
   314
        # the filesystem *now*.
7bccd04292a2 localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents: 12166
diff changeset
   315
        ctx = self[None]
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   316
        parts = util.splitpath(subpath)
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   317
        while parts:
15722
417127af3996 windows: use normalized path to check repository nesting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15604
diff changeset
   318
            prefix = '/'.join(parts)
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   319
            if prefix in ctx.substate:
15722
417127af3996 windows: use normalized path to check repository nesting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15604
diff changeset
   320
                if prefix == normsubpath:
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   321
                    return True
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   322
                else:
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   323
                    sub = ctx.sub(prefix)
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   324
                    return sub.checknested(subpath[len(prefix) + 1:])
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   325
            else:
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   326
                parts.pop()
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   327
        return False
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   328
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   329
    def peer(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   330
        return localpeer(self) # not cached to avoid reference cycle
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   331
17993
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   332
    def unfiltered(self):
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   333
        """Return unfiltered version of the repository
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   334
18644
3e92772d5383 spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents: 18520
diff changeset
   335
        Intended to be overwritten by filtered repo."""
17993
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   336
        return self
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   337
18100
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   338
    def filtered(self, name):
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   339
        """Return a filtered version of a repository"""
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   340
        # build a new class with the mixin and the current class
18644
3e92772d5383 spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents: 18520
diff changeset
   341
        # (possibly subclass of the repo)
18100
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   342
        class proxycls(repoview.repoview, self.unfiltered().__class__):
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   343
            pass
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   344
        return proxycls(self, name)
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   345
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
   346
    @repofilecache('bookmarks')
13355
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   347
    def _bookmarks(self):
17922
7f5dab94e48c bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents: 17857
diff changeset
   348
        return bookmarks.bmstore(self)
13355
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   349
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
   350
    @repofilecache('bookmarks.current')
13355
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   351
    def _bookmarkcurrent(self):
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   352
        return bookmarks.readcurrent(self)
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   353
16707
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   354
    def bookmarkheads(self, bookmark):
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   355
        name = bookmark.split('@', 1)[0]
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   356
        heads = []
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   357
        for mark, n in self._bookmarks.iteritems():
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   358
            if mark.split('@', 1)[0] == name:
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   359
                heads.append(n)
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   360
        return heads
15418
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15403
diff changeset
   361
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
   362
    @storecache('phaseroots')
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   363
    def _phasecache(self):
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   364
        return phases.phasecache(self, self._phasedefaults)
15420
e80d0d3198f0 phases: add a cache allowing to know in which phase a changeset is
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15418
diff changeset
   365
17070
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   366
    @storecache('obsstore')
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   367
    def obsstore(self):
17124
f1b7683f3f95 obsolete: move obsolete markers read/write logic to obsstore object
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17075
diff changeset
   368
        store = obsolete.obsstore(self.sopener)
17297
6955d69a52a4 obsolete: warns if markers exist in a repo where the feature is not enabled
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17295
diff changeset
   369
        if store and not obsolete._enabled:
17306
7d2967de2c04 obsolete: fix typos in comments introduced by 6955d69a52a4
Thomas Arendsen Hein <thomas@intevation.de>
parents: 17299
diff changeset
   370
            # message is rare enough to not be translated
17297
6955d69a52a4 obsolete: warns if markers exist in a repo where the feature is not enabled
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17295
diff changeset
   371
            msg = 'obsolete feature not enabled but %i markers found!\n'
6955d69a52a4 obsolete: warns if markers exist in a repo where the feature is not enabled
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17295
diff changeset
   372
            self.ui.warn(msg % len(list(store)))
17070
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   373
        return store
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   374
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
   375
    @storecache('00changelog.i')
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   376
    def changelog(self):
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   377
        c = changelog.changelog(self.sopener)
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   378
        if 'HG_PENDING' in os.environ:
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   379
            p = os.environ['HG_PENDING']
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   380
            if p.startswith(self.root):
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   381
                c.readpending('00changelog.i.a')
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   382
        return c
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   383
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
   384
    @storecache('00manifest.i')
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   385
    def manifest(self):
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   386
        return manifest.manifest(self.sopener)
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   387
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
   388
    @repofilecache('dirstate')
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   389
    def dirstate(self):
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   390
        warned = [0]
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   391
        def validate(node):
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   392
            try:
14064
e4bfb9c337f3 remove unused imports and variables
Alexander Solovyov <alexander@solovyov.net>
parents: 14056
diff changeset
   393
                self.changelog.rev(node)
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   394
                return node
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   395
            except error.LookupError:
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   396
                if not warned[0]:
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   397
                    warned[0] = True
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   398
                    self.ui.warn(_("warning: ignoring unknown"
13037
9beac11b8c56 localrepo: move string formatting out of gettext call
Martin Geisler <mg@aragost.com>
parents: 13032
diff changeset
   399
                                   " working parent %s!\n") % short(node))
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   400
                return nullid
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   401
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   402
        return dirstate.dirstate(self.opener, self.ui, self.root, validate)
2155
ff255b41b4aa support hooks written in python.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2150
diff changeset
   403
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   404
    def __getitem__(self, changeid):
8527
f9a80054dd3c use 'x is None' instead of 'x == None'
Martin Geisler <mg@lazybytes.net>
parents: 8515
diff changeset
   405
        if changeid is None:
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   406
            return context.workingctx(self)
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   407
        return context.changectx(self, changeid)
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   408
9924
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   409
    def __contains__(self, changeid):
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   410
        try:
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   411
            return bool(self.lookup(changeid))
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   412
        except error.RepoLookupError:
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   413
            return False
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   414
6750
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   415
    def __nonzero__(self):
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   416
        return True
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   417
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   418
    def __len__(self):
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   419
        return len(self.changelog)
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   420
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   421
    def __iter__(self):
17675
8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17670
diff changeset
   422
        return iter(self.changelog)
2155
ff255b41b4aa support hooks written in python.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2150
diff changeset
   423
15403
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   424
    def revs(self, expr, *args):
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   425
        '''Return a list of revisions matching the given revset'''
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   426
        expr = revset.formatspec(expr, *args)
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   427
        m = revset.match(None, expr)
17675
8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17670
diff changeset
   428
        return [r for r in m(self, list(self))]
15403
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   429
14902
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   430
    def set(self, expr, *args):
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   431
        '''
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   432
        Yield a context for each matching revision, after doing arg
14904
ff2d907a5af8 localrepo: fix comment on set
Matt Mackall <mpm@selenic.com>
parents: 14902
diff changeset
   433
        replacement via revset.formatspec
14902
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   434
        '''
15403
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   435
        for r in self.revs(expr, *args):
14902
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   436
            yield self[r]
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   437
2673
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2661
diff changeset
   438
    def url(self):
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2661
diff changeset
   439
        return 'file:' + self.root
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2661
diff changeset
   440
1718
c1996b84d4f5 make hook code nicer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1717
diff changeset
   441
    def hook(self, name, throw=False, **args):
4622
fff50306e6dd hooks: separate hook code into a separate module
Matt Mackall <mpm@selenic.com>
parents: 4619
diff changeset
   442
        return hook.hook(self.ui, self, name, throw, **args)
487
2ad41189bee5 Add initial hook support
mpm@selenic.com
parents: 484
diff changeset
   443
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
   444
    @unfilteredmethod
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   445
    def _tag(self, names, node, message, local, user, date, extra={}):
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   446
        if isinstance(names, str):
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   447
            names = (names,)
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   448
11063
eb23c876c111 tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11047
diff changeset
   449
        branches = self.branchmap()
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   450
        for name in names:
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   451
            self.hook('pretag', throw=True, node=hex(node), tag=name,
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   452
                      local=local)
11063
eb23c876c111 tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11047
diff changeset
   453
            if name in branches:
eb23c876c111 tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11047
diff changeset
   454
                self.ui.warn(_("warning: tag %s conflicts with existing"
eb23c876c111 tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11047
diff changeset
   455
                " branch name\n") % name)
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   456
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   457
        def writetags(fp, names, munge, prevtags):
5985
850494d62674 localrepo._tag: add a seek before writing the new tag
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5882
diff changeset
   458
            fp.seek(0, 2)
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   459
            if prevtags and prevtags[-1] != '\n':
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   460
                fp.write('\n')
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   461
            for name in names:
6671
938eddd76237 tag: record tag we're superseding, if any (issue 1102)
Matt Mackall <mpm@selenic.com>
parents: 6647
diff changeset
   462
                m = munge and munge(name) or name
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   463
                if (self._tagscache.tagtypes and
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   464
                    name in self._tagscache.tagtypes):
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   465
                    old = self.tags().get(name, nullid)
6671
938eddd76237 tag: record tag we're superseding, if any (issue 1102)
Matt Mackall <mpm@selenic.com>
parents: 6647
diff changeset
   466
                    fp.write('%s %s\n' % (hex(old), m))
938eddd76237 tag: record tag we're superseding, if any (issue 1102)
Matt Mackall <mpm@selenic.com>
parents: 6647
diff changeset
   467
                fp.write('%s %s\n' % (hex(node), m))
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   468
            fp.close()
5081
ea7b982b6c08 Remove trailing spaces
Thomas Arendsen Hein <thomas@intevation.de>
parents: 4932
diff changeset
   469
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   470
        prevtags = ''
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   471
        if local:
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   472
            try:
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   473
                fp = self.opener('localtags', 'r+')
7875
553aa0cbeab6 cleanup: drop unused assignments
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 7848
diff changeset
   474
            except IOError:
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   475
                fp = self.opener('localtags', 'a')
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   476
            else:
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   477
                prevtags = fp.read()
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   478
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   479
            # local tags are stored in the current charset
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   480
            writetags(fp, names, None, prevtags)
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   481
            for name in names:
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   482
                self.hook('tag', node=hex(node), tag=name, local=local)
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   483
            return
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   484
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   485
        try:
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   486
            fp = self.wfile('.hgtags', 'rb+')
14646
001788ef4bbb localrepo: don't attempt to open .hgtags twice if the error isn't ENOENT
Idan Kamara <idankk86@gmail.com>
parents: 14603
diff changeset
   487
        except IOError, e:
001788ef4bbb localrepo: don't attempt to open .hgtags twice if the error isn't ENOENT
Idan Kamara <idankk86@gmail.com>
parents: 14603
diff changeset
   488
            if e.errno != errno.ENOENT:
001788ef4bbb localrepo: don't attempt to open .hgtags twice if the error isn't ENOENT
Idan Kamara <idankk86@gmail.com>
parents: 14603
diff changeset
   489
                raise
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   490
            fp = self.wfile('.hgtags', 'ab')
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   491
        else:
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   492
            prevtags = fp.read()
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   493
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   494
        # committed tags are stored in UTF-8
7948
de377b1a9a84 move encoding bits from util to encoding
Matt Mackall <mpm@selenic.com>
parents: 7930
diff changeset
   495
        writetags(fp, names, encoding.fromlocal, prevtags)
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   496
13400
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13391
diff changeset
   497
        fp.close()
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13391
diff changeset
   498
15929
4091660dc130 tag: invalidate tag cache immediately after adding new tag (issue3210)
Mads Kiilerich <mads@kiilerich.com>
parents: 15922
diff changeset
   499
        self.invalidatecaches()
4091660dc130 tag: invalidate tag cache immediately after adding new tag (issue3210)
Mads Kiilerich <mads@kiilerich.com>
parents: 15922
diff changeset
   500
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   501
        if '.hgtags' not in self.dirstate:
11303
a1aad8333864 move working dir/dirstate methods from localrepo to workingctx
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 11301
diff changeset
   502
            self[None].add(['.hgtags'])
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   503
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
   504
        m = matchmod.exact(self.root, '', ['.hgtags'])
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
   505
        tagnode = self.commit(message, user, date, extra=extra, match=m)
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   506
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   507
        for name in names:
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   508
            self.hook('tag', node=hex(node), tag=name, local=local)
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   509
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   510
        return tagnode
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   511
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   512
    def tag(self, names, node, message, local, user, date):
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   513
        '''tag a revision with one or more symbolic names.
2601
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   514
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   515
        names is a list of strings or, when adding a single tag, names may be a
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   516
        string.
6334
7016f7fb8fe3 tab/space cleanup
Thomas Arendsen Hein <thomas@intevation.de>
parents: 6321
diff changeset
   517
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   518
        if local is True, the tags are stored in a per-repository file.
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   519
        otherwise, they are stored in the .hgtags file, and a new
2601
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   520
        changeset is committed with the change.
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   521
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   522
        keyword arguments:
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   523
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   524
        local: whether to store tags in non-version-controlled file
2601
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   525
        (default False)
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   526
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   527
        message: commit message to use if committing
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   528
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   529
        user: name of user to use if committing
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   530
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   531
        date: date tuple to use if committing'''
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   532
13133
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   533
        if not local:
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   534
            for x in self.status()[:5]:
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   535
                if '.hgtags' in x:
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   536
                    raise util.Abort(_('working copy of .hgtags is changed '
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   537
                                       '(please commit .hgtags manually)'))
2601
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   538
7814
4421abf8c85d tag: force load of tag cache
Matt Mackall <mpm@selenic.com>
parents: 7803
diff changeset
   539
        self.tags() # instantiate the cache
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   540
        self._tag(names, node, message, local, user, date)
2601
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   541
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   542
    @filteredpropertycache
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   543
    def _tagscache(self):
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   544
        '''Returns a tagscache object that contains various tags related
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   545
        caches.'''
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   546
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   547
        # This simplifies its cache management by having one decorated
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   548
        # function (this one) and the rest simply fetch things from it.
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   549
        class tagscache(object):
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   550
            def __init__(self):
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   551
                # These two define the set of tags for this repository. tags
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   552
                # maps tag name to node; tagtypes maps tag name to 'global' or
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   553
                # 'local'. (Global tags are defined by .hgtags across all
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   554
                # heads, and local tags are defined in .hg/localtags.)
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   555
                # They constitute the in-memory cache of tags.
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   556
                self.tags = self.tagtypes = None
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   557
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   558
                self.nodetagscache = self.tagslist = None
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   559
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   560
        cache = tagscache()
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   561
        cache.tags, cache.tagtypes = self._findtags()
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   562
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   563
        return cache
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   564
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   565
    def tags(self):
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   566
        '''return a mapping of tag to node'''
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   567
        t = {}
17715
21c503480986 clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17714
diff changeset
   568
        if self.changelog.filteredrevs:
21c503480986 clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17714
diff changeset
   569
            tags, tt = self._findtags()
21c503480986 clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17714
diff changeset
   570
        else:
21c503480986 clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17714
diff changeset
   571
            tags = self._tagscache.tags
21c503480986 clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17714
diff changeset
   572
        for k, v in tags.iteritems():
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   573
            try:
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   574
                # ignore tags to unknown nodes
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   575
                self.changelog.rev(v)
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   576
                t[k] = v
16679
2950d186a927 parsers: strictly check for 20-byte hashes where they're required
Bryan O'Sullivan <bryano@fb.com>
parents: 16551
diff changeset
   577
            except (error.LookupError, ValueError):
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   578
                pass
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   579
        return t
4210
caff92047e87 Refactor tags code to prepare for improving the algorithm
Matt Mackall <mpm@selenic.com>
parents: 4178
diff changeset
   580
9145
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   581
    def _findtags(self):
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   582
        '''Do the hard work of finding tags.  Return a pair of dicts
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   583
        (tags, tagtypes) where tags maps tag name to node, and tagtypes
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   584
        maps tag name to a string like \'global\' or \'local\'.
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   585
        Subclasses or extensions are free to add their own tags, but
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   586
        should be aware that the returned dicts will be retained for the
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   587
        duration of the localrepo object.'''
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   588
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   589
        # XXX what tagtype should subclasses/extensions use?  Currently
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   590
        # mq and bookmarks add tags, but do not set the tagtype at all.
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   591
        # Should each extension invent its own tag type?  Should there
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   592
        # be one tagtype for all such "virtual" tags?  Or is the status
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   593
        # quo fine?
4210
caff92047e87 Refactor tags code to prepare for improving the algorithm
Matt Mackall <mpm@selenic.com>
parents: 4178
diff changeset
   594
9148
b7837f0ed9fe localrepo: factor updatetags() out of readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9147
diff changeset
   595
        alltags = {}                    # map tag name to (node, hist)
5657
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   596
        tagtypes = {}
659
3662e3d6b690 Whitespace cleanup
Matt Mackall <mpm@selenic.com>
parents: 658
diff changeset
   597
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
   598
        tagsmod.findglobaltags(self.ui, self, alltags, tagtypes)
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
   599
        tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
5657
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   600
9152
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   601
        # Build the return dicts.  Have to re-encode tag names because
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   602
        # the tags module always uses UTF-8 (in order not to lose info
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   603
        # writing to the cache), but the rest of Mercurial wants them in
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   604
        # local encoding.
9145
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   605
        tags = {}
9147
234a230cc33b localrepo: improve readability of _findtags(), readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9146
diff changeset
   606
        for (name, (node, hist)) in alltags.iteritems():
234a230cc33b localrepo: improve readability of _findtags(), readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9146
diff changeset
   607
            if node != nullid:
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   608
                tags[encoding.tolocal(name)] = node
9145
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   609
        tags['tip'] = self.changelog.tip()
9152
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   610
        tagtypes = dict([(encoding.tolocal(name), value)
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   611
                         for (name, value) in tagtypes.iteritems()])
9145
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   612
        return (tags, tagtypes)
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   613
5657
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   614
    def tagtype(self, tagname):
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   615
        '''
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   616
        return the type of the given tag. result can be:
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   617
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   618
        'local'  : a local tag
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   619
        'global' : a global tag
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   620
        None     : tag does not exist
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   621
        '''
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   622
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   623
        return self._tagscache.tagtypes.get(tagname)
5657
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   624
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   625
    def tagslist(self):
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   626
        '''return a list of tags ordered by revision'''
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   627
        if not self._tagscache.tagslist:
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   628
            l = []
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   629
            for t, n in self.tags().iteritems():
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   630
                r = self.changelog.rev(n)
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   631
                l.append((r, t, n))
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   632
            self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   633
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   634
        return self._tagscache.tagslist
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   635
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   636
    def nodetags(self, node):
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   637
        '''return the tags associated with a node'''
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   638
        if not self._tagscache.nodetagscache:
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   639
            nodetagscache = {}
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   640
            for t, n in self._tagscache.tags.iteritems():
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   641
                nodetagscache.setdefault(n, []).append(t)
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   642
            for tags in nodetagscache.itervalues():
11047
c7dbd6c4877a tags: return tags in sorted order
Eric Eisner <ede@mit.edu>
parents: 10970
diff changeset
   643
                tags.sort()
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   644
            self._tagscache.nodetagscache = nodetagscache
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   645
        return self._tagscache.nodetagscache.get(node, [])
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   646
13384
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   647
    def nodebookmarks(self, node):
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   648
        marks = []
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   649
        for bookmark, n in self._bookmarks.iteritems():
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   650
            if n == node:
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   651
                marks.append(bookmark)
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   652
        return sorted(marks)
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   653
12066
d01e28657429 localrepo: introduce method for explicit branch cache update
Georg Brandl <georg@python.org>
parents: 12035
diff changeset
   654
    def branchmap(self):
d01e28657429 localrepo: introduce method for explicit branch cache update
Georg Brandl <georg@python.org>
parents: 12035
diff changeset
   655
        '''returns a dictionary {branch: [branchheads]}'''
18189
b9026ba002f6 branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18186
diff changeset
   656
        branchmap.updatecache(self)
b9026ba002f6 branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18186
diff changeset
   657
        return self._branchcaches[self.filtername]
17714
5210e5a556d9 clfilter: do not use branchmap cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17675
diff changeset
   658
7654
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
   659
16719
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   660
    def _branchtip(self, heads):
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   661
        '''return the tipmost branch head in heads'''
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   662
        tip = heads[-1]
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   663
        for h in reversed(heads):
16720
e825a89de5d7 context: add changectx.closesbranch() method
Brodie Rao <brodie@sf.io>
parents: 16719
diff changeset
   664
            if not self[h].closesbranch():
16719
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   665
                tip = h
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   666
                break
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   667
        return tip
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   668
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   669
    def branchtip(self, branch):
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   670
        '''return the tip node for a given branch'''
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   671
        if branch not in self.branchmap():
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   672
            raise error.RepoLookupError(_("unknown branch '%s'") % branch)
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   673
        return self._branchtip(self.branchmap()[branch])
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   674
7654
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
   675
    def branchtags(self):
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
   676
        '''return a dict where branch names map to the tipmost head of
7656
6a24fb994701 branch closing: referencing open and closed branches/heads
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7655
diff changeset
   677
        the branch, open heads come before closed'''
6a24fb994701 branch closing: referencing open and closed branches/heads
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7655
diff changeset
   678
        bt = {}
9675
ee913987e4b0 localrepo/branchcache: remove lbranchmap(), convert users to use utf-8 names
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 9674
diff changeset
   679
        for bn, heads in self.branchmap().iteritems():
16719
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   680
            bt[bn] = self._branchtip(heads)
7656
6a24fb994701 branch closing: referencing open and closed branches/heads
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7655
diff changeset
   681
        return bt
6a24fb994701 branch closing: referencing open and closed branches/heads
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7655
diff changeset
   682
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   683
    def lookup(self, key):
16378
c463f46fe050 localrepo: lookup now goes through context
Matt Mackall <mpm@selenic.com>
parents: 16371
diff changeset
   684
        return self[key].node()
67
a182f2561c8e Add tag support
mpm@selenic.com
parents: 65
diff changeset
   685
10960
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   686
    def lookupbranch(self, key, remote=None):
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   687
        repo = remote or self
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   688
        if key in repo.branchmap():
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   689
            return key
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   690
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   691
        repo = (remote and remote.local()) and remote or self
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   692
        return repo[key].branch()
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   693
13723
e615765fdcc7 wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13720
diff changeset
   694
    def known(self, nodes):
e615765fdcc7 wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13720
diff changeset
   695
        nm = self.changelog.nodemap
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   696
        pc = self._phasecache
15889
816209eaf963 phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15888
diff changeset
   697
        result = []
816209eaf963 phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15888
diff changeset
   698
        for n in nodes:
816209eaf963 phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15888
diff changeset
   699
            r = nm.get(n)
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   700
            resp = not (r is None or pc.phase(self, r) >= phases.secret)
15889
816209eaf963 phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15888
diff changeset
   701
            result.append(resp)
816209eaf963 phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15888
diff changeset
   702
        return result
13723
e615765fdcc7 wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13720
diff changeset
   703
926
b765e970c9ff Add a local() method to repository classes
mpm@selenic.com
parents: 923
diff changeset
   704
    def local(self):
14603
68a43fdd7d80 localrepo: local() returns self
Matt Mackall <mpm@selenic.com>
parents: 14549
diff changeset
   705
        return self
926
b765e970c9ff Add a local() method to repository classes
mpm@selenic.com
parents: 923
diff changeset
   706
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   707
    def cancopy(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   708
        return self.local() # so statichttprepo's override of local() works
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   709
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   710
    def join(self, f):
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   711
        return os.path.join(self.path, f)
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   712
244
43105253cf5e root relative IO and valid commit states
mpm@selenic.com
parents: 241
diff changeset
   713
    def wjoin(self, f):
43105253cf5e root relative IO and valid commit states
mpm@selenic.com
parents: 241
diff changeset
   714
        return os.path.join(self.root, f)
43105253cf5e root relative IO and valid commit states
mpm@selenic.com
parents: 241
diff changeset
   715
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   716
    def file(self, f):
1615
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
   717
        if f[0] == '/':
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
   718
            f = f[1:]
4258
b11a2fb59cf5 revlog: simplify revlog version handling
Matt Mackall <mpm@selenic.com>
parents: 4232
diff changeset
   719
        return filelog.filelog(self.sopener, f)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   720
6739
c9fbd6ec3489 context: avoid using None for working parent
Matt Mackall <mpm@selenic.com>
parents: 6736
diff changeset
   721
    def changectx(self, changeid):
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   722
        return self[changeid]
3218
8d4855fd9d7b merge: use new working context object in update
Matt Mackall <mpm@selenic.com>
parents: 3164
diff changeset
   723
3163
1605e336d229 Add localrepo.parents to get parent changectxs.
Matt Mackall <mpm@selenic.com>
parents: 3132
diff changeset
   724
    def parents(self, changeid=None):
6742
2d54e7c1e69d context: clean up parents()
Matt Mackall <mpm@selenic.com>
parents: 6740
diff changeset
   725
        '''get list of changectxs for parents of changeid'''
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   726
        return self[changeid].parents()
3163
1605e336d229 Add localrepo.parents to get parent changectxs.
Matt Mackall <mpm@selenic.com>
parents: 3132
diff changeset
   727
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   728
    def setparents(self, p1, p2=nullid):
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   729
        copies = self.dirstate.setparents(p1, p2)
18739
5b7175377bab setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents: 18520
diff changeset
   730
        pctx = self[p1]
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   731
        if copies:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   732
            # Adjust copy records, the dirstate cannot do it, it
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   733
            # requires access to parents manifests. Preserve them
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   734
            # only for entries added to first parent.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   735
            for f in copies:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   736
                if f not in pctx and copies[f] in pctx:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   737
                    self.dirstate.copy(copies[f], f)
18739
5b7175377bab setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents: 18520
diff changeset
   738
        if p2 == nullid:
5b7175377bab setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents: 18520
diff changeset
   739
            for f, s in sorted(self.dirstate.copies().items()):
5b7175377bab setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents: 18520
diff changeset
   740
                if f not in pctx and s not in pctx:
5b7175377bab setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents: 18520
diff changeset
   741
                    self.dirstate.copy(None, f)
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   742
2564
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   743
    def filectx(self, path, changeid=None, fileid=None):
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   744
        """changeid can be a changeset revision, node, or tag.
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   745
           fileid can be a file revision or node."""
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   746
        return context.filectx(self, path, changeid, fileid)
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   747
627
b6c42714d900 Add locate command.
Bryan O'Sullivan <bos@serpentine.com>
parents: 624
diff changeset
   748
    def getcwd(self):
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   749
        return self.dirstate.getcwd()
627
b6c42714d900 Add locate command.
Bryan O'Sullivan <bos@serpentine.com>
parents: 624
diff changeset
   750
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4516
diff changeset
   751
    def pathto(self, f, cwd=None):
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4516
diff changeset
   752
        return self.dirstate.pathto(f, cwd)
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4516
diff changeset
   753
291
2c4f2be05587 Add wopener for opening files in the working directory
mpm@selenic.com
parents: 288
diff changeset
   754
    def wfile(self, f, mode='r'):
2c4f2be05587 Add wopener for opening files in the working directory
mpm@selenic.com
parents: 288
diff changeset
   755
        return self.wopener(f, mode)
2c4f2be05587 Add wopener for opening files in the working directory
mpm@selenic.com
parents: 288
diff changeset
   756
4275
81402b2b294d use os.path.islink instead of util.is_link; remove util.is_link
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4273
diff changeset
   757
    def _link(self, f):
18949
138978f20180 localrepo: use "vfs.islink()" instead of "os.path.islink()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18948
diff changeset
   758
        return self.wvfs.islink(f)
4275
81402b2b294d use os.path.islink instead of util.is_link; remove util.is_link
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4273
diff changeset
   759
11698
9df481f8036d localrepo: refactor filter computation
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11669
diff changeset
   760
    def _loadfilter(self, filter):
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   761
        if filter not in self.filterpats:
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   762
            l = []
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   763
            for pat, cmd in self.ui.configitems(filter):
7226
b71a52f101dc Make it possible to disable filtering for a pattern.
Mads Kiilerich <mads@kiilerich.com>
parents: 7208
diff changeset
   764
                if cmd == '!':
b71a52f101dc Make it possible to disable filtering for a pattern.
Mads Kiilerich <mads@kiilerich.com>
parents: 7208
diff changeset
   765
                    continue
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
   766
                mf = matchmod.match(self.root, '', [pat])
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   767
                fn = None
6066
f3a8b5360100 Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents: 6065
diff changeset
   768
                params = cmd
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   769
                for name, filterfn in self._datafilters.iteritems():
6210
942287cb1f57 Removed trailing spaces from everything except test output
Thomas Arendsen Hein <thomas@intevation.de>
parents: 6201
diff changeset
   770
                    if cmd.startswith(name):
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   771
                        fn = filterfn
6066
f3a8b5360100 Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents: 6065
diff changeset
   772
                        params = cmd[len(name):].lstrip()
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   773
                        break
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   774
                if not fn:
5967
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   775
                    fn = lambda s, c, **kwargs: util.filter(s, c)
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   776
                # Wrap old filters not supporting keyword arguments
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   777
                if not inspect.getargspec(fn)[2]:
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   778
                    oldfn = fn
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   779
                    fn = lambda s, c, **kwargs: oldfn(s, c)
6066
f3a8b5360100 Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents: 6065
diff changeset
   780
                l.append((mf, fn, params))
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   781
            self.filterpats[filter] = l
12706
9ca08fbb750a localrepo: have _loadfilter return the loaded filter patterns
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12687
diff changeset
   782
        return self.filterpats[filter]
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   783
12707
2216ab103ea8 localrepo: load filter patterns outside of _filter
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12706
diff changeset
   784
    def _filter(self, filterpats, filename, data):
2216ab103ea8 localrepo: load filter patterns outside of _filter
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12706
diff changeset
   785
        for mf, fn, cmd in filterpats:
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   786
            if mf(filename):
9467
4c041f1ee1b4 do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents: 9437
diff changeset
   787
                self.ui.debug("filtering %s through %s\n" % (filename, cmd))
5967
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   788
                data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   789
                break
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   790
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   791
        return data
1019
a9cca981c423 Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents: 1013
diff changeset
   792
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   793
    @unfilteredpropertycache
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   794
    def _encodefilterpats(self):
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   795
        return self._loadfilter('encode')
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   796
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   797
    @unfilteredpropertycache
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   798
    def _decodefilterpats(self):
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   799
        return self._loadfilter('decode')
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   800
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   801
    def adddatafilter(self, name, filter):
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   802
        self._datafilters[name] = filter
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   803
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   804
    def wread(self, filename):
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   805
        if self._link(filename):
18950
647e3b0c8751 localrepo: use "vfs.readlink()" instead of "os.readlink()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18949
diff changeset
   806
            data = self.wvfs.readlink(filename)
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   807
        else:
14168
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   808
            data = self.wopener.read(filename)
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   809
        return self._filter(self._encodefilterpats, filename, data)
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   810
4006
67982d3ee76c symlinks: add flags param to wwrite
Matt Mackall <mpm@selenic.com>
parents: 4005
diff changeset
   811
    def wwrite(self, filename, data, flags):
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   812
        data = self._filter(self._decodefilterpats, filename, data)
6877
1d38f3605b20 util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents: 6875
diff changeset
   813
        if 'l' in flags:
1d38f3605b20 util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents: 6875
diff changeset
   814
            self.wopener.symlink(data, filename)
1d38f3605b20 util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents: 6875
diff changeset
   815
        else:
14184
4ab6e2d597cc fix errors reported by pyflakes test
Sune Foldager <cryo@cyanite.org>
parents: 14168
diff changeset
   816
            self.wopener.write(filename, data)
6877
1d38f3605b20 util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents: 6875
diff changeset
   817
            if 'x' in flags:
18951
d13916a00b7e localrepo: use "vfs.setflags()" instead of "util.setflags()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18950
diff changeset
   818
                self.wvfs.setflags(filename, False, True)
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   819
4005
656e06eebda7 replace filehandle version of wwrite with wwritedata
Matt Mackall <mpm@selenic.com>
parents: 4004
diff changeset
   820
    def wwritedata(self, filename, data):
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   821
        return self._filter(self._decodefilterpats, filename, data)
1019
a9cca981c423 Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents: 1013
diff changeset
   822
19853
eddc2a2d57e6 localrepo: make report level in repo.transaction configurable
David Soria Parra <dsp@experimentalworks.net>
parents: 19852
diff changeset
   823
    def transaction(self, desc, report=None):
8072
ecf7795479d5 transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents: 7948
diff changeset
   824
        tr = self._transref and self._transref() or None
ecf7795479d5 transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents: 7948
diff changeset
   825
        if tr and tr.running():
ecf7795479d5 transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents: 7948
diff changeset
   826
            return tr.nest()
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
   827
5865
e7127f669edb transactions: don't show a backtrace when journal exists
Matt Mackall <mpm@selenic.com>
parents: 5814
diff changeset
   828
        # abort here if the journal already exists
18947
9b82f93e3a7a localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18946
diff changeset
   829
        if self.svfs.exists("journal"):
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   830
            raise error.RepoError(
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   831
                _("abandoned transaction found - run hg recover"))
5865
e7127f669edb transactions: don't show a backtrace when journal exists
Matt Mackall <mpm@selenic.com>
parents: 5814
diff changeset
   832
16236
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   833
        self._writejournal(desc)
18952
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   834
        renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
19853
eddc2a2d57e6 localrepo: make report level in repo.transaction configurable
David Soria Parra <dsp@experimentalworks.net>
parents: 19852
diff changeset
   835
        rp = report and report or self.ui.warn
eddc2a2d57e6 localrepo: make report level in repo.transaction configurable
David Soria Parra <dsp@experimentalworks.net>
parents: 19852
diff changeset
   836
        tr = transaction.transaction(rp, self.sopener,
20087
cf3b8285af00 transaction: take journal file path relative to vfs to use file API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20082
diff changeset
   837
                                     "journal",
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   838
                                     aftertrans(renames),
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   839
                                     self.store.createmode)
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   840
        self._transref = weakref.ref(tr)
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   841
        return tr
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   842
16236
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   843
    def _journalfiles(self):
18952
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   844
        return ((self.svfs, 'journal'),
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   845
                (self.vfs, 'journal.dirstate'),
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   846
                (self.vfs, 'journal.branch'),
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   847
                (self.vfs, 'journal.desc'),
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   848
                (self.vfs, 'journal.bookmarks'),
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   849
                (self.svfs, 'journal.phaseroots'))
16236
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   850
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   851
    def undofiles(self):
18952
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   852
        return [vfs.join(undoname(x)) for vfs, x in self._journalfiles()]
16236
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   853
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   854
    def _writejournal(self, desc):
16456
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   855
        self.opener.write("journal.dirstate",
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   856
                          self.opener.tryread("dirstate"))
14168
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   857
        self.opener.write("journal.branch",
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   858
                          encoding.fromlocal(self.dirstate.branch()))
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   859
        self.opener.write("journal.desc",
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   860
                          "%d\n%s\n" % (len(self), desc))
16456
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   861
        self.opener.write("journal.bookmarks",
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   862
                          self.opener.tryread("bookmarks"))
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   863
        self.sopener.write("journal.phaseroots",
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   864
                           self.sopener.tryread("phaseroots"))
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   865
210
d2badbd7d1ad hg undo: fixup working dir state
mpm@selenic.com
parents: 207
diff changeset
   866
    def recover(self):
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
   867
        lock = self.lock()
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   868
        try:
18947
9b82f93e3a7a localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18946
diff changeset
   869
            if self.svfs.exists("journal"):
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   870
                self.ui.status(_("rolling back interrupted transaction\n"))
20087
cf3b8285af00 transaction: take journal file path relative to vfs to use file API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20082
diff changeset
   871
                transaction.rollback(self.sopener, "journal",
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   872
                                     self.ui.warn)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   873
                self.invalidate()
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   874
                return True
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   875
            else:
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   876
                self.ui.warn(_("no interrupted transaction available\n"))
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   877
                return False
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   878
        finally:
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
   879
            lock.release()
210
d2badbd7d1ad hg undo: fixup working dir state
mpm@selenic.com
parents: 207
diff changeset
   880
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   881
    def rollback(self, dryrun=False, force=False):
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
   882
        wlock = lock = None
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   883
        try:
1712
21dcf38e5d7d Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents: 1709
diff changeset
   884
            wlock = self.wlock()
4438
3900f684a150 Fix hg import --exact bug that hangs hg on failure.
Eric Hopper <hopper@omnifarious.org>
parents: 4417
diff changeset
   885
            lock = self.lock()
18947
9b82f93e3a7a localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18946
diff changeset
   886
            if self.svfs.exists("undo"):
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   887
                return self._rollback(dryrun, force)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   888
            else:
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   889
                self.ui.warn(_("no rollback information available\n"))
11177
6a64813276ed commands: initial audit of exit codes
Matt Mackall <mpm@selenic.com>
parents: 11174
diff changeset
   890
                return 1
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   891
        finally:
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
   892
            release(lock, wlock)
162
5dcbe4d9a30c Implement recover and undo commands
mpm@selenic.com
parents: 161
diff changeset
   893
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
   894
    @unfilteredmethod # Until we get smarter cache management
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   895
    def _rollback(self, dryrun, force):
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   896
        ui = self.ui
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   897
        try:
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   898
            args = self.opener.read('undo.desc').splitlines()
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   899
            (oldlen, desc, detail) = (int(args[0]), args[1], None)
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   900
            if len(args) >= 3:
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   901
                detail = args[2]
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   902
            oldtip = oldlen - 1
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   903
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   904
            if detail and ui.verbose:
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   905
                msg = (_('repository tip rolled back to revision %s'
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   906
                         ' (undo %s: %s)\n')
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   907
                       % (oldtip, desc, detail))
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   908
            else:
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   909
                msg = (_('repository tip rolled back to revision %s'
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   910
                         ' (undo %s)\n')
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   911
                       % (oldtip, desc))
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   912
        except IOError:
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   913
            msg = _('rolling back unknown transaction\n')
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   914
            desc = None
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   915
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   916
        if not force and self['.'] != self['tip'] and desc == 'commit':
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   917
            raise util.Abort(
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   918
                _('rollback of last commit while not checked out '
15187
0292f88d3b86 rollback: use a hint for force
Matt Mackall <mpm@selenic.com>
parents: 15183
diff changeset
   919
                  'may lose data'), hint=_('use -f to force'))
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   920
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   921
        ui.status(msg)
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   922
        if dryrun:
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   923
            return 0
15131
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   924
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   925
        parents = self.dirstate.parents()
18310
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
   926
        self.destroying()
20087
cf3b8285af00 transaction: take journal file path relative to vfs to use file API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20082
diff changeset
   927
        transaction.rollback(self.sopener, 'undo', ui.warn)
18947
9b82f93e3a7a localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18946
diff changeset
   928
        if self.vfs.exists('undo.bookmarks'):
18948
2f05fa162316 localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18947
diff changeset
   929
            self.vfs.rename('undo.bookmarks', 'bookmarks')
18947
9b82f93e3a7a localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18946
diff changeset
   930
        if self.svfs.exists('undo.phaseroots'):
18948
2f05fa162316 localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18947
diff changeset
   931
            self.svfs.rename('undo.phaseroots', 'phaseroots')
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   932
        self.invalidate()
15131
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   933
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   934
        parentgone = (parents[0] not in self.changelog.nodemap or
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   935
                      parents[1] not in self.changelog.nodemap)
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   936
        if parentgone:
18948
2f05fa162316 localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18947
diff changeset
   937
            self.vfs.rename('undo.dirstate', 'dirstate')
15131
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   938
            try:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   939
                branch = self.opener.read('undo.branch')
17360
935831597e16 rollback: write dirstate branch with correct encoding
Sune Foldager <cryo@cyanite.org>
parents: 17324
diff changeset
   940
                self.dirstate.setbranch(encoding.tolocal(branch))
15131
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   941
            except IOError:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   942
                ui.warn(_('named branch could not be reset: '
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   943
                          'current branch is still \'%s\'\n')
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   944
                        % self.dirstate.branch())
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   945
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   946
            self.dirstate.invalidate()
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   947
            parents = tuple([p.rev() for p in self.parents()])
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   948
            if len(parents) > 1:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   949
                ui.status(_('working directory now based on '
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   950
                            'revisions %d and %d\n') % parents)
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   951
            else:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   952
                ui.status(_('working directory now based on '
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   953
                            'revision %d\n') % parents)
17013
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
   954
        # TODO: if we know which new heads may result from this rollback, pass
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
   955
        # them to destroy(), which will prevent the branchhead cache from being
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
   956
        # invalidated.
15604
b8d8599410da rollback: always call destroyed() (regression from 1.9)
Greg Ward <greg-hg@gerg.ca>
parents: 15381
diff changeset
   957
        self.destroyed()
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   958
        return 0
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   959
10547
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
   960
    def invalidatecaches(self):
15988
827e0126738d localrepo: delete _phaserev when invalidating caches
Idan Kamara <idankk86@gmail.com>
parents: 15987
diff changeset
   961
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   962
        if '_tagscache' in vars(self):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   963
            # can't use delattr on proxy
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   964
            del self.__dict__['_tagscache']
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   965
18189
b9026ba002f6 branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18186
diff changeset
   966
        self.unfiltered()._branchcaches.clear()
18105
312262ebc223 cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18101
diff changeset
   967
        self.invalidatevolatilesets()
312262ebc223 cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18101
diff changeset
   968
312262ebc223 cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18101
diff changeset
   969
    def invalidatevolatilesets(self):
312262ebc223 cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18101
diff changeset
   970
        self.filteredrevcache.clear()
17469
fb72eec7efd8 obsolete: introduce caches for all meaningful sets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17434
diff changeset
   971
        obsolete.clearobscaches(self)
1784
2e0a288ca93e revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1782
diff changeset
   972
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   973
    def invalidatedirstate(self):
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   974
        '''Invalidates the dirstate, causing the next call to dirstate
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   975
        to check if it was modified since the last time it was read,
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   976
        rereading it if it has.
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   977
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   978
        This is different to dirstate.invalidate() that it doesn't always
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   979
        rereads the dirstate. Use dirstate.invalidate() if you want to
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   980
        explicitly read the dirstate again (i.e. restoring it to a previous
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   981
        known good state).'''
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   982
        if hasunfilteredcache(self, 'dirstate'):
16200
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
   983
            for k in self.dirstate._filecache:
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
   984
                try:
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
   985
                    delattr(self.dirstate, k)
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
   986
                except AttributeError:
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
   987
                    pass
17997
6089956e9880 clfilter: ensure cache invalidation is done on the main unfiltered repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17996
diff changeset
   988
            delattr(self.unfiltered(), 'dirstate')
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   989
10547
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
   990
    def invalidate(self):
18644
3e92772d5383 spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents: 18520
diff changeset
   991
        unfiltered = self.unfiltered() # all file caches are stored unfiltered
14935
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
   992
        for k in self._filecache:
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
   993
            # dirstate is invalidated separately in invalidatedirstate()
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
   994
            if k == 'dirstate':
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
   995
                continue
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
   996
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
   997
            try:
17997
6089956e9880 clfilter: ensure cache invalidation is done on the main unfiltered repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17996
diff changeset
   998
                delattr(unfiltered, k)
14935
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
   999
            except AttributeError:
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1000
                pass
10547
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
  1001
        self.invalidatecaches()
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
  1002
20091
abfe6a8e619b lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20088
diff changeset
  1003
    def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc):
161
0b4c5cb953d9 Simply repository locking
mpm@selenic.com
parents: 155
diff changeset
  1004
        try:
20091
abfe6a8e619b lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20088
diff changeset
  1005
            l = lockmod.lock(vfs, lockname, 0, releasefn, desc=desc)
7640
7197812e8d44 error: move lock errors
Matt Mackall <mpm@selenic.com>
parents: 7637
diff changeset
  1006
        except error.LockHeld, inst:
1531
2ba8bf7defda add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1516
diff changeset
  1007
            if not wait:
2016
ff5c9a92f556 fix backtrace printed when cannot get lock.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1998
diff changeset
  1008
                raise
3688
d92dad355000 Corrected "waiting for lock on repository FOO held by BAR" message.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3687
diff changeset
  1009
            self.ui.warn(_("waiting for lock on %s held by %r\n") %
d92dad355000 Corrected "waiting for lock on repository FOO held by BAR" message.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3687
diff changeset
  1010
                         (desc, inst.locker))
2016
ff5c9a92f556 fix backtrace printed when cannot get lock.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1998
diff changeset
  1011
            # default to 600 seconds timeout
20091
abfe6a8e619b lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20088
diff changeset
  1012
            l = lockmod.lock(vfs, lockname,
20088
7cbb79bddee7 localrepo: import "lock" module as "lockmod" for readability
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20087
diff changeset
  1013
                             int(self.ui.config("ui", "timeout", "600")),
7cbb79bddee7 localrepo: import "lock" module as "lockmod" for readability
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20087
diff changeset
  1014
                             releasefn, desc=desc)
1751
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1015
        if acquirefn:
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1016
            acquirefn()
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1017
        return l
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1018
15587
809d5d30e377 localrepo: rename _postrelease to _afterlock
Matt Mackall <mpm@selenic.com>
parents: 15586
diff changeset
  1019
    def _afterlock(self, callback):
15583
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1020
        """add a callback to the current repository lock.
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1021
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1022
        The callback will be executed on lock release."""
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1023
        l = self._lockref and self._lockref()
15588
632f4be4d1f3 localrepo: remove asserts in _afterlock
Matt Mackall <mpm@selenic.com>
parents: 15587
diff changeset
  1024
        if l:
15589
cc24e4ed3e0c lock: change name of release chain
Matt Mackall <mpm@selenic.com>
parents: 15588
diff changeset
  1025
            l.postrelease.append(callback)
16680
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1026
        else:
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1027
            callback()
15583
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1028
4914
9a2a73ea6135 repo locks: use True/False
Matt Mackall <mpm@selenic.com>
parents: 4913
diff changeset
  1029
    def lock(self, wait=True):
9309
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1030
        '''Lock the repository store (.hg/store) and return a weak reference
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1031
        to the lock. Use this before modifying the store (e.g. committing or
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1032
        stripping). If you are opening a transaction, get a lock as well.)'''
8108
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1033
        l = self._lockref and self._lockref()
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1034
        if l is not None and l.held:
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1035
            l.lock()
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1036
            return l
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1037
14931
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1038
        def unlock():
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1039
            self.store.write()
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
  1040
            if hasunfilteredcache(self, '_phasecache'):
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
  1041
                self._phasecache.write()
14931
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1042
            for k, ce in self._filecache.items():
18309
cfeab932cff7 localrepo: don't refresh filecache entries that aren't in __dict__
Idan Kamara <idankk86@gmail.com>
parents: 18305
diff changeset
  1043
                if k == 'dirstate' or k not in self.__dict__:
14931
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1044
                    continue
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1045
                ce.refresh()
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1046
20091
abfe6a8e619b lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20088
diff changeset
  1047
        l = self._lock(self.svfs, "lock", wait, unlock,
13391
d00bbff8600e fncachestore: defer updating the fncache file to a single file open
Adrian Buehlmann <adrian@cadifra.com>
parents: 13390
diff changeset
  1048
                       self.invalidate, _('repository %s') % self.origroot)
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1049
        self._lockref = weakref.ref(l)
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1050
        return l
1751
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1051
4914
9a2a73ea6135 repo locks: use True/False
Matt Mackall <mpm@selenic.com>
parents: 4913
diff changeset
  1052
    def wlock(self, wait=True):
9309
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1053
        '''Lock the non-store parts of the repository (everything under
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1054
        .hg except .hg/store) and return a weak reference to the lock.
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1055
        Use this before modifying files in .hg.'''
8108
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1056
        l = self._wlockref and self._wlockref()
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1057
        if l is not None and l.held:
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1058
            l.lock()
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1059
            return l
1531
2ba8bf7defda add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1516
diff changeset
  1060
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1061
        def unlock():
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1062
            self.dirstate.write()
18318
948f495fb230 localrepo: drop unnecessary check on wlock unlock
Idan Kamara <idankk86@gmail.com>
parents: 18314
diff changeset
  1063
            self._filecache['dirstate'].refresh()
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1064
20091
abfe6a8e619b lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20088
diff changeset
  1065
        l = self._lock(self.vfs, "wlock", wait, unlock,
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1066
                       self.invalidatedirstate, _('working directory of %s') %
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1067
                       self.origroot)
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1068
        self._wlockref = weakref.ref(l)
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1069
        return l
1531
2ba8bf7defda add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1516
diff changeset
  1070
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1071
    def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
3292
764688cf51e5 merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents: 3241
diff changeset
  1072
        """
3294
a2d93b186a0e commit: unify file-level commit code
Matt Mackall <mpm@selenic.com>
parents: 3293
diff changeset
  1073
        commit an individual file as part of a larger transaction
a2d93b186a0e commit: unify file-level commit code
Matt Mackall <mpm@selenic.com>
parents: 3293
diff changeset
  1074
        """
3292
764688cf51e5 merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents: 3241
diff changeset
  1075
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1076
        fname = fctx.path()
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1077
        text = fctx.data()
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1078
        flog = self.file(fname)
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1079
        fparent1 = manifest1.get(fname, nullid)
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1080
        fparent2 = fparent2o = manifest2.get(fname, nullid)
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1081
3292
764688cf51e5 merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents: 3241
diff changeset
  1082
        meta = {}
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1083
        copy = fctx.renamed()
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1084
        if copy and copy[0] != fname:
4058
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1085
            # Mark the new revision of this file as a copy of another
4516
96d8a56d4ef9 Removed trailing whitespace and tabs from python files
Thomas Arendsen Hein <thomas@intevation.de>
parents: 4510
diff changeset
  1086
            # file.  This copy data will effectively act as a parent
96d8a56d4ef9 Removed trailing whitespace and tabs from python files
Thomas Arendsen Hein <thomas@intevation.de>
parents: 4510
diff changeset
  1087
            # of this new revision.  If this is a merge, the first
4058
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1088
            # parent will be the nullid (meaning "look up the copy data")
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1089
            # and the second one will be the other parent.  For example:
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1090
            #
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1091
            # 0 --- 1 --- 3   rev1 changes file foo
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1092
            #   \       /     rev2 renames foo to bar and changes it
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1093
            #    \- 2 -/      rev3 should have bar with all changes and
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1094
            #                      should record that bar descends from
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1095
            #                      bar in rev2 and foo in rev1
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1096
            #
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1097
            # this allows this merge to succeed:
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1098
            #
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1099
            # 0 --- 1 --- 3   rev4 reverts the content change from rev2
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1100
            #   \       /     merging rev3 and rev4 should use bar@rev2
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1101
            #    \- 2 --- 4        as the merge base
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1102
            #
6874
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1103
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1104
            cfname = copy[0]
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1105
            crev = manifest1.get(cfname)
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1106
            newfparent = fparent2
6874
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1107
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1108
            if manifest2: # branch merge
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1109
                if fparent2 == nullid or crev is None: # copied on remote side
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1110
                    if cfname in manifest2:
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1111
                        crev = manifest2[cfname]
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1112
                        newfparent = fparent1
6874
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1113
6875
0d714a48ab53 add a fix for issue 1175
Matt Mackall <mpm@selenic.com>
parents: 6874
diff changeset
  1114
            # find source in nearest ancestor if we've lost track
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1115
            if not crev:
9467
4c041f1ee1b4 do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents: 9437
diff changeset
  1116
                self.ui.debug(" %s: searching for copy revision for %s\n" %
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1117
                              (fname, cfname))
13000
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1118
                for ancestor in self[None].ancestors():
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1119
                    if cfname in ancestor:
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1120
                        crev = ancestor[cfname].filenode()
6876
077f1e637cd8 Merge with stable
Matt Mackall <mpm@selenic.com>
parents: 6875 6840
diff changeset
  1121
                        break
6875
0d714a48ab53 add a fix for issue 1175
Matt Mackall <mpm@selenic.com>
parents: 6874
diff changeset
  1122
13000
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1123
            if crev:
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1124
                self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(crev)))
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1125
                meta["copy"] = cfname
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1126
                meta["copyrev"] = hex(crev)
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1127
                fparent1, fparent2 = nullid, newfparent
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1128
            else:
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1129
                self.ui.warn(_("warning: can't find ancestor for '%s' "
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1130
                               "copied from '%s'!\n") % (fname, cfname))
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1131
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1132
        elif fparent2 != nullid:
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1133
            # is one parent an ancestor of the other?
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1134
            fparentancestor = flog.ancestor(fparent1, fparent2)
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1135
            if fparentancestor == fparent1:
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1136
                fparent1, fparent2 = fparent2, nullid
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1137
            elif fparentancestor == fparent2:
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1138
                fparent2 = nullid
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1139
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1140
        # is the file changed?
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1141
        if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1142
            changelist.append(fname)
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1143
            return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1144
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1145
        # are just the flags changed during merge?
10320
808c187fc556 localrepo: minor formatting - remove double space
Henri Wiechers <hwiechers@gmail.com>
parents: 10282
diff changeset
  1146
        if fparent1 != fparent2o and manifest1.flags(fname) != fctx.flags():
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1147
            changelist.append(fname)
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1148
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1149
        return fparent1
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1150
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  1151
    @unfilteredmethod
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1152
    def commit(self, text="", user=None, date=None, match=None, force=False,
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1153
               editor=False, extra={}):
8515
865e08a7d6b0 localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 8503
diff changeset
  1154
        """Add a new revision to current repository.
865e08a7d6b0 localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 8503
diff changeset
  1155
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1156
        Revision information is gathered from the working directory,
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1157
        match can be used to filter the committed files. If editor is
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1158
        supplied, it is called to get a commit message.
8515
865e08a7d6b0 localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 8503
diff changeset
  1159
        """
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1160
8715
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1161
        def fail(f, msg):
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1162
            raise util.Abort('%s: %s' % (f, msg))
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1163
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1164
        if not match:
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
  1165
            match = matchmod.always(self.root, '')
8715
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1166
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1167
        if not force:
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1168
            vdirs = []
19138
e579687cb5d8 localrepo.commit: hook into match.explicitdir
Siddharth Agarwal <sid0@fb.com>
parents: 19097
diff changeset
  1169
            match.explicitdir = vdirs.append
8715
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1170
            match.bad = fail
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1171
8405
7cbf8fcd2453 commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents: 8404
diff changeset
  1172
        wlock = self.wlock()
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1173
        try:
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1174
            wctx = self[None]
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1175
            merge = len(wctx.parents()) > 1
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
  1176
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1177
            if (not force and merge and match and
8501
ab0e3f7ea315 commit: some tidying
Matt Mackall <mpm@selenic.com>
parents: 8500
diff changeset
  1178
                (match.files() or match.anypats())):
8397
613ac2856535 remove deprecated rawcommit
Matt Mackall <mpm@selenic.com>
parents: 8395
diff changeset
  1179
                raise util.Abort(_('cannot partially commit a merge '
613ac2856535 remove deprecated rawcommit
Matt Mackall <mpm@selenic.com>
parents: 8395
diff changeset
  1180
                                   '(do not specify files or patterns)'))
6706
716a1296e182 localrepo: replace dirstate by workingfilectx in filecommit()
Patrick Mezard <pmezard@gmail.com>
parents: 6705
diff changeset
  1181
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1182
            changes = self.status(match=match, clean=force)
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1183
            if force:
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1184
                changes[0].extend(changes[6]) # mq may commit unchanged files
3621
7d3d603e7df9 localrepo: factor commit and rawcommit
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3620
diff changeset
  1185
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1186
            # check subrepos
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1187
            subs = []
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1188
            commitsubs = set()
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1189
            newstate = wctx.substate.copy()
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1190
            # only manage subrepos and .hgsubstate if .hgsub is present
14536
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1191
            if '.hgsub' in wctx:
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1192
                # we'll decide whether to track this ourselves, thanks
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1193
                if '.hgsubstate' in changes[0]:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1194
                    changes[0].remove('.hgsubstate')
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1195
                if '.hgsubstate' in changes[2]:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1196
                    changes[2].remove('.hgsubstate')
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1197
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1198
                # compare current state to last committed state
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1199
                # build new substate based on last committed state
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1200
                oldstate = wctx.p1().substate
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1201
                for s in sorted(newstate.keys()):
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1202
                    if not match(s):
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1203
                        # ignore working copy, use old state if present
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1204
                        if s in oldstate:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1205
                            newstate[s] = oldstate[s]
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1206
                            continue
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1207
                        if not force:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1208
                            raise util.Abort(
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1209
                                _("commit with new subrepo %s excluded") % s)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1210
                    if wctx.sub(s).dirty(True):
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1211
                        if not self.ui.configbool('ui', 'commitsubrepos'):
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1212
                            raise util.Abort(
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1213
                                _("uncommitted changes in subrepo %s") % s,
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1214
                                hint=_("use --subrepos for recursive commit"))
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1215
                        subs.append(s)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1216
                        commitsubs.add(s)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1217
                    else:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1218
                        bs = wctx.sub(s).basestate()
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1219
                        newstate[s] = (newstate[s][0], bs, newstate[s][2])
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1220
                        if oldstate.get(s, (None, None, None))[1] != bs:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1221
                            subs.append(s)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1222
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1223
                # check for removed subrepos
14536
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1224
                for p in wctx.parents():
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1225
                    r = [s for s in p.substate if s not in newstate]
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1226
                    subs += [s for s in r if match(s)]
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1227
                if subs:
14536
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1228
                    if (not match('.hgsub') and
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1229
                        '.hgsub' in (wctx.modified() + wctx.added())):
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1230
                        raise util.Abort(
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1231
                            _("can't commit subrepos without .hgsub"))
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1232
                    changes[0].insert(0, '.hgsubstate')
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1233
14536
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1234
            elif '.hgsub' in changes[2]:
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1235
                # clean up .hgsubstate when .hgsub is removed
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1236
                if ('.hgsubstate' in wctx and
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1237
                    '.hgsubstate' not in changes[0] + changes[1] + changes[2]):
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1238
                    changes[2].insert(0, '.hgsubstate')
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1239
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1240
            # make sure all explicit patterns are matched
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1241
            if not force and match.files():
8710
bcb6e5bebd93 commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents: 8709
diff changeset
  1242
                matched = set(changes[0] + changes[1] + changes[2])
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1243
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1244
                for f in match.files():
17378
b05e517c2236 commit: normalize filenames when checking explicit files (issue3576)
Matt Mackall <mpm@selenic.com>
parents: 17360
diff changeset
  1245
                    f = self.dirstate.normalize(f)
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1246
                    if f == '.' or f in matched or f in wctx.substate:
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1247
                        continue
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1248
                    if f in changes[3]: # missing
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1249
                        fail(f, _('file not found!'))
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1250
                    if f in vdirs: # visited directory
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1251
                        d = f + '/'
8710
bcb6e5bebd93 commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents: 8709
diff changeset
  1252
                        for mf in matched:
bcb6e5bebd93 commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents: 8709
diff changeset
  1253
                            if mf.startswith(d):
bcb6e5bebd93 commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents: 8709
diff changeset
  1254
                                break
bcb6e5bebd93 commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents: 8709
diff changeset
  1255
                        else:
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1256
                            fail(f, _("no match under directory!"))
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1257
                    elif f not in self.dirstate:
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1258
                        fail(f, _("file not tracked!"))
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1259
18659
b946470efed9 localrepo: create context used for actual commit earlier
David Schleimer <dschleimer@fb.com>
parents: 18644
diff changeset
  1260
            cctx = context.workingctx(self, text, user, date, extra, changes)
b946470efed9 localrepo: create context used for actual commit earlier
David Schleimer <dschleimer@fb.com>
parents: 18644
diff changeset
  1261
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1262
            if (not force and not extra.get("close") and not merge
18660
7e6946ed5756 localrepo: use workingctx for validation in commit
David Schleimer <dschleimer@fb.com>
parents: 18659
diff changeset
  1263
                and not cctx.files()
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1264
                and wctx.branch() == wctx.p1().branch()):
8404
a2bc39ade36b commit: move 'nothing changed' test into commit()
Matt Mackall <mpm@selenic.com>
parents: 8403
diff changeset
  1265
                return None
a2bc39ade36b commit: move 'nothing changed' test into commit()
Matt Mackall <mpm@selenic.com>
parents: 8403
diff changeset
  1266
18660
7e6946ed5756 localrepo: use workingctx for validation in commit
David Schleimer <dschleimer@fb.com>
parents: 18659
diff changeset
  1267
            if merge and cctx.deleted():
16536
63c817ea4a70 commit: abort on merge with missing files
Patrick Mezard <patrick@mezard.eu>
parents: 16456
diff changeset
  1268
                raise util.Abort(_("cannot commit merge with missing files"))
63c817ea4a70 commit: abort on merge with missing files
Patrick Mezard <patrick@mezard.eu>
parents: 16456
diff changeset
  1269
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
  1270
            ms = mergemod.mergestate(self)
6888
7c36a4fb05a3 make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents: 6884
diff changeset
  1271
            for f in changes[0]:
7c36a4fb05a3 make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents: 6884
diff changeset
  1272
                if f in ms and ms[f] == 'u':
7c36a4fb05a3 make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents: 6884
diff changeset
  1273
                    raise util.Abort(_("unresolved merge conflicts "
13541
919174c0aaff Improve unresolved merge conflicts warning (issue2681)
Patrick Mezard <pmezard@gmail.com>
parents: 13526
diff changeset
  1274
                                       "(see hg help resolve)"))
8496
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1275
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1276
            if editor:
8994
4a1187d3cb00 commit: report modified subrepos in commit editor
Matt Mackall <mpm@selenic.com>
parents: 8954
diff changeset
  1277
                cctx._text = editor(self, cctx, subs)
9935
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1278
            edited = (text != cctx._text)
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1279
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1280
            # commit subs and write new state
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1281
            if subs:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1282
                for s in sorted(commitsubs):
11112
4a9bee613737 subrepo: print paths relative to upper repo root for push/pull/commit
Edouard Gomez <ed.gomez@free.fr>
parents: 11063
diff changeset
  1283
                    sub = wctx.sub(s)
4a9bee613737 subrepo: print paths relative to upper repo root for push/pull/commit
Edouard Gomez <ed.gomez@free.fr>
parents: 11063
diff changeset
  1284
                    self.ui.status(_('committing subrepository %s\n') %
12752
18b5b6392fcf subrepo: rename relpath to subrelpath and introduce reporelpath
Mads Kiilerich <mads@kiilerich.com>
parents: 12708
diff changeset
  1285
                        subrepo.subrelpath(sub))
11112
4a9bee613737 subrepo: print paths relative to upper repo root for push/pull/commit
Edouard Gomez <ed.gomez@free.fr>
parents: 11063
diff changeset
  1286
                    sr = sub.commit(cctx._text, user, date)
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1287
                    newstate[s] = (newstate[s][0], sr)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1288
                subrepo.writestate(self, newstate)
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1289
9934
720f70b720d3 commit: save commit message so it's not destroyed by rollback.
Greg Ward <greg-hg@gerg.ca>
parents: 9924
diff changeset
  1290
            # Save commit message in case this transaction gets rolled back
9949
bc3f762af82e commit: write last-message.txt with no content modifications.
Greg Ward <greg-hg@gerg.ca>
parents: 9935
diff changeset
  1291
            # (e.g. by a pretxncommit hook).  Leave the content alone on
bc3f762af82e commit: write last-message.txt with no content modifications.
Greg Ward <greg-hg@gerg.ca>
parents: 9935
diff changeset
  1292
            # the assumption that the user will use the same editor again.
14529
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  1293
            msgfn = self.savecommitmessage(cctx._text)
9934
720f70b720d3 commit: save commit message so it's not destroyed by rollback.
Greg Ward <greg-hg@gerg.ca>
parents: 9924
diff changeset
  1294
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1295
            p1, p2 = self.dirstate.parents()
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1296
            hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
9935
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1297
            try:
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1298
                self.hook("precommit", throw=True, parent1=hookp1,
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1299
                          parent2=hookp2)
9935
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1300
                ret = self.commitctx(cctx, True)
16705
c2d9ef43ff6c check-code: ignore naked excepts with a "re-raise" comment
Brodie Rao <brodie@sf.io>
parents: 16699
diff changeset
  1301
            except: # re-raises
9935
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1302
                if edited:
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1303
                    self.ui.write(
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1304
                        _('note: commit message saved in %s\n') % msgfn)
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1305
                raise
8496
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1306
13357
b67867940bd1 bookmarks: move commit action into core
Matt Mackall <mpm@selenic.com>
parents: 13356
diff changeset
  1307
            # update bookmarks, dirstate and mergestate
16706
a270ec977ba6 bookmarks: delete divergent bookmarks on merge
David Soria Parra <dsp@php.net>
parents: 16705
diff changeset
  1308
            bookmarks.update(self, [p1, p2], ret)
18661
4fb92f14a97a commit: factor out post-commit cleanup into workingctx
David Schleimer <dschleimer@fb.com>
parents: 18660
diff changeset
  1309
            cctx.markcommitted(ret)
8503
90f86a5330bb commit: tidy up mergestate slightly
Matt Mackall <mpm@selenic.com>
parents: 8502
diff changeset
  1310
            ms.reset()
6710
0aa91f69a4c4 localrepo: extract _commitctx() from commit()
Patrick Mezard <pmezard@gmail.com>
parents: 6709
diff changeset
  1311
        finally:
8405
7cbf8fcd2453 commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents: 8404
diff changeset
  1312
            wlock.release()
6710
0aa91f69a4c4 localrepo: extract _commitctx() from commit()
Patrick Mezard <pmezard@gmail.com>
parents: 6709
diff changeset
  1313
16680
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1314
        def commithook(node=hex(ret), parent1=hookp1, parent2=hookp2):
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1315
            self.hook("commit", node=node, parent1=parent1, parent2=parent2)
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1316
        self._afterlock(commithook)
10492
0e64d814d7d0 run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents: 10435
diff changeset
  1317
        return ret
0e64d814d7d0 run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents: 10435
diff changeset
  1318
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  1319
    @unfilteredmethod
8496
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1320
    def commitctx(self, ctx, error=False):
7077
ccbd39cad3c3 context: improve memctx documentation
Patrick Mezard <pmezard@gmail.com>
parents: 7072
diff changeset
  1321
        """Add a new revision to current repository.
8410
1d11d985c179 commit: combine _commitctx and commitctx, drop unused force argument
Matt Mackall <mpm@selenic.com>
parents: 8407
diff changeset
  1322
        Revision information is passed via the context argument.
7077
ccbd39cad3c3 context: improve memctx documentation
Patrick Mezard <pmezard@gmail.com>
parents: 7072
diff changeset
  1323
        """
6715
a3c41abfa828 context: add memctx for memory commits
Patrick Mezard <pmezard@gmail.com>
parents: 6712
diff changeset
  1324
8412
2bf4f380f6ab commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents: 8411
diff changeset
  1325
        tr = lock = None
12899
fabe61418a53 localrepo: do not modify ctx.remove() list in-place
Patrick Mezard <pmezard@gmail.com>
parents: 12847
diff changeset
  1326
        removed = list(ctx.removed())
8414
2348ce25849b commitctx: use contexts more fully
Matt Mackall <mpm@selenic.com>
parents: 8412
diff changeset
  1327
        p1, p2 = ctx.p1(), ctx.p2()
8412
2bf4f380f6ab commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents: 8411
diff changeset
  1328
        user = ctx.user()
990
5007e0bdeed2 Fix long-standing excessive file merges
mpm@selenic.com
parents: 981
diff changeset
  1329
8411
4d5916358abd commit: move lots of commitctx outside of the repo lock
Matt Mackall <mpm@selenic.com>
parents: 8410
diff changeset
  1330
        lock = self.lock()
4d5916358abd commit: move lots of commitctx outside of the repo lock
Matt Mackall <mpm@selenic.com>
parents: 8410
diff changeset
  1331
        try:
10881
a685011ed38e localrepo: add desc parameter to transaction
Steve Borho <steve@borho.org>
parents: 10877
diff changeset
  1332
            tr = self.transaction("commit")
4970
30d4d8985dd8 transactions: avoid late tear-down (issue641)
Matt Mackall <mpm@selenic.com>
parents: 4917
diff changeset
  1333
            trp = weakref.proxy(tr)
151
1f6c61a60586 Bail on attempts to do an empty commit
mpm@selenic.com
parents: 149
diff changeset
  1334
14162
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1335
            if ctx.files():
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1336
                m1 = p1.manifest().copy()
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1337
                m2 = p2.manifest()
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1338
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1339
                # check in files
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1340
                new = {}
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1341
                changed = []
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1342
                linkrev = len(self)
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1343
                for f in sorted(ctx.modified() + ctx.added()):
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1344
                    self.ui.note(f + "\n")
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1345
                    try:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1346
                        fctx = ctx[f]
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1347
                        new[f] = self._filecommit(fctx, m1, m2, linkrev, trp,
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1348
                                                  changed)
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1349
                        m1.set(f, fctx.flags())
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1350
                    except OSError, inst:
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1351
                        self.ui.warn(_("trouble committing %s!\n") % f)
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1352
                        raise
14162
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1353
                    except IOError, inst:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1354
                        errcode = getattr(inst, 'errno', errno.ENOENT)
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1355
                        if error or errcode and errcode != errno.ENOENT:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1356
                            self.ui.warn(_("trouble committing %s!\n") % f)
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1357
                            raise
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1358
                        else:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1359
                            removed.append(f)
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
  1360
14162
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1361
                # update manifest
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1362
                m1.update(new)
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1363
                removed = [f for f in sorted(removed) if f in m1 or f in m2]
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1364
                drop = [f for f in removed if f in m1]
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1365
                for f in drop:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1366
                    del m1[f]
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1367
                mn = self.manifest.add(m1, trp, linkrev, p1.manifestnode(),
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1368
                                       p2.manifestnode(), (new, drop))
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1369
                files = changed + removed
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1370
            else:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1371
                mn = p1.manifestnode()
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1372
                files = []
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
  1373
8499
fb9b83df45f3 commit: move description trimming into changelog
Matt Mackall <mpm@selenic.com>
parents: 8498
diff changeset
  1374
            # update changelog
7787
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  1375
            self.changelog.delayupdate()
14162
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1376
            n = self.changelog.add(mn, files, ctx.description(),
8499
fb9b83df45f3 commit: move description trimming into changelog
Matt Mackall <mpm@selenic.com>
parents: 8498
diff changeset
  1377
                                   trp, p1.node(), p2.node(),
8412
2bf4f380f6ab commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents: 8411
diff changeset
  1378
                                   user, ctx.date(), ctx.extra().copy())
7787
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  1379
            p = lambda: self.changelog.writepending() and self.root or ""
10492
0e64d814d7d0 run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents: 10435
diff changeset
  1380
            xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1381
            self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
7787
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  1382
                      parent2=xp2, pending=p)
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  1383
            self.changelog.finalize(trp)
15706
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1384
            # set the new commit is proper phase
16030
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16023
diff changeset
  1385
            targetphase = phases.newcommitphase(self.ui)
15706
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1386
            if targetphase:
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1387
                # retract boundary do not alter parent changeset.
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1388
                # if a parent have higher the resulting phase will
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1389
                # be compliant anyway
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1390
                #
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1391
                # if minimal phase was 0 we don't need to retract anything
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1392
                phases.retractboundary(self, targetphase, [n])
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1393
            tr.close()
18394
5010448197bc branchmap: update cache of 'unserved' filter on new changesets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18382
diff changeset
  1394
            branchmap.updatecache(self.filtered('served'))
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1395
            return n
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1396
        finally:
11230
5116a077c3da make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 11228
diff changeset
  1397
            if tr:
5116a077c3da make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 11228
diff changeset
  1398
                tr.release()
8405
7cbf8fcd2453 commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents: 8404
diff changeset
  1399
            lock.release()
660
2c83350784c3 Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents: 659
diff changeset
  1400
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  1401
    @unfilteredmethod
18310
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1402
    def destroying(self):
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1403
        '''Inform the repository that nodes are about to be destroyed.
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1404
        Intended for use by strip and rollback, so there's a common
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1405
        place for anything that has to be done before destroying history.
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1406
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1407
        This is mostly useful for saving state that is in memory and waiting
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1408
        to be flushed when the current lock is released. Because a call to
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1409
        destroyed is imminent, the repo will be invalidated causing those
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1410
        changes to stay in memory (waiting for the next unlock), or vanish
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1411
        completely.
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1412
        '''
18312
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1413
        # When using the same lock to commit and strip, the phasecache is left
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1414
        # dirty after committing. Then when we strip, the repo is invalidated,
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1415
        # causing those changes to disappear.
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1416
        if '_phasecache' in vars(self):
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1417
            self._phasecache.write()
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1418
18310
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1419
    @unfilteredmethod
18395
904b7109938e destroyed: drop complex branchcache rebuilt logic
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18394
diff changeset
  1420
    def destroyed(self):
9150
09a1ee498756 localrepo: add destroyed() method for strip/rollback to use (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9149
diff changeset
  1421
        '''Inform the repository that nodes have been destroyed.
09a1ee498756 localrepo: add destroyed() method for strip/rollback to use (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9149
diff changeset
  1422
        Intended for use by strip and rollback, so there's a common
17013
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1423
        place for anything that has to be done after destroying history.
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1424
        '''
18221
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1425
        # When one tries to:
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1426
        # 1) destroy nodes thus calling this method (e.g. strip)
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1427
        # 2) use phasecache somewhere (e.g. commit)
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1428
        #
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1429
        # then 2) will fail because the phasecache contains nodes that were
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1430
        # removed. We can either remove phasecache from the filecache,
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1431
        # causing it to reload next time it is accessed, or simply filter
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1432
        # the removed nodes now and write the updated cache.
18757
1c8e0d6ac3b0 localrepo: always write the filtered phasecache when nodes are destroyed (issue3827)
Idan Kamara <idankk86@gmail.com>
parents: 18739
diff changeset
  1433
        self._phasecache.filterunknown(self)
1c8e0d6ac3b0 localrepo: always write the filtered phasecache when nodes are destroyed (issue3827)
Idan Kamara <idankk86@gmail.com>
parents: 18739
diff changeset
  1434
        self._phasecache.write()
18221
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1435
18396
dd3fd3353e23 destroyed: update `unserved` branchcache instead
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18395
diff changeset
  1436
        # update the 'served' branch cache to help read only server process
18644
3e92772d5383 spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents: 18520
diff changeset
  1437
        # Thanks to branchcache collaboration this is done from the nearest
18396
dd3fd3353e23 destroyed: update `unserved` branchcache instead
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18395
diff changeset
  1438
        # filtered subset and it is expected to be fast.
dd3fd3353e23 destroyed: update `unserved` branchcache instead
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18395
diff changeset
  1439
        branchmap.updatecache(self.filtered('served'))
18223
6d6d0248530b destroyed: filter unknown before computing branchcache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18222
diff changeset
  1440
9151
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1441
        # Ensure the persistent tag cache is updated.  Doing it now
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1442
        # means that the tag cache only has to worry about destroyed
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1443
        # heads immediately after a strip/rollback.  That in turn
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1444
        # guarantees that "cachetip == currenttip" (comparing both rev
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1445
        # and node) always means no nodes have been added or destroyed.
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1446
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1447
        # XXX this is suboptimal when qrefresh'ing: we strip the current
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1448
        # head, refresh the tag cache, then immediately add a new head.
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1449
        # But I think doing it this way is necessary for the "instant
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1450
        # tag cache retrieval" case to work.
18313
3e4a944c0d04 destroyed: keep the filecache in sync with __dict__ (issue3335) (issue3693) (issue3743)
Idan Kamara <idankk86@gmail.com>
parents: 18312
diff changeset
  1451
        self.invalidate()
17324
9f94358f9f93 localrepo: clear the filecache on _rollback() and destroyed()
Idan Kamara <idankk86@gmail.com>
parents: 17306
diff changeset
  1452
6585
d3d1d39da2fa walk: remove cmdutil.walk
Matt Mackall <mpm@selenic.com>
parents: 6583
diff changeset
  1453
    def walk(self, match, node=None):
3532
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1454
        '''
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1455
        walk recursively through the directory tree or a given
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1456
        changeset, finding all files matched by the match
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1457
        function
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1458
        '''
6764
8db64464d136 context: add walk method
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
  1459
        return self[node].walk(match)
3532
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1460
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1461
    def status(self, node1='.', node2=None, match=None,
12166
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1462
               ignored=False, clean=False, unknown=False,
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1463
               listsubrepos=False):
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1464
        """return status of files between two nodes or node and working
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1465
        directory.
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1466
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1467
        If node1 is None, use the first dirstate parent instead.
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1468
        If node2 is None, compare node1 with working directory.
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1469
        """
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
  1470
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1471
        def mfmatches(ctx):
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1472
            mf = ctx.manifest().copy()
16645
9a21fc2c7d32 localrepo: optimize internode status calls using match.always
Jesse Glick <jesse.glick@oracle.com>
parents: 16628
diff changeset
  1473
            if match.always():
9a21fc2c7d32 localrepo: optimize internode status calls using match.always
Jesse Glick <jesse.glick@oracle.com>
parents: 16628
diff changeset
  1474
                return mf
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1475
            for fn in mf.keys():
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1476
                if not match(fn):
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1477
                    del mf[fn]
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1478
            return mf
741
156dc2f3be7f Fix some line wrapping
mpm@selenic.com
parents: 740
diff changeset
  1479
19569
00140039bd8f localrepo: remove unnecessary check of instance
Sean Farley <sean.michael.farley@gmail.com>
parents: 19515
diff changeset
  1480
        ctx1 = self[node1]
00140039bd8f localrepo: remove unnecessary check of instance
Sean Farley <sean.michael.farley@gmail.com>
parents: 19515
diff changeset
  1481
        ctx2 = self[node2]
7090
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1482
7435
5e13df32fb74 bundlerepo doesn't really have a dirstate, throw AttributeError if requested
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 7415
diff changeset
  1483
        working = ctx2.rev() is None
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1484
        parentworking = working and ctx1 == self['.']
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
  1485
        match = match or matchmod.always(self.root, self.getcwd())
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1486
        listignored, listclean, listunknown = ignored, clean, unknown
2474
1e32e2fe8a67 Fix cold cache diff performance
Chris Mason <mason@suse.com>
parents: 2463
diff changeset
  1487
7090
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1488
        # load earliest manifest first for caching reasons
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1489
        if not working and ctx2.rev() < ctx1.rev():
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1490
            ctx2.manifest()
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1491
7067
40d105a12cac status: don't warn about missing files present in base revision (issue1323)
Matt Mackall <mpm@selenic.com>
parents: 7064
diff changeset
  1492
        if not parentworking:
40d105a12cac status: don't warn about missing files present in base revision (issue1323)
Matt Mackall <mpm@selenic.com>
parents: 7064
diff changeset
  1493
            def bad(f, msg):
16144
4546a8513dcd localrepository: use 'changectx.dirs()' in 'status()' for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16116
diff changeset
  1494
                # 'f' may be a directory pattern from 'match.files()',
4546a8513dcd localrepository: use 'changectx.dirs()' in 'status()' for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16116
diff changeset
  1495
                # so 'f not in ctx1' is not enough
4546a8513dcd localrepository: use 'changectx.dirs()' in 'status()' for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16116
diff changeset
  1496
                if f not in ctx1 and f not in ctx1.dirs():
7067
40d105a12cac status: don't warn about missing files present in base revision (issue1323)
Matt Mackall <mpm@selenic.com>
parents: 7064
diff changeset
  1497
                    self.ui.warn('%s: %s\n' % (self.dirstate.pathto(f), msg))
40d105a12cac status: don't warn about missing files present in base revision (issue1323)
Matt Mackall <mpm@selenic.com>
parents: 7064
diff changeset
  1498
            match.bad = bad
40d105a12cac status: don't warn about missing files present in base revision (issue1323)
Matt Mackall <mpm@selenic.com>
parents: 7064
diff changeset
  1499
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1500
        if working: # we need to scan the working dir
11227
054549ccb680 status: avoid performance regression when no .hgsub is present
Matt Mackall <mpm@selenic.com>
parents: 11154
diff changeset
  1501
            subrepos = []
054549ccb680 status: avoid performance regression when no .hgsub is present
Matt Mackall <mpm@selenic.com>
parents: 11154
diff changeset
  1502
            if '.hgsub' in self.dirstate:
18364
6252b4f1c4b4 subrepos: process subrepos in sorted order
Mads Kiilerich <mads@kiilerich.com>
parents: 18356
diff changeset
  1503
                subrepos = sorted(ctx2.substate)
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10011
diff changeset
  1504
            s = self.dirstate.status(match, subrepos, listignored,
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10011
diff changeset
  1505
                                     listclean, listunknown)
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1506
            cmp, modified, added, removed, deleted, unknown, ignored, clean = s
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
  1507
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1508
            # check for any possibly clean files
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1509
            if parentworking and cmp:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1510
                fixup = []
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1511
                # do a full compare of any files that might have changed
8395
475552c03496 status: check cmp list in order
Matt Mackall <mpm@selenic.com>
parents: 8393
diff changeset
  1512
                for f in sorted(cmp):
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1513
                    if (f not in ctx1 or ctx2.flags(f) != ctx1.flags(f)
11702
eb07fbc21e9c filectx: use cmp(self, fctx) instead of cmp(self, text)
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11698
diff changeset
  1514
                        or ctx1[f].cmp(ctx2[f])):
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1515
                        modified.append(f)
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1516
                    else:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1517
                        fixup.append(f)
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1518
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1519
                # update dirstate for files that are actually clean
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1520
                if fixup:
11669
c47cb3193c53 localrepo.status: move fixup concatenation inside if block for clarity
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11665
diff changeset
  1521
                    if listclean:
c47cb3193c53 localrepo.status: move fixup concatenation inside if block for clarity
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11665
diff changeset
  1522
                        clean += fixup
c47cb3193c53 localrepo.status: move fixup concatenation inside if block for clarity
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11665
diff changeset
  1523
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1524
                    try:
8647
cb74433f9b41 localrepo: move comment
Adrian Buehlmann <adrian@cadifra.com>
parents: 8646
diff changeset
  1525
                        # updating the dirstate is optional
cb74433f9b41 localrepo: move comment
Adrian Buehlmann <adrian@cadifra.com>
parents: 8646
diff changeset
  1526
                        # so we don't wait on the lock
8646
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1527
                        wlock = self.wlock(False)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1528
                        try:
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1529
                            for f in fixup:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1530
                                self.dirstate.normal(f)
8646
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1531
                        finally:
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1532
                            wlock.release()
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1533
                    except error.LockError:
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1534
                        pass
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1535
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1536
        if not parentworking:
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1537
            mf1 = mfmatches(ctx1)
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1538
            if working:
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1539
                # we are comparing working dir against non-parent
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1540
                # generate a pseudo-manifest for the working dir
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1541
                mf2 = mfmatches(self['.'])
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1542
                for f in cmp + modified + added:
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1543
                    mf2[f] = None
6817
cf319797d61c minor status fixups
Matt Mackall <mpm@selenic.com>
parents: 6810
diff changeset
  1544
                    mf2.set(f, ctx2.flags(f))
1617
ece5d785e87a Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1616
diff changeset
  1545
                for f in removed:
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1546
                    if f in mf2:
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1547
                        del mf2[f]
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1548
            else:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1549
                # we are comparing two revisions
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1550
                deleted, unknown, ignored = [], [], []
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1551
                mf2 = mfmatches(ctx2)
4372
4ddc6d374265 localrepository.status: only acquire wlock if actually needed.
Bryan O'Sullivan <bos@serpentine.com>
parents: 4335
diff changeset
  1552
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1553
            modified, added, clean = [], [], []
16646
a1dcd842ce17 localrepo: optimize internode status calls using withflags
Jesse Glick <jesse.glick@oracle.com>
parents: 16645
diff changeset
  1554
            withflags = mf1.withflags() | mf2.withflags()
18714
7790d69af6d6 localrepo: iterate over manifest key/value pairs in status
Bryan O'Sullivan <bryano@fb.com>
parents: 18691
diff changeset
  1555
            for fn, mf2node in mf2.iteritems():
5915
d0576d065993 Prefer i in d over d.has_key(i)
Christian Ebert <blacktrash@gmx.net>
parents: 5913
diff changeset
  1556
                if fn in mf1:
14500
e880433a2e00 localrepo: don't add deleted files to list of modified/added files (issue2761)
Idan Kamara <idankk86@gmail.com>
parents: 14499
diff changeset
  1557
                    if (fn not in deleted and
16646
a1dcd842ce17 localrepo: optimize internode status calls using withflags
Jesse Glick <jesse.glick@oracle.com>
parents: 16645
diff changeset
  1558
                        ((fn in withflags and mf1.flags(fn) != mf2.flags(fn)) or
18714
7790d69af6d6 localrepo: iterate over manifest key/value pairs in status
Bryan O'Sullivan <bryano@fb.com>
parents: 18691
diff changeset
  1559
                         (mf1[fn] != mf2node and
7790d69af6d6 localrepo: iterate over manifest key/value pairs in status
Bryan O'Sullivan <bryano@fb.com>
parents: 18691
diff changeset
  1560
                          (mf2node or ctx1[fn].cmp(ctx2[fn]))))):
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1561
                        modified.append(fn)
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1562
                    elif listclean:
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1563
                        clean.append(fn)
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1564
                    del mf1[fn]
14500
e880433a2e00 localrepo: don't add deleted files to list of modified/added files (issue2761)
Idan Kamara <idankk86@gmail.com>
parents: 14499
diff changeset
  1565
                elif fn not in deleted:
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1566
                    added.append(fn)
1617
ece5d785e87a Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1616
diff changeset
  1567
            removed = mf1.keys()
ece5d785e87a Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1616
diff changeset
  1568
15348
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1569
        if working and modified and not self.dirstate._checklink:
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1570
            # Symlink placeholders may get non-symlink-like contents
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1571
            # via user error or dereferencing by NFS or Samba servers,
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1572
            # so we filter out any placeholders that don't look like a
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1573
            # symlink
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1574
            sane = []
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1575
            for f in modified:
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1576
                if ctx2.flags(f) == 'l':
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1577
                    d = ctx2[f].data()
19650
36f48c7d5944 localrepo.status: ignore empty symlink placeholders
Siddharth Agarwal <sid0@fb.com>
parents: 19635
diff changeset
  1578
                    if d == '' or len(d) >= 1024 or '\n' in d or util.binary(d):
15348
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1579
                        self.ui.debug('ignoring suspect symlink placeholder'
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1580
                                      ' "%s"\n' % f)
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1581
                        continue
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1582
                sane.append(f)
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1583
            modified = sane
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1584
6827
c978d6752dbb dirstate.walk: push sorting up
Matt Mackall <mpm@selenic.com>
parents: 6817
diff changeset
  1585
        r = modified, added, removed, deleted, unknown, ignored, clean
12166
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1586
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1587
        if listsubrepos:
12176
ecab10820983 subrepos: add function for iterating over ctx subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12175
diff changeset
  1588
            for subpath, sub in subrepo.itersubrepos(ctx1, ctx2):
12166
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1589
                if working:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1590
                    rev2 = None
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1591
                else:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1592
                    rev2 = ctx2.substate[subpath][1]
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1593
                try:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1594
                    submatch = matchmod.narrowmatcher(subpath, match)
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1595
                    s = sub.status(rev2, match=submatch, ignored=listignored,
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1596
                                   clean=listclean, unknown=listunknown,
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1597
                                   listsubrepos=True)
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1598
                    for rfiles, sfiles in zip(r, s):
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1599
                        rfiles.extend("%s/%s" % (subpath, f) for f in sfiles)
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1600
                except error.LookupError:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1601
                    self.ui.status(_("skipping missing subrepository: %s\n")
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1602
                                   % subpath)
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1603
13412
58c497d0e44d remove unnecessary list comprehensions
Martin Geisler <mg@aragost.com>
parents: 13411
diff changeset
  1604
        for l in r:
58c497d0e44d remove unnecessary list comprehensions
Martin Geisler <mg@aragost.com>
parents: 13411
diff changeset
  1605
            l.sort()
6827
c978d6752dbb dirstate.walk: push sorting up
Matt Mackall <mpm@selenic.com>
parents: 6817
diff changeset
  1606
        return r
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1607
8796
2bcef677a6c3 localrepo: remove 'closed' argument to heads(...) function
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 8731
diff changeset
  1608
    def heads(self, start=None):
1550
ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1532
diff changeset
  1609
        heads = self.changelog.heads(start)
ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1532
diff changeset
  1610
        # sort the output in rev descending order
13075
d73c3034deee coding style: fix gratuitous whitespace after Python keywords
Thomas Arendsen Hein <thomas@jtah.de>
parents: 13047
diff changeset
  1611
        return sorted(heads, key=self.changelog.rev, reverse=True)
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  1612
8694
ca8d05e1f1d1 localrepo: set heads and branchheads to be closed=False by default
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 8680
diff changeset
  1613
    def branchheads(self, branch=None, start=None, closed=False):
9475
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1614
        '''return a (possibly filtered) list of heads for the given branch
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1615
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1616
        Heads are returned in topological order, from newest to oldest.
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1617
        If branch is None, use the dirstate branch.
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1618
        If start is not None, return only heads reachable from start.
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1619
        If closed is True, return heads that are marked as closed as well.
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1620
        '''
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
  1621
        if branch is None:
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
  1622
            branch = self[None].branch()
9675
ee913987e4b0 localrepo/branchcache: remove lbranchmap(), convert users to use utf-8 names
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 9674
diff changeset
  1623
        branches = self.branchmap()
4648
8e503fa54d2d Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents: 4635
diff changeset
  1624
        if branch not in branches:
8e503fa54d2d Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents: 4635
diff changeset
  1625
            return []
7654
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
  1626
        # the cache returns heads ordered lowest to highest
9475
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1627
        bheads = list(reversed(branches[branch]))
4648
8e503fa54d2d Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents: 4635
diff changeset
  1628
        if start is not None:
7654
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
  1629
            # filter out the heads that cannot be reached from startrev
9475
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1630
            fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1631
            bheads = [h for h in bheads if h in fbheads]
7656
6a24fb994701 branch closing: referencing open and closed branches/heads
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7655
diff changeset
  1632
        if not closed:
16720
e825a89de5d7 context: add changectx.closesbranch() method
Brodie Rao <brodie@sf.io>
parents: 16719
diff changeset
  1633
            bheads = [h for h in bheads if not self[h].closesbranch()]
7654
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
  1634
        return bheads
4648
8e503fa54d2d Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents: 4635
diff changeset
  1635
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1636
    def branches(self, nodes):
1615
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
  1637
        if not nodes:
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
  1638
            nodes = [self.changelog.tip()]
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1639
        b = []
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1640
        for n in nodes:
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1641
            t = n
14494
1ffeeb91c55d check-code: flag 0/1 used as constant Boolean expression
Martin Geisler <mg@lazybytes.net>
parents: 14482
diff changeset
  1642
            while True:
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1643
                p = self.changelog.parents(n)
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1644
                if p[1] != nullid or p[0] == nullid:
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1645
                    b.append((t, n, p[0], p[1]))
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1646
                    break
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1647
                n = p[0]
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1648
        return b
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1649
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1650
    def between(self, pairs):
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1651
        r = []
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1652
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1653
        for top, bottom in pairs:
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1654
            n, l, i = top, [], 0
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1655
            f = 1
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1656
7708
a32847fa0df0 wire protocol: avoid infinite loop (issue1483)
Matt Mackall <mpm@selenic.com>
parents: 7564
diff changeset
  1657
            while n != bottom and n != nullid:
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1658
                p = self.changelog.parents(n)[0]
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1659
                if i == f:
575
7f5ce4bbdd7b More whitespace cleanups
mpm@selenic.com
parents: 566
diff changeset
  1660
                    l.append(n)
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1661
                    f = f * 2
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1662
                n = p
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1663
                i += 1
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1664
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1665
            r.append(l)
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1666
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1667
        return r
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1668
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1669
    def pull(self, remote, heads=None, force=False):
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1670
        if remote.local():
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1671
            missing = set(remote.requirements) - self.supported
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1672
            if missing:
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1673
                msg = _("required features are not"
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1674
                        " supported in the destination:"
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1675
                        " %s") % (', '.join(sorted(missing)))
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1676
                raise util.Abort(msg)
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1677
17126
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1678
        # don't open transaction for nothing or you break future useful
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1679
        # rollback call
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1680
        tr = None
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1681
        trname = 'pull\n' + util.hidepassword(remote.url())
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1682
        lock = self.lock()
2827
2a0c599f7bb0 fetch: hold lock and wlock across all operations
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2803
diff changeset
  1683
        try:
11301
3d0591a66118 move discovery methods from localrepo into new discovery module
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 11230
diff changeset
  1684
            tmp = discovery.findcommonincoming(self, remote, heads=heads,
3d0591a66118 move discovery methods from localrepo into new discovery module
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 11230
diff changeset
  1685
                                               force=force)
3d0591a66118 move discovery methods from localrepo into new discovery module
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 11230
diff changeset
  1686
            common, fetch, rheads = tmp
2827
2a0c599f7bb0 fetch: hold lock and wlock across all operations
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2803
diff changeset
  1687
            if not fetch:
2a0c599f7bb0 fetch: hold lock and wlock across all operations
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2803
diff changeset
  1688
                self.ui.status(_("no changes found\n"))
15650
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1689
                added = []
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1690
                result = 0
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1691
            else:
17126
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1692
                tr = self.transaction(trname)
13742
7abab875e647 discovery: avoid discovery when local graph is a subset of remote
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13741
diff changeset
  1693
                if heads is None and list(common) == [nullid]:
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1694
                    self.ui.status(_("requesting all changes\n"))
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1695
                elif heads is None and remote.capable('changegroupsubset'):
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1696
                    # issue1320, avoid a race if remote changed after discovery
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1697
                    heads = rheads
7415
6163ef936a00 protocol: use changegroupsubset() if possible (issue1389)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7377
diff changeset
  1698
14073
72c84f24b420 discovery: drop findoutgoing and simplify findcommonincoming's api
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14064
diff changeset
  1699
                if remote.capable('getbundle'):
19201
309c439cdbaa bundle-ng: add bundlecaps argument to getbundle() command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19200
diff changeset
  1700
                    # TODO: get bundlecaps from remote
13742
7abab875e647 discovery: avoid discovery when local graph is a subset of remote
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13741
diff changeset
  1701
                    cg = remote.getbundle('pull', common=common,
7abab875e647 discovery: avoid discovery when local graph is a subset of remote
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13741
diff changeset
  1702
                                          heads=heads or rheads)
7abab875e647 discovery: avoid discovery when local graph is a subset of remote
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13741
diff changeset
  1703
                elif heads is None:
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1704
                    cg = remote.changegroup(fetch, 'pull')
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1705
                elif not remote.capable('changegroupsubset'):
12067
a4fbbe0fbc38 Lowercase error messages
Martin Geisler <mg@lazybytes.net>
parents: 11640
diff changeset
  1706
                    raise util.Abort(_("partial pull cannot be done because "
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1707
                                           "other repository doesn't support "
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1708
                                           "changegroupsubset."))
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1709
                else:
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1710
                    cg = remote.changegroupsubset(fetch, heads, 'pull')
18498
4d9f7dd2ac82 pull: fix crash when pulling changeset that get hidden locally (issue3788)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18422
diff changeset
  1711
                # we use unfiltered changelog here because hidden revision must
4d9f7dd2ac82 pull: fix crash when pulling changeset that get hidden locally (issue3788)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18422
diff changeset
  1712
                # be taken in account for phase synchronization. They may
4d9f7dd2ac82 pull: fix crash when pulling changeset that get hidden locally (issue3788)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18422
diff changeset
  1713
                # becomes public and becomes visible again.
4d9f7dd2ac82 pull: fix crash when pulling changeset that get hidden locally (issue3788)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18422
diff changeset
  1714
                cl = self.unfiltered().changelog
4d9f7dd2ac82 pull: fix crash when pulling changeset that get hidden locally (issue3788)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18422
diff changeset
  1715
                clstart = len(cl)
15585
a348739da8f0 addchangegroup: remove the lock argument on the addchangegroup methods
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15584
diff changeset
  1716
                result = self.addchangegroup(cg, 'pull', remote.url())
18498
4d9f7dd2ac82 pull: fix crash when pulling changeset that get hidden locally (issue3788)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18422
diff changeset
  1717
                clend = len(cl)
4d9f7dd2ac82 pull: fix crash when pulling changeset that get hidden locally (issue3788)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18422
diff changeset
  1718
                added = [cl.node(r) for r in xrange(clstart, clend)]
15650
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1719
15956
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1720
            # compute target subset
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1721
            if heads is None:
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1722
                # We pulled every thing possible
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1723
                # sync on everything common
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1724
                subset = common + added
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1725
            else:
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1726
                # We pulled a specific subset
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1727
                # sync on this subset
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1728
                subset = heads
15650
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1729
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1730
            # Get remote phases data from remote
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1731
            remotephases = remote.listkeys('phases')
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1732
            publishing = bool(remotephases.get('publishing', False))
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1733
            if remotephases and not publishing:
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1734
                # remote is new and unpublishing
15892
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1735
                pheads, _dr = phases.analyzeremotephases(self, subset,
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1736
                                                         remotephases)
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1737
                phases.advanceboundary(self, phases.public, pheads)
15956
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1738
                phases.advanceboundary(self, phases.draft, subset)
15650
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1739
            else:
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1740
                # Remote is old or publishing all common changesets
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1741
                # should be seen as public
15956
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1742
                phases.advanceboundary(self, phases.public, subset)
17075
28ed1c4511ce obsolete: exchange obsolete marker over pushkey
Pierre-Yves.David@ens-lyon.org
parents: 17070
diff changeset
  1743
19054
d5f968f7716f obsolete: extract obsolescence marker pulling into a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19053
diff changeset
  1744
            def gettransaction():
d5f968f7716f obsolete: extract obsolescence marker pulling into a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19053
diff changeset
  1745
                if tr is None:
d5f968f7716f obsolete: extract obsolescence marker pulling into a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19053
diff changeset
  1746
                    return self.transaction(trname)
d5f968f7716f obsolete: extract obsolescence marker pulling into a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19053
diff changeset
  1747
                return tr
d5f968f7716f obsolete: extract obsolescence marker pulling into a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19053
diff changeset
  1748
d5f968f7716f obsolete: extract obsolescence marker pulling into a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19053
diff changeset
  1749
            obstr = obsolete.syncpull(self, remote, gettransaction)
d5f968f7716f obsolete: extract obsolescence marker pulling into a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19053
diff changeset
  1750
            if obstr is not None:
d5f968f7716f obsolete: extract obsolescence marker pulling into a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19053
diff changeset
  1751
                tr = obstr
d5f968f7716f obsolete: extract obsolescence marker pulling into a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19053
diff changeset
  1752
17126
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1753
            if tr is not None:
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1754
                tr.close()
2827
2a0c599f7bb0 fetch: hold lock and wlock across all operations
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2803
diff changeset
  1755
        finally:
17126
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1756
            if tr is not None:
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1757
                tr.release()
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
  1758
            lock.release()
622
e9fe5d5e67f7 Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents: 621
diff changeset
  1759
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1760
        return result
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1761
13327
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1762
    def checkpush(self, force, revs):
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1763
        """Extensions can override this function if additional checks have
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1764
        to be performed before pushing, or call it if they override push
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1765
        command.
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1766
        """
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1767
        pass
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1768
11211
e43c23d189a5 push: add --new-branch option to allow intial push of new branches
Sune Foldager <cryo@cyanite.org>
parents: 11177
diff changeset
  1769
    def push(self, remote, force=False, revs=None, newbranch=False):
11153
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  1770
        '''Push outgoing changesets (limited by revs) from the current
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  1771
        repository to remote. Return an integer:
16023
90f8b8dd0326 push: return 1 if no changes found (issue3228)
Matt Mackall <mpm@selenic.com>
parents: 16020
diff changeset
  1772
          - None means nothing to push
90f8b8dd0326 push: return 1 if no changes found (issue3228)
Matt Mackall <mpm@selenic.com>
parents: 16020
diff changeset
  1773
          - 0 means HTTP error
11153
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  1774
          - 1 means we pushed and remote head count is unchanged *or*
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  1775
            we have outgoing changesets but refused to push
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  1776
          - other values as described by addchangegroup()
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  1777
        '''
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1778
        if remote.local():
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1779
            missing = set(self.requirements) - remote.local().supported
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1780
            if missing:
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1781
                msg = _("required features are not"
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1782
                        " supported in the destination:"
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1783
                        " %s") % (', '.join(sorted(missing)))
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1784
                raise util.Abort(msg)
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
  1785
2439
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
  1786
        # there are two ways to push to remote repo:
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
  1787
        #
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
  1788
        # addchangegroup assumes local user can lock remote
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
  1789
        # repo (local filesystem, old ssh servers).
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
  1790
        #
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
  1791
        # unbundle assumes local user cannot lock remote repo (new ssh
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
  1792
        # servers, http servers).
816
8674b7803714 Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents: 814
diff changeset
  1793
17193
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
  1794
        if not remote.canpush():
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
  1795
            raise util.Abort(_("destination does not support push"))
18044
f3991bcf4f0f push: reunite comment with the line of code it describes
Kevin Bullock <kbullock@ringworld.org>
parents: 18016
diff changeset
  1796
        unfi = self.unfiltered()
19096
0e4af72cbd7f push: factorise phase movement in a simple closure
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19054
diff changeset
  1797
        def localphasemove(nodes, phase=phases.public):
0e4af72cbd7f push: factorise phase movement in a simple closure
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19054
diff changeset
  1798
            """move <nodes> to <phase> in the local source repo"""
19097
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1799
            if locallock is not None:
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1800
                phases.advanceboundary(self, phase, nodes)
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1801
            else:
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1802
                # repo is not locked, do not change any phases!
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1803
                # Informs the user that phases should have been moved when
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1804
                # applicable.
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1805
                actualmoves = [n for n in nodes if phase < self[n].phase()]
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1806
                phasestr = phases.phasenames[phase]
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1807
                if actualmoves:
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1808
                    self.ui.status(_('cannot lock source repo, skipping local'
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1809
                                     ' %s phase update\n') % phasestr)
15952
ec8a9e06cf05 mq-safety: don't apply safety on non-outgoing changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15933
diff changeset
  1810
        # get local lock as we might write phase data
19097
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1811
        locallock = None
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1812
        try:
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1813
            locallock = self.lock()
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1814
        except IOError, err:
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1815
            if err.errno != errno.EACCES:
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1816
                raise
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1817
            # source repo cannot be locked.
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1818
            # We do not abort the push, but just disable the local phase
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1819
            # synchronisation.
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1820
            msg = 'cannot lock source repository: %s\n' % err
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1821
            self.ui.debug(msg)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1822
        try:
15952
ec8a9e06cf05 mq-safety: don't apply safety on non-outgoing changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15933
diff changeset
  1823
            self.checkpush(force, revs)
ec8a9e06cf05 mq-safety: don't apply safety on non-outgoing changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15933
diff changeset
  1824
            lock = None
ec8a9e06cf05 mq-safety: don't apply safety on non-outgoing changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15933
diff changeset
  1825
            unbundle = remote.capable('unbundle')
ec8a9e06cf05 mq-safety: don't apply safety on non-outgoing changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15933
diff changeset
  1826
            if not unbundle:
ec8a9e06cf05 mq-safety: don't apply safety on non-outgoing changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15933
diff changeset
  1827
                lock = remote.lock()
15485
fa47291b3f1f phases: mark content pushed as public in local repo on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15484
diff changeset
  1828
            try:
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1829
                # discovery
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1830
                fci = discovery.findcommonincoming
18007
2e30972d859d clfilter: unfilter some parts of the push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18000
diff changeset
  1831
                commoninc = fci(unfi, remote, force=force)
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1832
                common, inc, remoteheads = commoninc
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1833
                fco = discovery.findcommonoutgoing
18007
2e30972d859d clfilter: unfilter some parts of the push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18000
diff changeset
  1834
                outgoing = fco(unfi, remote, onlyheads=revs,
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1835
                               commoninc=commoninc, force=force)
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1836
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1837
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1838
                if not outgoing.missing:
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1839
                    # nothing to push
18007
2e30972d859d clfilter: unfilter some parts of the push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18000
diff changeset
  1840
                    scmutil.nochangesfound(unfi.ui, unfi, outgoing.excluded)
16023
90f8b8dd0326 push: return 1 if no changes found (issue3228)
Matt Mackall <mpm@selenic.com>
parents: 16020
diff changeset
  1841
                    ret = None
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1842
                else:
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1843
                    # something to push
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1844
                    if not force:
17169
c18ecebed3f1 push: refuse to push obsolete changesets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17161
diff changeset
  1845
                        # if self.obsstore == False --> no obsolete
c18ecebed3f1 push: refuse to push obsolete changesets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17161
diff changeset
  1846
                        # then, save the iteration
18007
2e30972d859d clfilter: unfilter some parts of the push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18000
diff changeset
  1847
                        if unfi.obsstore:
17169
c18ecebed3f1 push: refuse to push obsolete changesets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17161
diff changeset
  1848
                            # this message are here for 80 char limit reason
17833
0c1185f6ddd7 obsolete: simplify push abort message
push includes an xxx changeset: yyyyyyyyyy
parents: 17821
diff changeset
  1849
                            mso = _("push includes obsolete changeset: %s!")
18162
df1b37c8ae67 obsolete: factorise troubles detection during push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18137
diff changeset
  1850
                            mst = "push includes %s changeset: %s!"
df1b37c8ae67 obsolete: factorise troubles detection during push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18137
diff changeset
  1851
                            # plain versions for i18n tool to detect them
df1b37c8ae67 obsolete: factorise troubles detection during push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18137
diff changeset
  1852
                            _("push includes unstable changeset: %s!")
df1b37c8ae67 obsolete: factorise troubles detection during push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18137
diff changeset
  1853
                            _("push includes bumped changeset: %s!")
df1b37c8ae67 obsolete: factorise troubles detection during push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18137
diff changeset
  1854
                            _("push includes divergent changeset: %s!")
17172
12fdaa30063a push: refuse to push unstable changesets without force
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17169
diff changeset
  1855
                            # If we are to push if there is at least one
12fdaa30063a push: refuse to push unstable changesets without force
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17169
diff changeset
  1856
                            # obsolete or unstable changeset in missing, at
12fdaa30063a push: refuse to push unstable changesets without force
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17169
diff changeset
  1857
                            # least one of the missinghead will be obsolete or
12fdaa30063a push: refuse to push unstable changesets without force
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17169
diff changeset
  1858
                            # unstable. So checking heads only is ok
12fdaa30063a push: refuse to push unstable changesets without force
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17169
diff changeset
  1859
                            for node in outgoing.missingheads:
18007
2e30972d859d clfilter: unfilter some parts of the push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18000
diff changeset
  1860
                                ctx = unfi[node]
17169
c18ecebed3f1 push: refuse to push obsolete changesets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17161
diff changeset
  1861
                                if ctx.obsolete():
17855
526081552f3d localrepo: translate "push includes X changeset" only once
Thomas Arendsen Hein <thomas@intevation.de>
parents: 17834
diff changeset
  1862
                                    raise util.Abort(mso % ctx)
18162
df1b37c8ae67 obsolete: factorise troubles detection during push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18137
diff changeset
  1863
                                elif ctx.troubled():
df1b37c8ae67 obsolete: factorise troubles detection during push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18137
diff changeset
  1864
                                    raise util.Abort(_(mst)
df1b37c8ae67 obsolete: factorise troubles detection during push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18137
diff changeset
  1865
                                                     % (ctx.troubles()[0],
df1b37c8ae67 obsolete: factorise troubles detection during push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18137
diff changeset
  1866
                                                        ctx))
18007
2e30972d859d clfilter: unfilter some parts of the push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18000
diff changeset
  1867
                        discovery.checkheads(unfi, remote, outgoing,
15986
ba959f6e10f8 discovery: fix regression when checking heads for pre 1.4 client (issue3218)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15956
diff changeset
  1868
                                             remoteheads, newbranch,
ba959f6e10f8 discovery: fix regression when checking heads for pre 1.4 client (issue3218)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15956
diff changeset
  1869
                                             bool(inc))
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1870
19201
309c439cdbaa bundle-ng: add bundlecaps argument to getbundle() command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19200
diff changeset
  1871
                    # TODO: get bundlecaps from remote
309c439cdbaa bundle-ng: add bundlecaps argument to getbundle() command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19200
diff changeset
  1872
                    bundlecaps = None
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1873
                    # create a changegroup from local
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1874
                    if revs is None and not outgoing.excluded:
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1875
                        # push everything,
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1876
                        # use the fast path, no race possible on push
19202
0455fc94ae00 bundle-ng: move gengroup into bundler, pass repo object to bundler
Sune Foldager <cryo@cyanite.org>
parents: 19201
diff changeset
  1877
                        bundler = changegroup.bundle10(self, bundlecaps)
19203
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  1878
                        cg = self._changegroupsubset(outgoing,
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  1879
                                                     bundler,
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  1880
                                                     'push',
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  1881
                                                     fastpath=True)
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1882
                    else:
19201
309c439cdbaa bundle-ng: add bundlecaps argument to getbundle() command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19200
diff changeset
  1883
                        cg = self.getlocalbundle('push', outgoing, bundlecaps)
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1884
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1885
                    # apply changegroup to remote
15485
fa47291b3f1f phases: mark content pushed as public in local repo on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15484
diff changeset
  1886
                    if unbundle:
fa47291b3f1f phases: mark content pushed as public in local repo on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15484
diff changeset
  1887
                        # local repo finds heads on server, finds out what
fa47291b3f1f phases: mark content pushed as public in local repo on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15484
diff changeset
  1888
                        # revs it must push. once revs transferred, if server
fa47291b3f1f phases: mark content pushed as public in local repo on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15484
diff changeset
  1889
                        # finds it has different heads (someone else won
fa47291b3f1f phases: mark content pushed as public in local repo on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15484
diff changeset
  1890
                        # commit/push race), server aborts.
fa47291b3f1f phases: mark content pushed as public in local repo on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15484
diff changeset
  1891
                        if force:
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1892
                            remoteheads = ['force']
15485
fa47291b3f1f phases: mark content pushed as public in local repo on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15484
diff changeset
  1893
                        # ssh: return remote's addchangegroup()
fa47291b3f1f phases: mark content pushed as public in local repo on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15484
diff changeset
  1894
                        # http: return remote's addchangegroup() or 0 for error
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1895
                        ret = remote.unbundle(cg, remoteheads, 'push')
15485
fa47291b3f1f phases: mark content pushed as public in local repo on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15484
diff changeset
  1896
                    else:
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1897
                        # we return an integer indicating remote head count
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1898
                        # change
15585
a348739da8f0 addchangegroup: remove the lock argument on the addchangegroup methods
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15584
diff changeset
  1899
                        ret = remote.addchangegroup(cg, 'push', self.url())
15651
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1900
15933
b8696a6676be phases: only synchronize on common changeset when push fails
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15932
diff changeset
  1901
                if ret:
17521
6a78548eaa86 spelling: synchronize
timeless@mozdev.org
parents: 17520
diff changeset
  1902
                    # push succeed, synchronize target of the push
15956
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1903
                    cheads = outgoing.missingheads
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1904
                elif revs is None:
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1905
                    # All out push fails. synchronize all common
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1906
                    cheads = outgoing.commonheads
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1907
                else:
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1908
                    # I want cheads = heads(::missingheads and ::commonheads)
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1909
                    # (missingheads is revs with secret changeset filtered out)
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1910
                    #
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1911
                    # This can be expressed as:
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1912
                    #     cheads = ( (missingheads and ::commonheads)
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1913
                    #              + (commonheads and ::missingheads))"
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1914
                    #              )
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1915
                    #
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1916
                    # while trying to push we already computed the following:
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1917
                    #     common = (::commonheads)
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1918
                    #     missing = ((commonheads::missingheads) - commonheads)
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1919
                    #
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1920
                    # We can pick:
17424
e7cfe3587ea4 fix trivial spelling errors
Mads Kiilerich <mads@kiilerich.com>
parents: 17378
diff changeset
  1921
                    # * missingheads part of common (::commonheads)
15956
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1922
                    common = set(outgoing.common)
16020
7460f3a1fd6c push: fix coding errors in unused branch
Matt Mackall <mpm@selenic.com>
parents: 16018
diff changeset
  1923
                    cheads = [node for node in revs if node in common]
16628
3c738cb162bf localrepo: cleanup var names and comments
redstone
parents: 16626
diff changeset
  1924
                    # and
15956
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1925
                    # * commonheads parents on missing
18007
2e30972d859d clfilter: unfilter some parts of the push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18000
diff changeset
  1926
                    revset = unfi.set('%ln and parents(roots(%ln))',
16020
7460f3a1fd6c push: fix coding errors in unused branch
Matt Mackall <mpm@selenic.com>
parents: 16018
diff changeset
  1927
                                     outgoing.commonheads,
7460f3a1fd6c push: fix coding errors in unused branch
Matt Mackall <mpm@selenic.com>
parents: 16018
diff changeset
  1928
                                     outgoing.missing)
7460f3a1fd6c push: fix coding errors in unused branch
Matt Mackall <mpm@selenic.com>
parents: 16018
diff changeset
  1929
                    cheads.extend(c.node() for c in revset)
15651
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1930
                # even when we don't push, exchanging phase data is useful
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1931
                remotephases = remote.listkeys('phases')
18520
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1932
                if (self.ui.configbool('ui', '_usedassubrepo', False)
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1933
                    and remotephases    # server supports phases
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1934
                    and ret is None # nothing was pushed
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1935
                    and remotephases.get('publishing', False)):
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1936
                    # When:
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1937
                    # - this is a subrepo push
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1938
                    # - and remote support phase
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1939
                    # - and no changeset was pushed
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1940
                    # - and remote is publishing
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1941
                    # We may be in issue 3871 case!
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1942
                    # We drop the possible phase synchronisation done by
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1943
                    # courtesy to publish changesets possibly locally draft
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1944
                    # on the remote.
751135cca13c subrepo: allows to drop courtesy phase sync (issue3781)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18498
diff changeset
  1945
                    remotephases = {'publishing': 'True'}
15651
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1946
                if not remotephases: # old server or public only repo
19096
0e4af72cbd7f push: factorise phase movement in a simple closure
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19054
diff changeset
  1947
                    localphasemove(cheads)
15651
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1948
                    # don't push any phase data as there is nothing to push
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1949
                else:
15933
b8696a6676be phases: only synchronize on common changeset when push fails
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15932
diff changeset
  1950
                    ana = phases.analyzeremotephases(self, cheads, remotephases)
15892
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1951
                    pheads, droots = ana
15651
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1952
                    ### Apply remote phase on local
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1953
                    if remotephases.get('publishing', False):
19096
0e4af72cbd7f push: factorise phase movement in a simple closure
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19054
diff changeset
  1954
                        localphasemove(cheads)
15651
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1955
                    else: # publish = False
19096
0e4af72cbd7f push: factorise phase movement in a simple closure
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19054
diff changeset
  1956
                        localphasemove(pheads)
0e4af72cbd7f push: factorise phase movement in a simple closure
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19054
diff changeset
  1957
                        localphasemove(cheads, phases.draft)
15651
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1958
                    ### Apply local phase on remote
15820
2673006f7989 phases: fix phase synchronization on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15818
diff changeset
  1959
15892
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1960
                    # Get the list of all revs draft on remote by public here.
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1961
                    # XXX Beware that revset break if droots is not strictly
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1962
                    # XXX root we may want to ensure it is but it is costly
18007
2e30972d859d clfilter: unfilter some parts of the push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18000
diff changeset
  1963
                    outdated =  unfi.set('heads((%ln::%ln) and public())',
15933
b8696a6676be phases: only synchronize on common changeset when push fails
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15932
diff changeset
  1964
                                         droots, cheads)
15892
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1965
                    for newremotehead in outdated:
15820
2673006f7989 phases: fix phase synchronization on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15818
diff changeset
  1966
                        r = remote.pushkey('phases',
2673006f7989 phases: fix phase synchronization on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15818
diff changeset
  1967
                                           newremotehead.hex(),
15892
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1968
                                           str(phases.draft),
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1969
                                           str(phases.public))
15820
2673006f7989 phases: fix phase synchronization on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15818
diff changeset
  1970
                        if not r:
15892
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1971
                            self.ui.warn(_('updating %s to public failed!\n')
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1972
                                            % newremotehead)
17294
d2217df3a7cf obsolete: add debug output regarding obsolete marker exchange.
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17293
diff changeset
  1973
                self.ui.debug('try to push obsolete markers to remote\n')
19053
f74f2a4e3327 obsolete: extract obsolescence marker pushing into a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18952
diff changeset
  1974
                obsolete.syncpush(self, remote)
15485
fa47291b3f1f phases: mark content pushed as public in local repo on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15484
diff changeset
  1975
            finally:
15952
ec8a9e06cf05 mq-safety: don't apply safety on non-outgoing changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15933
diff changeset
  1976
                if lock is not None:
ec8a9e06cf05 mq-safety: don't apply safety on non-outgoing changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15933
diff changeset
  1977
                    lock.release()
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1978
        finally:
19097
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1979
            if locallock is not None:
3f5e75c22585 push: make locking of source optional (issue3684)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 19096
diff changeset
  1980
                locallock.release()
622
e9fe5d5e67f7 Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents: 621
diff changeset
  1981
20027
4b06b2a445a1 bookmarks: rewrite pushing bookmarks in "localrepository.push()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19928
diff changeset
  1982
        bookmarks.updateremote(self.ui, unfi, remote, revs)
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1983
        return ret
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1984
5763
e20de0caf8e7 Show number of changesets written to bundle files by default (issue569)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 5760
diff changeset
  1985
    def changegroupinfo(self, nodes, source):
e20de0caf8e7 Show number of changesets written to bundle files by default (issue569)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 5760
diff changeset
  1986
        if self.ui.verbose or source == 'bundle':
e20de0caf8e7 Show number of changesets written to bundle files by default (issue569)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 5760
diff changeset
  1987
            self.ui.status(_("%d changesets found\n") % len(nodes))
3513
9383af6f236d Show number (-v) and list (--debug) of changesets with bundle/pull/push etc.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3500
diff changeset
  1988
        if self.ui.debugflag:
9467
4c041f1ee1b4 do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents: 9437
diff changeset
  1989
            self.ui.debug("list of changesets:\n")
3513
9383af6f236d Show number (-v) and list (--debug) of changesets with bundle/pull/push etc.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3500
diff changeset
  1990
            for node in nodes:
9383af6f236d Show number (-v) and list (--debug) of changesets with bundle/pull/push etc.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3500
diff changeset
  1991
                self.ui.debug("%s\n" % hex(node))
9383af6f236d Show number (-v) and list (--debug) of changesets with bundle/pull/push etc.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3500
diff changeset
  1992
13703
48d606d7192b changegroupsubset: extranodes are no longer needed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 13662
diff changeset
  1993
    def changegroupsubset(self, bases, heads, source):
9437
1c4e4004f3a6 Improve some docstrings relating to changegroups and prepush().
Greg Ward <greg-hg@gerg.ca>
parents: 9425
diff changeset
  1994
        """Compute a changegroup consisting of all the nodes that are
14549
48ec0763afbb check-code: catch misspellings of descendant
Matt Mackall <mpm@selenic.com>
parents: 14536
diff changeset
  1995
        descendants of any of the bases and ancestors of any of the heads.
9437
1c4e4004f3a6 Improve some docstrings relating to changegroups and prepush().
Greg Ward <greg-hg@gerg.ca>
parents: 9425
diff changeset
  1996
        Return a chunkbuffer object whose read() method will return
1c4e4004f3a6 Improve some docstrings relating to changegroups and prepush().
Greg Ward <greg-hg@gerg.ca>
parents: 9425
diff changeset
  1997
        successive changegroup chunks.
1466
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  1998
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  1999
        It is fairly complex as determining which filenodes and which
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2000
        manifest nodes need to be included for the changeset to be complete
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2001
        is non-trivial.
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2002
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2003
        Another wrinkle is doing the reverse, figuring out which changeset in
5908
afa1e6122be7 changegroupsubset: accept list of per-revlog nodes to include
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5907
diff changeset
  2004
        the changegroup a particular filenode or manifestnode belongs to.
afa1e6122be7 changegroupsubset: accept list of per-revlog nodes to include
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5907
diff changeset
  2005
        """
9820
0b999aec64e8 bundle: don't send too many changesets (Issue1704)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 9691
diff changeset
  2006
        cl = self.changelog
0b999aec64e8 bundle: don't send too many changesets (Issue1704)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 9691
diff changeset
  2007
        if not bases:
0b999aec64e8 bundle: don't send too many changesets (Issue1704)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 9691
diff changeset
  2008
            bases = [nullid]
19203
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2009
        # TODO: remove call to nodesbetween.
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2010
        csets, bases, heads = cl.nodesbetween(bases, heads)
19203
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2011
        bases = [p for n in bases for p in cl.parents(n) if p != nullid]
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2012
        outgoing = discovery.outgoing(cl, bases, heads)
19202
0455fc94ae00 bundle-ng: move gengroup into bundler, pass repo object to bundler
Sune Foldager <cryo@cyanite.org>
parents: 19201
diff changeset
  2013
        bundler = changegroup.bundle10(self)
19203
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2014
        return self._changegroupsubset(outgoing, bundler, source)
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2015
19201
309c439cdbaa bundle-ng: add bundlecaps argument to getbundle() command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19200
diff changeset
  2016
    def getlocalbundle(self, source, outgoing, bundlecaps=None):
15837
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  2017
        """Like getbundle, but taking a discovery.outgoing as an argument.
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  2018
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  2019
        This is only implemented for local repos and reuses potentially
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  2020
        precomputed sets in outgoing."""
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  2021
        if not outgoing.missing:
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  2022
            return None
19202
0455fc94ae00 bundle-ng: move gengroup into bundler, pass repo object to bundler
Sune Foldager <cryo@cyanite.org>
parents: 19201
diff changeset
  2023
        bundler = changegroup.bundle10(self, bundlecaps)
19203
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2024
        return self._changegroupsubset(outgoing, bundler, source)
15837
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  2025
19201
309c439cdbaa bundle-ng: add bundlecaps argument to getbundle() command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19200
diff changeset
  2026
    def getbundle(self, source, heads=None, common=None, bundlecaps=None):
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2027
        """Like changegroupsubset, but returns the set difference between the
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2028
        ancestors of heads and the ancestors common.
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2029
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2030
        If heads is None, use the local heads. If common is None, use [nullid].
9820
0b999aec64e8 bundle: don't send too many changesets (Issue1704)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 9691
diff changeset
  2031
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2032
        The nodes in common might not all be known locally due to the way the
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2033
        current discovery protocol works.
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2034
        """
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2035
        cl = self.changelog
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2036
        if common:
18086
739c88ff043c clfilter: fix `nodemap` usage in `getbundle`
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18073
diff changeset
  2037
            hasnode = cl.hasnode
739c88ff043c clfilter: fix `nodemap` usage in `getbundle`
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18073
diff changeset
  2038
            common = [n for n in common if hasnode(n)]
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2039
        else:
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2040
            common = [nullid]
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2041
        if not heads:
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2042
            heads = cl.heads()
15837
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  2043
        return self.getlocalbundle(source,
19201
309c439cdbaa bundle-ng: add bundlecaps argument to getbundle() command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19200
diff changeset
  2044
                                   discovery.outgoing(cl, common, heads),
309c439cdbaa bundle-ng: add bundlecaps argument to getbundle() command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19200
diff changeset
  2045
                                   bundlecaps=bundlecaps)
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2046
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  2047
    @unfilteredmethod
19203
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2048
    def _changegroupsubset(self, outgoing, bundler, source,
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2049
                           fastpath=False):
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2050
        commonrevs = outgoing.common
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2051
        csets = outgoing.missing
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2052
        heads = outgoing.missingheads
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2053
        # We go through the fast path if we get told to, or if all (unfiltered
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2054
        # heads have been requested (since we then know there all linkrevs will
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2055
        # be pulled by the client).
13703
48d606d7192b changegroupsubset: extranodes are no longer needed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 13662
diff changeset
  2056
        heads.sort()
19203
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2057
        fastpathlinkrev = fastpath or (
627cd7842e5d bundle-ng: unify _changegroup and _changegroupsubset
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19202
diff changeset
  2058
                self.filtername is None and heads == sorted(self.heads()))
7233
9f0e52e1df77 fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7229
diff changeset
  2059
1736
50de0887bbcd add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1732
diff changeset
  2060
        self.hook('preoutgoing', throw=True, source=source)
13706
7beb9834d185 changegroupsubset: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13703
diff changeset
  2061
        self.changegroupinfo(csets, source)
19204
e9c5b1c246dc bundle-ng: move bundle generation to changegroup.py
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 19203
diff changeset
  2062
        gengroup = bundler.generate(commonrevs, csets, fastpathlinkrev, source)
19202
0455fc94ae00 bundle-ng: move gengroup into bundler, pass repo object to bundler
Sune Foldager <cryo@cyanite.org>
parents: 19201
diff changeset
  2063
        return changegroup.unbundle10(util.chunkbuffer(gengroup), 'UN')
1458
1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents: 1457
diff changeset
  2064
1736
50de0887bbcd add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1732
diff changeset
  2065
    def changegroup(self, basenodes, source):
7233
9f0e52e1df77 fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7229
diff changeset
  2066
        # to avoid a race we use changegroupsubset() (issue1320)
9f0e52e1df77 fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7229
diff changeset
  2067
        return self.changegroupsubset(basenodes, self.heads(), source)
9f0e52e1df77 fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7229
diff changeset
  2068
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  2069
    @unfilteredmethod
15585
a348739da8f0 addchangegroup: remove the lock argument on the addchangegroup methods
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15584
diff changeset
  2070
    def addchangegroup(self, source, srctype, url, emptyok=False):
11153
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  2071
        """Add the changegroup returned by source.read() to this repo.
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  2072
        srctype is a string like 'push', 'pull', or 'unbundle'.  url is
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  2073
        the URL of the repo where this changegroup is coming from.
635
85e2209d401c Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents: 634
diff changeset
  2074
11153
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  2075
        Return an integer summarizing the change to this repo:
3803
2aef481ac73c Don't report an error when closing heads during local push (issue387)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3801
diff changeset
  2076
        - nothing changed or no source: 0
2aef481ac73c Don't report an error when closing heads during local push (issue387)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3801
diff changeset
  2077
        - more heads than before: 1+added heads (2..n)
11153
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  2078
        - fewer heads than before: -1-removed heads (-2..-n)
3803
2aef481ac73c Don't report an error when closing heads during local push (issue387)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3801
diff changeset
  2079
        - number of heads stays the same: 1
2aef481ac73c Don't report an error when closing heads during local push (issue387)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3801
diff changeset
  2080
        """
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2081
        def csmap(x):
9467
4c041f1ee1b4 do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents: 9437
diff changeset
  2082
            self.ui.debug("add changeset %s\n" % short(x))
6750
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
  2083
            return len(cl)
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2084
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2085
        def revmap(x):
1998
65cc17ae9649 fix race in localrepo.addchangegroup.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1995
diff changeset
  2086
            return cl.rev(x)
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2087
1615
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
  2088
        if not source:
2019
ced2d3620f95 add merge command. means same thing as "update -m".
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1998
diff changeset
  2089
            return 0
1730
0f1d2c75db5e add prechangegroup and pretxnchangegroup hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1721
diff changeset
  2090
2673
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2661
diff changeset
  2091
        self.hook('prechangegroup', throw=True, source=srctype, url=url)
1730
0f1d2c75db5e add prechangegroup and pretxnchangegroup hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1721
diff changeset
  2092
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2093
        changesets = files = revisions = 0
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2094
        efiles = set()
225
1651a3e61925 fix repo locking
mpm@selenic.com
parents: 224
diff changeset
  2095
2395
8ed45fb1053a remove appendfile for the manifest when adding a changegroup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 2362
diff changeset
  2096
        # write changelog data to temp files so concurrent readers will not see
8ed45fb1053a remove appendfile for the manifest when adding a changegroup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 2362
diff changeset
  2097
        # inconsistent view
4261
cd7b36b7869c restructure changelog file appending
Matt Mackall <mpm@selenic.com>
parents: 4258
diff changeset
  2098
        cl = self.changelog
cd7b36b7869c restructure changelog file appending
Matt Mackall <mpm@selenic.com>
parents: 4258
diff changeset
  2099
        cl.delayupdate()
14036
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2100
        oldheads = cl.heads()
1998
65cc17ae9649 fix race in localrepo.addchangegroup.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1995
diff changeset
  2101
14076
924c82157d46 url: move URL parsing functions into util to improve startup time
Brodie Rao <brodie@bitheap.org>
parents: 14073
diff changeset
  2102
        tr = self.transaction("\n".join([srctype, util.hidepassword(url)]))
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2103
        try:
4970
30d4d8985dd8 transactions: avoid late tear-down (issue641)
Matt Mackall <mpm@selenic.com>
parents: 4917
diff changeset
  2104
            trp = weakref.proxy(tr)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2105
            # pull off the changeset group
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2106
            self.ui.status(_("adding changesets\n"))
8393
59160ca338f7 localrepo: use more direct vars in addchangegroup
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 8392
diff changeset
  2107
            clstart = len(cl)
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2108
            class prog(object):
10496
45734b51c99b progress: mark strings for translation
Martin Geisler <mg@lazybytes.net>
parents: 10492
diff changeset
  2109
                step = _('changesets')
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2110
                count = 1
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2111
                ui = self.ui
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2112
                total = None
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2113
                def __call__(self):
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2114
                    self.ui.progress(self.step, self.count, unit=_('chunks'),
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2115
                                     total=self.total)
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2116
                    self.count += 1
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2117
            pr = prog()
12334
50946802593d bundle: refactor progress callback
Matt Mackall <mpm@selenic.com>
parents: 12333
diff changeset
  2118
            source.callback = pr
50946802593d bundle: refactor progress callback
Matt Mackall <mpm@selenic.com>
parents: 12333
diff changeset
  2119
14144
3c3c53d8343a unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14102
diff changeset
  2120
            source.changelogheader()
15890
e234eda20984 revlog: make addgroup returns a list of node contained in the added source
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15889
diff changeset
  2121
            srccontent = cl.addgroup(source, csmap, trp)
e234eda20984 revlog: make addgroup returns a list of node contained in the added source
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15889
diff changeset
  2122
            if not (srccontent or emptyok):
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2123
                raise util.Abort(_("received changelog group is empty"))
8393
59160ca338f7 localrepo: use more direct vars in addchangegroup
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 8392
diff changeset
  2124
            clend = len(cl)
59160ca338f7 localrepo: use more direct vars in addchangegroup
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 8392
diff changeset
  2125
            changesets = clend - clstart
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2126
            for c in xrange(clstart, clend):
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2127
                efiles.update(self[c].files())
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2128
            efiles = len(efiles)
10496
45734b51c99b progress: mark strings for translation
Martin Geisler <mg@lazybytes.net>
parents: 10492
diff changeset
  2129
            self.ui.progress(_('changesets'), None)
1040
35e883d1ff9b Show number of new heads when doing a pull
mpm@selenic.com
parents: 1019
diff changeset
  2130
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2131
            # pull off the manifest group
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2132
            self.ui.status(_("adding manifests\n"))
10496
45734b51c99b progress: mark strings for translation
Martin Geisler <mg@lazybytes.net>
parents: 10492
diff changeset
  2133
            pr.step = _('manifests')
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2134
            pr.count = 1
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2135
            pr.total = changesets # manifests <= changesets
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2136
            # no need to check for empty manifest group here:
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2137
            # if the result of the merge of 1 and 2 is the same in 3 and 4,
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2138
            # no new manifest will be created and the manifest group will
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2139
            # be empty during the pull
14144
3c3c53d8343a unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14102
diff changeset
  2140
            source.manifestheader()
12335
e21fe9c5fb25 bundle: get rid of chunkiter
Matt Mackall <mpm@selenic.com>
parents: 12334
diff changeset
  2141
            self.manifest.addgroup(source, revmap, trp)
10496
45734b51c99b progress: mark strings for translation
Martin Geisler <mg@lazybytes.net>
parents: 10492
diff changeset
  2142
            self.ui.progress(_('manifests'), None)
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2143
10418
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2144
            needfiles = {}
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2145
            if self.ui.configbool('server', 'validate', default=False):
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2146
                # validate incoming csets have their manifests
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2147
                for cset in xrange(clstart, clend):
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2148
                    mfest = self.changelog.read(self.changelog.node(cset))[0]
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2149
                    mfest = self.manifest.readdelta(mfest)
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2150
                    # store file nodes we must see
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2151
                    for f, n in mfest.iteritems():
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2152
                        needfiles.setdefault(f, set()).add(n)
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2153
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2154
            # process the files
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2155
            self.ui.status(_("adding file changes\n"))
14756
fdcf6f09b68d localrepo: mark progress step for translation
Wagner Bruna <wbruna@yahoo.com>
parents: 14646
diff changeset
  2156
            pr.step = _('files')
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2157
            pr.count = 1
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2158
            pr.total = efiles
12334
50946802593d bundle: refactor progress callback
Matt Mackall <mpm@selenic.com>
parents: 12333
diff changeset
  2159
            source.callback = None
50946802593d bundle: refactor progress callback
Matt Mackall <mpm@selenic.com>
parents: 12333
diff changeset
  2160
19291
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2161
            newrevs, newfiles = self.addchangegroupfiles(source, revmap, trp,
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2162
                                                         pr, needfiles)
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2163
            revisions += newrevs
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2164
            files += newfiles
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2165
14036
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2166
            dh = 0
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2167
            if oldheads:
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2168
                heads = cl.heads()
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2169
                dh = len(heads) - len(oldheads)
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2170
                for h in heads:
16720
e825a89de5d7 context: add changectx.closesbranch() method
Brodie Rao <brodie@sf.io>
parents: 16719
diff changeset
  2171
                    if h not in oldheads and self[h].closesbranch():
14036
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2172
                        dh -= 1
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2173
            htext = ""
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2174
            if dh:
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2175
                htext = _(" (%+d heads)") % dh
1998
65cc17ae9649 fix race in localrepo.addchangegroup.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1995
diff changeset
  2176
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2177
            self.ui.status(_("added %d changesets"
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2178
                             " with %d changes to %d files%s\n")
14036
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2179
                             % (changesets, revisions, files, htext))
18105
312262ebc223 cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18101
diff changeset
  2180
            self.invalidatevolatilesets()
1040
35e883d1ff9b Show number of new heads when doing a pull
mpm@selenic.com
parents: 1019
diff changeset
  2181
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2182
            if changesets > 0:
8392
7e5cbb09515b localrepo: use cl throughout in addchangegroup
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 8390
diff changeset
  2183
                p = lambda: cl.writepending() and self.root or ""
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2184
                self.hook('pretxnchangegroup', throw=True,
8393
59160ca338f7 localrepo: use more direct vars in addchangegroup
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 8392
diff changeset
  2185
                          node=hex(cl.node(clstart)), source=srctype,
7787
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  2186
                          url=url, pending=p)
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  2187
15484
a44446ff9ad8 phases: marked content of a changegroup as published
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15483
diff changeset
  2188
            added = [cl.node(r) for r in xrange(clstart, clend)]
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15651
diff changeset
  2189
            publishing = self.ui.configbool('phases', 'publish', True)
15891
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2190
            if srctype == 'push':
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15651
diff changeset
  2191
                # Old server can not push the boundary themself.
15891
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2192
                # New server won't push the boundary if changeset already
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2193
                # existed locally as secrete
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2194
                #
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2195
                # We should not use added here but the list of all change in
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2196
                # the bundle
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2197
                if publishing:
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2198
                    phases.advanceboundary(self, phases.public, srccontent)
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2199
                else:
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2200
                    phases.advanceboundary(self, phases.draft, srccontent)
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2201
                    phases.retractboundary(self, phases.draft, added)
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2202
            elif srctype != 'strip':
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2203
                # publishing only alter behavior during push
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2204
                #
249d3420ec9c phases: move phase according what was pushed not only what was added added
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15890
diff changeset
  2205
                # strip should not touch boundary at all
15818
57241845a4bb phases: store phase values in constant instead of using raw integer
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15735
diff changeset
  2206
                phases.retractboundary(self, phases.draft, added)
15646
218ec96c45d7 phases: add a phases.publish option
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15611
diff changeset
  2207
7787
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  2208
            # make changelog see real files again
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  2209
            cl.finalize(trp)
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2210
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2211
            tr.close()
15584
9df9444e96ec addchangegroup: use a postrelease callback to call changegroup hook
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15583
diff changeset
  2212
15586
98ec09582f72 addchangegroup: ony queue hooks when we have changesets
Matt Mackall <mpm@selenic.com>
parents: 15585
diff changeset
  2213
            if changesets > 0:
18137
d8e7b3a14957 strip: do not update branchcache during strip (issue3745)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18131
diff changeset
  2214
                if srctype != 'strip':
d8e7b3a14957 strip: do not update branchcache during strip (issue3745)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18131
diff changeset
  2215
                    # During strip, branchcache is invalid but coming call to
d8e7b3a14957 strip: do not update branchcache during strip (issue3745)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18131
diff changeset
  2216
                    # `destroyed` will repair it.
d8e7b3a14957 strip: do not update branchcache during strip (issue3745)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18131
diff changeset
  2217
                    # In other case we can safely update cache on disk.
18394
5010448197bc branchmap: update cache of 'unserved' filter on new changesets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18382
diff changeset
  2218
                    branchmap.updatecache(self.filtered('served'))
15586
98ec09582f72 addchangegroup: ony queue hooks when we have changesets
Matt Mackall <mpm@selenic.com>
parents: 15585
diff changeset
  2219
                def runhooks():
19884
fc3fbca35085 changegroup: don't run changegroup hooks if nodes are gone
Durham Goode <durham@fb.com>
parents: 19853
diff changeset
  2220
                    # These hooks run when the lock releases, not when the
fc3fbca35085 changegroup: don't run changegroup hooks if nodes are gone
Durham Goode <durham@fb.com>
parents: 19853
diff changeset
  2221
                    # transaction closes. So it's possible for the changelog
fc3fbca35085 changegroup: don't run changegroup hooks if nodes are gone
Durham Goode <durham@fb.com>
parents: 19853
diff changeset
  2222
                    # to have changed since we last saw it.
fc3fbca35085 changegroup: don't run changegroup hooks if nodes are gone
Durham Goode <durham@fb.com>
parents: 19853
diff changeset
  2223
                    if clstart >= len(self):
fc3fbca35085 changegroup: don't run changegroup hooks if nodes are gone
Durham Goode <durham@fb.com>
parents: 19853
diff changeset
  2224
                        return
fc3fbca35085 changegroup: don't run changegroup hooks if nodes are gone
Durham Goode <durham@fb.com>
parents: 19853
diff changeset
  2225
15584
9df9444e96ec addchangegroup: use a postrelease callback to call changegroup hook
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15583
diff changeset
  2226
                    # forcefully update the on-disk branch cache
9df9444e96ec addchangegroup: use a postrelease callback to call changegroup hook
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15583
diff changeset
  2227
                    self.ui.debug("updating the branch cache\n")
9df9444e96ec addchangegroup: use a postrelease callback to call changegroup hook
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15583
diff changeset
  2228
                    self.hook("changegroup", node=hex(cl.node(clstart)),
9df9444e96ec addchangegroup: use a postrelease callback to call changegroup hook
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15583
diff changeset
  2229
                              source=srctype, url=url)
9df9444e96ec addchangegroup: use a postrelease callback to call changegroup hook
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15583
diff changeset
  2230
9df9444e96ec addchangegroup: use a postrelease callback to call changegroup hook
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15583
diff changeset
  2231
                    for n in added:
9df9444e96ec addchangegroup: use a postrelease callback to call changegroup hook
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15583
diff changeset
  2232
                        self.hook("incoming", node=hex(n), source=srctype,
9df9444e96ec addchangegroup: use a postrelease callback to call changegroup hook
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15583
diff changeset
  2233
                                  url=url)
18672
b2b4ddc55caa blackbox: log incoming changes via ui.log()
Durham Goode <durham@fb.com>
parents: 18661
diff changeset
  2234
18677
539210ed2069 blackbox: only show new heads on incoming
Durham Goode <durham@fb.com>
parents: 18672
diff changeset
  2235
                    newheads = [h for h in self.heads() if h not in oldheads]
18672
b2b4ddc55caa blackbox: log incoming changes via ui.log()
Durham Goode <durham@fb.com>
parents: 18661
diff changeset
  2236
                    self.ui.log("incoming",
18691
4f485bd68f1d blackbox: do not translate the log messages
Durham Goode <durham@fb.com>
parents: 18677
diff changeset
  2237
                                "%s incoming changes - new heads: %s\n",
18672
b2b4ddc55caa blackbox: log incoming changes via ui.log()
Durham Goode <durham@fb.com>
parents: 18661
diff changeset
  2238
                                len(added),
18677
539210ed2069 blackbox: only show new heads on incoming
Durham Goode <durham@fb.com>
parents: 18672
diff changeset
  2239
                                ', '.join([hex(c[:6]) for c in newheads]))
15587
809d5d30e377 localrepo: rename _postrelease to _afterlock
Matt Mackall <mpm@selenic.com>
parents: 15586
diff changeset
  2240
                self._afterlock(runhooks)
15584
9df9444e96ec addchangegroup: use a postrelease callback to call changegroup hook
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15583
diff changeset
  2241
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2242
        finally:
11230
5116a077c3da make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 11228
diff changeset
  2243
            tr.release()
3803
2aef481ac73c Don't report an error when closing heads during local push (issue387)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3801
diff changeset
  2244
        # never return 0 here:
14036
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2245
        if dh < 0:
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2246
            return dh - 1
3803
2aef481ac73c Don't report an error when closing heads during local push (issue387)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3801
diff changeset
  2247
        else:
14036
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2248
            return dh + 1
232
fc4a6e5b5812 hg resolve: merge a given node into the working directory
mpm@selenic.com
parents: 231
diff changeset
  2249
19291
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2250
    def addchangegroupfiles(self, source, revmap, trp, pr, needfiles):
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2251
        revisions = 0
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2252
        files = 0
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2253
        while True:
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2254
            chunkdata = source.filelogheader()
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2255
            if not chunkdata:
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2256
                break
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2257
            f = chunkdata["filename"]
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2258
            self.ui.debug("adding %s revisions\n" % f)
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2259
            pr()
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2260
            fl = self.file(f)
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2261
            o = len(fl)
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2262
            if not fl.addgroup(source, revmap, trp):
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2263
                raise util.Abort(_("received file revlog group is empty"))
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2264
            revisions += len(fl) - o
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2265
            files += 1
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2266
            if f in needfiles:
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2267
                needs = needfiles[f]
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2268
                for new in xrange(o, len(fl)):
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2269
                    n = fl.node(new)
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2270
                    if n in needs:
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2271
                        needs.remove(n)
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2272
                    else:
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2273
                        raise util.Abort(
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2274
                            _("received spurious file revlog entry"))
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2275
                if not needs:
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2276
                    del needfiles[f]
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2277
        self.ui.progress(_('files'), None)
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2278
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2279
        for f, needs in needfiles.iteritems():
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2280
            fl = self.file(f)
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2281
            for n in needs:
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2282
                try:
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2283
                    fl.rev(n)
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2284
                except error.LookupError:
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2285
                    raise util.Abort(
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2286
                        _('missing file data for %s:%s - run hg verify') %
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2287
                        (f, hex(n)))
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2288
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2289
        return revisions, files
93635f69c93b changegroup: move changegroup file adding to a separate function
Durham Goode <durham@fb.com>
parents: 19204
diff changeset
  2290
12296
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2291
    def stream_in(self, remote, requirements):
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2292
        lock = self.lock()
3564
eda9e7c9300d New UnexpectedOutput exception to catch server errors in localrepo.stream_in
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3513
diff changeset
  2293
        try:
17740
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2294
            # Save remote branchmap. We will use it later
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2295
            # to speed up branchcache creation
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2296
            rbranchmap = None
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2297
            if remote.capable("branchmap"):
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2298
                rbranchmap = remote.branchmap()
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2299
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2300
            fp = remote.stream_out()
3564
eda9e7c9300d New UnexpectedOutput exception to catch server errors in localrepo.stream_in
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3513
diff changeset
  2301
            l = fp.readline()
eda9e7c9300d New UnexpectedOutput exception to catch server errors in localrepo.stream_in
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3513
diff changeset
  2302
            try:
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2303
                resp = int(l)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2304
            except ValueError:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2305
                raise error.ResponseError(
16941
a1eb17bed550 localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents: 16866
diff changeset
  2306
                    _('unexpected response from remote server:'), l)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2307
            if resp == 1:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2308
                raise util.Abort(_('operation forbidden by server'))
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2309
            elif resp == 2:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2310
                raise util.Abort(_('locking the remote repository failed'))
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2311
            elif resp != 0:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2312
                raise util.Abort(_('the server sent an unknown error code'))
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2313
            self.ui.status(_('streaming all changes\n'))
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2314
            l = fp.readline()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2315
            try:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2316
                total_files, total_bytes = map(int, l.split(' ', 1))
7063
be2daa324ddf Add missing catch of a TypeError
Bernhard Leiner <bleiner@gmail.com>
parents: 6877
diff changeset
  2317
            except (ValueError, TypeError):
7641
d2f753830f80 error: move UnexpectedOutput (now ResponseError)
Matt Mackall <mpm@selenic.com>
parents: 7640
diff changeset
  2318
                raise error.ResponseError(
16941
a1eb17bed550 localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents: 16866
diff changeset
  2319
                    _('unexpected response from remote server:'), l)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2320
            self.ui.status(_('%d files to transfer, %s of data\n') %
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2321
                           (total_files, util.bytecount(total_bytes)))
16770
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  2322
            handled_bytes = 0
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  2323
            self.ui.progress(_('clone'), 0, total=total_bytes)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2324
            start = time.time()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2325
            for i in xrange(total_files):
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2326
                # XXX doesn't support '\n' or '\r' in filenames
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2327
                l = fp.readline()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2328
                try:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2329
                    name, size = l.split('\0', 1)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2330
                    size = int(size)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2331
                except (ValueError, TypeError):
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2332
                    raise error.ResponseError(
16941
a1eb17bed550 localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents: 16866
diff changeset
  2333
                        _('unexpected response from remote server:'), l)
16398
def789752b60 stream_in: avoid debug calls when debug is disabled
Matt Mackall <mpm@selenic.com>
parents: 16378
diff changeset
  2334
                if self.ui.debugflag:
def789752b60 stream_in: avoid debug calls when debug is disabled
Matt Mackall <mpm@selenic.com>
parents: 16378
diff changeset
  2335
                    self.ui.debug('adding %s (%s)\n' %
def789752b60 stream_in: avoid debug calls when debug is disabled
Matt Mackall <mpm@selenic.com>
parents: 16378
diff changeset
  2336
                                  (name, util.bytecount(size)))
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2337
                # for backwards compat, name was partially encoded
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2338
                ofp = self.sopener(store.decodedir(name), 'w')
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2339
                for chunk in util.filechunkiter(fp, limit=size):
16770
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  2340
                    handled_bytes += len(chunk)
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  2341
                    self.ui.progress(_('clone'), handled_bytes,
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  2342
                                     total=total_bytes)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2343
                    ofp.write(chunk)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2344
                ofp.close()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2345
            elapsed = time.time() - start
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2346
            if elapsed <= 0:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2347
                elapsed = 0.001
16770
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  2348
            self.ui.progress(_('clone'), None)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2349
            self.ui.status(_('transferred %s in %.1f seconds (%s/sec)\n') %
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2350
                           (util.bytecount(total_bytes), elapsed,
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2351
                            util.bytecount(total_bytes / elapsed)))
12296
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2352
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  2353
            # new requirements = old non-format requirements +
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  2354
            #                    new format-related
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2355
            # requirements from the streamed-in repository
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2356
            requirements.update(set(self.requirements) - self.supportedformats)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2357
            self._applyrequirements(requirements)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2358
            self._writerequirements()
12296
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2359
17740
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2360
            if rbranchmap:
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2361
                rbheads = []
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2362
                for bheads in rbranchmap.itervalues():
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2363
                    rbheads.extend(bheads)
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2364
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2365
                if rbheads:
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2366
                    rtiprev = max((int(self.changelog.rev(node))
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2367
                            for node in rbheads))
18125
ad194a8ab5c1 branchmap: add the tipnode (cache key) on the branchcache object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18124
diff changeset
  2368
                    cache = branchmap.branchcache(rbranchmap,
18126
090ada0acddb branchmap: add the tiprev (cache key) on the branchmap object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18125
diff changeset
  2369
                                                  self[rtiprev].node(),
090ada0acddb branchmap: add the tiprev (cache key) on the branchmap object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18125
diff changeset
  2370
                                                  rtiprev)
18397
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  2371
                    # Try to stick it as low as possible
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  2372
                    # filter above served are unlikely to be fetch from a clone
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  2373
                    for candidate in ('base', 'immutable', 'served'):
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  2374
                        rview = self.filtered(candidate)
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  2375
                        if cache.validfor(rview):
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  2376
                            self._branchcaches[candidate] = cache
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  2377
                            cache.write(rview)
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  2378
                            break
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2379
            self.invalidate()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2380
            return len(self.heads()) + 1
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2381
        finally:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2382
            lock.release()
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
  2383
2613
479e26afa10f clone: do not make streaming default. add --stream option instead.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2612
diff changeset
  2384
    def clone(self, remote, heads=[], stream=False):
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  2385
        '''clone remote repository.
1382
b113e7db06e9 hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents: 1375
diff changeset
  2386
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  2387
        keyword arguments:
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  2388
        heads: list of revs to clone (forces use of pull)
2621
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  2389
        stream: use streaming clone if possible'''
247
863b508c5b36 migrate verify
mpm@selenic.com
parents: 244
diff changeset
  2390
2621
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  2391
        # now, all clients that can request uncompressed clones can
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  2392
        # read repo formats supported by all servers that can serve
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  2393
        # them.
247
863b508c5b36 migrate verify
mpm@selenic.com
parents: 244
diff changeset
  2394
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  2395
        # if revlog format changes, client will have to check version
2621
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  2396
        # and format flags on "stream" capability, and use
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  2397
        # uncompressed only if compatible.
247
863b508c5b36 migrate verify
mpm@selenic.com
parents: 244
diff changeset
  2398
16361
6097ede2be4d protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents: 16253
diff changeset
  2399
        if not stream:
17427
57c6c24b9bc4 improve some comments and docstrings, fixing issues found when spell checking
Mads Kiilerich <mads@kiilerich.com>
parents: 17424
diff changeset
  2400
            # if the server explicitly prefers to stream (for fast LANs)
16361
6097ede2be4d protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents: 16253
diff changeset
  2401
            stream = remote.capable('stream-preferred')
6097ede2be4d protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents: 16253
diff changeset
  2402
12296
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2403
        if stream and not heads:
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2404
            # 'stream' means remote revlog format is revlogv1 only
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2405
            if remote.capable('stream'):
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2406
                return self.stream_in(remote, set(('revlogv1',)))
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2407
            # otherwise, 'streamreqs' contains the remote revlog format
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2408
            streamreqs = remote.capable('streamreqs')
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2409
            if streamreqs:
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2410
                streamreqs = set(streamreqs.split(','))
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2411
                # if we support it, stream in and adjust our requirements
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2412
                if not streamreqs - self.supportedformats:
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2413
                    return self.stream_in(remote, streamreqs)
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  2414
        return self.pull(remote, heads)
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  2415
11368
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  2416
    def pushkey(self, namespace, key, old, new):
14102
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2417
        self.hook('prepushkey', throw=True, namespace=namespace, key=key,
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2418
                  old=old, new=new)
17293
d3f84ccc5495 pushkey: add more verbose debug output regarding pushkey
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17252
diff changeset
  2419
        self.ui.debug('pushing key for "%s:%s"\n' % (namespace, key))
14102
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2420
        ret = pushkey.push(self, namespace, key, old, new)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2421
        self.hook('pushkey', namespace=namespace, key=key, old=old, new=new,
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2422
                  ret=ret)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2423
        return ret
11368
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  2424
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  2425
    def listkeys(self, namespace):
14102
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2426
        self.hook('prelistkeys', throw=True, namespace=namespace)
17293
d3f84ccc5495 pushkey: add more verbose debug output regarding pushkey
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17252
diff changeset
  2427
        self.ui.debug('listing keys for "%s"\n' % namespace)
14102
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2428
        values = pushkey.list(self, namespace)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2429
        self.hook('listkeys', namespace=namespace, values=values)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2430
        return values
11368
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  2431
14048
58e58406ed19 wireproto: add test for new optional arg missing on server
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14036
diff changeset
  2432
    def debugwireargs(self, one, two, three=None, four=None, five=None):
13720
9c4e04fe267e debug: add debugwireargs to test argument passing over the wire
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13716
diff changeset
  2433
        '''used to test argument passing over the wire'''
14048
58e58406ed19 wireproto: add test for new optional arg missing on server
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14036
diff changeset
  2434
        return "%s %s %s %s %s" % (one, two, three, four, five)
11368
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  2435
14529
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2436
    def savecommitmessage(self, text):
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2437
        fp = self.opener('last-message.txt', 'wb')
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2438
        try:
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2439
            fp.write(text)
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2440
        finally:
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2441
            fp.close()
18054
b35e3364f94a check-code: there must also be whitespace between ')' and operator
Mads Kiilerich <madski@unity3d.com>
parents: 18044
diff changeset
  2442
        return self.pathto(fp.name[len(self.root) + 1:])
14529
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2443
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  2444
# used to avoid circular references so destructors work
3790
f183c18568df localrepo: change aftertrans to be independant of the store path
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3773
diff changeset
  2445
def aftertrans(files):
f183c18568df localrepo: change aftertrans to be independant of the store path
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3773
diff changeset
  2446
    renamefiles = [tuple(t) for t in files]
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  2447
    def a():
18952
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
  2448
        for vfs, src, dest in renamefiles:
16441
9dd10a574af2 localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents: 16426
diff changeset
  2449
            try:
18952
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
  2450
                vfs.rename(src, dest)
16441
9dd10a574af2 localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents: 16426
diff changeset
  2451
            except OSError: # journal file does not yet exist
9dd10a574af2 localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents: 16426
diff changeset
  2452
                pass
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  2453
    return a
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  2454
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  2455
def undoname(fn):
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  2456
    base, name = os.path.split(fn)
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  2457
    assert name.startswith('journal')
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  2458
    return os.path.join(base, name.replace('journal', 'undo', 1))
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  2459
2740
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
  2460
def instance(ui, path, create):
14825
de9eb6b1da4f util: rename the util.localpath that uses url to urllocalpath (issue2875)
Mads Kiilerich <mads@kiilerich.com>
parents: 14756
diff changeset
  2461
    return localrepository(ui, util.urllocalpath(path), create)
3223
53e843840349 Whitespace/Tab cleanup
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3164
diff changeset
  2462
2740
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
  2463
def islocal(path):
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
  2464
    return True