/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/bzrdir.py

  • Committer: Aaron Bentley
  • Date: 2006-11-17 04:06:03 UTC
  • mfrom: (2139 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2162.
  • Revision ID: aaron.bentley@utoronto.ca-20061117040603-pgebxndswvwk26tt
Merge from bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
28
28
# TODO: Can we move specific formats into separate modules to make this file
29
29
# smaller?
30
30
 
31
 
from copy import deepcopy
32
31
from cStringIO import StringIO
33
32
import os
 
33
 
 
34
from bzrlib.lazy_import import lazy_import
 
35
lazy_import(globals(), """
 
36
from copy import deepcopy
34
37
from stat import S_ISDIR
35
 
from unittest import TestSuite
 
38
import unittest
36
39
 
37
40
import bzrlib
38
 
import bzrlib.errors as errors
39
 
from bzrlib.lockable_files import LockableFiles, TransportLock
40
 
from bzrlib.lockdir import LockDir
 
41
from bzrlib import (
 
42
    errors,
 
43
    lockable_files,
 
44
    lockdir,
 
45
    revision as _mod_revision,
 
46
    urlutils,
 
47
    xml4,
 
48
    xml5,
 
49
    )
41
50
from bzrlib.osutils import (
42
 
                            abspath,
43
 
                            pathjoin,
44
 
                            safe_unicode,
45
 
                            sha_strings,
46
 
                            sha_string,
47
 
                            )
48
 
import bzrlib.revision
 
51
    safe_unicode,
 
52
    sha_strings,
 
53
    sha_string,
 
54
    )
49
55
from bzrlib.store.revision.text import TextRevisionStore
50
56
from bzrlib.store.text import TextStore
51
57
from bzrlib.store.versioned import WeaveStore
52
 
from bzrlib.trace import mutter
53
58
from bzrlib.transactions import WriteTransaction
54
59
from bzrlib.transport import get_transport
 
60
from bzrlib.weave import Weave
 
61
""")
 
62
 
 
63
from bzrlib.trace import mutter
55
64
from bzrlib.transport.local import LocalTransport
56
 
import bzrlib.urlutils as urlutils
57
 
from bzrlib.weave import Weave
58
 
from bzrlib.xml4 import serializer_v4
59
 
import bzrlib.xml5
60
65
 
61
66
 
62
67
class BzrDir(object):
188
193
    def _make_tail(self, url):
189
194
        head, tail = urlutils.split(url)
190
195
        if tail and tail != '.':
191
 
            t = bzrlib.transport.get_transport(head)
 
196
            t = get_transport(head)
192
197
            try:
193
198
                t.mkdir(tail)
194
199
            except errors.FileExists:
210
215
                    "not one of %r" % cls)
211
216
        head, tail = urlutils.split(base)
212
217
        if tail and tail != '.':
213
 
            t = bzrlib.transport.get_transport(head)
 
218
            t = get_transport(head)
214
219
            try:
215
220
                t.mkdir(tail)
216
221
            except errors.FileExists:
341
346
        """
342
347
        raise NotImplementedError(self.create_workingtree)
343
348
 
 
349
    def destroy_workingtree(self):
 
350
        """Destroy the working tree at this BzrDir.
 
351
 
 
352
        Formats that do not support this may raise UnsupportedOperation.
 
353
        """
 
354
        raise NotImplementedError(self.destroy_workingtree)
 
355
 
 
356
    def destroy_workingtree_metadata(self):
 
357
        """Destroy the control files for the working tree at this BzrDir.
 
358
 
 
359
        The contents of working tree files are not affected.
 
360
        Formats that do not support this may raise UnsupportedOperation.
 
361
        """
 
362
        raise NotImplementedError(self.destroy_workingtree_metadata)
 
363
 
344
364
    def find_repository(self):
345
365
        """Find the repository that should be used for a_bzrdir.
346
366
 
665
685
        # TODO: jam 20060426 we probably need a test in here in the
666
686
        #       case that the newly sprouted branch is a remote one
667
687
        if result_repo is None or result_repo.make_working_trees():
668
 
            result.create_workingtree()
 
688
            wt = result.create_workingtree()
 
689
            if wt.inventory.root is None:
 
690
                try:
 
691
                    wt.set_root_id(self.open_workingtree.get_root_id())
 
692
                except errors.NoWorkingTree:
 
693
                    pass
669
694
        return result
670
695
 
671
696
 
675
700
    def __init__(self, _transport, _format):
676
701
        """See BzrDir.__init__."""
677
702
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
678
 
        assert self._format._lock_class == TransportLock
 
703
        assert self._format._lock_class == lockable_files.TransportLock
679
704
        assert self._format._lock_file_name == 'branch-lock'
