/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: Andrew Bennetts
  • Date: 2009-07-23 07:37:05 UTC
  • mto: This revision was merged to the branch mainline in revision 4573.
  • Revision ID: andrew.bennetts@canonical.com-20090723073705-l9shzmc4ix74zv18
Handle failures more gracefully.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/branch.py
 
1
# Copyright (C) 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
"""Server-side branch related request implmentations."""
 
18
 
 
19
 
 
20
from bzrlib import errors
 
21
from bzrlib.bzrdir import BzrDir
 
22
from bzrlib.smart.request import (
 
23
    FailedSmartServerResponse,
 
24
    SmartServerRequest,
 
25
    SuccessfulSmartServerResponse,
 
26
    )
 
27
 
 
28
 
 
29
class SmartServerBranchRequest(SmartServerRequest):
 
30
    """Base class for handling common branch request logic.
 
31
    """
 
32
 
 
33
    def do(self, path, *args):
 
34
        """Execute a request for a branch at path.
 
35
 
 
36
        All Branch requests take a path to the branch as their first argument.
 
37
 
 
38
        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
        """
 
44
        transport = self.transport_from_client_path(path)
 
45
        bzrdir = BzrDir.open_from_transport(transport)
 
46
        if bzrdir.get_branch_reference() is not None:
 
47
            raise errors.NotBranchError(transport.base)
 
48
        branch = bzrdir.open_branch(ignore_fallbacks=True)
 
49
        return self.do_with_branch(branch, *args)
 
50
 
 
51
 
 
52
class SmartServerLockedBranchRequest(SmartServerBranchRequest):
 
53
    """Base class for handling common branch request logic for requests that
 
54
    need a write lock.
 
55
    """
 
56
 
 
57
    def do_with_branch(self, branch, branch_token, repo_token, *args):
 
58
        """Execute a request for a branch.
 
59
 
 
60
        A write lock will be acquired with the given tokens for the branch and
 
61
        repository locks.  The lock will be released once the request is
 
62
        processed.  The physical lock state won't be changed.
 
63
        """
 
64
        # XXX: write a test for LockContention
 
65
        branch.repository.lock_write(token=repo_token)
 
66
        try:
 
67
            branch.lock_write(token=branch_token)
 
68
            try:
 
69
                return self.do_with_locked_branch(branch, *args)
 
70
            finally:
 
71
                branch.unlock()
 
72
        finally:
 
73
            branch.repository.unlock()
 
74
 
 
75
 
 
76
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
 
77
 
 
78
    def do_with_branch(self, branch):
 
79
        """Return the content of branch.conf
 
80
 
 
81
        The body is not utf8 decoded - its the literal bytestream from disk.
 
82
        """
 
83
        try:
 
84
            content = branch._transport.get_bytes('branch.conf')
 
85
        except errors.NoSuchFile:
 
86
            content = ''
 
87
        return SuccessfulSmartServerResponse( ('ok', ), content)
 
88
 
 
89
 
 
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='/'):
 
109
        SmartServerLockedBranchRequest.__init__(
 
110
            self, backing_transport, root_client_path)
 
111
        self.locked = False
 
112
        
 
113
    def do_with_locked_branch(self, branch):
 
114
        # We need to keep this branch locked until we get a body with the tags
 
115
        # bytes.
 
116
        self.branch = branch
 
117
        self.branch.lock_write()
 
118
        self.locked = True
 
119
 
 
120
    def do_body(self, bytes):
 
121
        self.branch._set_tags_bytes(bytes)
 
122
        return SuccessfulSmartServerResponse(())
 
123
 
 
124
    def do_end(self):
 
125
        if not self.locked:
 
126
            # We never acquired the branch successfully in the first place, so
 
127
            # there's nothing more to do.
 
128
            # XXX: perhaps it should be easier for request classes to do
 
129
            # nothing further if they have raised an error previously?  It
 
130
            # seems a bit messy to require them to keep track of this state.
 
131
            return
 
132
        try:
 
133
            return SmartServerLockedBranchRequest.do_end(self)
 
134
        finally:
 
135
            # Only try unlocking if we locked successfully in the first place
 
136
            self.branch.unlock()
 
137
 
 
138
 
 
139
class SmartServerBranchRequestGetStackedOnURL(SmartServerBranchRequest):
 
140
 
 
141
    def do_with_branch(self, branch):
 
