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

  • Committer: Robert Collins
  • Date: 2008-01-06 20:04:22 UTC
  • mto: (3221.11.1 StackableBranch)
  • mto: This revision was merged to the branch mainline in revision 3226.
  • Revision ID: robertc@robertcollins.net-20080106200422-x8yz6cxotlzltvwp
The bzrdir format registry now accepts an ``alias`` keyword to
register_metadir, used to indicate that a format name is an alias for
some other format and thus should not be reported when describing the
format. (Robert Collins)
-------------- This line and the fmllowing will be ignored --------------

modified:
  NEWS
  bzrlib/bzrdir.py
  bzrlib/info.py
  bzrlib/tests/test_bzrdir.py
  bzrlib/tests/test_info.py

=== modified file 'NEWS'
--- a/NEWS      2008-01-02 22:30:46 +0000
+++ b/NEWS      2008-01-06 20:04:15 +0000
@@ -135,6 +135,11 @@
     * Patience Diff now supports arbitrary python objects, as long as they
       support ``hash()``. (John Arbash Meinel)
 
+    * The bzrdir format registry now accepts an ``alias`` keyword to
+      register_metadir, used to indicate that a format name is an alias for
+      some other format and thus should not be reported when describing the
+      format. (Robert Collins)
+
   API BREAKS:
 
   TESTING:

=== modified file 'bzrlib/bzrdir.py'
--- a/bzrlib/bzrdir.py  2008-01-02 22:30:46 +0000
+++ b/bzrlib/bzrdir.py  2008-01-06 19:41:29 +0000
@@ -2447,12 +2447,22 @@
     e.g. BzrDirMeta1 with weave repository.  Also, it's more user-oriented.
     """
 
+    def __init__(self):
+        """Create a BzrDirFormatRegistry."""
+        self._aliases = set()
+        super(BzrDirFormatRegistry, self).__init__()
+
+    def aliases(self):
+        """Return a set of the format names which are aliases."""
+        return frozenset(self._aliases)
+
     def register_metadir(self, key,
              repository_format, help, native=True, deprecated=False,
              branch_format=None,
              tree_format=None,
              hidden=False,
-             experimental=False):
+             experimental=False,
+             alias=False):
         """Register a metadir subformat.
 
         These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
@@ -2491,10 +2501,10 @@
                 bd.repository_format = _load(repository_format)
             return bd
         self.register(key, helper, help, native, deprecated, hidden,
-            experimental)
+            experimental, alias)
 
     def register(self, key, factory, help, native=True, deprecated=False,
-                 hidden=False, experimental=False):
+                 hidden=False, experimental=False, alias=False):
         """Register a BzrDirFormat factory.
         
         The factory must be a callable that takes one parameter: the key.
@@ -2505,11 +2515,15 @@
         """
         registry.Registry.register(self, key, factory, help,
             BzrDirFormatInfo(native, deprecated, hidden, experimental))
