mercurial/localrepo.py
author Pierre-Yves David <pierre-yves.david@logilab.fr>
Sat, 22 Dec 2012 01:59:05 +0100
changeset 18125 ad194a8ab5c1
parent 18124 79db6d40bced
child 18126 090ada0acddb
permissions -rw-r--r--
branchmap: add the tipnode (cache key) on the branchcache object Gathering data and cache key paves the way to a lot of simplification.
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
17075
28ed1c4511ce obsolete: exchange obsolete marker over pushkey
Pierre-Yves.David@ens-lyon.org
parents: 17070
diff changeset
    11
import lock, transaction, store, encoding, base85
14902
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
    12
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
    13
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
    14
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
    15
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
    16
from lock import release
11303
a1aad8333864 move working dir/dirstate methods from localrepo to workingctx
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 11301
diff changeset
    17
import weakref, errno, os, time, inspect
18117
526e7ec5c96e branchmap: extract write logic from localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18114
diff changeset
    18
import branchmap
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
    19
propertycache = util.propertycache
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
    20
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
    21
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    22
class repofilecache(filecache):
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    23
    """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
    24
    """
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
    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
    27
        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
    28
    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
    29
        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
    30
    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
    31
        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
    32
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    33
class storecache(repofilecache):
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    34
    """filecache for files in the store"""
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    35
    def join(self, obj, fname):
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    36
        return obj.sjoin(fname)
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    37
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    38
class unfilteredpropertycache(propertycache):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    39
    """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
    40
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    41
    def __get__(self, repo, type=None):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    42
        return super(unfilteredpropertycache, self).__get__(repo.unfiltered())
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    43
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    44
class filteredpropertycache(propertycache):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    45
    """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
    46
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    47
    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
    48
        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
    49
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 hasunfilteredcache(repo, name):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    52
    """check if an repo and a unfilteredproperty cached value for <name>"""
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    53
    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
    54
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
    55
def unfilteredmethod(orig):
17994
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    56
    """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
    57
    def wrapper(repo, *args, **kwargs):
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    58
        return orig(repo.unfiltered(), *args, **kwargs)
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    59
    return wrapper
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    60
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    61
MODERNCAPS = set(('lookup', 'branchmap', 'pushkey', 'known', 'getbundle'))
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    62
LEGACYCAPS = MODERNCAPS.union(set(['changegroupsubset']))
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    63
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    64
class localpeer(peer.peerrepository):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    65
    '''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
    66
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    67
    def __init__(self, repo, caps=MODERNCAPS):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    68
        peer.peerrepository.__init__(self)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    69
        self._repo = repo
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    70
        self.ui = repo.ui
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    71
        self._caps = repo._restrictcapabilities(caps)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    72
        self.requirements = repo.requirements
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    73
        self.supportedformats = repo.supportedformats
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    74
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    75
    def close(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    76
        self._repo.close()
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    77
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    78
    def _capabilities(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    79
        return self._caps
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    80
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    81
    def local(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    82
        return self._repo
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    83
17193
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
    84
    def canpush(self):
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
    85
        return True
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
    86
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    87
    def url(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    88
        return self._repo.url()
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    89
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    90
    def lookup(self, key):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    91
        return self._repo.lookup(key)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    92
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    93
    def branchmap(self):
17205
97eff00046de repo: move visibleheads and visiblebranchmap logic in discovery
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17204
diff changeset
    94
        return discovery.visiblebranchmap(self._repo)
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    95
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    96
    def heads(self):
17205
97eff00046de repo: move visibleheads and visiblebranchmap logic in discovery
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17204
diff changeset
    97
        return discovery.visibleheads(self._repo)
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    98
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    99
    def known(self, nodes):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   100
        return self._repo.known(nodes)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   101
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   102
    def getbundle(self, source, heads=None, common=None):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   103
        return self._repo.getbundle(source, heads=heads, common=common)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   104
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   105
    # 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
   106
    # unbundle instead.
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   107
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   108
    def lock(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   109
        return self._repo.lock()
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   110
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   111
    def addchangegroup(self, cg, source, url):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   112
        return self._repo.addchangegroup(cg, source, url)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   113
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   114
    def pushkey(self, namespace, key, old, new):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   115
        return self._repo.pushkey(namespace, key, old, new)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   116
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   117
    def listkeys(self, namespace):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   118
        return self._repo.listkeys(namespace)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   119
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   120
    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
   121
        '''used to test argument passing over the wire'''
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   122
        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
   123
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   124
class locallegacypeer(localpeer):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   125
    '''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
   126
    restricted capabilities'''
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   127
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   128
    def __init__(self, repo):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   129
        localpeer.__init__(self, repo, caps=LEGACYCAPS)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   130
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   131
    def branches(self, nodes):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   132
        return self._repo.branches(nodes)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   133
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   134
    def between(self, pairs):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   135
        return self._repo.between(pairs)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   136
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   137
    def changegroup(self, basenodes, source):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   138
        return self._repo.changegroup(basenodes, source)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   139
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   140
    def changegroupsubset(self, bases, heads, source):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   141
        return self._repo.changegroupsubset(bases, heads, source)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   142
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   143
class localrepository(object):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   144
14270
d6907a5674a2 revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14232
diff changeset
   145
    supportedformats = set(('revlogv1', 'generaldelta'))
12687
34d8247a4595 store: encode first period or space in filenames (issue1713)
Adrian Buehlmann <adrian@cadifra.com>
parents: 12622
diff changeset
   146
    supported = supportedformats | set(('store', 'fncache', 'shared',
34d8247a4595 store: encode first period or space in filenames (issue1713)
Adrian Buehlmann <adrian@cadifra.com>
parents: 12622
diff changeset
   147
                                        'dotencode'))
17137
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   148
    openerreqs = set(('revlogv1', 'generaldelta'))
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   149
    requirements = ['revlogv1']
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   150
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   151
    def _baserequirements(self, create):
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   152
        return self.requirements[:]
2439
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
   153
14363
82f3b0f3f0a5 localrepo, sshrepo: use Boolean create argument in __init__
Martin Geisler <mg@lazybytes.net>
parents: 14333
diff changeset
   154
    def __init__(self, baseui, path=None, create=False):
17650
bf2eb3a126d2 localrepo: use "vfs" constructor instead of "opener" one
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17550
diff changeset
   155
        self.wvfs = scmutil.vfs(path, expand=True)
bf2eb3a126d2 localrepo: use "vfs" constructor instead of "opener" one
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17550
diff changeset
   156
        self.wopener = self.wvfs
17157
87e8440964a0 localrepo: use path expansion API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17156
diff changeset
   157
        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
   158
        self.path = self.wvfs.join(".hg")
3850
a4457828ca1a move code around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3803
diff changeset
   159
        self.origroot = path
14220
21b8ce4d3331 rename path_auditor to pathauditor
Adrian Buehlmann <adrian@cadifra.com>
parents: 14195
diff changeset
   160
        self.auditor = scmutil.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
   161
        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
   162
        self.opener = self.vfs
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   163
        self.baseui = baseui
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   164
        self.ui = baseui.copy()
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
   165
        # 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
   166
        # 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
   167
        # 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
   168
        self._phasedefaults = []
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   169
        try:
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   170
            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
   171
            extensions.loadall(self.ui)
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   172
        except IOError:
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   173
            pass
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   174
17161
be016e96117a localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17160
diff changeset
   175
        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
   176
            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
   177
                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
   178
                    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
   179
                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
   180
                requirements = self._baserequirements(create)
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   181
                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
   182
                    self.vfs.mkdir("store")
4166
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   183
                    requirements.append("store")
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   184
                    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
   185
                        requirements.append("fncache")
12687
34d8247a4595 store: encode first period or space in filenames (issue1713)
Adrian Buehlmann <adrian@cadifra.com>
parents: 12622
diff changeset
   186
                        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
   187
                            requirements.append('dotencode')
4166
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   188
                    # 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
   189
                    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
   190
                        "00changelog.i",
4166
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   191
                        '\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
   192
                        ' 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
   193
                    )
14270
d6907a5674a2 revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14232
diff changeset
   194
                if self.ui.configbool('format', 'generaldelta', False):
d6907a5674a2 revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14232
diff changeset
   195
                    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
   196
                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
   197
            else:
7637
1d54e2f6c0b7 error: move repo errors
Matt Mackall <mpm@selenic.com>
parents: 7633
diff changeset
   198
                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
   199
        elif create:
7637
1d54e2f6c0b7 error: move repo errors
Matt Mackall <mpm@selenic.com>
parents: 7633
diff changeset
   200
            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
   201
        else:
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   202
            try:
17160
22b9b1d2f5d4 localrepo: use "vfs" intead of "opener" while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17159
diff changeset
   203
                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
   204
            except IOError, inst:
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   205
                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
   206
                    raise
14482
58b36e9ea783 introduce new function scmutil.readrequires
Adrian Buehlmann <adrian@cadifra.com>
parents: 14434
diff changeset
   207
                requirements = set()
405
99470ae6b424 Check if repository exists
mpm@selenic.com
parents: 402
diff changeset
   208
8799
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   209
        self.sharedpath = self.path
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   210
        try:
15381
c519cd8f0169 backout dbdb777502dc (issue3077) (issue3071)
Matt Mackall <mpm@selenic.com>
parents: 15355
diff changeset
   211
            s = os.path.realpath(self.opener.read("sharedpath").rstrip('\n'))
8799
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   212
            if not os.path.exists(s):
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   213
                raise error.RepoError(
8908
105343f9f744 Fix warning: Seen unexpected token "%"
Dongsheng Song <dongsheng.song@gmail.com>
parents: 8813
diff changeset
   214
                    _('.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
   215
            self.sharedpath = s
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   216
        except IOError, inst:
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   217
            if inst.errno != errno.ENOENT:
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   218
                raise
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   219
17654
1dc37491e9fb localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17650
diff changeset
   220
        self.store = store.store(requirements, self.sharedpath, scmutil.vfs)
6840
80e51429cb9a introduce store classes
Adrian Buehlmann <adrian@cadifra.com>
parents: 6839
diff changeset
   221
        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
   222
        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
   223
        self.sopener = self.svfs
6840
80e51429cb9a introduce store classes
Adrian Buehlmann <adrian@cadifra.com>
parents: 6839
diff changeset
   224
        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
   225
        self.vfs.createmode = self.store.createmode
12295
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   226
        self._applyrequirements(requirements)
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   227
        if create:
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   228
            self._writerequirements()
3850
a4457828ca1a move code around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3803
diff changeset
   229
9146
5614a628d173 localrepo: rename in-memory tag cache instance attributes (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9145
diff changeset
   230
13047
6c375e07d673 branch: operate on branch names in local string space where possible
Matt Mackall <mpm@selenic.com>
parents: 13037
diff changeset
   231
        self._branchcache = None
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   232
        self.filterpats = {}
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   233
        self._datafilters = {}
4916
5c5d23d93447 Use a weakref for recursive transactions
Matt Mackall <mpm@selenic.com>
parents: 4915
diff changeset
   234
        self._transref = self._lockref = self._wlockref = None
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   235
14929
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   236
        # 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
   237
        # (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
   238
        #
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   239
        # 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
   240
        self._filecache = {}
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   241
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
   242
        # 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
   243
        # 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
   244
        # - 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
   245
        # - 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
   246
        # - 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
   247
        # - 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
   248
        # - 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
   249
        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
   250
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   251
    def close(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   252
        pass
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   253
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   254
    def _restrictcapabilities(self, caps):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   255
        return caps
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   256
12295
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   257
    def _applyrequirements(self, requirements):
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   258
        self.requirements = requirements
14333
31a5973fcf96 revlog: get rid of defversion
Sune Foldager <cryo@cyanite.org>
parents: 14274
diff changeset
   259
        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
   260
                                           if r in self.openerreqs)
12295
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   261
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   262
    def _writerequirements(self):
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   263
        reqfile = self.opener("requires", "w")
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   264
        for r in self.requirements:
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   265
            reqfile.write("%s\n" % r)
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   266
        reqfile.close()
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   267
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   268
    def _checknested(self, path):
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   269
        """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
   270
        if not path.startswith(self.root):
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   271
            return False
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   272
        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
   273
        normsubpath = util.pconvert(subpath)
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   274
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   275
        # 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
   276
        # 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
   277
        #
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   278
        #   $ 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
   279
        #
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   280
        # 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
   281
        # parent revision.
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   282
        #
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   283
        # 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
   284
        # 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
   285
        # 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
   286
        # 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
   287
        # panics when it sees sub/.hg/.
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   288
        #
12174
7bccd04292a2 localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents: 12166
diff changeset
   289
        # 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
   290
        # 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
   291
        # the filesystem *now*.
7bccd04292a2 localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents: 12166
diff changeset
   292
        ctx = self[None]
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   293
        parts = util.splitpath(subpath)
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   294
        while parts:
