/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2010-04-23 00:44:15 UTC
  • mto: This revision was merged to the branch mainline in revision 5189.
  • Revision ID: mbp@canonical.com-20100423004415-py8ozrtkjo6tphj2
Update more code to use user_transport when it should

Show diffs side-by-side

added added

removed removed

Lines of Context:
283
283
        new_history.reverse()
284
284
        return new_history
285
285
 
286
 
    def lock_write(self, token=None):
287
 
        """Lock the branch for write operations.
288
 
 
289
 
        :param token: A token to permit reacquiring a previously held and
290
 
            preserved lock.
291
 
        :return: A BranchWriteLockResult.
292
 
        """
 
286
    def lock_write(self):
293
287
        raise NotImplementedError(self.lock_write)
294
288
 
295
289
    def lock_read(self):
296
 
        """Lock the branch for read operations.
297
 
 
298
 
        :return: An object with an unlock method which will release the lock
299
 
            obtained.
300
 
        """
301
290
        raise NotImplementedError(self.lock_read)
302
291
 
303
292
    def unlock(self):
428
417
            * 'include' - the stop revision is the last item in the result
429
418
            * 'with-merges' - include the stop revision and all of its
430
419
              merged revisions in the result
431
 
            * 'with-merges-without-common-ancestry' - filter out revisions 
432
 
              that are in both ancestries
433
420
        :param direction: either 'reverse' or 'forward':
434
421
            * reverse means return the start_revision_id first, i.e.
435
422
              start at the most recent revision and go backwards in history
466
453
            stop_revision_id, stop_rule)
467
454
        # Make sure we don't return revisions that are not part of the
468
455
        # start_revision_id ancestry.
469
 
        filtered = self._filter_start_non_ancestors(filtered)
 
456
        filtered = self._filter_non_ancestors(filtered)
470
457
        if direction == 'reverse':
471
458
            return filtered
472
459
        if direction == 'forward':
509
496
                       node.end_of_merge)
510
497
                if rev_id == stop_revision_id:
511
498
                    return
512
 
        elif stop_rule == 'with-merges-without-common-ancestry':
513
 
            # We want to exclude all revisions that are already part of the
514
 
            # stop_revision_id ancestry.
515
 
            graph = self.repository.get_graph()
516
 
            ancestors = graph.find_unique_ancestors(start_revision_id,
517
 
                                                    [stop_revision_id])
518
 
            for node in rev_iter:
519
 
                rev_id = node.key[-1]
520
 
                if rev_id not in ancestors:
521
 
                    continue
522
 
                yield (rev_id, node.merge_depth, node.revno,
523
 
                       node.end_of_merge)
524
499
        elif stop_rule == 'with-merges':
525
500
            stop_rev = self.repository.get_revision(stop_revision_id)
526
501
            if stop_rev.parent_ids:
549
524
        else:
550
525
            raise ValueError('invalid stop_rule %r' % stop_rule)
551
526
 
552
 
    def _filter_start_non_ancestors(self, rev_iter):
 
527
    def _filter_non_ancestors(self, rev_iter):
553
528
        # If we started from a dotted revno, we want to consider it as a tip
554
529
        # and don't want to yield revisions that are not part of its
555
530
        # ancestry. Given the order guaranteed by the merge sort, we will see
646
621
        :param pb: An optional progress bar to use.
647
622
        :return: None
648
623
        """
649
 
        if self.base == from_branch.base:
 
624
        if self.control_url == from_branch.control_url:
650
625
            return (0, [])
651
626
        if pb is not None:
652
627
            symbol_versioning.warn(
805
780
                # stream from one of them to the other.  This does mean doing
806
781
                # separate SSH connection setup, but unstacking is not a
807
782
                # common operation so it's tolerable.
808
 
                new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
 
783
                new_bzrdir = bzrdir.BzrDir.open_from_transport(
 
784
                    self.bzrdir.user_transport)
809
785
                new_repository = new_bzrdir.find_repository()
810
786
                self.repository = new_repository
811
787
                if self.repository._fallback_repositories:
1236
1212
            if repository_policy is not None:
1237
1213
                repository_policy.configure_branch(result)
1238
1214
            self.copy_content_into(result, revision_id=revision_id)
1239
 
            result.set_parent(self.bzrdir.root_transport.base)
 
1215
            result.set_parent(self.bzrdir.user_url)
1240
1216
        finally:
1241
1217
            result.unlock()
1242
1218
        return result
1429
1405
        :return: A branch associated with the file_id
1430
1406
        """