+        if alias:
+            self._aliases.add(key)
 
     def register_lazy(self, key, module_name, member_name, help, native=True,
-                      deprecated=False, hidden=False, experimental=False):
+        deprecated=False, hidden=False, experimental=False, alias=False):
         registry.Registry.register_lazy(self, key, module_name, member_name,
             help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
+        if alias:
+            self._aliases.add(key)
 
     def set_default(self, key):
         """Set the 'default' key to be a clone of the supplied key.
@@ -2518,6 +2532,7 @@
         """
         registry.Registry.register(self, 'default', self.get(key),
             self.get_help(key), info=self.get_info(key))
+        self._aliases.add('default')
 
     def set_default_repository(self, key):
         """Set the FormatRegistry default and Repository default.
@@ -2670,6 +2685,7 @@
     tree_format='bzrlib.workingtree.WorkingTreeFormat4',
     hidden=False,
     )
+# The following two formats should always just be aliases.
 format_registry.register_metadir('development',
     'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0',
     help='Current development format. Can convert data to and from pack-0.92 '
@@ -2681,6 +2697,7 @@
     branch_format='bzrlib.branch.BzrBranchFormat6',
     tree_format='bzrlib.workingtree.WorkingTreeFormat4',
     experimental=True,
+    alias=True,
     )
 format_registry.register_metadir('development-subtree',
     'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0Subtree',
@@ -2693,7 +2710,9 @@
     branch_format='bzrlib.branch.BzrBranchFormat6',
     tree_format='bzrlib.workingtree.WorkingTreeFormat4',
     experimental=True,
+    alias=True,
     )
+# And the development formats which the will have aliased one of follow:
 format_registry.register_metadir('development0',
     'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0',
     help='Trivial rename of pack-0.92 to provide a development format. '

=== modified file 'bzrlib/info.py'
--- a/bzrlib/info.py    2007-11-06 09:00:25 +0000
+++ b/bzrlib/info.py    2008-01-06 20:01:30 +0000
@@ -440,7 +440,9 @@
         tree.bzrdir.root_transport.base):
         branch = None
         repository = None
-    for key in bzrdir.format_registry.keys():
+    non_aliases = set(bzrdir.format_registry.keys())
+    non_aliases.difference_update(bzrdir.format_registry.aliases())
+    for key in non_aliases:
         format = bzrdir.format_registry.make_bzrdir(key)
         if isinstance(format, bzrdir.BzrDirMetaFormat1):
             if (tree and format.workingtree_format !=
@@ -457,11 +459,12 @@
         candidates.append(key)
     if len(candidates) == 0:
         return 'unnamed'
-    new_candidates = [c for c in candidates if c != 'default']
-    if len(new_candidates) > 0:
-        candidates = new_candidates
+    candidates.sort()
     new_candidates = [c for c in candidates if not
         bzrdir.format_registry.get_info(c).hidden]
     if len(new_candidates) > 0:
+        # If there are any non-hidden formats that match, only return those to
+        # avoid listing hidden formats except when only a hidden format will
+        # do.
         candidates = new_candidates
     return ' or '.join(candidates)

=== modified file 'bzrlib/tests/test_bzrdir.py'
--- a/bzrlib/tests/test_bzrdir.py       2007-12-21 20:32:22 +0000
+++ b/bzrlib/tests/test_bzrdir.py       2008-01-06 19:45:00 +0000
@@ -170,6 +170,16 @@
         finally:
             bzrdir.format_registry.set_default_repository(old_default)
 
+    def test_aliases(self):
+        a_registry = bzrdir.BzrDirFormatRegistry()
+        a_registry.register('weave', bzrdir.BzrDirFormat6,
+            'Pre-0.8 format.  Slower and does not support checkouts or shared'
+            ' repositories', deprecated=True)
+        a_registry.register('weavealias', bzrdir.BzrDirFormat6,
+            'Pre-0.8 format.  Slower and does not support checkouts or shared'
+            ' repositories', deprecated=True, alias=True)
+        self.assertEqual(frozenset(['weavealias']), a_registry.aliases())
+    
 
 class SampleBranch(bzrlib.branch.Branch):
     """A dummy branch for guess what, dummy use."""

=== modified file 'bzrlib/tests/test_info.py'
--- a/bzrlib/tests/test_info.py 2007-11-26 13:55:51 +0000
+++ b/bzrlib/tests/test_info.py 2008-01-06 20:02:10 +0000
@@ -126,16 +126,22 @@
 
     def test_describe_tree_format(self):
         for key in bzrdir.format_registry.keys():
-            if key == 'default':
+            if key in bzrdir.format_registry.aliases():
                 continue
             self.assertTreeDescription(key)
 
     def test_describe_checkout_format(self):
         for key in bzrdir.format_registry.keys():
-            if key in ('default', 'weave', 'experimental'):
-                continue
-            if key.startswith('experimental-'):
-                # these are typically hidden or aliases for other formats
+            if key in bzrdir.format_registry.aliases():
+                # Aliases will not describe correctly in the UI because the
+                # real format is found.
+                continue
+            # legacy: weave does not support checkouts
+            if key == 'weave':
+                continue
+            if bzrdir.format_registry.get_info(key).experimental:
+                # We don't require that experimental formats support checkouts
+                # or describe correctly in the UI.
                 continue
             expected = None
             if key in ('dirstate', 'dirstate-tags', 'dirstate-with-subtree',
@@ -149,7 +155,7 @@
 
     def test_describe_branch_format(self):
         for key in bzrdir.format_registry.keys():
-            if key == 'default':
+            if key in bzrdir.format_registry.aliases():
                 continue
             expected = None
             if key in ('dirstate', 'knit'):
@@ -158,7 +164,7 @@
 
     def test_describe_repo_format(self):
         for key in bzrdir.format_registry.keys():
-            if key == 'default':
+            if key in bzrdir.format_registry.aliases():
                 continue
             expected = None
             if key in ('dirstate', 'knit', 'dirstate-tags'):

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transactions.py
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
#   Authors: Robert Collins <robert.collins@canonical.com>
 
3
#
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
#
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with this program; if not, write to the Free Software
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
"""This module provides a transactional facility.
 
19
 
 
20
Transactions provide hooks to allow data objects (i.e. inventory weaves or
 
21
the revision-history file) to be placed in a registry and retrieved later
 
22
during the same transaction. Transactions in bzr are not atomic - they
 
23
depend on data ordering of writes, so we do not have commit or rollback
 
24
facilities at the transaction level.
 
25
 
 
26
Read only transactions raise an assert when objects are listed as dirty
 
27
against them - preventing unintended writes.
 
28
 
 
29
Write transactions preserve dirty objects in the cache, though due to the
 
30
write ordering approach we use for consistency 'dirty' is a misleading term.
 
31
A dirty object is one we have modified.
 
32
 
 
33
Both read and write transactions *may* flush unchanged objects out of 
 
34
memory, unless they are marked as 'precious' which indicates that 
 
35
repeated reads cannot be obtained if the object is ejected, or that
 
36
the object is an expensive one for obtaining.
 
37
"""
 
38
 
 
39
import sys
 
40
 
 
41
import bzrlib.errors as errors
 
42
from bzrlib.identitymap import IdentityMap, NullIdentityMap
 
43
from bzrlib.trace import mutter
 
44
 
 
45
 
 
46
class ReadOnlyTransaction(object):
 
47
    """A read only unit of work for data objects."""
 
48
 
 
49
    def finish(self):
 
50
        """Clean up this transaction."""
 
51
 
 
52
    def __init__(self):
 
53
        super(ReadOnlyTransaction, self).__init__()
 
54
        self.map = IdentityMap()
 
55
        self._clean_objects = set()
 
56
        self._clean_queue = []
 
57
        self._limit = -1
 
58
        self._precious_objects = set()
 
59
 
 
60
    def is_clean(self, an_object):
 
61
        """Return True if an_object is clean."""
 
62
        return (an_object in self._clean_objects)
 
63
 
 
64
    def register_clean(self, an_object, precious=False):
 
65
        """Register an_object as being clean.
 
66
        
 
67
        If the precious hint is True, the object will not
 
68
        be ejected from the object identity map ever.
 
69
        """
 
70
        self._clean_objects.add(an_object)
 
71
        self._clean_queue.append(an_object)
 
72
        if precious:
 
73
            self._precious_objects.add(an_object)
 
74
        self._trim()
 
75
 
 
76
    def register_dirty(self, an_object):
 
77
        """Register an_object as being dirty."""
 
78
        raise errors.ReadOnlyObjectDirtiedError(an_object)
 
79
 
 
80
    def set_cache_size(self, size):
 
81
        """Set a new cache size."""
 
82
        assert -1 <= size
 
83
        self._limit = size
 
84
        self._trim()
 
85
 
 
86
    def _trim(self):
 
87
        """Trim the cache back if needed."""
 
88
        if self._limit < 0 or self._limit - len(self._clean_objects) > 0:
 
89
            return
 
90
        needed = len(self._clean_objects) - self._limit
 
91
        offset = 0
 
92
        while needed and offset < len(self._clean_objects):
 
93
            # references we know of:
 
94
            # temp passed to getrefcount in our frame
 
95
            # temp in getrefcount's frame
 
96
            # the map forward
 
97
            # the map backwards
 
98
            # _clean_objects
 
99
            # _clean_queue
 
100
            # 1 missing ?
 
101
            if (sys.getrefcount(self._clean_queue[offset]) <= 7 and
 
102
                not self._clean_queue[offset] in self._precious_objects):
 
103
                removed = self._clean_queue[offset]
 
104
                self._clean_objects.remove(removed)
 
105
                del self._clean_queue[offset]
 
106
                self.map.remove_object(removed)
 
107
                mutter('removed object %r', removed)
 
108
                needed -= 1
 
109
            else:
 
110
                offset += 1
 
111
 
 
112
    def writeable(self):
 
113
        """Read only transactions do not allow writes."""
 
114
 
 
115
 
 
116
class WriteTransaction(ReadOnlyTransaction):
 
117
    """A write transaction
 
118
 
 
119
    - caches domain objects
 
120
    - clean objects can be removed from the cache
 
121
    - dirty objects are retained.
 
122
    """
 
123
 
 
124
    def finish(self):
 
125
        """Clean up this transaction."""
 
126
        for thing in self._dirty_objects:
 
127
            callback = getattr(thing, 'transaction_finished', None)
 
128
            if callback is not None:
 
129
                callback()
 
130
 
 
131
    def __init__(self):
 
132
        super(WriteTransaction, self).__init__()
 
133
        self._dirty_objects = set()
 
134
 
 
135
    def is_dirty(self, an_object):
 
136
        """Return True if an_object is dirty."""
 
137
        return (an_object in self._dirty_objects)
 
138
 
 
139
    def register_dirty(self, an_object):
 
140
        """Register an_object as being dirty.
 
141
        
 
142
        Dirty objects are not ejected from the identity map
 
143
        until the transaction finishes and get informed
 
144
        when the transaction finishes.
 
145
        """
 
146
        self._dirty_objects.add(an_object)
 
147
        if self.is_clean(an_object):
 
148
            self._clean_objects.remove(an_object)
 
149
            del self._clean_queue[self._clean_queue.index(an_object)]
 
150
        self._trim()
 
151
 
 
152
    def writeable(self):
 
153
        """Write transactions allow writes."""
 
154
        return True
 
155
 
 
156
        
 
157
class PassThroughTransaction(object):
 
158
    """A pass through transaction
 
159
    
 
160
    - nothing is cached.
 
161
    - nothing ever gets into the identity map.
 
162
    """
 
163
 
 
164
    def finish(self):
 
165
        """Clean up this transaction."""
 
166
        for thing in self._dirty_objects:
 
167
            callback = getattr(thing, 'transaction_finished', None)
 
168
            if callback is not None:
 
169
                callback()
 
170
 
 
171
    def __init__(self):
 
172
        super(PassThroughTransaction, self).__init__()
 
173
        self.map = NullIdentityMap()
 
174
        self._dirty_objects = set()
 
175
 
 
176
    def register_clean(self, an_object, precious=False):
 
177
        """Register an_object as being clean.
 
178
        
 
179
        Note that precious is only a hint, and PassThroughTransaction
 
180
        ignores it.
 
181
        """
 
182
 
 
183
    def register_dirty(self, an_object):
 
184
        """Register an_object as being dirty.
 
185
        
 
186
        Dirty objects get informed
 
187
        when the transaction finishes.
 
188
        """
 
189
        self._dirty_objects.add(an_object)
 
190
 
 
191
    def set_cache_size(self, ignored):
 
192
        """Do nothing, we are passing through."""
 
193
 
 
194
    def writeable(self):
 
195
        """Pass through transactions allow writes."""
 
196
        return True