15722
417127af3996 windows: use normalized path to check repository nesting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15604
diff changeset
   295
            prefix = '/'.join(parts)
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   296
            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
   297
                if prefix == normsubpath:
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   298
                    return True
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   299
                else:
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   300
                    sub = ctx.sub(prefix)
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   301
                    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
   302
            else:
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   303
                parts.pop()
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   304
        return False
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   305
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   306
    def peer(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   307
        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
   308
17993
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   309
    def unfiltered(self):
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   310
        """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
   311
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   312
        Intended to be ovewritten by filtered repo."""
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   313
        return self
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   314
18100
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   315
    def filtered(self, name):
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   316
        """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
   317
        # build a new class with the mixin and the current class
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   318
        # (possibily subclass of the repo)
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   319
        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
   320
            pass
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   321
        return proxycls(self, name)
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   322
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
   323
    @repofilecache('bookmarks')
13355
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   324
    def _bookmarks(self):
17922
7f5dab94e48c bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents: 17857
diff changeset
   325
        return bookmarks.bmstore(self)
13355
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   326
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
   327
    @repofilecache('bookmarks.current')
13355
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   328
    def _bookmarkcurrent(self):
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   329
        return bookmarks.readcurrent(self)
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   330
16707
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   331
    def bookmarkheads(self, bookmark):
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   332
        name = bookmark.split('@', 1)[0]
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   333
        heads = []
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   334
        for mark, n in self._bookmarks.iteritems():
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   335
            if mark.split('@', 1)[0] == name:
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   336
                heads.append(n)
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   337
        return heads
15418
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15403
diff changeset
   338
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
   339
    @storecache('phaseroots')
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   340
    def _phasecache(self):
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   341
        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
   342
17070
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   343
    @storecache('obsstore')
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   344
    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
   345
        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
   346
        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
   347
            # 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
   348
            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
   349
            self.ui.warn(msg % len(list(store)))
17070
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   350
        return store
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   351
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   352
    @unfilteredpropertycache
17208
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   353
    def hiddenrevs(self):
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   354
        """hiddenrevs: revs that should be hidden by command and tools
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   355
17532
e4b2f0ebd6e2 en-us: initialization
timeless@mozdev.org
parents: 17521
diff changeset
   356
        This set is carried on the repo to ease initialization and lazy
17427
57c6c24b9bc4 improve some comments and docstrings, fixing issues found when spell checking
Mads Kiilerich <mads@kiilerich.com>
parents: 17424
diff changeset
   357
        loading; it'll probably move back to changelog for efficiency and
17537
31f32a96e1e3 Merge spelling fixes
Bryan O'Sullivan <bryano@fb.com>
parents: 17469 17532
diff changeset
   358
        consistency reasons.
17208
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   359
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   360
        Note that the hiddenrevs will needs invalidations when
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   361
        - a new changesets is added (possible unstable above extinct)
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   362
        - a new obsolete marker is added (possible new extinct changeset)
17434
038f4f0439d7 test: remove invalid hidden rev in graphlog test
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17427
diff changeset
   363
038f4f0439d7 test: remove invalid hidden rev in graphlog test
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17427
diff changeset
   364
        hidden changesets cannot have non-hidden descendants
17208
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   365
        """
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   366
        hidden = set()
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   367
        if self.obsstore:
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   368
            ### hide extinct changeset that are not accessible by any mean
17716
1adba7ff4d26 hidden: remove tags use in hidden computation
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17715
diff changeset
   369
            hiddenquery = 'extinct() - ::(. + bookmark())'
17208
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   370
            hidden.update(self.revs(hiddenquery))
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   371
        return hidden
8018f2340807 obsolete: mark unreachable extinct changesets as hidden
Pierre-Yves.David@ens-lyon.org
parents: 17207
diff changeset
   372
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
   373
    @storecache('00changelog.i')
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   374
    def changelog(self):
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   375
        c = changelog.changelog(self.sopener)
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   376
        if 'HG_PENDING' in os.environ:
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   377
            p = os.environ['HG_PENDING']
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   378
            if p.startswith(self.root):
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   379
                c.readpending('00changelog.i.a')
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   380
        return c
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   381
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
   382
    @storecache('00manifest.i')
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   383
    def manifest(self):
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   384
        return manifest.manifest(self.sopener)
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   385
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
   386
    @repofilecache('dirstate')
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   387
    def dirstate(self):
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   388
        warned = [0]
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   389
        def validate(node):
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   390
            try:
14064
e4bfb9c337f3 remove unused imports and variables
Alexander Solovyov <alexander@solovyov.net>
parents: 14056
diff changeset
   391
                self.changelog.rev(node)
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   392
                return node
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   393
            except error.LookupError:
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   394
                if not warned[0]:
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   395
                    warned[0] = True
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   396
                    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
   397
                                   " 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
   398
                return nullid
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   399
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   400
        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
   401
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   402
    def __getitem__(self, changeid):
8527
f9a80054dd3c use 'x is None' instead of 'x == None'
Martin Geisler <mg@lazybytes.net>
parents: 8515
diff changeset
   403
        if changeid is None:
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   404
            return context.workingctx(self)
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   405
        return context.changectx(self, changeid)
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   406
9924
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   407
    def __contains__(self, changeid):
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   408
        try:
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   409
            return bool(self.lookup(changeid))
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   410
        except error.RepoLookupError:
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   411
            return False
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   412
6750
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   413
    def __nonzero__(self):
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   414
        return True
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   415
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   416
    def __len__(self):
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   417
        return len(self.changelog)
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   418
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   419
    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
   420
        return iter(self.changelog)
2155
ff255b41b4aa support hooks written in python.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2150
diff changeset
   421
15403
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   422
    def revs(self, expr, *args):
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   423
        '''Return a list of revisions matching the given revset'''
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   424
        expr = revset.formatspec(expr, *args)
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   425
        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
   426
        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
   427
14902
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   428
    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
   429
        '''
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   430
        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
   431
        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
   432
        '''
15403
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   433
        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
   434
            yield self[r]
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   435
2673
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2661
diff changeset
   436
    def url(self):
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2661
diff changeset
   437
        return 'file:' + self.root
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2661
diff changeset
   438
1718
c1996b84d4f5 make hook code nicer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1717
diff changeset
   439
    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
   440
        return hook.hook(self.ui, self, name, throw, **args)
487
2ad41189bee5 Add initial hook support
mpm@selenic.com
parents: 484
diff changeset
   441
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
   442
    @unfilteredmethod
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   443
    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
   444
        if isinstance(names, str):
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   445
            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
   446
11063
eb23c876c111 tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11047
diff changeset
   447
        branches = self.branchmap()
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   448
        for name in names:
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   449
            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
   450
                      local=local)
11063
eb23c876c111 tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11047
diff changeset
   451
            if name in branches:
eb23c876c111 tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11047
diff changeset
   452
                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
   453
                " 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
   454
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   455
        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
   456
            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
   457
            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
   458
                fp.write('\n')
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   459
            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
   460
                m = munge and munge(name) or name
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   461
                if (self._tagscache.tagtypes and
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   462
                    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
   463
                    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
   464
                    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
   465
                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
   466
            fp.close()
5081
ea7b982b6c08 Remove trailing spaces
Thomas Arendsen Hein <thomas@intevation.de>
parents: 4932
diff changeset
   467
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
        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
   469
        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
   470
            try:
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   471
                fp = self.opener('localtags', 'r+')
7875
553aa0cbeab6 cleanup: drop unused assignments
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 7848
diff changeset
   472
            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
   473
                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
   474
            else:
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   475
                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
   476
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
   477
            # 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
   478
            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
   479
            for name in names:
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   480
                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
   481
            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
   482
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   483
        try:
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   484
            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
   485
        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
   486
            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
   487
                raise
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   488
            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
   489
        else:
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   490
            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
   491
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
   492
        # 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
   493
        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
   494
13400
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13391
diff changeset
   495
        fp.close()
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13391
diff changeset
   496
15929
4091660dc130 tag: invalidate tag cache immediately after adding new tag (issue3210)
Mads Kiilerich <mads@kiilerich.com>
parents: 15922
diff changeset
   497
        self.invalidatecaches()
4091660dc130 tag: invalidate tag cache immediately after adding new tag (issue3210)
Mads Kiilerich <mads@kiilerich.com>
parents: 15922
diff changeset
   498
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   499
        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
   500
            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
   501
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
   502
        m = matchmod.exact(self.root, '', ['.hgtags'])
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
   503
        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
   504
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   505
        for name in names:
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   506
            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
   507
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   508
        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
   509
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   510
    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
   511
        '''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
   512
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   513
        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
   514
        string.
6334
7016f7fb8fe3 tab/space cleanup
Thomas Arendsen Hein <thomas@intevation.de>
parents: 6321
diff changeset
   515
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   516
        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
   517
        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
   518
        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
   519
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   520
        keyword arguments:
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   521
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   522
        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
   523
        (default False)
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   524
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   525
        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
   526
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   527
        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
   528
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   529
        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
   530
13133
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   531
        if not local:
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   532
            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
   533
                if '.hgtags' in x:
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   534
                    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
   535
                                       '(please commit .hgtags manually)'))
2601
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   536
7814
4421abf8c85d tag: force load of tag cache
Matt Mackall <mpm@selenic.com>
parents: 7803
diff changeset
   537
        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
   538
        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
   539
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   540
    @filteredpropertycache
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   541
    def _tagscache(self):
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   542
        '''Returns a tagscache object that contains various tags related
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   543
        caches.'''
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   544
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   545
        # 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
   546
        # 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
   547
        class tagscache(object):
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   548
            def __init__(self):
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   549
                # 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
   550
                # 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
   551
                # '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
   552
                # 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
   553
                # 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
   554
                self.tags = self.tagtypes = None
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   555
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   556
                self.nodetagscache = self.tagslist = 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
        cache = tagscache()
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   559
        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
   560
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   561
        return cache
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   562
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   563
    def tags(self):
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   564
        '''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
   565
        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
   566
        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
   567
            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
   568
        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
   569
            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
   570
        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
   571
            try:
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   572
                # ignore tags to unknown nodes
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   573
                self.changelog.rev(v)
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   574
                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
   575
            except (error.LookupError, ValueError):
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   576
                pass
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   577
        return t
4210
caff92047e87 Refactor tags code to prepare for improving the algorithm
Matt Mackall <mpm@selenic.com>
parents: 4178
diff changeset
   578
9145
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   579
    def _findtags(self):
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   580
        '''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
   581
        (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
   582
        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
   583
        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
   584
        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
   585
        duration of the localrepo object.'''
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   586
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   587
        # 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
   588
        # 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
   589
        # 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
   590
        # 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
   591
        # quo fine?
4210
caff92047e87 Refactor tags code to prepare for improving the algorithm
Matt Mackall <mpm@selenic.com>
parents: 4178
diff changeset
   592
9148
b7837f0ed9fe localrepo: factor updatetags() out of readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9147
diff changeset
   593
        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
   594
        tagtypes = {}
659
3662e3d6b690 Whitespace cleanup
Matt Mackall <mpm@selenic.com>
parents: 658
diff changeset
   595
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
   596
        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
   597
        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
   598
9152
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   599
        # 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
   600
        # 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
   601
        # 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
   602
        # local encoding.
9145
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   603
        tags = {}
9147
234a230cc33b localrepo: improve readability of _findtags(), readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9146
diff changeset
   604
        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
   605
            if node != nullid:
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   606
                tags[encoding.tolocal(name)] = node
9145
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   607
        tags['tip'] = self.changelog.tip()
9152
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   608
        tagtypes = dict([(encoding.tolocal(name), value)
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   609
                         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
   610
        return (tags, tagtypes)
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   611
5657
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   612
    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
   613
        '''
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   614
        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
   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
        '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
   617
        '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
   618
        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
   619
        '''
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   620
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   621
        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
   622
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   623
    def tagslist(self):
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   624
        '''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
   625
        if not self._tagscache.tagslist:
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   626
            l = []
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   627
            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
   628
                r = self.changelog.rev(n)
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   629
                l.append((r, t, n))
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   630
            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
   631
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   632
        return self._tagscache.tagslist
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   633
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   634
    def nodetags(self, node):
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   635
        '''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
   636
        if not self._tagscache.nodetagscache:
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   637
            nodetagscache = {}
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   638
            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
   639
                nodetagscache.setdefault(n, []).append(t)
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   640
            for tags in nodetagscache.itervalues():
11047
c7dbd6c4877a tags: return tags in sorted order
Eric Eisner <ede@mit.edu>
parents: 10970
diff changeset
   641
                tags.sort()
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   642
            self._tagscache.nodetagscache = nodetagscache
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   643
        return self._tagscache.nodetagscache.get(node, [])
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   644
13384
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   645
    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
   646
        marks = []
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   647
        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
   648
            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
   649
                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
   650
        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
   651
18112
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   652
    def _cacheabletip(self):
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   653
        """tip-most revision stable enought to used in persistent cache
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   654
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   655
        This function is overwritten by MQ to ensure we do not write cache for
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   656
        a part of the history that will likely change.
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   657
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   658
        Efficient handling of filtered revision in branchcache should offer a
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   659
        better alternative. But we are using this approach until it is ready.
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   660
        """
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   661
        cl = self.changelog
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   662
        return cl.rev(cl.tip())
569091b938a9 branchmap: simplify _branchtags using a new _cacheabletip method
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18106
diff changeset
   663
12066
d01e28657429 localrepo: introduce method for explicit branch cache update
Georg Brandl <georg@python.org>
parents: 12035
diff changeset
   664
    def branchmap(self):
d01e28657429 localrepo: introduce method for explicit branch cache update
Georg Brandl <georg@python.org>
parents: 12035
diff changeset
   665
        '''returns a dictionary {branch: [branchheads]}'''
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
   666
        if self.changelog.filteredrevs:
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
   667
            # some changeset are excluded we can't use the cache
18124
79db6d40bced branchmap: store branchcache in a dedicated object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18123
diff changeset
   668
            bmap = branchmap.branchcache()
18120
88990d3e3d75 branchmap: extract _updatebranchcache from repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18119
diff changeset
   669
            branchmap.update(self, bmap, (self[r] for r in self))
88990d3e3d75 branchmap: extract _updatebranchcache from repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18119
diff changeset
   670
            return bmap
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
   671
        else:
18121
f8a13f061a8a branchmap: extract updatebranchcache from repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18120
diff changeset
   672
            branchmap.updatecache(self)
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
   673
            return self._branchcache
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
   674
7654
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
   675
16719
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   676
    def _branchtip(self, heads):
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   677
        '''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
   678
        tip = heads[-1]
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   679
        for h in reversed(heads):
16720
e825a89de5d7 context: add changectx.closesbranch() method
Brodie Rao <brodie@sf.io>
parents: 16719
diff changeset
   680
            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
   681
                tip = h
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   682
                break
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   683
        return tip
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   684
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   685
    def branchtip(self, branch):
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   686
        '''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
   687
        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
   688
            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
   689
        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
   690
7654
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
   691
    def branchtags(self):
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
   692
        '''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
   693
        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
   694
        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
   695
        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
   696
            bt[bn] = self._branchtip(heads)
7656
6a24fb994701 branch closing: referencing open and closed branches/heads
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7655
diff changeset
   697
        return bt
6a24fb994701 branch closing: referencing open and closed branches/heads
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7655
diff changeset
   698
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   699
    def lookup(self, key):
16378
c463f46fe050 localrepo: lookup now goes through context
Matt Mackall <mpm@selenic.com>
parents: 16371
diff changeset
   700
        return self[key].node()
67
a182f2561c8e Add tag support
mpm@selenic.com
parents: 65
diff changeset
   701
10960
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   702
    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
   703
        repo = remote or self
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   704
        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
   705
            return key
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   706
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   707
        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
   708
        return repo[key].branch()
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   709
13723
e615765fdcc7 wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13720
diff changeset
   710
    def known(self, nodes):
e615765fdcc7 wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13720
diff changeset
   711
        nm = self.changelog.nodemap
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   712
        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
   713
        result = []
816209eaf963 phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15888
diff changeset
   714
        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
   715
            r = nm.get(n)
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   716
            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
   717
            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
   718
        return result
13723
e615765fdcc7 wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13720
diff changeset
   719
926
b765e970c9ff Add a local() method to repository classes
mpm@selenic.com
parents: 923
diff changeset
   720
    def local(self):
14603
68a43fdd7d80 localrepo: local() returns self
Matt Mackall <mpm@selenic.com>
parents: 14549
diff changeset
   721
        return self
926
b765e970c9ff Add a local() method to repository classes
mpm@selenic.com
parents: 923
diff changeset
   722
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   723
    def cancopy(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   724
        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
   725
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   726
    def join(self, f):
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   727
        return os.path.join(self.path, f)
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   728
244
43105253cf5e root relative IO and valid commit states
mpm@selenic.com
parents: 241
diff changeset
   729
    def wjoin(self, f):
43105253cf5e root relative IO and valid commit states
mpm@selenic.com
parents: 241
diff changeset
   730
        return os.path.join(self.root, f)
43105253cf5e root relative IO and valid commit states
mpm@selenic.com
parents: 241
diff changeset
   731
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   732
    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
   733
        if f[0] == '/':
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
   734
            f = f[1:]
4258
b11a2fb59cf5 revlog: simplify revlog version handling
Matt Mackall <mpm@selenic.com>
parents: 4232
diff changeset
   735
        return filelog.filelog(self.sopener, f)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   736
6739
c9fbd6ec3489 context: avoid using None for working parent
Matt Mackall <mpm@selenic.com>
parents: 6736
diff changeset
   737
    def changectx(self, changeid):
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   738
        return self[changeid]
3218
8d4855fd9d7b merge: use new working context object in update
Matt Mackall <mpm@selenic.com>
parents: 3164
diff changeset
   739
3163
1605e336d229 Add localrepo.parents to get parent changectxs.
Matt Mackall <mpm@selenic.com>
parents: 3132
diff changeset
   740
    def parents(self, changeid=None):
6742
2d54e7c1e69d context: clean up parents()
Matt Mackall <mpm@selenic.com>
parents: 6740
diff changeset
   741
        '''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
   742
        return self[changeid].parents()
3163
1605e336d229 Add localrepo.parents to get parent changectxs.
Matt Mackall <mpm@selenic.com>
parents: 3132
diff changeset
   743
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   744
    def setparents(self, p1, p2=nullid):
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   745
        copies = self.dirstate.setparents(p1, p2)
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   746
        if copies:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   747
            # 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
   748
            # 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
   749
            # 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
   750
            pctx = self[p1]
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   751
            for f in copies:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   752
                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
   753
                    self.dirstate.copy(copies[f], f)
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   754
2564
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   755
    def filectx(self, path, changeid=None, fileid=None):
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   756
        """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
   757
           fileid can be a file revision or node."""
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   758
        return context.filectx(self, path, changeid, fileid)
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   759
627
b6c42714d900 Add locate command.
Bryan O'Sullivan <bos@serpentine.com>
parents: 624
diff changeset
   760
    def getcwd(self):
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   761
        return self.dirstate.getcwd()
627
b6c42714d900 Add locate command.
Bryan O'Sullivan <bos@serpentine.com>
parents: 624
diff changeset
   762
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4516
diff changeset
   763
    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
   764
        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
   765
291
2c4f2be05587 Add wopener for opening files in the working directory
mpm@selenic.com
parents: 288
diff changeset
   766
    def wfile(self, f, mode='r'):
2c4f2be05587 Add wopener for opening files in the working directory
mpm@selenic.com
parents: 288
diff changeset
   767
        return self.wopener(f, mode)
2c4f2be05587 Add wopener for opening files in the working directory
mpm@selenic.com
parents: 288
diff changeset
   768
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
   769
    def _link(self, f):
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
   770
        return os.path.islink(self.wjoin(f))
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
   771
11698
9df481f8036d localrepo: refactor filter computation
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11669
diff changeset
   772
    def _loadfilter(self, filter):
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   773
        if filter not in self.filterpats:
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   774
            l = []
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   775
            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
   776
                if cmd == '!':
b71a52f101dc Make it possible to disable filtering for a pattern.
Mads Kiilerich <mads@kiilerich.com>
parents: 7208
diff changeset
   777
                    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
   778
                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
   779
                fn = None
6066
f3a8b5360100 Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents: 6065
diff changeset
   780
                params = cmd
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   781
                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
   782
                    if cmd.startswith(name):
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   783
                        fn = filterfn
6066
f3a8b5360100 Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents: 6065
diff changeset
   784
                        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
   785
                        break
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   786
                if not fn:
5967
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   787
                    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
   788
                # 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
   789
                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
   790
                    oldfn = fn
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   791
                    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
   792
                l.append((mf, fn, params))
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   793
            self.filterpats[filter] = l
12706
9ca08fbb750a localrepo: have _loadfilter return the loaded filter patterns
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12687
diff changeset
   794
        return self.filterpats[filter]
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   795
12707
2216ab103ea8 localrepo: load filter patterns outside of _filter
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12706
diff changeset
   796
    def _filter(self, filterpats, filename, data):
2216ab103ea8 localrepo: load filter patterns outside of _filter
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12706
diff changeset
   797
        for mf, fn, cmd in filterpats:
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   798
            if mf(filename):
9467
4c041f1ee1b4 do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents: 9437
diff changeset
   799
                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
   800
                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
   801
                break
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   802
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   803
        return data
1019
a9cca981c423 Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents: 1013
diff changeset
   804
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   805
    @unfilteredpropertycache
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   806
    def _encodefilterpats(self):
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   807
        return self._loadfilter('encode')
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   808
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   809
    @unfilteredpropertycache
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   810
    def _decodefilterpats(self):
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   811
        return self._loadfilter('decode')
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   812
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   813
    def adddatafilter(self, name, filter):
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   814
        self._datafilters[name] = filter
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   815
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   816
    def wread(self, filename):
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   817
        if self._link(filename):
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   818
            data = os.readlink(self.wjoin(filename))
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   819
        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
   820
            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
   821
        return self._filter(self._encodefilterpats, filename, data)
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   822
4006
67982d3ee76c symlinks: add flags param to wwrite
Matt Mackall <mpm@selenic.com>
parents: 4005
diff changeset
   823
    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
   824
        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
   825
        if 'l' in flags:
1d38f3605b20 util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents: 6875
diff changeset
   826
            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
   827
        else:
14184
4ab6e2d597cc fix errors reported by pyflakes test
Sune Foldager <cryo@cyanite.org>
parents: 14168
diff changeset
   828
            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
   829
            if 'x' in flags:
14232
df2399663392 rename util.set_flags to setflags
Adrian Buehlmann <adrian@cadifra.com>
parents: 14220
diff changeset
   830
                util.setflags(self.wjoin(filename), False, True)
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   831
4005
656e06eebda7 replace filehandle version of wwrite with wwritedata
Matt Mackall <mpm@selenic.com>
parents: 4004
diff changeset
   832
    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
   833
        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
   834
10881
a685011ed38e localrepo: add desc parameter to transaction
Steve Borho <steve@borho.org>
parents: 10877
diff changeset
   835
    def transaction(self, desc):
8072
ecf7795479d5 transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents: 7948
diff changeset
   836
        tr = self._transref and self._transref() or None
ecf7795479d5 transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents: 7948
diff changeset
   837
        if tr and tr.running():
ecf7795479d5 transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents: 7948
diff changeset
   838
            return tr.nest()
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
   839
5865
e7127f669edb transactions: don't show a backtrace when journal exists
Matt Mackall <mpm@selenic.com>
parents: 5814
diff changeset
   840
        # abort here if the journal already exists
e7127f669edb transactions: don't show a backtrace when journal exists
Matt Mackall <mpm@selenic.com>
parents: 5814
diff changeset
   841
        if os.path.exists(self.sjoin("journal")):
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   842
            raise error.RepoError(
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   843
                _("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
   844
16236
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   845
        self._writejournal(desc)
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   846
        renames = [(x, undoname(x)) for x in self._journalfiles()]
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   847
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   848
        tr = transaction.transaction(self.ui.warn, self.sopener,
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   849
                                     self.sjoin("journal"),
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   850
                                     aftertrans(renames),
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   851
                                     self.store.createmode)
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   852
        self._transref = weakref.ref(tr)
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   853
        return tr
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   854
16236
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   855
    def _journalfiles(self):
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   856
        return (self.sjoin('journal'), self.join('journal.dirstate'),
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   857
                self.join('journal.branch'), self.join('journal.desc'),
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   858
                self.join('journal.bookmarks'),
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   859
                self.sjoin('journal.phaseroots'))
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   860
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   861
    def undofiles(self):
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   862
        return [undoname(x) for x in self._journalfiles()]
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   863
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   864
    def _writejournal(self, desc):
16456
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   865
        self.opener.write("journal.dirstate",
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   866
                          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
   867
        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
   868
                          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
   869
        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
   870
                          "%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
   871
        self.opener.write("journal.bookmarks",
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   872
                          self.opener.tryread("bookmarks"))
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   873
        self.sopener.write("journal.phaseroots",
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   874
                           self.sopener.tryread("phaseroots"))
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   875
210
d2badbd7d1ad hg undo: fixup working dir state
mpm@selenic.com
parents: 207
diff changeset
   876
    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
   877
        lock = self.lock()
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   878
        try:
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   879
            if os.path.exists(self.sjoin("journal")):
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   880
                self.ui.status(_("rolling back interrupted transaction\n"))
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   881
                transaction.rollback(self.sopener, self.sjoin("journal"),
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   882
                                     self.ui.warn)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   883
                self.invalidate()
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   884
                return True
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   885
            else:
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   886
                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
   887
                return False
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   888
        finally:
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
   889
            lock.release()
210
d2badbd7d1ad hg undo: fixup working dir state
mpm@selenic.com
parents: 207
diff changeset
   890
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   891
    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
   892
        wlock = lock = None
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   893
        try:
1712
21dcf38e5d7d Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents: 1709
diff changeset
   894
            wlock = self.wlock()
4438
3900f684a150 Fix hg import --exact bug that hangs hg on failure.
Eric Hopper <hopper@omnifarious.org>
parents: 4417
diff changeset
   895
            lock = self.lock()
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   896
            if os.path.exists(self.sjoin("undo")):
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   897
                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
   898
            else:
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   899
                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
   900
                return 1
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   901
        finally:
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
   902
            release(lock, wlock)
162
5dcbe4d9a30c Implement recover and undo commands
mpm@selenic.com
parents: 161
diff changeset
   903
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
   904
    @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
   905
    def _rollback(self, dryrun, force):
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   906
        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
   907
        try:
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   908
            args = self.opener.read('undo.desc').splitlines()
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   909
            (oldlen, desc, detail) = (int(args[0]), args[1], None)
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   910
            if len(args) >= 3:
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   911
                detail = args[2]
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   912
            oldtip = oldlen - 1
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   913
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   914
            if detail and ui.verbose:
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   915
                msg = (_('repository tip rolled back to revision %s'
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   916
                         ' (undo %s: %s)\n')
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   917
                       % (oldtip, desc, detail))
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   918
            else:
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   919
                msg = (_('repository tip rolled back to revision %s'
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   920
                         ' (undo %s)\n')
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   921
                       % (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
   922
        except IOError:
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   923
            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
   924
            desc = None
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   925
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   926
        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
   927
            raise util.Abort(
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   928
                _('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
   929
                  '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
   930
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   931
        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
   932
        if dryrun:
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   933
            return 0
15131
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   934
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   935
        parents = self.dirstate.parents()
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   936
        transaction.rollback(self.sopener, self.sjoin('undo'), ui.warn)
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   937
        if os.path.exists(self.join('undo.bookmarks')):
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   938
            util.rename(self.join('undo.bookmarks'),
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   939
                        self.join('bookmarks'))
15455
c6f87bdab2a1 phases: add rollback support
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15454
diff changeset
   940
        if os.path.exists(self.sjoin('undo.phaseroots')):
c6f87bdab2a1 phases: add rollback support
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15454
diff changeset
   941
            util.rename(self.sjoin('undo.phaseroots'),
c6f87bdab2a1 phases: add rollback support
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15454
diff changeset
   942
                        self.sjoin('phaseroots'))
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   943
        self.invalidate()
15131
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   944
17324
9f94358f9f93 localrepo: clear the filecache on _rollback() and destroyed()
Idan Kamara <idankk86@gmail.com>
parents: 17306
diff changeset
   945
        # Discard all cache entries to force reloading everything.
9f94358f9f93 localrepo: clear the filecache on _rollback() and destroyed()
Idan Kamara <idankk86@gmail.com>
parents: 17306
diff changeset
   946
        self._filecache.clear()
9f94358f9f93 localrepo: clear the filecache on _rollback() and destroyed()
Idan Kamara <idankk86@gmail.com>
parents: 17306
diff changeset
   947
15131
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   948
        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
   949
                      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
   950
        if parentgone:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   951
            util.rename(self.join('undo.dirstate'), self.join('dirstate'))
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   952
            try:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   953
                branch = self.opener.read('undo.branch')
17360
935831597e16 rollback: write dirstate branch with correct encoding
Sune Foldager <cryo@cyanite.org>
parents: 17324
diff changeset
   954
                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
   955
            except IOError:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   956
                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
   957
                          'current branch is still \'%s\'\n')
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   958
                        % self.dirstate.branch())
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   959
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   960
            self.dirstate.invalidate()
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   961
            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
   962
            if len(parents) > 1:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   963
                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
   964
                            'revisions %d and %d\n') % parents)
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   965
            else:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   966
                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
   967
                            '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
   968
        # 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
   969
        # 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
   970
        # invalidated.
15604
b8d8599410da rollback: always call destroyed() (regression from 1.9)
Greg Ward <greg-hg@gerg.ca>
parents: 15381
diff changeset
   971
        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
   972
        return 0
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   973
10547
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
   974
    def invalidatecaches(self):
15988
827e0126738d localrepo: delete _phaserev when invalidating caches
Idan Kamara <idankk86@gmail.com>
parents: 15987
diff changeset
   975
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   976
        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
   977
            # 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
   978
            del self.__dict__['_tagscache']
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   979
17995
a5d85476da6e clfilter: ensure `branchcache` logic runs unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17994
diff changeset
   980
        self.unfiltered()._branchcache = None # in UTF-8
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
   981
        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
   982
312262ebc223 cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18101
diff changeset
   983
    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
   984
        self.filteredrevcache.clear()
17469
fb72eec7efd8 obsolete: introduce caches for all meaningful sets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17434
diff changeset
   985
        obsolete.clearobscaches(self)
18106
2cf01eb74842 hidden: invalidate hiddenrevs when needed
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18105
diff changeset
   986
        if 'hiddenrevs' in vars(self):
2cf01eb74842 hidden: invalidate hiddenrevs when needed
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18105
diff changeset
   987
            del self.hiddenrevs
1784
2e0a288ca93e revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1782
diff changeset
   988
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   989
    def invalidatedirstate(self):
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   990
        '''Invalidates the dirstate, causing the next call to dirstate
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   991
        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
   992
        rereading it if it has.
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   993
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
   994
        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
   995
        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
   996
        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
   997
        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
   998
        if hasunfilteredcache(self, 'dirstate'):
16200
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
   999
            for k in self.dirstate._filecache:
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
  1000
                try:
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
  1001
                    delattr(self.dirstate, k)
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
  1002
                except AttributeError:
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
  1003
                    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
  1004
            delattr(self.unfiltered(), 'dirstate')
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1005
10547
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
  1006
    def invalidate(self):
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
  1007
        unfiltered = self.unfiltered() # all filecaches are stored on unfiltered
14935
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1008
        for k in self._filecache:
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1009
            # dirstate is invalidated separately in invalidatedirstate()
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1010
            if k == 'dirstate':
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1011
                continue
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1012
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1013
            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
  1014
                delattr(unfiltered, k)
14935
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1015
            except AttributeError:
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1016
                pass
10547
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
  1017
        self.invalidatecaches()
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
  1018
4913
46e39935ce33 rename and simplify do_lock
Matt Mackall <mpm@selenic.com>
parents: 4912
diff changeset
  1019
    def _lock(self, lockname, wait, releasefn, acquirefn, desc):
161
0b4c5cb953d9 Simply repository locking
mpm@selenic.com
parents: 155
diff changeset
  1020
        try:
3457
ff06fe0703ef localrepo: add separate methods for manipulating repository data
Matt Mackall <mpm@selenic.com>
parents: 3456
diff changeset
  1021
            l = lock.lock(lockname, 0, releasefn, desc=desc)
7640
7197812e8d44 error: move lock errors
Matt Mackall <mpm@selenic.com>
parents: 7637
diff changeset
  1022
        except error.LockHeld, inst:
1531
2ba8bf7defda add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1516
diff changeset
  1023
            if not wait:
2016
ff5c9a92f556 fix backtrace printed when cannot get lock.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1998
diff changeset
  1024
                raise
3688
d92dad355000 Corrected "waiting for lock on repository FOO held by BAR" message.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3687
diff changeset
  1025
            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
  1026
                         (desc, inst.locker))
2016
ff5c9a92f556 fix backtrace printed when cannot get lock.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1998
diff changeset
  1027
            # default to 600 seconds timeout
3457
ff06fe0703ef localrepo: add separate methods for manipulating repository data
Matt Mackall <mpm@selenic.com>
parents: 3456
diff changeset
  1028
            l = lock.lock(lockname, int(self.ui.config("ui", "timeout", "600")),
2016
ff5c9a92f556 fix backtrace printed when cannot get lock.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1998
diff changeset
  1029
                          releasefn, desc=desc)
1751
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1030
        if acquirefn:
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1031
            acquirefn()
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1032
        return l
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1033
15587
809d5d30e377 localrepo: rename _postrelease to _afterlock
Matt Mackall <mpm@selenic.com>
parents: 15586
diff changeset
  1034
    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
  1035
        """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
  1036
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1037
        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
  1038
        l = self._lockref and self._lockref()
15588
632f4be4d1f3 localrepo: remove asserts in _afterlock
Matt Mackall <mpm@selenic.com>
parents: 15587
diff changeset
  1039
        if l:
15589
cc24e4ed3e0c lock: change name of release chain
Matt Mackall <mpm@selenic.com>
parents: 15588
diff changeset
  1040
            l.postrelease.append(callback)
16680
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1041
        else:
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1042
            callback()
15583
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1043
4914
9a2a73ea6135 repo locks: use True/False
Matt Mackall <mpm@selenic.com>
parents: 4913
diff changeset
  1044
    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
  1045
        '''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
  1046
        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
  1047
        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
  1048
        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
  1049
        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
  1050
            l.lock()
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1051
            return l
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1052
14931
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1053
        def unlock():
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1054
            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
  1055
            if hasunfilteredcache(self, '_phasecache'):
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
  1056
                self._phasecache.write()
14931
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1057
            for k, ce in self._filecache.items():
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1058
                if k == 'dirstate':
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1059
                    continue
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1060
                ce.refresh()
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1061
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1062
        l = self._lock(self.sjoin("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
  1063
                       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
  1064
        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
  1065
        return l
1751
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1066
4914
9a2a73ea6135 repo locks: use True/False
Matt Mackall <mpm@selenic.com>
parents: 4913
diff changeset
  1067
    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
  1068
        '''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
  1069
        .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
  1070
        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
  1071
        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
  1072
        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
  1073
            l.lock()
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1074
            return l
1531
2ba8bf7defda add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1516
diff changeset
  1075
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1076
        def unlock():
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1077
            self.dirstate.write()
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1078
            ce = self._filecache.get('dirstate')
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1079
            if ce:
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1080
                ce.refresh()
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1081
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1082
        l = self._lock(self.join("wlock"), wait, unlock,
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1083
                       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
  1084
                       self.origroot)
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1085
        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
  1086
        return l
1531
2ba8bf7defda add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1516
diff changeset
  1087
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1088
    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
  1089
        """
3294
a2d93b186a0e commit: unify file-level commit code
Matt Mackall <mpm@selenic.com>
parents: 3293
diff changeset
  1090
        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
  1091
        """
3292
764688cf51e5 merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents: 3241
diff changeset
  1092
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1093
        fname = fctx.path()
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1094
        text = fctx.data()
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1095
        flog = self.file(fname)
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1096
        fparent1 = manifest1.get(fname, nullid)
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1097
        fparent2 = fparent2o = manifest2.get(fname, nullid)
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1098
3292
764688cf51e5 merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents: 3241
diff changeset
  1099
        meta = {}
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1100
        copy = fctx.renamed()
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1101
        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
  1102
            # 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
  1103
            # 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
  1104
            # 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
  1105
            # 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
  1106
            # 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
  1107
            #
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
  1108
            # 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
  1109
            #   \       /     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
  1110
            #    \- 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
  1111
            #                      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
  1112
            #                      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
  1113
            #
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
  1114
            # 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
  1115
            #
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
  1116
            # 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
  1117
            #   \       /     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
  1118
            #    \- 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
  1119
            #
6874
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1120
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1121
            cfname = copy[0]
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1122
            crev = manifest1.get(cfname)
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1123
            newfparent = fparent2
6874
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1124
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1125
            if manifest2: # branch merge
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1126
                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
  1127
                    if cfname in manifest2:
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1128
                        crev = manifest2[cfname]
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1129
                        newfparent = fparent1
6874
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1130
6875
0d714a48ab53 add a fix for issue 1175
Matt Mackall <mpm@selenic.com>
parents: 6874
diff changeset
  1131
            # 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
  1132
            if not crev:
9467
4c041f1ee1b4 do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents: 9437
diff changeset
  1133
                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
  1134
                              (fname, cfname))