142
        stacked_on_url = branch.get_stacked_on_url()
 
143
        return SuccessfulSmartServerResponse(('ok', stacked_on_url))
 
144
 
 
145
 
 
146
class SmartServerRequestRevisionHistory(SmartServerBranchRequest):
 
147
 
 
148
    def do_with_branch(self, branch):
 
149
        """Get the revision history for the branch.
 
150
 
 
151
        The revision list is returned as the body content,
 
152
        with each revision utf8 encoded and \x00 joined.
 
153
        """
 
154
        return SuccessfulSmartServerResponse(
 
155
            ('ok', ), ('\x00'.join(branch.revision_history())))
 
156
 
 
157
 
 
158
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
 
159
 
 
160
    def do_with_branch(self, branch):
 
161
        """Return branch.last_revision_info().
 
162
 
 
163
        The revno is encoded in decimal, the revision_id is encoded as utf8.
 
164
        """
 
165
        revno, last_revision = branch.last_revision_info()
 
166
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
 
167
 
 
168
 
 
169
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
 
170
    """Base class for handling common branch request logic for requests that
 
171
    update the branch tip.
 
172
    """
 
173
 
 
174
    def do_with_locked_branch(self, branch, *args):
 
175
        try:
 
176
            return self.do_tip_change_with_locked_branch(branch, *args)
 
177
        except errors.TipChangeRejected, e:
 
178
            msg = e.msg
 
179
            if isinstance(msg, unicode):
 
180
                msg = msg.encode('utf-8')
 
181
            return FailedSmartServerResponse(('TipChangeRejected', msg))
 
182
 
 
183
 
 
184
class SmartServerBranchRequestSetConfigOption(SmartServerLockedBranchRequest):
 
185
    """Set an option in the branch configuration."""
 
186
 
 
187
    def do_with_locked_branch(self, branch, value, name, section):
 
188
        if not section:
 
189
            section = None
 
190
        branch._get_config().set_option(value.decode('utf8'), name, section)
 
191
        return SuccessfulSmartServerResponse(())
 
192
 
 
193
 
 
194
class SmartServerBranchRequestSetLastRevision(SmartServerSetTipRequest):
 
195
 
 
196
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
 
197
        if new_last_revision_id == 'null:':
 
198
            branch.set_revision_history([])
 
199
        else:
 
200
            if not branch.repository.has_revision(new_last_revision_id):
 
201
                return FailedSmartServerResponse(
 
202
                    ('NoSuchRevision', new_last_revision_id))
 
203
            branch.set_revision_history(branch._lefthand_history(
 
204
                new_last_revision_id, None, None))
 
205
        return SuccessfulSmartServerResponse(('ok',))
 
206
 
 
207
 
 
208
class SmartServerBranchRequestSetLastRevisionEx(SmartServerSetTipRequest):
 
209
 
 
210
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id,
 
211
            allow_divergence, allow_overwrite_descendant):
 
212
        """Set the last revision of the branch.
 
213
 
 
214
        New in 1.6.
 
215
 
 
216
        :param new_last_revision_id: the revision ID to set as the last
 
217
            revision of the branch.
 
218
        :param allow_divergence: A flag.  If non-zero, change the revision ID
 
219
            even if the new_last_revision_id's ancestry has diverged from the
 
220
            current last revision.  If zero, a 'Diverged' error will be
 
221
            returned if new_last_revision_id is not a descendant of the current
 
222
            last revision.
 
223
        :param allow_overwrite_descendant:  A flag.  If zero and
 
224
            new_last_revision_id is not a descendant of the current last
 
225
            revision, then the last revision will not be changed.  If non-zero
 
226
            and there is no divergence, then the last revision is always
 
227
            changed.
 
228
 
 
229
        :returns: on success, a tuple of ('ok', revno, revision_id), where
 
230
            revno and revision_id are the new values of the current last
 
231
            revision info.  The revision_id might be different to the
 
232
            new_last_revision_id if allow_overwrite_descendant was not set.
 
233
        """
 
234
        do_not_overwrite_descendant = not allow_overwrite_descendant
 
235
        try:
 
236
            last_revno, last_rev = branch.last_revision_info()
 
237
            graph = branch.repository.get_graph()
 
238
            if not allow_divergence or do_not_overwrite_descendant:
 