1431
1407
        # FIXME should provide multiple branches, based on config
1432
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base,
 
1408
        return Branch.open(self.user_transport.clone(path).base,
1433
1409
                           possible_transports=possible_transports)
1434
1410
 
1435
1411
    def supports_tags(self):
1565
1541
        """Return the short format description for this format."""
1566
1542
        raise NotImplementedError(self.get_format_description)
1567
1543
 
1568
 
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1569
 
        hooks = Branch.hooks['post_branch_init']
1570
 
        if not hooks:
1571
 
            return
1572
 
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
1573
 
        for hook in hooks:
1574
 
            hook(params)
1575
 
 
1576
1544
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1577
1545
                           lock_type='metadir', set_format=True):
1578
1546
        """Initialize a branch in a bzrdir, with specified files
1614
1582
        finally:
1615
1583
            if lock_taken:
1616
1584
                control_files.unlock()
1617
 
        branch = self.open(a_bzrdir, name, _found=True)
1618
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1619
 
        return branch
 
1585
        return self.open(a_bzrdir, name, _found=True)
1620
1586
 
1621
1587
    def initialize(self, a_bzrdir, name=None):
1622
1588
        """Create a branch of this format in a_bzrdir.
1782
1748
            "should return a tag name or None if no tag name could be "
1783
1749
            "determined. The first non-None tag name returned will be used.",
1784
1750
            (2, 2), None))
1785
 
        self.create_hook(HookPoint('post_branch_init',
1786
 
            "Called after new branch initialization completes. "
1787
 
            "post_branch_init is called with a "
1788
 
            "bzrlib.branch.BranchInitHookParams. "
1789
 
            "Note that init, branch and checkout (both heavyweight and "
1790
 
            "lightweight) will all trigger this hook.", (2, 2), None))