13000
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1135
                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
  1136
                    if cfname in ancestor:
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1137
                        crev = ancestor[cfname].filenode()
6876
077f1e637cd8 Merge with stable
Matt Mackall <mpm@selenic.com>
parents: 6875 6840
diff changeset
  1138
                        break
6875
0d714a48ab53 add a fix for issue 1175
Matt Mackall <mpm@selenic.com>
parents: 6874
diff changeset
  1139
13000
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1140
            if crev:
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1141
                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
  1142
                meta["copy"] = cfname
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1143
                meta["copyrev"] = hex(crev)
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1144
                fparent1, fparent2 = nullid, newfparent
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1145
            else:
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1146
                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
  1147
                               "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
  1148
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1149
        elif fparent2 != nullid:
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1150
            # 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
  1151
            fparentancestor = flog.ancestor(fparent1, fparent2)
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1152
            if fparentancestor == fparent1:
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1153
                fparent1, fparent2 = fparent2, nullid
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1154
            elif fparentancestor == fparent2:
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1155
                fparent2 = nullid
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1156
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1157
        # is the file changed?
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1158
        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
  1159
            changelist.append(fname)
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1160
            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
  1161
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1162
        # are just the flags changed during merge?
10320
808c187fc556 localrepo: minor formatting - remove double space
Henri Wiechers <hwiechers@gmail.com>
parents: 10282
diff changeset
  1163
        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
  1164
            changelist.append(fname)
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1165
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1166
        return fparent1
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1167
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  1168
    @unfilteredmethod
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1169
    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
  1170
               editor=False, extra={}):