239
                relation = branch._revision_relations(
 
240
                    last_rev, new_last_revision_id, graph)
 
241
                if relation == 'diverged' and not allow_divergence:
 
242
                    return FailedSmartServerResponse(('Diverged',))
 
243
                if relation == 'a_descends_from_b' and do_not_overwrite_descendant:
 
244
                    return SuccessfulSmartServerResponse(
 
245
                        ('ok', last_revno, last_rev))
 
246
            new_revno = graph.find_distance_to_null(
 
247
                new_last_revision_id, [(last_rev, last_revno)])
 
248
            branch.set_last_revision_info(new_revno, new_last_revision_id)
 
249
        except errors.GhostRevisionsHaveNoRevno:
 
250
            return FailedSmartServerResponse(
 
251
                ('NoSuchRevision', new_last_revision_id))
 
252
        return SuccessfulSmartServerResponse(
 
253
            ('ok', new_revno, new_last_revision_id))
 
254
 
 
255
 
 
256
class SmartServerBranchRequestSetLastRevisionInfo(SmartServerSetTipRequest):
 
257
    """Branch.set_last_revision_info.  Sets the revno and the revision ID of
 
258
    the specified branch.
 
259
 
 
260
    New in bzrlib 1.4.
 
261
    """
 
262
 
 
263
    def do_tip_change_with_locked_branch(self, branch, new_revno,
 
264
            new_last_revision_id):
 
265
        try:
 
266
            branch.set_last_revision_info(int(new_revno), new_last_revision_id)
 
267
        except errors.NoSuchRevision:
 
268
            return FailedSmartServerResponse(
 
269
                ('NoSuchRevision', new_last_revision_id))
 
270
        return SuccessfulSmartServerResponse(('ok',))
 
271
 
 
272
 
 
273
class SmartServerBranchRequestSetParentLocation(SmartServerLockedBranchRequest):
 
274
    """Set the parent location for a branch.
 
275
    
 
276
    Takes a location to set, which must be utf8 encoded.
 
277
    """
 
278
 
 
279
    def do_with_locked_branch(self, branch, location):
 
280
        branch._set_parent_location(location)
 
281
        return SuccessfulSmartServerResponse(())
 
282
 
 
283
 
 
284
class SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
 
285
 
 
286
    def do_with_branch(self, branch, branch_token='', repo_token=''):
 
287
        if branch_token == '':
 
288
            branch_token = None
 
289
        if repo_token == '':
 
290
            repo_token = None
 
291
        try:
 
292
            repo_token = branch.repository.lock_write(token=repo_token)
 
293
            try:
 
294
                branch_token = branch.lock_write(token=branch_token)
 
295
            finally:
 
296
                # this leaves the repository with 1 lock
 
297
                branch.repository.unlock()
 
298
        except errors.LockContention:
 
299
            return FailedSmartServerResponse(('LockContention',))
 
300
        except errors.TokenMismatch:
 
301
            return FailedSmartServerResponse(('TokenMismatch',))
 
302
        except errors.UnlockableTransport:
 
303
            return FailedSmartServerResponse(('UnlockableTransport',))
 
304
        except errors.LockFailed, e:
 
305
            return FailedSmartServerResponse(('LockFailed', str(e.lock), str(e.why)))
 
306
        if repo_token is None:
 
307
            repo_token = ''
 
308
        else:
 
309
            branch.repository.leave_lock_in_place()
 
310
        branch.leave_lock_in_place()
 
311
        branch.unlock()
 
312
        return SuccessfulSmartServerResponse(('ok', branch_token, repo_token))
 
313
 
 
314
 
 
315
class SmartServerBranchRequestUnlock(SmartServerBranchRequest):
 
316
 
 
317
    def do_with_branch(self, branch, branch_token, repo_token):
 
318
        try:
 
319
            branch.repository.lock_write(token=repo_token)
 
320
            try:
 
321
                branch.lock_write(token=branch_token)
 
322
            finally:
 
323
                branch.repository.unlock()
 
324
        except errors.TokenMismatch:
 
325
            return FailedSmartServerResponse(('TokenMismatch',))
 
326
        if repo_token:
 
327
            branch.repository.dont_leave_lock_in_place()
 
328
        branch.dont_leave_lock_in_place()
 
329
        branch.unlock()
 
330
        return SuccessfulSmartServerResponse(('ok',))
 
331