680
 
        self._control_files = LockableFiles(self.get_branch_transport(None),
 
705
        self._control_files = lockable_files.LockableFiles(
 
706
                                            self.get_branch_transport(None),
681
707
                                            self._format._lock_file_name,
682
708
                                            self._format._lock_class)
683
709
 
727
753
        # done on this format anyway. So - acceptable wart.
728
754
        result = self.open_workingtree()
729
755
        if revision_id is not None:
730
 
            if revision_id == bzrlib.revision.NULL_REVISION:
 
756
            if revision_id == _mod_revision.NULL_REVISION:
731
757
                result.set_parent_ids([])
732
758
            else:
733
759
                result.set_parent_ids([revision_id])
734
760
        return result
735
761
 
 
762
    def destroy_workingtree(self):
 
763
        """See BzrDir.destroy_workingtree."""
 
764
        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
 
765
 
 
766
    def destroy_workingtree_metadata(self):
 
767
        """See BzrDir.destroy_workingtree_metadata."""
 
768
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata, 
 
769
                                          self)
 
770
 
736
771
    def get_branch_transport(self, branch_format):
737
772
        """See BzrDir.get_branch_transport()."""
738
773
        if branch_format is None:
878
913
        from bzrlib.workingtree import WorkingTreeFormat
879
914
        return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
880
915
 
 
916
    def destroy_workingtree(self):
 
917
        """See BzrDir.destroy_workingtree."""
 
918
        wt = self.open_workingtree()
 
919
        repository = wt.branch.repository
 
920
        empty = repository.revision_tree(bzrlib.revision.NULL_REVISION)
 
921
        wt.revert([], old_tree=empty)
 
922
        self.destroy_workingtree_metadata()
 
923
 
 
924
    def destroy_workingtree_metadata(self):
 
925
        self.transport.delete_tree('checkout')
 
926
 
881
927
    def _get_mkdir_mode(self):
882
928
        """Figure out the mode to use when creating a bzrdir subdir."""
883
 
        temp_control = LockableFiles(self.transport, '', TransportLock)
 
929
        temp_control = lockable_files.LockableFiles(self.transport, '',
 
930
                                     lockable_files.TransportLock)
884
931
        return temp_control._dir_mode
885
932
 
886
933
    def get_branch_transport(self, branch_format):
1062
1109
        """Initialize a new bzrdir in the base directory of a Transport."""
1063
1110
        # Since we don't have a .bzr directory, inherit the
1064
1111
        # mode from the root directory
1065
 
        temp_control = LockableFiles(transport, '', TransportLock)
 
1112
        temp_control = lockable_files.LockableFiles(transport,
 
1113
                            '', lockable_files.TransportLock)
1066
1114
        temp_control._transport.mkdir('.bzr',
1067
1115
                                      # FIXME: RBC 20060121 don't peek under
1068
1116
                                      # the covers
1077
1125
                      ('branch-format', self.get_format_string()),
1078
1126
                      ]
1079
1127
        # NB: no need to escape relative paths that are url safe.
1080
 
        control_files = LockableFiles(control, self._lock_file_name, 
1081
 
                                      self._lock_class)
 
1128
        control_files = lockable_files.LockableFiles(control,
 
1129
                            self._lock_file_name, self._lock_class)
1082
1130
        control_files.create_lock()
1083
1131
        control_files.lock_write()
1084
1132
        try:
1126
1174
        _found is a private parameter, do not use it.
1127
1175
        """
1128
1176
        if not _found:
1129
 
            assert isinstance(BzrDirFormat.find_format(transport),
1130
 
                              self.__class__)
 
1177
            found_format = BzrDirFormat.find_format(transport)
 
1178
            if not isinstance(found_format, self.__class__):
 
1179
                raise AssertionError("%s was asked to open %s, but it seems to need "
 
1180
                        "format %s" 
 
1181
                        % (self, transport, found_format))
1131
1182
        return self._open(transport)
1132
1183
 
1133
1184
    def _open(self, transport):
1187
1238
    removed in format 5; write support for this format has been removed.
1188
1239
    """
1189
1240
 
1190
 
    _lock_class = TransportLock
 
1241
    _lock_class = lockable_files.TransportLock
1191
1242
 
1192
1243
    def get_format_string(self):
1193
1244
        """See BzrDirFormat.get_format_string()."""
1237
1288
       Unhashed stores in the repository.
1238
1289
    """
1239
1290
 
1240
 
    _lock_class = TransportLock
 
1291
    _lock_class = lockable_files.TransportLock
1241
1292
 
1242
1293
    def get_format_string(self):
1243
1294
        """See BzrDirFormat.get_format_string()."""
1296
1347
     - Format 6 repositories [always]
1297
1348
    """
1298
1349
 
1299
 
    _lock_class = TransportLock
 
1350
    _lock_class = lockable_files.TransportLock
1300
1351
 
1301
1352
    def get_format_string(self):
1302
1353
        """See BzrDirFormat.get_format_string()."""