8515
865e08a7d6b0 localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 8503
diff changeset
  1171
        """Add a new revision to current repository.
865e08a7d6b0 localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 8503
diff changeset
  1172
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1173
        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
  1174
        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
  1175
        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
  1176
        """
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1177
8715
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1178
        def fail(f, msg):
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1179
            raise util.Abort('%s: %s' % (f, msg))
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1180
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1181
        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
  1182
            match = matchmod.always(self.root, '')
8715
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1183
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1184
        if not force:
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1185
            vdirs = []
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1186
            match.dir = vdirs.append
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1187
            match.bad = fail
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1188
8405
7cbf8fcd2453 commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents: 8404
diff changeset
  1189
        wlock = self.wlock()
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1190
        try:
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1191
            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
  1192
            merge = len(wctx.parents()) > 1
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
  1193
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1194
            if (not force and merge and match and
8501
ab0e3f7ea315 commit: some tidying
Matt Mackall <mpm@selenic.com>
parents: 8500
diff changeset
  1195
                (match.files() or match.anypats())):
8397
613ac2856535 remove deprecated rawcommit
Matt Mackall <mpm@selenic.com>
parents: 8395
diff changeset
  1196
                raise util.Abort(_('cannot partially commit a merge '
613ac2856535 remove deprecated rawcommit
Matt Mackall <mpm@selenic.com>
parents: 8395
diff changeset
  1197
                                   '(do not specify files or patterns)'))
6706
716a1296e182 localrepo: replace dirstate by workingfilectx in filecommit()
Patrick Mezard <pmezard@gmail.com>
parents: 6705
diff changeset
  1198
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1199
            changes = self.status(match=match, clean=force)
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1200
            if force:
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1201
                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
  1202
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1203
            # check subrepos
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1204
            subs = []
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1205
            commitsubs = set()
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1206
            newstate = wctx.substate.copy()
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1207
            # 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
  1208
            if '.hgsub' in wctx:
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1209
                # 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
  1210
                if '.hgsubstate' in changes[0]:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1211
                    changes[0].remove('.hgsubstate')
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1212
                if '.hgsubstate' in changes[2]:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1213
                    changes[2].remove('.hgsubstate')
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1214
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1215
                # 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
  1216
                # 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
  1217
                oldstate = wctx.p1().substate
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1218
                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
  1219
                    if not match(s):
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1220
                        # 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
  1221
                        if s in oldstate:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1222
                            newstate[s] = oldstate[s]
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1223
                            continue
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1224
                        if not force:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1225
                            raise util.Abort(
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1226
                                _("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
  1227
                    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
  1228
                        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
  1229
                            raise util.Abort(
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1230
                                _("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
  1231
                                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
  1232
                        subs.append(s)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1233
                        commitsubs.add(s)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1234
                    else:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1235
                        bs = wctx.sub(s).basestate()
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1236
                        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
  1237
                        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
  1238
                            subs.append(s)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1239
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1240
                # 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
  1241
                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
  1242
                    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
  1243
                    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
  1244
                if subs:
14536
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1245
                    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
  1246
                        '.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
  1247
                        raise util.Abort(
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1248
                            _("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
  1249
                    changes[0].insert(0, '.hgsubstate')
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1250
14536
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1251
            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
  1252
                # 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
  1253
                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
  1254
                    '.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
  1255
                    changes[2].insert(0, '.hgsubstate')
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1256
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1257
            # 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
  1258
            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
  1259
                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
  1260
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1261
                for f in match.files():
17378
b05e517c2236 commit: normalize filenames when checking explicit files (issue3576)
Matt Mackall <mpm@selenic.com>
parents: 17360
diff changeset
  1262
                    f = self.dirstate.normalize(f)
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1263
                    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
  1264
                        continue
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1265
                    if f in changes[3]: # missing
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1266
                        fail(f, _('file not found!'))
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1267
                    if f in vdirs: # visited directory
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1268
                        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
  1269
                        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
  1270
                            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
  1271
                                break
bcb6e5bebd93 commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents: 8709
diff changeset
  1272
                        else:
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1273
                            fail(f, _("no match under directory!"))
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1274
                    elif f not in self.dirstate:
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1275
                        fail(f, _("file not tracked!"))
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1276
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1277
            if (not force and not extra.get("close") and not merge
8501
ab0e3f7ea315 commit: some tidying
Matt Mackall <mpm@selenic.com>
parents: 8500
diff changeset
  1278
                and not (changes[0] or changes[1] or changes[2])
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1279
                and wctx.branch() == wctx.p1().branch()):
8404
a2bc39ade36b commit: move 'nothing changed' test into commit()
Matt Mackall <mpm@selenic.com>
parents: 8403
diff changeset
  1280
                return None
a2bc39ade36b commit: move 'nothing changed' test into commit()
Matt Mackall <mpm@selenic.com>
parents: 8403
diff changeset
  1281
16536
63c817ea4a70 commit: abort on merge with missing files
Patrick Mezard <patrick@mezard.eu>
parents: 16456
diff changeset
  1282
            if merge and changes[3]:
63c817ea4a70 commit: abort on merge with missing files
Patrick Mezard <patrick@mezard.eu>
parents: 16456
diff changeset
  1283
                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
  1284
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
  1285
            ms = mergemod.mergestate(self)
6888
7c36a4fb05a3 make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents: 6884
diff changeset
  1286
            for f in changes[0]:
7c36a4fb05a3 make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents: 6884
diff changeset
  1287
                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
  1288
                    raise util.Abort(_("unresolved merge conflicts "
13541
919174c0aaff Improve unresolved merge conflicts warning (issue2681)
Patrick Mezard <pmezard@gmail.com>
parents: 13526
diff changeset
  1289
                                       "(see hg help resolve)"))
8496
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1290
10969
ca052b484e56 context: remove parents parameter to workingctx
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10960
diff changeset
  1291
            cctx = context.workingctx(self, text, user, date, extra, changes)
8496
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1292
            if editor:
8994
4a1187d3cb00 commit: report modified subrepos in commit editor
Matt Mackall <mpm@selenic.com>
parents: 8954
diff changeset
  1293
                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
  1294
            edited = (text != cctx._text)
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1295
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1296
            # 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
  1297
            if subs:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1298
                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
  1299
                    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
  1300
                    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
  1301
                        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
  1302
                    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
  1303
                    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
  1304
                subrepo.writestate(self, newstate)
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1305
9934
720f70b720d3 commit: save commit message so it's not destroyed by rollback.
Greg Ward <greg-hg@gerg.ca>
parents: 9924
diff changeset
  1306
            # 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
  1307
            # (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
  1308
            # 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
  1309
            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
  1310
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1311
            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
  1312
            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
  1313
            try:
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1314
                self.hook("precommit", throw=True, parent1=hookp1,
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1315
                          parent2=hookp2)
9935
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1316
                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
  1317
            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
  1318
                if edited:
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1319
                    self.ui.write(
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1320
                        _('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
  1321
                raise
8496
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1322
13357
b67867940bd1 bookmarks: move commit action into core
Matt Mackall <mpm@selenic.com>
parents: 13356
diff changeset
  1323
            # update bookmarks, dirstate and mergestate
16706
a270ec977ba6 bookmarks: delete divergent bookmarks on merge
David Soria Parra <dsp@php.net>
parents: 16705
diff changeset
  1324
            bookmarks.update(self, [p1, p2], ret)
8416
9dfee83c93c8 commit: hoist the rest of the dirstate manipulation out of commitctx
Matt Mackall <mpm@selenic.com>
parents: 8415
diff changeset
  1325
            for f in changes[0] + changes[1]:
9dfee83c93c8 commit: hoist the rest of the dirstate manipulation out of commitctx
Matt Mackall <mpm@selenic.com>
parents: 8415
diff changeset
  1326
                self.dirstate.normal(f)
9dfee83c93c8 commit: hoist the rest of the dirstate manipulation out of commitctx
Matt Mackall <mpm@selenic.com>
parents: 8415
diff changeset
  1327
            for f in changes[2]:
14434
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14365
diff changeset
  1328
                self.dirstate.drop(f)
8416
9dfee83c93c8 commit: hoist the rest of the dirstate manipulation out of commitctx
Matt Mackall <mpm@selenic.com>
parents: 8415
diff changeset
  1329
            self.dirstate.setparents(ret)
8503
90f86a5330bb commit: tidy up mergestate slightly
Matt Mackall <mpm@selenic.com>
parents: 8502
diff changeset
  1330
            ms.reset()
6710
0aa91f69a4c4 localrepo: extract _commitctx() from commit()
Patrick Mezard <pmezard@gmail.com>
parents: 6709
diff changeset
  1331
        finally:
8405
7cbf8fcd2453 commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents: 8404
diff changeset
  1332
            wlock.release()
6710
0aa91f69a4c4 localrepo: extract _commitctx() from commit()
Patrick Mezard <pmezard@gmail.com>
parents: 6709
diff changeset
  1333
16680
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1334
        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
  1335
            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
  1336
        self._afterlock(commithook)
10492
0e64d814d7d0 run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents: 10435
diff changeset
  1337
        return ret
0e64d814d7d0 run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents: 10435
diff changeset
  1338
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  1339
    @unfilteredmethod
8496
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1340
    def commitctx(self, ctx, error=False):
7077
ccbd39cad3c3 context: improve memctx documentation
Patrick Mezard <pmezard@gmail.com>
parents: 7072
diff changeset
  1341
        """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
  1342
        Revision information is passed via the context argument.
7077
ccbd39cad3c3 context: improve memctx documentation
Patrick Mezard <pmezard@gmail.com>
parents: 7072
diff changeset
  1343
        """
6715
a3c41abfa828 context: add memctx for memory commits
Patrick Mezard <pmezard@gmail.com>
parents: 6712
diff changeset
  1344
8412
2bf4f380f6ab commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents: 8411
diff changeset
  1345
        tr = lock = None
12899
fabe61418a53 localrepo: do not modify ctx.remove() list in-place
Patrick Mezard <pmezard@gmail.com>
parents: 12847
diff changeset
  1346
        removed = list(ctx.removed())
8414
2348ce25849b commitctx: use contexts more fully
Matt Mackall <mpm@selenic.com>
parents: 8412
diff changeset
  1347
        p1, p2 = ctx.p1(), ctx.p2()
8412
2bf4f380f6ab commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents: 8411
diff changeset
  1348
        user = ctx.user()
990
5007e0bdeed2 Fix long-standing excessive file merges
mpm@selenic.com
parents: 981
diff changeset
  1349
8411
4d5916358abd commit: move lots of commitctx outside of the repo lock
Matt Mackall <mpm@selenic.com>
parents: 8410
diff changeset
  1350
        lock = self.lock()
4d5916358abd commit: move lots of commitctx outside of the repo lock
Matt Mackall <mpm@selenic.com>
parents: 8410
diff changeset
  1351
        try:
10881
a685011ed38e localrepo: add desc parameter to transaction
Steve Borho <steve@borho.org>
parents: 10877
diff changeset
  1352
            tr = self.transaction("commit")
4970
30d4d8985dd8 transactions: avoid late tear-down (issue641)
Matt Mackall <mpm@selenic.com>
parents: 4917
diff changeset
  1353
            trp = weakref.proxy(tr)
151
1f6c61a60586 Bail on attempts to do an empty commit
mpm@selenic.com
parents: 149
diff changeset
  1354
14162
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1355
            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
  1356
                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
  1357
                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
  1358
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1359
                # 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
  1360
                new = {}
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1361
                changed = []
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1362
                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
  1363
                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
  1364
                    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
  1365
                    try:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1366
                        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
  1367
                        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
  1368
                                                  changed)
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1369
                        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
  1370
                    except OSError, inst:
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1371
                        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
  1372
                        raise
14162
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1373
                    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
  1374
                        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
  1375
                        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
  1376
                            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
  1377
                            raise
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1378
                        else:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1379
                            removed.append(f)
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
  1380
14162
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1381
                # update manifest
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1382
                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
  1383
                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
  1384
                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
  1385
                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
  1386
                    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
  1387
                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
  1388
                                       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
  1389
                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
  1390
            else:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1391
                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
  1392
                files = []
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
  1393
8499
fb9b83df45f3 commit: move description trimming into changelog
Matt Mackall <mpm@selenic.com>
parents: 8498
diff changeset
  1394
            # update changelog
7787
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  1395
            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
  1396
            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
  1397
                                   trp, p1.node(), p2.node(),
8412
2bf4f380f6ab commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents: 8411
diff changeset
  1398
                                   user, ctx.date(), ctx.extra().copy())
7787
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  1399
            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
  1400
            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
  1401
            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
  1402
                      parent2=xp2, pending=p)
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  1403
            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
  1404
            # 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
  1405
            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
  1406
            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
  1407
                # 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
  1408
                # 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
  1409
                # 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
  1410
                #
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
  1411
                # 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
  1412
                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
  1413
            tr.close()
18121
f8a13f061a8a branchmap: extract updatebranchcache from repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18120
diff changeset
  1414
            branchmap.updatecache(self)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1415
            return n
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1416
        finally:
11230
5116a077c3da make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 11228
diff changeset
  1417
            if tr:
5116a077c3da make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 11228
diff changeset
  1418
                tr.release()
8405
7cbf8fcd2453 commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents: 8404
diff changeset
  1419
            lock.release()
660
2c83350784c3 Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents: 659
diff changeset
  1420
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  1421
    @unfilteredmethod
17013
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1422
    def destroyed(self, newheadnodes=None):
9150
09a1ee498756 localrepo: add destroyed() method for strip/rollback to use (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9149
diff changeset
  1423
        '''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
  1424
        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
  1425
        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
  1426
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1427
        If you know the branchheadcache was uptodate before nodes were removed
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1428
        and you also know the set of candidate new heads that may have resulted
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1429
        from the destruction, you can set newheadnodes.  This will enable the
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1430
        code to update the branchheads cache, rather than having future code
17424
e7cfe3587ea4 fix trivial spelling errors
Mads Kiilerich <mads@kiilerich.com>
parents: 17378
diff changeset
  1431
        decide it's invalid and regenerating it from scratch.
17013
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1432
        '''
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1433
        # If we have info, newheadnodes, on how to update the branch cache, do
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1434
        # it, Otherwise, since nodes were destroyed, the cache is stale and this
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1435
        # will be caught the next time it is read.
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1436
        if newheadnodes:
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1437
            tiprev = len(self) - 1
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1438
            ctxgen = (self[node] for node in newheadnodes
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1439
                      if self.changelog.hasnode(node))
18120
88990d3e3d75 branchmap: extract _updatebranchcache from repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18119
diff changeset
  1440
            branchmap.update(self, self._branchcache, ctxgen)
18125
ad194a8ab5c1 branchmap: add the tipnode (cache key) on the branchcache object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18124
diff changeset
  1441
            self._branchcache.tipnode = self.changelog.tip()
ad194a8ab5c1 branchmap: add the tipnode (cache key) on the branchcache object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18124
diff changeset
  1442
            branchmap.write(self, self._branchcache, self._branchcache.tipnode,
18117
526e7ec5c96e branchmap: extract write logic from localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18114
diff changeset
  1443
                            tiprev)
9151
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1444
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1445
        # 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
  1446
        # 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
  1447
        # 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
  1448
        # guarantees that "cachetip == currenttip" (comparing both rev
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1449
        # 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
  1450
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1451
        # 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
  1452
        # 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
  1453
        # 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
  1454
        # tag cache retrieval" case to work.
10547
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
  1455
        self.invalidatecaches()
9150
09a1ee498756 localrepo: add destroyed() method for strip/rollback to use (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9149
diff changeset
  1456
17324
9f94358f9f93 localrepo: clear the filecache on _rollback() and destroyed()
Idan Kamara <idankk86@gmail.com>
parents: 17306
diff changeset
  1457
        # Discard all cache entries to force reloading everything.
9f94358f9f93 localrepo: clear the filecache on _rollback() and destroyed()
Idan Kamara <idankk86@gmail.com>
parents: 17306
diff changeset
  1458
        self._filecache.clear()
9f94358f9f93 localrepo: clear the filecache on _rollback() and destroyed()
Idan Kamara <idankk86@gmail.com>
parents: 17306
diff changeset
  1459
6585
d3d1d39da2fa walk: remove cmdutil.walk
Matt Mackall <mpm@selenic.com>
parents: 6583
diff changeset
  1460
    def walk(self, match, node=None):
3532
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1461
        '''
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1462
        walk recursively through the directory tree or a given
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1463
        changeset, finding all files matched by the match
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1464
        function
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1465
        '''
6764
8db64464d136 context: add walk method
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
  1466
        return self[node].walk(match)
3532
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1467
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1468
    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
  1469
               ignored=False, clean=False, unknown=False,
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1470
               listsubrepos=False):
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1471
        """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
  1472
        directory.
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1473
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1474
        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
  1475
        If node2 is None, compare node1 with working directory.
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1476
        """
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
  1477
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1478
        def mfmatches(ctx):
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1479
            mf = ctx.manifest().copy()
16645
9a21fc2c7d32 localrepo: optimize internode status calls using match.always
Jesse Glick <jesse.glick@oracle.com>
parents: 16628
diff changeset
  1480
            if match.always():
9a21fc2c7d32 localrepo: optimize internode status calls using match.always
Jesse Glick <jesse.glick@oracle.com>
parents: 16628
diff changeset
  1481
                return mf
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1482
            for fn in mf.keys():
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1483
                if not match(fn):
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1484
                    del mf[fn]
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1485
            return mf
741
156dc2f3be7f Fix some line wrapping
mpm@selenic.com
parents: 740
diff changeset
  1486
7090
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1487
        if isinstance(node1, context.changectx):
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1488
            ctx1 = node1
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1489
        else:
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1490
            ctx1 = self[node1]
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1491
        if isinstance(node2, context.changectx):
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1492
            ctx2 = node2
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1493
        else:
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1494
            ctx2 = self[node2]
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1495
7435
5e13df32fb74 bundlerepo doesn't really have a dirstate, throw AttributeError if requested
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 7415
diff changeset
  1496
        working = ctx2.rev() is None
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1497
        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
  1498
        match = match or matchmod.always(self.root, self.getcwd())
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1499
        listignored, listclean, listunknown = ignored, clean, unknown
2474
1e32e2fe8a67 Fix cold cache diff performance
Chris Mason <mason@suse.com>
parents: 2463
diff changeset
  1500
7090
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1501
        # load earliest manifest first for caching reasons
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1502
        if not working and ctx2.rev() < ctx1.rev():
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1503
            ctx2.manifest()
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1504
7067
40d105a12cac status: don't warn about missing files present in base revision (issue1323)
Matt Mackall <mpm@selenic.com>
parents: 7064
diff changeset
  1505
        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
  1506
            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
  1507
                # '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
  1508
                # 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
  1509
                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
  1510
                    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
  1511
            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
  1512
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1513
        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
  1514
            subrepos = []
054549ccb680 status: avoid performance regression when no .hgsub is present
Matt Mackall <mpm@selenic.com>
parents: 11154
diff changeset
  1515
            if '.hgsub' in self.dirstate:
14870
f73c7b70df68 subrepo: use working copy of .hgsub to filter status (issue2901)
Matt Mackall <mpm@selenic.com>
parents: 14825
diff changeset
  1516
                subrepos = ctx2.substate.keys()
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10011
diff changeset
  1517
            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
  1518
                                     listclean, listunknown)
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1519
            cmp, modified, added, removed, deleted, unknown, ignored, clean = s
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
  1520
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1521
            # check for any possibly clean files
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1522
            if parentworking and cmp:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1523
                fixup = []
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1524
                # 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
  1525
                for f in sorted(cmp):
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1526
                    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
  1527
                        or ctx1[f].cmp(ctx2[f])):
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1528
                        modified.append(f)
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1529
                    else:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1530
                        fixup.append(f)
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1531
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1532
                # update dirstate for files that are actually clean
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1533
                if fixup:
11669
c47cb3193c53 localrepo.status: move fixup concatenation inside if block for clarity
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11665
diff changeset
  1534
                    if listclean:
c47cb3193c53 localrepo.status: move fixup concatenation inside if block for clarity
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11665
diff changeset
  1535
                        clean += fixup
c47cb3193c53 localrepo.status: move fixup concatenation inside if block for clarity
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11665
diff changeset
  1536
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1537
                    try:
8647
cb74433f9b41 localrepo: move comment
Adrian Buehlmann <adrian@cadifra.com>
parents: 8646
diff changeset
  1538
                        # updating the dirstate is optional
cb74433f9b41 localrepo: move comment
Adrian Buehlmann <adrian@cadifra.com>
parents: 8646
diff changeset
  1539
                        # 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
  1540
                        wlock = self.wlock(False)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1541
                        try:
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1542
                            for f in fixup:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1543
                                self.dirstate.normal(f)
8646
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1544
                        finally:
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1545
                            wlock.release()
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1546
                    except error.LockError:
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1547
                        pass
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1548
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1549
        if not parentworking:
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1550
            mf1 = mfmatches(ctx1)
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1551
            if working:
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1552
                # we are comparing working dir against non-parent
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1553
                # generate a pseudo-manifest for the working dir
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1554
                mf2 = mfmatches(self['.'])
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1555
                for f in cmp + modified + added:
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1556
                    mf2[f] = None
6817
cf319797d61c minor status fixups
Matt Mackall <mpm@selenic.com>
parents: 6810
diff changeset
  1557
                    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
  1558
                for f in removed:
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1559
                    if f in mf2:
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1560
                        del mf2[f]
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1561
            else:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1562
                # we are comparing two revisions
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1563
                deleted, unknown, ignored = [], [], []
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1564
                mf2 = mfmatches(ctx2)
4372
4ddc6d374265 localrepository.status: only acquire wlock if actually needed.
Bryan O'Sullivan <bos@serpentine.com>
parents: 4335
diff changeset
  1565
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1566
            modified, added, clean = [], [], []
16646
a1dcd842ce17 localrepo: optimize internode status calls using withflags
Jesse Glick <jesse.glick@oracle.com>
parents: 16645
diff changeset
  1567
            withflags = mf1.withflags() | mf2.withflags()
6827
c978d6752dbb dirstate.walk: push sorting up
Matt Mackall <mpm@selenic.com>
parents: 6817
diff changeset
  1568
            for fn in mf2:
5915
d0576d065993 Prefer i in d over d.has_key(i)
Christian Ebert <blacktrash@gmx.net>
parents: 5913
diff changeset
  1569
                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
  1570
                    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
  1571
                        ((fn in withflags and mf1.flags(fn) != mf2.flags(fn)) or
14500
e880433a2e00 localrepo: don't add deleted files to list of modified/added files (issue2761)
Idan Kamara <idankk86@gmail.com>
parents: 14499
diff changeset
  1572
                         (mf1[fn] != mf2[fn] and
e880433a2e00 localrepo: don't add deleted files to list of modified/added files (issue2761)
Idan Kamara <idankk86@gmail.com>
parents: 14499
diff changeset
  1573
                          (mf2[fn] or ctx1[fn].cmp(ctx2[fn]))))):
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1574
                        modified.append(fn)
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1575
                    elif listclean:
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1576
                        clean.append(fn)
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1577
                    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
  1578
                elif fn not in deleted:
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1579
                    added.append(fn)
1617
ece5d785e87a Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1616
diff changeset
  1580
            removed = mf1.keys()
ece5d785e87a Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1616
diff changeset
  1581
15348
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1582
        if working and modified and not self.dirstate._checklink:
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1583
            # Symlink placeholders may get non-symlink-like contents
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1584
            # 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
  1585
            # 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
  1586
            # symlink
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1587
            sane = []
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1588
            for f in modified:
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1589
                if ctx2.flags(f) == 'l':
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1590
                    d = ctx2[f].data()
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1591
                    if len(d) >= 1024 or '\n' in d or util.binary(d):
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1592
                        self.ui.debug('ignoring suspect symlink placeholder'
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1593
                                      ' "%s"\n' % f)
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1594
                        continue
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1595
                sane.append(f)
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1596
            modified = sane
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1597
6827
c978d6752dbb dirstate.walk: push sorting up
Matt Mackall <mpm@selenic.com>
parents: 6817
diff changeset
  1598
        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
  1599
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1600
        if listsubrepos:
12176
ecab10820983 subrepos: add function for iterating over ctx subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12175
diff changeset
  1601
            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
  1602
                if working:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1603
                    rev2 = None
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1604
                else:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1605
                    rev2 = ctx2.substate[subpath][1]
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1606
                try:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1607
                    submatch = matchmod.narrowmatcher(subpath, match)
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1608
                    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
  1609
                                   clean=listclean, unknown=listunknown,
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1610
                                   listsubrepos=True)
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1611
                    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
  1612
                        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
  1613
                except error.LookupError:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1614
                    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
  1615
                                   % subpath)
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1616
13412
58c497d0e44d remove unnecessary list comprehensions
Martin Geisler <mg@aragost.com>
parents: 13411
diff changeset
  1617
        for l in r:
58c497d0e44d remove unnecessary list comprehensions
Martin Geisler <mg@aragost.com>
parents: 13411
diff changeset
  1618
            l.sort()
6827
c978d6752dbb dirstate.walk: push sorting up
Matt Mackall <mpm@selenic.com>
parents: 6817
diff changeset
  1619
        return r
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1620
8796
2bcef677a6c3 localrepo: remove 'closed' argument to heads(...) function
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 8731
diff changeset
  1621
    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
  1622
        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
  1623
        # 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
  1624
        return sorted(heads, key=self.changelog.rev, reverse=True)
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  1625
8694
ca8d05e1f1d1 localrepo: set heads and branchheads to be closed=False by default
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 8680
diff changeset
  1626
    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
  1627
        '''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
  1628
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1629
        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
  1630
        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
  1631
        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
  1632
        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
  1633
        '''
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
  1634
        if branch is None:
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
  1635
            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
  1636
        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
  1637
        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
  1638
            return []
7654
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
  1639
        # 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
  1640
        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
  1641
        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
  1642
            # 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
  1643
            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
  1644
            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
  1645
        if not closed:
16720
e825a89de5d7 context: add changectx.closesbranch() method
Brodie Rao <brodie@sf.io>
parents: 16719
diff changeset
  1646
            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
  1647
        return bheads
4648
8e503fa54d2d Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents: 4635
diff changeset
  1648
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1649
    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
  1650
        if not nodes:
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
  1651
            nodes = [self.changelog.tip()]
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1652
        b = []
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1653
        for n in nodes:
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1654
            t = n
14494
1ffeeb91c55d check-code: flag 0/1 used as constant Boolean expression
Martin Geisler <mg@lazybytes.net>
parents: 14482
diff changeset
  1655
            while True:
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1656
                p = self.changelog.parents(n)
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1657
                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
  1658
                    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
  1659
                    break
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1660
                n = p[0]
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1661
        return b
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1662
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1663
    def between(self, pairs):
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1664
        r = []
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1665
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1666
        for top, bottom in pairs:
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1667
            n, l, i = top, [], 0
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1668
            f = 1
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1669
7708
a32847fa0df0 wire protocol: avoid infinite loop (issue1483)
Matt Mackall <mpm@selenic.com>
parents: 7564
diff changeset
  1670
            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
  1671
                p = self.changelog.parents(n)[0]
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1672
                if i == f:
575
7f5ce4bbdd7b More whitespace cleanups
mpm@selenic.com
parents: 566
diff changeset
  1673
                    l.append(n)
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1674
                    f = f * 2
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1675
                n = p
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1676
                i += 1
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1677
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1678
            r.append(l)
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1679
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1680
        return r
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1681
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1682
    def pull(self, remote, heads=None, force=False):
17126
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1683
        # 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
  1684
        # rollback call
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1685
        tr = None
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1686
        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
  1687
        lock = self.lock()
2827
2a0c599f7bb0 fetch: hold lock and wlock across all operations
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2803
diff changeset
  1688
        try:
11301
3d0591a66118 move discovery methods from localrepo into new discovery module
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 11230
diff changeset
  1689
            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
  1690
                                               force=force)
