/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/smart/branch.py

  • Committer: James Westby
  • Date: 2007-09-18 18:55:00 UTC
  • mto: (2866.1.1 james.westby)
  • mto: This revision was merged to the branch mainline in revision 2867.
  • Revision ID: jw+debian@jameswestby.net-20070918185500-91alkjx8zolds1v8
Fix log against smart server branches that don't support tags. (#140615)

Add get_reverse_tag_dict to DisabledTags for branches that falsely
claim that they support tags (namely smart server branches). When the
remote branch was an old format without tags this caused log to fail.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/branch.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Server-side branch related request implmentations."""
18
18
 
27
27
 
28
28
 
29
29
class SmartServerBranchRequest(SmartServerRequest):
30
 
    """Base class for handling common branch request logic.
31
 
    """
 
30
    """Base class for handling common branch request logic."""
32
31
 
33
32
    def do(self, path, *args):
34
33
        """Execute a request for a branch at path.
35
34
 
36
 
        All Branch requests take a path to the branch as their first argument.
37
 
 
38
35
        If the branch is a branch reference, NotBranchError is raised.
39
 
 
40
 
        :param path: The path for the repository as received from the
41
 
            client.
42
 
        :return: A SmartServerResponse from self.do_with_branch().
43
36
        """
44
 
        transport = self.transport_from_client_path(path)
 
37
        transport = self._backing_transport.clone(path)
45
38
        bzrdir = BzrDir.open_from_transport(transport)
46
39
        if bzrdir.get_branch_reference() is not None:
47
40
            raise errors.NotBranchError(transport.base)
48
 
        branch = bzrdir.open_branch(ignore_fallbacks=True)
 
41
        branch = bzrdir.open_branch()
49
42
        return self.do_with_branch(branch, *args)
50
43
 
51
44
 
74
67
 
75
68
 
76
69
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
77
 
 
 
70
    
78
71
    def do_with_branch(self, branch):
79
 
        """Return the content of branch.conf
80
 
 
 
72
        """Return the content of branch.control_files.get('branch.conf').
 
73
        
81
74
        The body is not utf8 decoded - its the literal bytestream from disk.
82
75
        """
83
76
        try:
84
 
            content = branch._transport.get_bytes('branch.conf')
 
77
            content = branch.control_files.get('branch.conf').read()
85
78
        except errors.NoSuchFile:
86
79
            content = ''
87
80
        return SuccessfulSmartServerResponse( ('ok', ), content)
88
81
 
89
82
 
90
 
class SmartServerBranchGetParent(SmartServerBranchRequest):
91
 
 
92
 
    def do_with_branch(self, branch):
93
 
        """Return the parent of branch."""
94
 
        parent = branch._get_parent_location() or ''
95
 
        return SuccessfulSmartServerResponse((parent,))
96
 
 
97
 
 
98
 
class SmartServerBranchGetTagsBytes(SmartServerBranchRequest):
99
 
 
100
 
    def do_with_branch(self, branch):
101
 
        """Return the _get_tags_bytes for a branch."""
102
 
        bytes = branch._get_tags_bytes()
103
 
        return SuccessfulSmartServerResponse((bytes,))
104
 
 
105
 
 
106
 
class SmartServerBranchSetTagsBytes(SmartServerLockedBranchRequest):
107
 
 
108
 
    def __init__(self, backing_transport, root_client_path='/', jail_root=None):
109
 
        SmartServerLockedBranchRequest.__init__(
110
 
            self, backing_transport, root_client_path, jail_root)
111
 
        self.locked = False
112
 
        
113
 
    def do_with_locked_branch(self, branch):
114
 
        """Call _set_tags_bytes for a branch.
115
 
 
116
 
        New in 1.18.
117
 
        """
118
 
        # We need to keep this branch locked until we get a body with the tags
119
 
        # bytes.
120
 
        self.branch = branch
121
 
        self.branch.lock_write()
122
 
        self.locked = True
123
 
 
124
 
    def do_body(self, bytes):
125
 
        self.branch._set_tags_bytes(bytes)
126
 
        return SuccessfulSmartServerResponse(())
127
 
 
128
 
    def do_end(self):
129
 
        # TODO: this request shouldn't have to do this housekeeping manually.
130
 
        # Some of this logic probably belongs in a base class.
131
 
        if not self.locked:
132
 
            # We never acquired the branch successfully in the first place, so
