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