3d0591a66118 move discovery methods from localrepo into new discovery module
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 11230
diff changeset
  1691
            common, fetch, rheads = tmp
2827
2a0c599f7bb0 fetch: hold lock and wlock across all operations
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2803
diff changeset
  1692
            if not fetch:
2a0c599f7bb0 fetch: hold lock and wlock across all operations
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2803
diff changeset
  1693
                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
  1694
                added = []
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1695
                result = 0
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1696
            else:
17126
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1697
                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
  1698
                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
  1699
                    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
  1700
                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
  1701
                    # 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
  1702
                    heads = rheads
7415
6163ef936a00 protocol: use changegroupsubset() if possible (issue1389)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7377
diff changeset
  1703
14073
72c84f24b420 discovery: drop findoutgoing and simplify findcommonincoming's api
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14064
diff changeset
  1704
                if remote.capable('getbundle'):
13742
7abab875e647 discovery: avoid discovery when local graph is a subset of remote
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13741
diff changeset
  1705
                    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
  1706
                                          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
  1707
                elif heads is None:
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1708
                    cg = remote.changegroup(fetch, 'pull')
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1709
                elif not remote.capable('changegroupsubset'):
12067
a4fbbe0fbc38 Lowercase error messages
Martin Geisler <mg@lazybytes.net>
parents: 11640
diff changeset
  1710
                    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
  1711
                                           "other repository doesn't support "
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1712
                                           "changegroupsubset."))
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1713
                else:
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1714
                    cg = remote.changegroupsubset(fetch, heads, 'pull')
15650
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1715
                clstart = len(self.changelog)
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())
15650
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1717
                clend = len(self.changelog)
5b26667fc4d3 phases: exchange phase boundaries on pull
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15646
diff changeset
  1718
                added = [self.changelog.node(r) for r in xrange(clstart, clend)]
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
17298
59c14bf5a48c pushkey: do not exchange obsole markers if feature is disabled
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17297
diff changeset
  1744
            if obsolete._enabled:
17857
8ef4b022d562 obsolete: add missing line feed in debug error message
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17855
diff changeset
  1745
                self.ui.debug('fetching remote obsolete markers\n')
17298
59c14bf5a48c pushkey: do not exchange obsole markers if feature is disabled
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17297
diff changeset
  1746
                remoteobs = remote.listkeys('obsolete')
59c14bf5a48c pushkey: do not exchange obsole markers if feature is disabled
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17297
diff changeset
  1747
                if 'dump0' in remoteobs:
59c14bf5a48c pushkey: do not exchange obsole markers if feature is disabled
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17297
diff changeset
  1748
                    if tr is None:
59c14bf5a48c pushkey: do not exchange obsole markers if feature is disabled
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17297
diff changeset
  1749
                        tr = self.transaction(trname)
59c14bf5a48c pushkey: do not exchange obsole markers if feature is disabled
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17297
diff changeset
  1750
                    for key in sorted(remoteobs, reverse=True):
59c14bf5a48c pushkey: do not exchange obsole markers if feature is disabled
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17297
diff changeset
  1751
                        if key.startswith('dump'):
59c14bf5a48c pushkey: do not exchange obsole markers if feature is disabled
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17297
diff changeset
  1752
                            data = base85.b85decode(remoteobs[key])
59c14bf5a48c pushkey: do not exchange obsole markers if feature is disabled
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17297
diff changeset
  1753
                            self.obsstore.mergemarkers(tr, data)
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
  1754
                    self.invalidatevolatilesets()
17126
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1755
            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
  1756
                tr.close()
2827
2a0c599f7bb0 fetch: hold lock and wlock across all operations
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2803
diff changeset
  1757
        finally:
17126
8fa8717b47b6 obsolete: write obsolete marker inside a transaction
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17125
diff changeset
  1758
            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
  1759
                tr.release()
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
  1760
            lock.release()
622
e9fe5d5e67f7 Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents: 621
diff changeset
  1761
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1762
        return result
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1763
13327
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1764
    def checkpush(self, force, revs):
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1765
        """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
  1766
        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
  1767
        command.
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1768
        """
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1769
        pass
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1770
11211
e43c23d189a5 push: add --new-branch option to allow intial push of new branches
Sune Foldager <cryo@cyanite.org>
parents: 11177
diff changeset
  1771
    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
  1772
        '''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
  1773
        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
  1774
          - None means nothing to push
90f8b8dd0326 push: return 1 if no changes found (issue3228)
Matt Mackall <mpm@selenic.com>
parents: 16020
diff changeset
  1775
          - 0 means HTTP error
11153
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  1776
          - 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
  1777
            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
  1778
          - 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
  1779
        '''
2439
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
  1780
        # 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
  1781
        #
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
  1782
        # 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
  1783
        # 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
  1784
        #
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
  1785
        # 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
  1786
        # servers, http servers).
