1
# Copyright (C) 2006 Canonical Ltd
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Server-side branch related request implmentations."""
20
from bzrlib import errors
21
from bzrlib.bzrdir import BzrDir
22
from bzrlib.smart.request import (
23
FailedSmartServerResponse,
25
SuccessfulSmartServerResponse,
29
class SmartServerBranchRequest(SmartServerRequest):
30
"""Base class for handling common branch request logic.
33
def do(self, path, *args):
34
"""Execute a request for a branch at path.
36
All Branch requests take a path to the branch as their first argument.
38
If the branch is a branch reference, NotBranchError is raised.
40
:param path: The path for the repository as received from the
42
:return: A SmartServerResponse from self.do_with_branch().
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()
49
return self.do_with_branch(branch, *args)
52
class SmartServerLockedBranchRequest(SmartServerBranchRequest):
53
"""Base class for handling common branch request logic for requests that
57
def do_with_branch(self, branch, branch_token, repo_token, *args):
58
"""Execute a request for a branch.
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.
64
# XXX: write a test for LockContention
65
branch.repository.lock_write(token=repo_token)
67
branch.lock_write(token=branch_token)
69
return self.do_with_locked_branch(branch, *args)
73
branch.repository.unlock()
76
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
78
def do_with_branch(self, branch):
79
"""Return the content of branch.conf
81
The body is not utf8 decoded - its the literal bytestream from disk.
83
# This was at one time called by RemoteBranchLockableFiles
84
# intercepting access to this file; as of 1.5 it is not called by the
85
# client but retained for compatibility. It may be called again to
86
# allow the client to get the configuration without needing vfs
89
content = branch._transport.get_bytes('branch.conf')
90
except errors.NoSuchFile:
92
return SuccessfulSmartServerResponse( ('ok', ), content)
95
class SmartServerBranchGetParent(SmartServerBranchRequest):
97
def do_with_branch(self, branch):
98
"""Return the parent of branch."""
99
parent = branch._get_parent_location() or ''
100
return SuccessfulSmartServerResponse((parent,))
103
class SmartServerBranchGetTagsBytes(SmartServerBranchRequest):
105
def do_with_branch(self, branch):
106
"""Return the _get_tags_bytes for a branch."""
107
bytes = branch._get_tags_bytes()
108
return SuccessfulSmartServerResponse((bytes,))
111
class SmartServerBranchRequestGetStackedOnURL(SmartServerBranchRequest):
113
def do_with_branch(self, branch):
114
stacked_on_url = branch.get_stacked_on_url()
115
return SuccessfulSmartServerResponse(('ok', stacked_on_url))
118
class SmartServerRequestRevisionHistory(SmartServerBranchRequest):
120
def do_with_branch(self, branch):
121
"""Get the revision history for the branch.
123
The revision list is returned as the body content,
124
with each revision utf8 encoded and \x00 joined.
126
return SuccessfulSmartServerResponse(
127
('ok', ), ('\x00'.join(branch.revision_history())))
130
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
132
def do_with_branch(self, branch):
133
"""Return branch.last_revision_info().
135
The revno is encoded in decimal, the revision_id is encoded as utf8.
137
revno, last_revision = branch.last_revision_info()
138
return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
141
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
142
"""Base class for handling common branch request logic for requests that
143
update the branch tip.
146
def do_with_locked_branch(self, branch, *args):
148
return self.do_tip_change_with_locked_branch(branch, *args)
149
except errors.TipChangeRejected, e:
151
if isinstance(msg, unicode):
152
msg = msg.encode('utf-8')
153
return FailedSmartServerResponse(('TipChangeRejected', msg))
156
class SmartServerBranchRequestSetLastRevision(SmartServerSetTipRequest):
158
def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
159
if new_last_revision_id == 'null:':
160
branch.set_revision_history([])
162
if not branch.repository.has_revision(new_last_revision_id):
163
return FailedSmartServerResponse(
164
('NoSuchRevision', new_last_revision_id))
165
branch.set_revision_history(branch._lefthand_history(
166
new_last_revision_id, None, None))
167
return SuccessfulSmartServerResponse(('ok',))
170
class SmartServerBranchRequestSetLastRevisionEx(SmartServerSetTipRequest):
172
def do_tip_change_with_locked_branch(self, branch, new_last_revision_id,
173
allow_divergence, allow_overwrite_descendant):
174
"""Set the last revision of the branch.
178
:param new_last_revision_id: the revision ID to set as the last
179
revision of the branch.
180
:param allow_divergence: A flag. If non-zero, change the revision ID
181
even if the new_last_revision_id's ancestry has diverged from the
182
current last revision. If zero, a 'Diverged' error will be
183
returned if new_last_revision_id is not a descendant of the current
185
:param allow_overwrite_descendant: A flag. If zero and
186
new_last_revision_id is not a descendant of the current last
187
revision, then the last revision will not be changed. If non-zero
188
and there is no divergence, then the last revision is always
191
:returns: on success, a tuple of ('ok', revno, revision_id), where
192
revno and revision_id are the new values of the current last
193
revision info. The revision_id might be different to the
194
new_last_revision_id if allow_overwrite_descendant was not set.
196
do_not_overwrite_descendant = not allow_overwrite_descendant
198
last_revno, last_rev = branch.last_revision_info()
199
graph = branch.repository.get_graph()
200
if not allow_divergence or do_not_overwrite_descendant:
201
relation = branch._revision_relations(
202
last_rev, new_last_revision_id, graph)
203
if relation == 'diverged' and not allow_divergence:
204
return FailedSmartServerResponse(('Diverged',))
205
if relation == 'a_descends_from_b' and do_not_overwrite_descendant:
206
return SuccessfulSmartServerResponse(
207
('ok', last_revno, last_rev))
208
new_revno = graph.find_distance_to_null(
209
new_last_revision_id, [(last_rev, last_revno)])
210
branch.set_last_revision_info(new_revno, new_last_revision_id)
211
except errors.GhostRevisionsHaveNoRevno:
212
return FailedSmartServerResponse(
213
('NoSuchRevision', new_last_revision_id))
214
return SuccessfulSmartServerResponse(
215
('ok', new_revno, new_last_revision_id))
218
class SmartServerBranchRequestSetLastRevisionInfo(SmartServerSetTipRequest):
219
"""Branch.set_last_revision_info. Sets the revno and the revision ID of
220
the specified branch.
225
def do_tip_change_with_locked_branch(self, branch, new_revno,
226
new_last_revision_id):
228
branch.set_last_revision_info(int(new_revno), new_last_revision_id)
229
except errors.NoSuchRevision:
230
return FailedSmartServerResponse(
231
('NoSuchRevision', new_last_revision_id))
232
return SuccessfulSmartServerResponse(('ok',))
235
class SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
237
def do_with_branch(self, branch, branch_token='', repo_token=''):
238
if branch_token == '':
243
repo_token = branch.repository.lock_write(token=repo_token)
245
branch_token = branch.lock_write(token=branch_token)
247
# this leaves the repository with 1 lock
248
branch.repository.unlock()
249
except errors.LockContention:
250
return FailedSmartServerResponse(('LockContention',))
251
except errors.TokenMismatch:
252
return FailedSmartServerResponse(('TokenMismatch',))
253
except errors.UnlockableTransport:
254
return FailedSmartServerResponse(('UnlockableTransport',))
255
except errors.LockFailed, e:
256
return FailedSmartServerResponse(('LockFailed', str(e.lock), str(e.why)))
257
if repo_token is None:
260
branch.repository.leave_lock_in_place()
261
branch.leave_lock_in_place()
263
return SuccessfulSmartServerResponse(('ok', branch_token, repo_token))
266
class SmartServerBranchRequestUnlock(SmartServerBranchRequest):
268
def do_with_branch(self, branch, branch_token, repo_token):
270
branch.repository.lock_write(token=repo_token)
272
branch.lock_write(token=branch_token)
274
branch.repository.unlock()
275
except errors.TokenMismatch:
276
return FailedSmartServerResponse(('TokenMismatch',))
278
branch.repository.dont_leave_lock_in_place()
279
branch.dont_leave_lock_in_place()
281
return SuccessfulSmartServerResponse(('ok',))
added
removed
bzrlib/smart/branch.py