1791
 
        self.create_hook(HookPoint('post_switch',
1792
 
            "Called after a checkout switches branch. "
1793
 
            "post_switch is called with a "
1794
 
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
1795
1751
 
1796
1752
 
1797
1753
 
1837
1793
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1838
1794
 
1839
1795
 
1840
 
class BranchInitHookParams(object):
1841
 
    """Object holding parameters passed to *_branch_init hooks.
1842
 
 
1843
 
    There are 4 fields that hooks may wish to access:
1844
 
 
1845
 
    :ivar format: the branch format
1846
 
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
1847
 
    :ivar name: name of colocated branch, if any (or None)
1848
 
    :ivar branch: the branch created
1849
 
 
1850
 
    Note that for lightweight checkouts, the bzrdir and format fields refer to
1851
 
    the checkout, hence they are different from the corresponding fields in
1852
 
    branch, which refer to the original branch.
1853
 
    """
1854
 
 
1855
 
    def __init__(self, format, a_bzrdir, name, branch):
1856
 
        """Create a group of BranchInitHook parameters.
1857
 
 
1858
 
        :param format: the branch format
1859
 
        :param a_bzrdir: the BzrDir where the branch will be/has been
1860
 
            initialized
1861
 
        :param name: name of colocated branch, if any (or None)
1862
 
        :param branch: the branch created
1863
 
 
1864
 
        Note that for lightweight checkouts, the bzrdir and format fields refer
1865
 
        to the checkout, hence they are different from the corresponding fields
1866
 
        in branch, which refer to the original branch.
1867
 
        """
1868
 
        self.format = format
1869
 
        self.bzrdir = a_bzrdir
1870
 
        self.name = name
1871
 
        self.branch = branch
1872
 
 
1873
 
    def __eq__(self, other):
1874
 
        return self.__dict__ == other.__dict__
1875
 
 
1876
 
    def __repr__(self):
1877
 
        if self.branch:
1878
 
            return "<%s of %s>" % (self.__class__.__name__, self.branch)
1879
 
        else:
1880
 
            return "<%s of format:%s bzrdir:%s>" % (
1881
 
                self.__class__.__name__, self.branch,
1882
 
                self.format, self.bzrdir)
1883
 
 
1884
 
 
1885
 
class SwitchHookParams(object):
1886
 
    """Object holding parameters passed to *_switch hooks.
1887
 
 
1888
 
    There are 4 fields that hooks may wish to access:
1889
 
 
1890
 
    :ivar control_dir: BzrDir of the checkout to change
1891
 
    :ivar to_branch: branch that the checkout is to reference
1892
 
    :ivar force: skip the check for local commits in a heavy checkout
1893
 
    :ivar revision_id: revision ID to switch to (or None)
1894
 
    """
1895
 
 
1896
 
    def __init__(self, control_dir, to_branch, force, revision_id):
1897
 
        """Create a group of SwitchHook parameters.
1898
 
 
1899
 
        :param control_dir: BzrDir of the checkout to change
1900
 
        :param to_branch: branch that the checkout is to reference
1901
 
        :param force: skip the check for local commits in a heavy checkout
1902
 
        :param revision_id: revision ID to switch to (or None)
1903
 
        """
1904
 
        self.control_dir = control_dir
1905
 
        self.to_branch = to_branch
1906
 
        self.force = force
1907
 
        self.revision_id = revision_id
1908
 
 
1909
 
    def __eq__(self, other):
1910
 
        return self.__dict__ == other.__dict__
1911
 
 
1912
 
    def __repr__(self):
1913
 
        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
1914
 
            self.control_dir, self.to_branch,
1915
 
            self.revision_id)
1916
 
 
1917
 
 
1918
1796
class BzrBranchFormat4(BranchFormat):
1919
1797
    """Bzr branch format 4.
1920
1798
 
2189
2067
        branch_transport.put_bytes('location',
2190
2068
            target_branch.bzrdir.user_url)
2191
2069
        branch_transport.put_bytes('format', self.get_format_string())
2192
 
        branch = self.open(
 
2070
        return self.open(
2193
2071
            a_bzrdir, name, _found=True,
2194
2072
            possible_transports=[target_branch.bzrdir.root_transport])
2195
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2196
 
        return branch
2197
2073
 
2198
2074
    def __init__(self):
2199
2075
        super(BranchReferenceFormat, self).__init__()
2276
2152
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2277
2153
 
2278
2154
 
2279
 
class BranchWriteLockResult(object):
2280
 
    """The result of write locking a branch.
2281
 
 
2282
 
    :ivar branch_token: The token obtained from the underlying branch lock, or
2283
 
        None.
2284
 
    :ivar unlock: A callable which will unlock the lock.
2285
 
    """
2286
 
 
2287
 
    def __init__(self, unlock, branch_token):
2288
 
        self.branch_token = branch_token
2289
 
        self.unlock = unlock
2290
 
 
2291
 
 
2292
2155
class BzrBranch(Branch, _RelockDebugMixin):
2293
2156
    """A branch stored in the actual filesystem.
2294
2157
 
2348
2211
        return self.control_files.is_locked()
2349
2212
 
2350
2213
    def lock_write(self, token=None):
2351
 
        """Lock the branch for write operations.
2352
 
 
2353
 
        :param token: A token to permit reacquiring a previously held and
2354
 
            preserved lock.
2355
 
        :return: A BranchWriteLockResult.
2356
 
        """
2357
2214
        if not self.is_locked():
2358
2215
            self._note_lock('w')
2359
2216
        # All-in-one needs to always unlock/lock.
2365
2222
        else:
2366
2223
            took_lock = False
2367
2224
        try:
2368
 
            return BranchWriteLockResult(self.unlock,
2369
 
                self.control_files.lock_write(token=token))
 
2225
            return self.control_files.lock_write(token=token)
2370
2226
        except:
2371
2227
            if took_lock:
2372
2228
                self.repository.unlock()
2373
2229
            raise
2374
2230
 
2375
2231
    def lock_read(self):
2376
 
        """Lock the branch for read operations.
2377
 
 
2378
 
        :return: An object with an unlock method which will release the lock
2379
 
            obtained.
2380
 
        """
2381
2232
        if not self.is_locked():
2382
2233
            self._note_lock('r')
2383
2234
        # All-in-one needs to always unlock/lock.
2390
2241
            took_lock = False
2391
2242
        try:
2392
2243
            self.control_files.lock_read()
2393
 
            return self
2394
2244
        except:
2395
2245
            if took_lock:
2396
2246
                self.repository.unlock()
2919
2769
        return stacked_url
2920
2770
 
2921
2771
    def _get_append_revisions_only(self):
2922
 
        return self.get_config(
2923
 
            ).get_user_option_as_bool('append_revisions_only')
 
2772
        value = self.get_config().get_user_option('append_revisions_only')
 
2773
        return value == 'True'
2924
2774
 
2925
2775
    @needs_write_lock
2926
2776
    def generate_revision_history(self, revision_id, last_rev=None,