816
8674b7803714 Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents: 814
diff changeset
  1787
17193
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
  1788
        if not remote.canpush():
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
  1789
            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
  1790
        unfi = self.unfiltered()
15952
ec8a9e06cf05 mq-safety: don't apply safety on non-outgoing changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15933
diff changeset
  1791
        # get local lock as we might write phase data
ec8a9e06cf05 mq-safety: don't apply safety on non-outgoing changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15933
diff changeset
  1792
        locallock = self.lock()
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1793
        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
  1794
            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
  1795
            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
  1796
            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
  1797
            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
  1798
                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
  1799
            try:
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1800
                # discovery
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1801
                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
  1802
                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
  1803
                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
  1804
                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
  1805
                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
  1806
                               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
  1807
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1808
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1809
                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
  1810
                    # 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
  1811
                    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
  1812
                    ret = None
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1813
                else:
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1814
                    # something to push
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1815
                    if not force:
17169
c18ecebed3f1 push: refuse to push obsolete changesets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17161
diff changeset
  1816
                        # 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
  1817
                        # 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
  1818
                        if unfi.obsstore:
17169
c18ecebed3f1 push: refuse to push obsolete changesets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17161
diff changeset
  1819
                            # 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
  1820
                            mso = _("push includes obsolete changeset: %s!")
0c1185f6ddd7 obsolete: simplify push abort message
push includes an xxx changeset: yyyyyyyyyy
parents: 17821
diff changeset
  1821
                            msu = _("push includes unstable changeset: %s!")
17834
743d04dd48ec push: refuse to push bumped changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17833
diff changeset
  1822
                            msb = _("push includes bumped changeset: %s!")
18073
e411fd79ca69 obsolete: refuse to push divergent changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18054
diff changeset
  1823
                            msd = _("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
  1824
                            # 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
  1825
                            # 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
  1826
                            # 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
  1827
                            # 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
  1828
                            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
  1829
                                ctx = unfi[node]
17169
c18ecebed3f1 push: refuse to push obsolete changesets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17161
diff changeset
  1830
                                if ctx.obsolete():
17855
526081552f3d localrepo: translate "push includes X changeset" only once
Thomas Arendsen Hein <thomas@intevation.de>
parents: 17834
diff changeset
  1831
                                    raise util.Abort(mso % ctx)
17172
12fdaa30063a push: refuse to push unstable changesets without force
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17169
diff changeset
  1832
                                elif ctx.unstable():
17855
526081552f3d localrepo: translate "push includes X changeset" only once
Thomas Arendsen Hein <thomas@intevation.de>
parents: 17834
diff changeset
  1833
                                    raise util.Abort(msu % ctx)
17834
743d04dd48ec push: refuse to push bumped changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17833
diff changeset
  1834
                                elif ctx.bumped():
17855
526081552f3d localrepo: translate "push includes X changeset" only once
Thomas Arendsen Hein <thomas@intevation.de>
parents: 17834
diff changeset
  1835
                                    raise util.Abort(msb % ctx)
18073
e411fd79ca69 obsolete: refuse to push divergent changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18054
diff changeset
  1836
                                elif ctx.divergent():
e411fd79ca69 obsolete: refuse to push divergent changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18054
diff changeset
  1837
                                    raise util.Abort(msd % ctx)
18007
2e30972d859d clfilter: unfilter some parts of the push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18000
diff changeset
  1838
                        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
  1839
                                             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
  1840
                                             bool(inc))
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1841
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1842
                    # 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
  1843
                    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
  1844
                        # push everything,
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1845
                        # use the fast path, no race possible on push
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1846
                        cg = self._changegroup(outgoing.missing, 'push')
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1847
                    else:
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1848
                        cg = self.getlocalbundle('push', outgoing)
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1849
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1850
                    # 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
  1851
                    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
  1852
                        # 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
  1853
                        # 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
  1854
                        # 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
  1855
                        # 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
  1856
                        if force:
15932
4154338f0bc0 discovery: diet discovery.prepush from non-discovery code
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15929
diff changeset
  1857
                            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
  1858
                        # 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
  1859
                        # 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
  1860
                        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
  1861
                    else:
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1862
                        # we return an integer indicating remote head count
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1863
                        # 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
  1864
                        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
  1865
15933
b8696a6676be phases: only synchronize on common changeset when push fails
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15932
diff changeset
  1866
                if ret:
17521
6a78548eaa86 spelling: synchronize
timeless@mozdev.org
parents: 17520
diff changeset
  1867
                    # 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
  1868
                    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
  1869
                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
  1870
                    # 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
  1871
                    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
  1872
                else:
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1873
                    # 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
  1874
                    # (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
  1875
                    #
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1876
                    # 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
  1877
                    #     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
  1878
                    #              + (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
  1879
                    #              )
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1880
                    #
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1881
                    # 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
  1882
                    #     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
  1883
                    #     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
  1884
                    #
5653f2d166ea push: prevent moving phases outside of the pushed subset
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15952
diff changeset
  1885
                    # We can pick:
17424
e7cfe3587ea4 fix trivial spelling errors
Mads Kiilerich <mads@kiilerich.com>
parents: 17378
diff changeset
  1886
                    # * 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
  1887
                    common = set(outgoing.common)
16020
7460f3a1fd6c push: fix coding errors in unused branch
Matt Mackall <mpm@selenic.com>
parents: 16018
diff changeset
  1888
                    cheads = [node for node in revs if node in common]
16628
3c738cb162bf localrepo: cleanup var names and comments
redstone
parents: 16626
diff changeset
  1889
                    # 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
  1890
                    # * 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
  1891
                    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
  1892
                                     outgoing.commonheads,
7460f3a1fd6c push: fix coding errors in unused branch
Matt Mackall <mpm@selenic.com>
parents: 16018
diff changeset
  1893
                                     outgoing.missing)
7460f3a1fd6c push: fix coding errors in unused branch
Matt Mackall <mpm@selenic.com>
parents: 16018
diff changeset
  1894
                    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
  1895
                # 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
  1896
                remotephases = remote.listkeys('phases')
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1897
                if not remotephases: # old server or public only repo
15933
b8696a6676be phases: only synchronize on common changeset when push fails
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15932
diff changeset
  1898
                    phases.advanceboundary(self, phases.public, cheads)
15651
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1899
                    # 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
  1900
                else:
15933
b8696a6676be phases: only synchronize on common changeset when push fails
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15932
diff changeset
  1901
                    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
  1902
                    pheads, droots = ana
15651
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1903
                    ### Apply remote phase on local
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1904
                    if remotephases.get('publishing', False):
15933
b8696a6676be phases: only synchronize on common changeset when push fails
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15932
diff changeset
  1905
                        phases.advanceboundary(self, phases.public, cheads)
15651
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1906
                    else: # publish = False
15892
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1907
                        phases.advanceboundary(self, phases.public, pheads)
15933
b8696a6676be phases: only synchronize on common changeset when push fails
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15932
diff changeset
  1908
                        phases.advanceboundary(self, phases.draft, cheads)
15651
e69a3cdad37e phases: exchange phase boundaries on push
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15650
diff changeset
  1909
                    ### 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
  1910
15892
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15891
diff changeset
  1911
                    # 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
  1912
                    # 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
  1913
                    # 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
  1914
                    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
  1915
                                         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
  1916
                    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
  1917
                        r = remote.pushkey('phases',
2673006f7989 phases: fix phase synchronization on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15818
diff changeset
  1918
                                           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
  1919
                                           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
  1920
                                           str(phases.public))
15820
2673006f7989 phases: fix phase synchronization on push
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15818
diff changeset
  1921
                        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
  1922
                            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
  1923
                                            % newremotehead)
17294
d2217df3a7cf obsolete: add debug output regarding obsolete marker exchange.
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17293
diff changeset
  1924
                self.ui.debug('try to push obsolete markers to remote\n')
17298
59c14bf5a48c pushkey: do not exchange obsole markers if feature is disabled
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17297
diff changeset
  1925
                if (obsolete._enabled and self.obsstore and
17252
16fad7323e56 push: do not try to push remote obsolete if local has none
Patrick Mezard <patrick@mezard.eu>
parents: 17248
diff changeset
  1926
                    'obsolete' in remote.listkeys('namespaces')):
17295
1f08ecc7febb pushkey: splits obsolete marker exchange into multiple keys
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17294
diff changeset
  1927
                    rslts = []
1f08ecc7febb pushkey: splits obsolete marker exchange into multiple keys
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17294
diff changeset
  1928
                    remotedata = self.listkeys('obsolete')
1f08ecc7febb pushkey: splits obsolete marker exchange into multiple keys
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17294
diff changeset
  1929
                    for key in sorted(remotedata, reverse=True):
1f08ecc7febb pushkey: splits obsolete marker exchange into multiple keys
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17294
diff changeset
  1930
                        # reverse sort to ensure we end with dump0
1f08ecc7febb pushkey: splits obsolete marker exchange into multiple keys
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17294
diff changeset
  1931
                        data = remotedata[key]
1f08ecc7febb pushkey: splits obsolete marker exchange into multiple keys
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17294
diff changeset
  1932
                        rslts.append(remote.pushkey('obsolete', key, '', data))
1f08ecc7febb pushkey: splits obsolete marker exchange into multiple keys
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17294
diff changeset
  1933
                    if [r for r in rslts if not r]:
1f08ecc7febb pushkey: splits obsolete marker exchange into multiple keys
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17294
diff changeset
  1934
                        msg = _('failed to push some obsolete markers!\n')
1f08ecc7febb pushkey: splits obsolete marker exchange into multiple keys
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17294
diff changeset
  1935
                        self.ui.warn(msg)
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
  1936
            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
  1937
                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
  1938
                    lock.release()
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1939
        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
  1940
            locallock.release()
622
e9fe5d5e67f7 Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents: 621
diff changeset
  1941
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1942
        self.ui.debug("checking for updated bookmarks\n")
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1943
        rb = remote.listkeys('bookmarks')
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1944
        for k in rb.keys():
18009
67c874d14c2c clfilter: use unfiltered repo for bookmark push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18007
diff changeset
  1945
            if k in unfi._bookmarks:
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1946
                nr, nl = rb[k], hex(self._bookmarks[k])
18009
67c874d14c2c clfilter: use unfiltered repo for bookmark push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18007
diff changeset
  1947
                if nr in unfi:
67c874d14c2c clfilter: use unfiltered repo for bookmark push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18007
diff changeset
  1948
                    cr = unfi[nr]
67c874d14c2c clfilter: use unfiltered repo for bookmark push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18007
diff changeset
  1949
                    cl = unfi[nl]
67c874d14c2c clfilter: use unfiltered repo for bookmark push logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18007
diff changeset
  1950
                    if bookmarks.validdest(unfi, cr, cl):
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1951
                        r = remote.pushkey('bookmarks', k, nr, nl)
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1952
                        if r:
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1953
                            self.ui.status(_("updating bookmark %s\n") % k)
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1954
                        else:
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1955
                            self.ui.warn(_('updating bookmark %s'
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1956
                                           ' failed!\n') % k)
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1957
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1958
        return ret
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1959
5763
e20de0caf8e7 Show number of changesets written to bundle files by default (issue569)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 5760
diff changeset
  1960
    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
  1961
        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
  1962
            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
  1963
        if self.ui.debugflag:
9467
4c041f1ee1b4 do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents: 9437
diff changeset
  1964
            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
  1965
            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
  1966
                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
  1967
13703
48d606d7192b changegroupsubset: extranodes are no longer needed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 13662
diff changeset
  1968
    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
  1969
        """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
  1970
        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
  1971
        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
  1972
        successive changegroup chunks.
1466
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  1973
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  1974
        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
  1975
        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
  1976
        is non-trivial.
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  1977
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  1978
        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
  1979
        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
  1980
        """
9820
0b999aec64e8 bundle: don't send too many changesets (Issue1704)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 9691
diff changeset
  1981
        cl = self.changelog
0b999aec64e8 bundle: don't send too many changesets (Issue1704)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 9691
diff changeset
  1982
        if not bases:
0b999aec64e8 bundle: don't send too many changesets (Issue1704)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 9691
diff changeset
  1983
            bases = [nullid]
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  1984
        csets, bases, heads = cl.nodesbetween(bases, heads)
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  1985
        # We assume that all ancestors of bases are known