1356
1407
     - Format 7 repositories [optional]
1357
1408
    """
1358
1409
 
1359
 
    _lock_class = LockDir
 
1410
    _lock_class = lockdir.LockDir
1360
1411
 
1361
1412
    def get_converter(self, format=None):
1362
1413
        """See BzrDirFormat.get_converter()."""
1416
1467
        self._formats = formats
1417
1468
    
1418
1469
    def adapt(self, test):
1419
 
        result = TestSuite()
 
1470
        result = unittest.TestSuite()
1420
1471
        for format in self._formats:
1421
1472
            new_test = deepcopy(test)
1422
1473
            new_test.transport_server = self._transport_server
1520
1571
        self.bzrdir.transport.delete_tree('text-store')
1521
1572
 
1522
1573
    def _convert_working_inv(self):
1523
 
        inv = serializer_v4.read_inventory(self.branch.control_files.get('inventory'))
1524
 
        new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
1574
        inv = xml4.serializer_v4.read_inventory(
 
1575
                    self.branch.control_files.get('inventory'))
 
1576
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1525
1577
        # FIXME inventory is a working tree change.
1526
1578
        self.branch.control_files.put('inventory', StringIO(new_inv_xml))
1527
1579
 
1553
1605
                                                      prefixed=False,
1554
1606
                                                      compressed=True))
1555
1607
        try:
1556
 
            transaction = bzrlib.transactions.WriteTransaction()
 
1608
            transaction = WriteTransaction()
1557
1609
            for i, rev_id in enumerate(self.converted_revs):
1558
1610
                self.pb.update('write revision', i, len(self.converted_revs))
1559
1611
                _revision_store.add_revision(self.revisions[rev_id], transaction)
1585
1637
    def _load_old_inventory(self, rev_id):
1586
1638
        assert rev_id not in self.converted_revs
1587
1639
        old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1588
 
        inv = serializer_v4.read_inventory_from_string(old_inv_xml)
 
1640
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
1589
1641
        inv.revision_id = rev_id
1590
1642
        rev = self.revisions[rev_id]
1591
1643
        if rev.inventory_sha1:
1596
1648
    def _load_updated_inventory(self, rev_id):
1597
1649
        assert rev_id in self.converted_revs
1598
1650
        inv_xml = self.inv_weave.get_text(rev_id)
1599
 
        inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(inv_xml)
 
1651
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml)
1600
1652
        return inv
1601
1653
 
1602
1654
    def _convert_one_rev(self, rev_id):
1618
1670
                assert getattr(ie, 'revision', None) is not None, \
1619
1671
                    'no revision on {%s} in {%s}' % \
1620
1672
                    (file_id, rev.revision_id)
1621
 
        new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
1673
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1622
1674
        new_inv_sha1 = sha_string(new_inv_xml)
1623
1675
        self.inv_weave.add_lines(rev.revision_id, 
1624
1676
                                 present_parents,
1657
1709
                                                  entry_vf=w)
1658
1710
        for old_revision in previous_entries:
1659
1711
                # if this fails, its a ghost ?
1660
 
                assert old_revision in self.converted_revs 
 
1712
                assert old_revision in self.converted_revs, \
 
1713
                    "Revision {%s} not in converted_revs" % old_revision
1661
1714
        self.snapshot_ie(previous_entries, ie, w, rev_id)
1662
1715
        del ie.text_id
1663
1716
        assert getattr(ie, 'revision', None) is not None
1817
1870
                if name in bzrcontents:
1818
1871
                    self.bzrdir.transport.delete(name)
1819
1872
        else:
 
1873
            from bzrlib.workingtree import WorkingTreeFormat3
1820
1874
            self.step('Upgrading working tree')
1821
1875
            self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
1822
1876
            self.make_lock('checkout')
1823
1877
            self.put_format(
1824
 
                'checkout', bzrlib.workingtree.WorkingTreeFormat3())
 
1878
                'checkout', WorkingTreeFormat3())
1825
1879
            self.bzrdir.transport.delete_multi(
1826
1880
                self.garbage_inventories, self.pb)
1827
1881
            for entry in checkout_files:
1836
1890
    def make_lock(self, name):
1837
1891
        """Make a lock for the new control dir name."""
1838
1892
        self.step('Make %s lock' % name)
1839
 
        ld = LockDir(self.bzrdir.transport, 
1840
 
                     '%s/lock' % name,
1841
 
                     file_modebits=self.file_mode,
1842
 
                     dir_modebits=self.dir_mode)
 
1893
        ld = lockdir.LockDir(self.bzrdir.transport,
 
1894
                             '%s/lock' % name,
 
1895
                             file_modebits=self.file_mode,
 
1896
                             dir_modebits=self.dir_mode)
1843
1897
        ld.create()
1844
1898
 
1845
1899
    def move_entry(self, new_dir, entry):