133
 
            # there's nothing more to do.
134
 
            return
135
 
        try:
136
 
            return SmartServerLockedBranchRequest.do_end(self)
137
 
        finally:
138
 
            # Only try unlocking if we locked successfully in the first place
139
 
            self.branch.unlock()
140
 
 
141
 
 
142
 
class SmartServerBranchRequestGetStackedOnURL(SmartServerBranchRequest):
143
 
 
144
 
    def do_with_branch(self, branch):
145
 
        stacked_on_url = branch.get_stacked_on_url()
146
 
        return SuccessfulSmartServerResponse(('ok', stacked_on_url))
147
 
 
148
 
 
149
83
class SmartServerRequestRevisionHistory(SmartServerBranchRequest):
150
84
 
151
85
    def do_with_branch(self, branch):
159
93
 
160
94
 
161
95
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
162
 
 
 
96
    
163
97
    def do_with_branch(self, branch):
164
98
        """Return branch.last_revision_info().
165
 
 
 
99
        
166
100
        The revno is encoded in decimal, the revision_id is encoded as utf8.
167
101
        """
168
102
        revno, last_revision = branch.last_revision_info()
169
103
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
170
104
 
171
105
 
172
 
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
173
 
    """Base class for handling common branch request logic for requests that
174
 
    update the branch tip.
175
 
    """
176
 
 
177
 
    def do_with_locked_branch(self, branch, *args):
178
 
        try:
179
 
            return self.do_tip_change_with_locked_branch(branch, *args)
180
 
        except errors.TipChangeRejected, e:
181
 
            msg = e.msg
182
 
            if isinstance(msg, unicode):
183
 
                msg = msg.encode('utf-8')
184
 
            return FailedSmartServerResponse(('TipChangeRejected', msg))
185
 
 
186
 
 
187
 
class SmartServerBranchRequestSetConfigOption(SmartServerLockedBranchRequest):
188
 
    """Set an option in the branch configuration."""
189
 
 
190
 
    def do_with_locked_branch(self, branch, value, name, section):
191
 
        if not section:
192
 
            section = None
193
 
        branch._get_config().set_option(value.decode('utf8'), name, section)
194
 
        return SuccessfulSmartServerResponse(())
195
 
 
196
 
 
197
 
class SmartServerBranchRequestSetLastRevision(SmartServerSetTipRequest):
198
 
 
199
 
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
 
106
class SmartServerBranchRequestSetLastRevision(SmartServerLockedBranchRequest):
 
107
    
 
108
    def do_with_locked_branch(self, branch, new_last_revision_id):
200
109
        if new_last_revision_id == 'null:':
201
110
            branch.set_revision_history([])
202
111
        else:
203
112
            if not branch.repository.has_revision(new_last_revision_id):
204
113
                return FailedSmartServerResponse(
205
114
                    ('NoSuchRevision', new_last_revision_id))
206
 
            branch.set_revision_history(branch._lefthand_history(
207
 
                new_last_revision_id, None, None))
208
 
        return SuccessfulSmartServerResponse(('ok',))
209
 
 
210
 
 
211
 
class SmartServerBranchRequestSetLastRevisionEx(SmartServerSetTipRequest):
212
 
 
213
 
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id,
214
 
            allow_divergence, allow_overwrite_descendant):
215
 
        """Set the last revision of the branch.
216
 
 
217
 
        New in 1.6.
218
 
 
219
 
        :param new_last_revision_id: the revision ID to set as the last
220
 
            revision of the branch.
221
 
        :param allow_divergence: A flag.  If non-zero, change the revision ID
222
 
            even if the new_last_revision_id's ancestry has diverged from the
223
 
            current last revision.  If zero, a 'Diverged' error will be
224
 
            returned if new_last_revision_id is not a descendant of the current
225
 
            last revision.
226
 
        :param allow_overwrite_descendant:  A flag.  If zero and
227
 
            new_last_revision_id is not a descendant of the current last
228
 
            revision, then the last revision will not be changed.  If non-zero
229
 
            and there is no divergence, then the last revision is always
230
 
            changed.
231
 
 
232
 
        :returns: on success, a tuple of ('ok', revno, revision_id), where
233
 
            revno and revision_id are the new values of the current last
234
 
            revision info.  The revision_id might be different to the
235
 
            new_last_revision_id if allow_overwrite_descendant was not set.
236
 
        """