18092
ff36650e4238 localrepo: use lazy ancestor membership testing
Siddharth Agarwal <sid0@fb.com>
parents: 18086
diff changeset
  1986
        common = cl.ancestors([cl.rev(n) for n in bases])
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  1987
        return self._changegroupsubset(common, csets, heads, source)
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  1988
15837
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  1989
    def getlocalbundle(self, source, outgoing):
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  1990
        """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
  1991
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  1992
        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
  1993
        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
  1994
        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
  1995
            return None
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  1996
        return self._changegroupsubset(outgoing.common,
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  1997
                                       outgoing.missing,
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  1998
                                       outgoing.missingheads,
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  1999
                                       source)
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  2000
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2001
    def getbundle(self, source, heads=None, common=None):
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2002
        """Like changegroupsubset, but returns the set difference between the
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2003
        ancestors of heads and the ancestors common.
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2004
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2005
        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
  2006
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2007
        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
  2008
        current discovery protocol works.
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2009
        """
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2010
        cl = self.changelog
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2011
        if common:
18086
739c88ff043c clfilter: fix `nodemap` usage in `getbundle`
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18073
diff changeset
  2012
            hasnode = cl.hasnode
739c88ff043c clfilter: fix `nodemap` usage in `getbundle`
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18073
diff changeset
  2013
            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
  2014
        else:
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2015
            common = [nullid]
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2016
        if not heads:
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2017
            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
  2018
        return self.getlocalbundle(source,
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15820
diff changeset
  2019
                                   discovery.outgoing(cl, common, heads))
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2020
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  2021
    @unfilteredmethod
13741
b51bf961b3cb wireproto: add getbundle() function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13723
diff changeset
  2022
    def _changegroupsubset(self, commonrevs, csets, heads, source):
1466
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2023
9820
0b999aec64e8 bundle: don't send too many changesets (Issue1704)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 9691
diff changeset
  2024
        cl = self.changelog
13706
7beb9834d185 changegroupsubset: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13703
diff changeset
  2025
        mf = self.manifest
7beb9834d185 changegroupsubset: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13703
diff changeset
  2026
        mfs = {} # needed manifests
7beb9834d185 changegroupsubset: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13703
diff changeset
  2027
        fnodes = {} # needed file nodes
13812
2b70683888b9 changegroup: minor ordering and renaming changes for similarity
Matt Mackall <mpm@selenic.com>
parents: 13811
diff changeset
  2028
        changedfiles = set()
13829
7b7c1d9d08ab changegroup: unnest flookup
Matt Mackall <mpm@selenic.com>
parents: 13826
diff changeset
  2029
        fstate = ['', {}]
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2030
        count = [0, 0]
13706
7beb9834d185 changegroupsubset: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13703
diff changeset
  2031
13703
48d606d7192b changegroupsubset: extranodes are no longer needed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 13662
diff changeset
  2032
        # can we go through the fast path ?
48d606d7192b changegroupsubset: extranodes are no longer needed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 13662
diff changeset
  2033
        heads.sort()
13707
296e78744d32 changegroupsubset: more minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13706
diff changeset
  2034
        if heads == sorted(self.heads()):
13706
7beb9834d185 changegroupsubset: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13703
diff changeset
  2035
            return self._changegroup(csets, source)
7233
9f0e52e1df77 fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7229
diff changeset
  2036
9820
0b999aec64e8 bundle: don't send too many changesets (Issue1704)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 9691
diff changeset
  2037
        # slow path
1736
50de0887bbcd add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1732
diff changeset
  2038
        self.hook('preoutgoing', throw=True, source=source)
13706
7beb9834d185 changegroupsubset: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13703
diff changeset
  2039
        self.changegroupinfo(csets, source)
1458
1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents: 1457
diff changeset
  2040
13810
0252abaafb8a changegroup: refactor prune as a filter
Matt Mackall <mpm@selenic.com>
parents: 13809
diff changeset
  2041
        # filter any nodes that claim to be part of the known set
0252abaafb8a changegroup: refactor prune as a filter
Matt Mackall <mpm@selenic.com>
parents: 13809
diff changeset
  2042
        def prune(revlog, missing):
16426
b50fee9a2dad changegroupsubset: optimize function lookup in prune
Matt Mackall <mpm@selenic.com>
parents: 16425
diff changeset
  2043
            rr, rl = revlog.rev, revlog.linkrev
14521
d27f669bad7c localrepo: use list comprehension instead of generators
Sune Foldager <cryo@cyanite.org>
parents: 14520
diff changeset
  2044
            return [n for n in missing
16426
b50fee9a2dad changegroupsubset: optimize function lookup in prune
Matt Mackall <mpm@selenic.com>
parents: 16425
diff changeset
  2045
                    if rl(rr(n)) not in commonrevs]
1458
1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents: 1457
diff changeset
  2046
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2047
        progress = self.ui.progress
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2048
        _bundling = _('bundling')
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2049
        _changesets = _('changesets')
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2050
        _manifests = _('manifests')
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2051
        _files = _('files')
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2052
13830
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2053
        def lookup(revlog, x):
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2054
            if revlog == cl:
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2055
                c = cl.read(x)
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2056
                changedfiles.update(c[3])
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2057
                mfs.setdefault(c[0], x)
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2058
                count[0] += 1
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2059
                progress(_bundling, count[0],
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2060
                         unit=_changesets, total=count[1])
13830
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2061
                return x
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2062
            elif revlog == mf:
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2063
                clnode = mfs[x]
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2064
                mdata = mf.readfast(x)
16422
c0b5bab3fb11 changegroupsubset: avoid setdefault in inner loop
Matt Mackall <mpm@selenic.com>
parents: 16421
diff changeset
  2065
                for f, n in mdata.iteritems():
16419
784606ae0029 changegroupsubset: renest inner loop
Matt Mackall <mpm@selenic.com>
parents: 16398
diff changeset
  2066
                    if f in changedfiles:
16422
c0b5bab3fb11 changegroupsubset: avoid setdefault in inner loop
Matt Mackall <mpm@selenic.com>
parents: 16421
diff changeset
  2067
                        fnodes[f].setdefault(n, clnode)
13830
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2068
                count[0] += 1
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2069
                progress(_bundling, count[0],
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2070
                         unit=_manifests, total=count[1])
16422
c0b5bab3fb11 changegroupsubset: avoid setdefault in inner loop
Matt Mackall <mpm@selenic.com>
parents: 16421
diff changeset
  2071
                return clnode
13830
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2072
            else:
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2073
                progress(_bundling, count[0], item=fstate[0],
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2074
                         unit=_files, total=count[1])
13830
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2075
                return fstate[1][x]
1458
1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents: 1457
diff changeset
  2076
13831
d69c9510d648 changegroup: introduce bundler objects
Matt Mackall <mpm@selenic.com>
parents: 13830
diff changeset
  2077
        bundler = changegroup.bundle10(lookup)
14365
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2078
        reorder = self.ui.config('bundle', 'reorder', 'auto')
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2079
        if reorder == 'auto':
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2080
            reorder = None
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2081
        else:
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2082
            reorder = util.parsebool(reorder)
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
  2083
635
85e2209d401c Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents: 634
diff changeset
  2084
        def gengroup():
1466
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2085
            # Create a changenode group generator that will call our functions
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2086
            # back to lookup the owning changenode and collect information.
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2087
            count[:] = [0, len(csets)]
14365
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2088
            for chunk in cl.group(csets, bundler, reorder=reorder):
13709
53826e7a1d22 changegroupsubset: more renaming
Matt Mackall <mpm@selenic.com>
parents: 13708
diff changeset
  2089
                yield chunk
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2090
            progress(_bundling, None)
10432
8a8030fc57d6 localrepo: provide indeterminate progress information while bundling
Augie Fackler <durin42@gmail.com>
parents: 10430
diff changeset
  2091
1466
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2092
            # Create a generator for the manifestnodes that calls our lookup
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2093
            # and data collection functions back.
16422
c0b5bab3fb11 changegroupsubset: avoid setdefault in inner loop
Matt Mackall <mpm@selenic.com>
parents: 16421
diff changeset
  2094
            for f in changedfiles:
c0b5bab3fb11 changegroupsubset: avoid setdefault in inner loop
Matt Mackall <mpm@selenic.com>
parents: 16421
diff changeset
  2095
                fnodes[f] = {}
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2096
            count[:] = [0, len(mfs)]
14365
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2097
            for chunk in mf.group(prune(mf, mfs), bundler, reorder=reorder):
13709
53826e7a1d22 changegroupsubset: more renaming
Matt Mackall <mpm@selenic.com>
parents: 13708
diff changeset
  2098
                yield chunk
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2099
            progress(_bundling, None)
1466
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2100
13706
7beb9834d185 changegroupsubset: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13703
diff changeset
  2101
            mfs.clear()
1466
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2102
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2103
            # Go through all our files in order sorted by name.
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2104
            count[:] = [0, len(changedfiles)]
13829
7b7c1d9d08ab changegroup: unnest flookup
Matt Mackall <mpm@selenic.com>
parents: 13826
diff changeset
  2105
            for fname in sorted(changedfiles):
1458
1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents: 1457
diff changeset
  2106
                filerevlog = self.file(fname)
6750
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
  2107
                if not len(filerevlog):
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  2108
                    raise util.Abort(_("empty or missing revlog for %s")
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  2109
                                     % fname)
13829
7b7c1d9d08ab changegroup: unnest flookup
Matt Mackall <mpm@selenic.com>
parents: 13826
diff changeset
  2110
                fstate[0] = fname
7b7c1d9d08ab changegroup: unnest flookup
Matt Mackall <mpm@selenic.com>
parents: 13826
diff changeset
  2111
                fstate[1] = fnodes.pop(fname, {})
13783
c196352d935b changegroup: fold progress meter into callbacks
Matt Mackall <mpm@selenic.com>
parents: 13782
diff changeset
  2112
14522
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2113
                nodelist = prune(filerevlog, fstate[1])
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2114
                if nodelist:
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2115
                    count[0] += 1
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2116
                    yield bundler.fileheader(fname)
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2117
                    for chunk in filerevlog.group(nodelist, bundler, reorder):
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2118
                        yield chunk
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2119
1466
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2120
            # Signal that no more groups are left.
13831
d69c9510d648 changegroup: introduce bundler objects
Matt Mackall <mpm@selenic.com>
parents: 13830
diff changeset
  2121
            yield bundler.close()
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2122
            progress(_bundling, None)
635
85e2209d401c Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents: 634
diff changeset
  2123
13706
7beb9834d185 changegroupsubset: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13703
diff changeset
  2124
            if csets:
7beb9834d185 changegroupsubset: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13703
diff changeset
  2125
                self.hook('outgoing', node=hex(csets[0]), source=source)
1736
50de0887bbcd add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1732
diff changeset
  2126
12337
6a6149487817 bundle: encapsulate all bundle streams in unbundle class
Matt Mackall <mpm@selenic.com>
parents: 12335
diff changeset
  2127
        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
  2128
1736
50de0887bbcd add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1732
diff changeset
  2129
    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
  2130
        # 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
  2131
        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
  2132
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  2133
    @unfilteredmethod
9820
0b999aec64e8 bundle: don't send too many changesets (Issue1704)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 9691
diff changeset
  2134
    def _changegroup(self, nodes, source):
9437
1c4e4004f3a6 Improve some docstrings relating to changegroups and prepush().
Greg Ward <greg-hg@gerg.ca>
parents: 9425
diff changeset
  2135
        """Compute the changegroup of all nodes that we have that a recipient
1c4e4004f3a6 Improve some docstrings relating to changegroups and prepush().
Greg Ward <greg-hg@gerg.ca>
parents: 9425
diff changeset
  2136
        doesn't.  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
  2137
        successive changegroup chunks.
1466
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2138
b6d9ea0bc107 Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents: 1464
diff changeset
  2139
        This is much easier than the previous function as we can assume that
7233
9f0e52e1df77 fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7229
diff changeset
  2140
        the recipient has any changenode we aren't sending them.
9f0e52e1df77 fix pull racing with push/commit (issue1320)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7229
diff changeset
  2141
9820
0b999aec64e8 bundle: don't send too many changesets (Issue1704)
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 9691
diff changeset
  2142
        nodes is the set of nodes to send"""
1736
50de0887bbcd add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1732
diff changeset
  2143
13812
2b70683888b9 changegroup: minor ordering and renaming changes for similarity
Matt Mackall <mpm@selenic.com>
parents: 13811
diff changeset
  2144
        cl = self.changelog
2b70683888b9 changegroup: minor ordering and renaming changes for similarity
Matt Mackall <mpm@selenic.com>
parents: 13811
diff changeset
  2145
        mf = self.manifest
2b70683888b9 changegroup: minor ordering and renaming changes for similarity
Matt Mackall <mpm@selenic.com>
parents: 13811
diff changeset
  2146
        mfs = {}
2b70683888b9 changegroup: minor ordering and renaming changes for similarity
Matt Mackall <mpm@selenic.com>
parents: 13811
diff changeset
  2147
        changedfiles = set()
13829
7b7c1d9d08ab changegroup: unnest flookup
Matt Mackall <mpm@selenic.com>
parents: 13826
diff changeset
  2148
        fstate = ['']
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2149
        count = [0, 0]
1736
50de0887bbcd add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1732
diff changeset
  2150
13812
2b70683888b9 changegroup: minor ordering and renaming changes for similarity
Matt Mackall <mpm@selenic.com>
parents: 13811
diff changeset
  2151
        self.hook('preoutgoing', throw=True, source=source)
5763
e20de0caf8e7 Show number of changesets written to bundle files by default (issue569)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 5760
diff changeset
  2152
        self.changegroupinfo(nodes, source)
1458
1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents: 1457
diff changeset
  2153
8152
08e1baf924ca replace set-like dictionaries with real sets
Martin Geisler <mg@lazybytes.net>
parents: 8151
diff changeset
  2154
        revset = set([cl.rev(n) for n in nodes])
635
85e2209d401c Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents: 634
diff changeset
  2155
6750
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
  2156
        def gennodelst(log):
16425
70bf4dc52c91 changegroup: optimize gennodelist
Matt Mackall <mpm@selenic.com>
parents: 16422
diff changeset
  2157
            ln, llr = log.node, log.linkrev
70bf4dc52c91 changegroup: optimize gennodelist
Matt Mackall <mpm@selenic.com>
parents: 16422
diff changeset
  2158
            return [ln(r) for r in log if llr(r) in revset]
70bf4dc52c91 changegroup: optimize gennodelist
Matt Mackall <mpm@selenic.com>
parents: 16422
diff changeset
  2159
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2160
        progress = self.ui.progress
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2161
        _bundling = _('bundling')
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2162
        _changesets = _('changesets')
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2163
        _manifests = _('manifests')
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2164
        _files = _('files')
1458
1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents: 1457
diff changeset
  2165
13830
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2166
        def lookup(revlog, x):
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2167
            if revlog == cl:
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2168
                c = cl.read(x)
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2169
                changedfiles.update(c[3])
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2170
                mfs.setdefault(c[0], x)
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2171
                count[0] += 1
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2172
                progress(_bundling, count[0],
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2173
                         unit=_changesets, total=count[1])
13830
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2174
                return x
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2175
            elif revlog == mf:
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2176
                count[0] += 1
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2177
                progress(_bundling, count[0],
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2178
                         unit=_manifests, total=count[1])
13830
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2179
                return cl.node(revlog.linkrev(revlog.rev(x)))
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2180
            else:
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2181
                progress(_bundling, count[0], item=fstate[0],
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2182
                    total=count[1], unit=_files)
13830
2dc6e09f2a7d changegroup: combine lookup functions
Matt Mackall <mpm@selenic.com>
parents: 13829
diff changeset
  2183
                return cl.node(revlog.linkrev(revlog.rev(x)))
13829
7b7c1d9d08ab changegroup: unnest flookup
Matt Mackall <mpm@selenic.com>
parents: 13826
diff changeset
  2184
13831
d69c9510d648 changegroup: introduce bundler objects
Matt Mackall <mpm@selenic.com>
parents: 13830
diff changeset
  2185
        bundler = changegroup.bundle10(lookup)
14365
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2186
        reorder = self.ui.config('bundle', 'reorder', 'auto')
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2187
        if reorder == 'auto':
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2188
            reorder = None
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2189
        else:
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2190
            reorder = util.parsebool(reorder)
1458
1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents: 1457
diff changeset
  2191
1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents: 1457
diff changeset
  2192
        def gengroup():
9437
1c4e4004f3a6 Improve some docstrings relating to changegroups and prepush().
Greg Ward <greg-hg@gerg.ca>
parents: 9425
diff changeset
  2193
            '''yield a sequence of changegroup chunks (strings)'''
635
85e2209d401c Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents: 634
diff changeset
  2194
            # construct a list of all changed files
1458
1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents: 1457
diff changeset
  2195
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2196
            count[:] = [0, len(nodes)]
14365
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2197
            for chunk in cl.group(nodes, bundler, reorder=reorder):
13716
6d7338f5320a changegroup: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13714
diff changeset
  2198
                yield chunk
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2199
            progress(_bundling, None)
635
85e2209d401c Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents: 634
diff changeset
  2200
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2201
            count[:] = [0, len(mfs)]
14365
a8e3931e3fb5 revlog: linearize created changegroups in generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14363
diff changeset
  2202
            for chunk in mf.group(gennodelst(mf), bundler, reorder=reorder):
13716
6d7338f5320a changegroup: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 13714
diff changeset
  2203
                yield chunk
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2204
            progress(_bundling, None)
635
85e2209d401c Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents: 634
diff changeset
  2205
16421
859ef739339e changegroupsubset: drop repeated len() calls
Matt Mackall <mpm@selenic.com>
parents: 16420
diff changeset
  2206
            count[:] = [0, len(changedfiles)]
13829
7b7c1d9d08ab changegroup: unnest flookup
Matt Mackall <mpm@selenic.com>
parents: 13826
diff changeset
  2207
            for fname in sorted(changedfiles):
1458
1033892bbb87 This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents: 1457
diff changeset
  2208
                filerevlog = self.file(fname)
6750
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
  2209
                if not len(filerevlog):
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  2210
                    raise util.Abort(_("empty or missing revlog for %s")
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  2211
                                     % fname)
13829
7b7c1d9d08ab changegroup: unnest flookup
Matt Mackall <mpm@selenic.com>
parents: 13826
diff changeset
  2212
                fstate[0] = fname
14522
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2213
                nodelist = gennodelst(filerevlog)
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2214
                if nodelist:
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2215
                    count[0] += 1
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2216
                    yield bundler.fileheader(fname)
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2217
                    for chunk in filerevlog.group(nodelist, bundler, reorder):
5ca61ef6ff00 localrepo: simplify file bundling code and fix progress bug
Sune Foldager <cryo@cyanite.org>
parents: 14521
diff changeset
  2218
                        yield chunk
13831
d69c9510d648 changegroup: introduce bundler objects
Matt Mackall <mpm@selenic.com>
parents: 13830
diff changeset
  2219
            yield bundler.close()
16420
4df2d335b8f6 changegroup: reduce progress overhead
Matt Mackall <mpm@selenic.com>
parents: 16419
diff changeset
  2220
            progress(_bundling, None)
635
85e2209d401c Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents: 634
diff changeset
  2221
2107
7ff92c04f8e5 Don't die calling outgoing hook if we have no changesets
Matt Mackall <mpm@selenic.com>
parents: 2098
diff changeset
  2222
            if nodes:
7ff92c04f8e5 Don't die calling outgoing hook if we have no changesets
Matt Mackall <mpm@selenic.com>
parents: 2098
diff changeset
  2223
                self.hook('outgoing', node=hex(nodes[0]), source=source)
635
85e2209d401c Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents: 634
diff changeset
  2224
12337
6a6149487817 bundle: encapsulate all bundle streams in unbundle class
Matt Mackall <mpm@selenic.com>
parents: 12335
diff changeset
  2225
        return changegroup.unbundle10(util.chunkbuffer(gengroup()), 'UN')
635
85e2209d401c Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents: 634
diff changeset
  2226
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  2227
    @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
  2228
    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
  2229
        """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
  2230
        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
  2231
        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
  2232
11153
9936ed1d04f4 push: document return values between various repo methods.
Greg Ward <greg-hg@gerg.ca>
parents: 11112
diff changeset
  2233
        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
  2234
        - 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
  2235
        - 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
  2236
        - 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
  2237
        - 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
  2238
        """
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2239
        def csmap(x):
9467
4c041f1ee1b4 do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents: 9437
diff changeset
  2240
            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
  2241
            return len(cl)
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2242
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2243
        def revmap(x):
1998
65cc17ae9649 fix race in localrepo.addchangegroup.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1995
diff changeset
  2244
            return cl.rev(x)
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2245
1615
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
  2246
        if not source:
2019
ced2d3620f95 add merge command. means same thing as "update -m".
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1998
diff changeset
  2247
            return 0
1730
0f1d2c75db5e add prechangegroup and pretxnchangegroup hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1721
diff changeset
  2248
2673
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2661
diff changeset
  2249
        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
  2250
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2251
        changesets = files = revisions = 0
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2252
        efiles = set()
225
1651a3e61925 fix repo locking
mpm@selenic.com
parents: 224
diff changeset
  2253
2395
8ed45fb1053a remove appendfile for the manifest when adding a changegroup
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 2362
diff changeset
  2254
        # 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
  2255
        # inconsistent view
4261
cd7b36b7869c restructure changelog file appending
Matt Mackall <mpm@selenic.com>
parents: 4258
diff changeset
  2256
        cl = self.changelog
cd7b36b7869c restructure changelog file appending
Matt Mackall <mpm@selenic.com>
parents: 4258
diff changeset
  2257
        cl.delayupdate()
14036
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2258
        oldheads = cl.heads()
1998
65cc17ae9649 fix race in localrepo.addchangegroup.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1995
diff changeset
  2259
14076
924c82157d46 url: move URL parsing functions into util to improve startup time
Brodie Rao <brodie@bitheap.org>
parents: 14073
diff changeset
  2260
        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
  2261
        try:
4970
30d4d8985dd8 transactions: avoid late tear-down (issue641)
Matt Mackall <mpm@selenic.com>
parents: 4917
diff changeset
  2262
            trp = weakref.proxy(tr)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2263
            # pull off the changeset group
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2264
            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
  2265
            clstart = len(cl)
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2266
            class prog(object):
10496
45734b51c99b progress: mark strings for translation
Martin Geisler <mg@lazybytes.net>
parents: 10492
diff changeset
  2267
                step = _('changesets')
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2268
                count = 1
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2269
                ui = self.ui
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2270
                total = None
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2271
                def __call__(self):
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2272
                    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
  2273
                                     total=self.total)
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2274
                    self.count += 1
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2275
            pr = prog()
12334
50946802593d bundle: refactor progress callback
Matt Mackall <mpm@selenic.com>
parents: 12333
diff changeset
  2276
            source.callback = pr
50946802593d bundle: refactor progress callback
Matt Mackall <mpm@selenic.com>
parents: 12333
diff changeset
  2277
14144
3c3c53d8343a unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14102
diff changeset
  2278
            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
  2279
            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
  2280
            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
  2281
                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
  2282
            clend = len(cl)
59160ca338f7 localrepo: use more direct vars in addchangegroup
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 8392
diff changeset
  2283
            changesets = clend - clstart
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2284
            for c in xrange(clstart, clend):
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2285
                efiles.update(self[c].files())
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2286
            efiles = len(efiles)
10496
45734b51c99b progress: mark strings for translation
Martin Geisler <mg@lazybytes.net>
parents: 10492
diff changeset
  2287
            self.ui.progress(_('changesets'), None)
1040
35e883d1ff9b Show number of new heads when doing a pull
mpm@selenic.com
parents: 1019
diff changeset
  2288
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2289
            # pull off the manifest group
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2290
            self.ui.status(_("adding manifests\n"))
10496
45734b51c99b progress: mark strings for translation
Martin Geisler <mg@lazybytes.net>
parents: 10492
diff changeset
  2291
            pr.step = _('manifests')
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2292
            pr.count = 1
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2293
            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
  2294
            # 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
  2295
            # 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
  2296
            # 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
  2297
            # be empty during the pull
14144
3c3c53d8343a unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14102
diff changeset
  2298
            source.manifestheader()
12335
e21fe9c5fb25 bundle: get rid of chunkiter
Matt Mackall <mpm@selenic.com>
parents: 12334
diff changeset
  2299
            self.manifest.addgroup(source, revmap, trp)
10496
45734b51c99b progress: mark strings for translation
Martin Geisler <mg@lazybytes.net>
parents: 10492
diff changeset
  2300
            self.ui.progress(_('manifests'), None)
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2301
10418
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2302
            needfiles = {}
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2303
            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
  2304
                # 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
  2305
                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
  2306
                    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
  2307
                    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
  2308
                    # 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
  2309
                    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
  2310
                        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
  2311
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2312
            # process the files
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2313
            self.ui.status(_("adding file changes\n"))
14756
fdcf6f09b68d localrepo: mark progress step for translation
Wagner Bruna <wbruna@yahoo.com>
parents: 14646
diff changeset
  2314
            pr.step = _('files')
10430
5cef810e588f localrepo: show indeterminate progress for incoming data
Augie Fackler <durin42@gmail.com>
parents: 10429
diff changeset
  2315
            pr.count = 1
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2316
            pr.total = efiles
12334
50946802593d bundle: refactor progress callback
Matt Mackall <mpm@selenic.com>
parents: 12333
diff changeset
  2317
            source.callback = None
50946802593d bundle: refactor progress callback
Matt Mackall <mpm@selenic.com>
parents: 12333
diff changeset
  2318
14494
1ffeeb91c55d check-code: flag 0/1 used as constant Boolean expression
Martin Geisler <mg@lazybytes.net>
parents: 14482
diff changeset
  2319
            while True:
14144
3c3c53d8343a unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14102
diff changeset
  2320
                chunkdata = source.filelogheader()
3c3c53d8343a unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14102
diff changeset
  2321
                if not chunkdata:
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2322
                    break
14144
3c3c53d8343a unbundler: separate delta and header parsing
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 14102
diff changeset
  2323
                f = chunkdata["filename"]
9467
4c041f1ee1b4 do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents: 9437
diff changeset
  2324
                self.ui.debug("adding %s revisions\n" % f)
10888
5e18023820a9 progress: show approximate progress info for pull
Matt Mackall <mpm@selenic.com>
parents: 10886
diff changeset
  2325
                pr()
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2326
                fl = self.file(f)
6750
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
  2327
                o = len(fl)
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
  2328
                if not fl.addgroup(source, revmap, trp):
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2329
                    raise util.Abort(_("received file revlog group is empty"))
6750
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
  2330
                revisions += len(fl) - o
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2331
                files += 1
10418
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2332
                if f in needfiles:
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2333
                    needs = needfiles[f]
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2334
                    for new in xrange(o, len(fl)):
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2335
                        n = fl.node(new)
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2336
                        if n in needs:
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2337
                            needs.remove(n)
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2338
                    if not needs:
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2339
                        del needfiles[f]
10496
45734b51c99b progress: mark strings for translation
Martin Geisler <mg@lazybytes.net>
parents: 10492
diff changeset
  2340
            self.ui.progress(_('files'), None)
10418
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2341
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2342
            for f, needs in needfiles.iteritems():
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2343
                fl = self.file(f)
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2344
                for n in needs:
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2345
                    try:
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2346
                        fl.rev(n)
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2347
                    except error.LookupError:
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2348
                        raise util.Abort(
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2349
                            _('missing file data for %s:%s - run hg verify') %
5fc090ba08a6 localrepo: add optional validation (defaults to off) for incoming changes
Augie Fackler <durin42@gmail.com>
parents: 10405
diff changeset
  2350
                            (f, hex(n)))
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2351
14036
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2352
            dh = 0
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2353
            if oldheads:
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2354
                heads = cl.heads()
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2355
                dh = len(heads) - len(oldheads)
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2356
                for h in heads:
16720
e825a89de5d7 context: add changectx.closesbranch() method
Brodie Rao <brodie@sf.io>
parents: 16719
diff changeset
  2357
                    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
  2358
                        dh -= 1
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2359
            htext = ""
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2360
            if dh:
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2361
                htext = _(" (%+d heads)") % dh
1998
65cc17ae9649 fix race in localrepo.addchangegroup.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1995
diff changeset
  2362
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2363
            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
  2364
                             " 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
  2365
                             % (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
  2366
            self.invalidatevolatilesets()
1040
35e883d1ff9b Show number of new heads when doing a pull
mpm@selenic.com
parents: 1019
diff changeset
  2367
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2368
            if changesets > 0:
8392
7e5cbb09515b localrepo: use cl throughout in addchangegroup
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 8390
diff changeset
  2369
                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
  2370
                self.hook('pretxnchangegroup', throw=True,
8393
59160ca338f7 localrepo: use more direct vars in addchangegroup
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 8392
diff changeset
  2371
                          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
  2372
                          url=url, pending=p)
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  2373
15484
a44446ff9ad8 phases: marked content of a changegroup as published
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15483
diff changeset
  2374
            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
  2375
            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
  2376
            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
  2377
                # 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
  2378
                # 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
  2379
                # 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
  2380
                #
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
  2381
                # 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
  2382
                # 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
  2383
                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
  2384
                    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
  2385
                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
  2386
                    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
  2387
                    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
  2388
            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
  2389
                # 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
  2390
                #
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
  2391
                # 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
  2392
                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
  2393
7787
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  2394
            # make changelog see real files again
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  2395
            cl.finalize(trp)
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  2396
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2397
            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
  2398
15586
98ec09582f72 addchangegroup: ony queue hooks when we have changesets
Matt Mackall <mpm@selenic.com>
parents: 15585
diff changeset
  2399
            if changesets > 0:
18121
f8a13f061a8a branchmap: extract updatebranchcache from repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18120
diff changeset
  2400
                branchmap.updatecache(self)
15586
98ec09582f72 addchangegroup: ony queue hooks when we have changesets
Matt Mackall <mpm@selenic.com>
parents: 15585
diff changeset
  2401
                def 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
  2402
                    # 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
  2403
                    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
  2404
                    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
  2405
                              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
  2406
9df9444e96ec addchangegroup: use a postrelease callback to call changegroup hook
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15583
diff changeset
  2407
                    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
  2408
                        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
  2409
                                  url=url)
15587
809d5d30e377 localrepo: rename _postrelease to _afterlock
Matt Mackall <mpm@selenic.com>
parents: 15586
diff changeset
  2410
                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
  2411
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  2412
        finally:
11230
5116a077c3da make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 11228
diff changeset
  2413
            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
  2414
        # never return 0 here:
14036
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2415
        if dh < 0:
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2416
            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
  2417
        else:
14036
90d997a812dc changegroup: do not count closed new heads (issue2697)
Adrian Buehlmann <adrian@cadifra.com>
parents: 14004
diff changeset
  2418
            return dh + 1
232
fc4a6e5b5812 hg resolve: merge a given node into the working directory
mpm@selenic.com
parents: 231
diff changeset
  2419
12296
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2420
    def stream_in(self, remote, requirements):
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2421
        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
  2422
        try:
17740
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2423
            # 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
  2424
            # to speed up branchcache creation
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2425
            rbranchmap = None
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2426
            if remote.capable("branchmap"):
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2427
                rbranchmap = remote.branchmap()
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2428
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2429
            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
  2430
            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
  2431
            try:
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2432
                resp = int(l)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2433
            except ValueError:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2434
                raise error.ResponseError(
16941
a1eb17bed550 localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents: 16866
diff changeset
  2435
                    _('unexpected response from remote server:'), l)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2436
            if resp == 1:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2437
                raise util.Abort(_('operation forbidden by server'))
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2438
            elif resp == 2:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2439
                raise util.Abort(_('locking the remote repository failed'))
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2440
            elif resp != 0:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2441
                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
  2442
            self.ui.status(_('streaming all changes\n'))
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2443
            l = fp.readline()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2444
            try:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2445
                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
  2446
            except (ValueError, TypeError):
7641
d2f753830f80 error: move UnexpectedOutput (now ResponseError)
Matt Mackall <mpm@selenic.com>
parents: 7640
diff changeset
  2447
                raise error.ResponseError(
16941
a1eb17bed550 localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents: 16866
diff changeset
  2448
                    _('unexpected response from remote server:'), l)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2449
            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
  2450
                           (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
  2451
            handled_bytes = 0
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  2452
            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
  2453
            start = time.time()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2454
            for i in xrange(total_files):
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2455
                # 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
  2456
                l = fp.readline()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2457
                try:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2458
                    name, size = l.split('\0', 1)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2459
                    size = int(size)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2460
                except (ValueError, TypeError):
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2461
                    raise error.ResponseError(
16941
a1eb17bed550 localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents: 16866
diff changeset
  2462
                        _('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
  2463
                if self.ui.debugflag:
def789752b60 stream_in: avoid debug calls when debug is disabled
Matt Mackall <mpm@selenic.com>
parents: 16378
diff changeset
  2464
                    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
  2465
                                  (name, util.bytecount(size)))
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2466
                # for backwards compat, name was partially encoded
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2467
                ofp = self.sopener(store.decodedir(name), 'w')
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2468
                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
  2469
                    handled_bytes += len(chunk)
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  2470
                    self.ui.progress(_('clone'), handled_bytes,
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  2471
                                     total=total_bytes)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2472
                    ofp.write(chunk)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2473
                ofp.close()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2474
            elapsed = time.time() - start
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2475
            if elapsed <= 0:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2476
                elapsed = 0.001
16770
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  2477
            self.ui.progress(_('clone'), None)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2478
            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
  2479
                           (util.bytecount(total_bytes), elapsed,
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2480
                            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
  2481
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  2482
            # new requirements = old non-format requirements +
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  2483
            #                    new format-related
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2484
            # requirements from the streamed-in repository
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2485
            requirements.update(set(self.requirements) - self.supportedformats)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2486
            self._applyrequirements(requirements)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2487
            self._writerequirements()
12296
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2488
17740
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2489
            if rbranchmap:
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2490
                rbheads = []
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2491
                for bheads in rbranchmap.itervalues():
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2492
                    rbheads.extend(bheads)
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2493
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2494
                if rbheads:
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  2495
                    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
  2496
                            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
  2497
                    cache = branchmap.branchcache(rbranchmap,
ad194a8ab5c1 branchmap: add the tipnode (cache key) on the branchcache object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18124
diff changeset
  2498
                                                  self[rtiprev].node())
ad194a8ab5c1 branchmap: add the tipnode (cache key) on the branchcache object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18124
diff changeset
  2499
                    self._branchcache = cache
ad194a8ab5c1 branchmap: add the tipnode (cache key) on the branchcache object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18124
diff changeset
  2500
                    branchmap.write(self, cache, cache.tipnode, rtiprev)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2501
            self.invalidate()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2502
            return len(self.heads()) + 1
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2503
        finally:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  2504
            lock.release()
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
  2505
2613
479e26afa10f clone: do not make streaming default. add --stream option instead.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2612
diff changeset
  2506
    def clone(self, remote, heads=[], stream=False):
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  2507
        '''clone remote repository.
1382
b113e7db06e9 hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents: 1375
diff changeset
  2508
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  2509
        keyword arguments:
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  2510
        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
  2511
        stream: use streaming clone if possible'''
247
863b508c5b36 migrate verify
mpm@selenic.com
parents: 244
diff changeset
  2512
2621
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  2513
        # 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
  2514
        # 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
  2515
        # them.
247
863b508c5b36 migrate verify
mpm@selenic.com
parents: 244
diff changeset
  2516
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  2517
        # 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
  2518
        # 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
  2519
        # uncompressed only if compatible.
247
863b508c5b36 migrate verify
mpm@selenic.com
parents: 244
diff changeset
  2520
16361
6097ede2be4d protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents: 16253
diff changeset
  2521
        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
  2522
            # 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
  2523
            stream = remote.capable('stream-preferred')
6097ede2be4d protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents: 16253
diff changeset
  2524
12296
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2525
        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
  2526
            # '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
  2527
            if remote.capable('stream'):
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2528
                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
  2529
            # 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
  2530
            streamreqs = remote.capable('streamreqs')
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2531
            if streamreqs:
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2532
                streamreqs = set(streamreqs.split(','))
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  2533
                # 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
  2534
                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
  2535
                    return self.stream_in(remote, streamreqs)
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  2536
        return self.pull(remote, heads)
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  2537
11368
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  2538
    def pushkey(self, namespace, key, old, new):
14102
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2539
        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
  2540
                  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
  2541
        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
  2542
        ret = pushkey.push(self, namespace, key, old, new)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2543
        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
  2544
                  ret=ret)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2545
        return ret
11368
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  2546
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  2547
    def listkeys(self, namespace):
14102
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2548
        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
  2549
        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
  2550
        values = pushkey.list(self, namespace)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2551
        self.hook('listkeys', namespace=namespace, values=values)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  2552
        return values
11368
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  2553
14048
58e58406ed19 wireproto: add test for new optional arg missing on server
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14036
diff changeset
  2554
    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
  2555
        '''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
  2556
        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
  2557
14529
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2558
    def savecommitmessage(self, text):
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2559
        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
  2560
        try:
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2561
            fp.write(text)
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2562
        finally:
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  2563
            fp.close()
18054
b35e3364f94a check-code: there must also be whitespace between ')' and operator
Mads Kiilerich <madski@unity3d.com>
parents: 18044
diff changeset
  2564
        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
  2565
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  2566
# 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
  2567
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
  2568
    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
  2569
    def a():
3790
f183c18568df localrepo: change aftertrans to be independant of the store path
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3773
diff changeset
  2570
        for src, dest in renamefiles:
16441
9dd10a574af2 localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents: 16426
diff changeset
  2571
            try:
9dd10a574af2 localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents: 16426
diff changeset
  2572
                util.rename(src, dest)
9dd10a574af2 localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents: 16426
diff changeset
  2573
            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
  2574
                pass
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  2575
    return a
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  2576
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  2577
def undoname(fn):
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  2578
    base, name = os.path.split(fn)
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  2579
    assert name.startswith('journal')
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  2580
    return os.path.join(base, name.replace('journal', 'undo', 1))
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  2581
2740
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
  2582
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
  2583
    return localrepository(ui, util.urllocalpath(path), create)
3223
53e843840349 Whitespace/Tab cleanup
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3164
diff changeset
  2584
2740
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
  2585
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
  2586
    return True