237
 
        do_not_overwrite_descendant = not allow_overwrite_descendant
238
 
        try:
239
 
            last_revno, last_rev = branch.last_revision_info()
240
 
            graph = branch.repository.get_graph()
241
 
            if not allow_divergence or do_not_overwrite_descendant:
242
 
                relation = branch._revision_relations(
243
 
                    last_rev, new_last_revision_id, graph)
244
 
                if relation == 'diverged' and not allow_divergence:
245
 
                    return FailedSmartServerResponse(('Diverged',))
246
 
                if relation == 'a_descends_from_b' and do_not_overwrite_descendant:
247
 
                    return SuccessfulSmartServerResponse(
248
 
                        ('ok', last_revno, last_rev))
249
 
            new_revno = graph.find_distance_to_null(
250
 
                new_last_revision_id, [(last_rev, last_revno)])
251
 
            branch.set_last_revision_info(new_revno, new_last_revision_id)
252
 
        except errors.GhostRevisionsHaveNoRevno:
253
 
            return FailedSmartServerResponse(
254
 
                ('NoSuchRevision', new_last_revision_id))
255
 
        return SuccessfulSmartServerResponse(
256
 
            ('ok', new_revno, new_last_revision_id))
257
 
 
258
 
 
259
 
class SmartServerBranchRequestSetLastRevisionInfo(SmartServerSetTipRequest):
260
 
    """Branch.set_last_revision_info.  Sets the revno and the revision ID of
261
 
    the specified branch.
262
 
 
263
 
    New in bzrlib 1.4.
264
 
    """
265
 
 
266
 
    def do_tip_change_with_locked_branch(self, branch, new_revno,
267
 
            new_last_revision_id):
268
 
        try:
269
 
            branch.set_last_revision_info(int(new_revno), new_last_revision_id)
270
 
        except errors.NoSuchRevision:
271
 
            return FailedSmartServerResponse(
272
 
                ('NoSuchRevision', new_last_revision_id))
273
 
        return SuccessfulSmartServerResponse(('ok',))
274
 
 
275
 
 
276
 
class SmartServerBranchRequestSetParentLocation(SmartServerLockedBranchRequest):
277
 
    """Set the parent location for a branch.
278
 
    
279
 
    Takes a location to set, which must be utf8 encoded.
280
 
    """
281
 
 
282
 
    def do_with_locked_branch(self, branch, location):
283
 
        branch._set_parent_location(location)
284
 
        return SuccessfulSmartServerResponse(())
 
115
            branch.generate_revision_history(new_last_revision_id)
 
116
        return SuccessfulSmartServerResponse(('ok',))
285
117
 
286
118
 
287
119
class SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
288
 
 
 
120
    
289
121
    def do_with_branch(self, branch, branch_token='', repo_token=''):
290
122
        if branch_token == '':
291
123
            branch_token = None
296
128
            try:
297
129
                branch_token = branch.lock_write(token=branch_token)
298
130
            finally:
299
 
                # this leaves the repository with 1 lock
300
131
                branch.repository.unlock()
301
132
        except errors.LockContention:
302
133
            return FailedSmartServerResponse(('LockContention',))
304
135
            return FailedSmartServerResponse(('TokenMismatch',))
305
136
        except errors.UnlockableTransport:
306
137
            return FailedSmartServerResponse(('UnlockableTransport',))
307
 
        except errors.LockFailed, e:
308
 
            return FailedSmartServerResponse(('LockFailed', str(e.lock), str(e.why)))
309
 
        if repo_token is None:
310
 
            repo_token = ''
311
 
        else:
312
 
            branch.repository.leave_lock_in_place()
 
138
        branch.repository.leave_lock_in_place()
313
139
        branch.leave_lock_in_place()
314
140
        branch.unlock()
315
141
        return SuccessfulSmartServerResponse(('ok', branch_token, repo_token))
326
152
                branch.repository.unlock()
327
153
        except errors.TokenMismatch:
328
154
            return FailedSmartServerResponse(('TokenMismatch',))
329
 
        if repo_token:
330
 
            branch.repository.dont_leave_lock_in_place()
 
155
        branch.repository.dont_leave_lock_in_place()
331
156
        branch.dont_leave_lock_in_place()
332
157
        branch.unlock()
333
158
        return SuccessfulSmartServerResponse(('ok',))
334
 
 
 
159