← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/branch.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/branch.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Server-side branch related request implmentations."""
18
18
 
 
19
from __future__ import absolute_import
19
20
 
20
 
from bzrlib import errors
21
 
from bzrlib.bzrdir import BzrDir
 
21
from bzrlib import (
 
22
    bencode,
 
23
    errors,
 
24
    revision as _mod_revision,
 
25
    )
 
26
from bzrlib.controldir import ControlDir
22
27
from bzrlib.smart.request import (
23
28
    FailedSmartServerResponse,
24
29
    SmartServerRequest,
32
37
 
33
38
    def do(self, path, *args):
34
39
        """Execute a request for a branch at path.
35
 
    
 
40
 
36
41
        All Branch requests take a path to the branch as their first argument.
37
42
 
38
43
        If the branch is a branch reference, NotBranchError is raised.
42
47
        :return: A SmartServerResponse from self.do_with_branch().
43
48
        """
44
49
        transport = self.transport_from_client_path(path)
45
 
        bzrdir = BzrDir.open_from_transport(transport)
46
 
        if bzrdir.get_branch_reference() is not None:
 
50
        controldir = ControlDir.open_from_transport(transport)
 
51
        if controldir.get_branch_reference() is not None:
47
52
            raise errors.NotBranchError(transport.base)
48
 
        branch = bzrdir.open_branch()
 
53
        branch = controldir.open_branch(ignore_fallbacks=True)
49
54
        return self.do_with_branch(branch, *args)
50
55
 
51
56
 
73
78
            branch.repository.unlock()
74
79
 
75
80
 
 
81
class SmartServerBranchBreakLock(SmartServerBranchRequest):
 
82
 
 
83
    def do_with_branch(self, branch):
 
84
        """Break a branch lock.
 
85
        """
 
86
        branch.break_lock()
 
87
        return SuccessfulSmartServerResponse(('ok', ), )
 
88
 
 
89
 
76
90
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
77
 
    
 
91
 
78
92
    def do_with_branch(self, branch):
79
93
        """Return the content of branch.conf
80
 
        
 
94
 
81
95
        The body is not utf8 decoded - its the literal bytestream from disk.
82
96
        """
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
87
 
        # access.
88
97
        try:
89
 
            content = branch._transport.get_bytes('branch.conf')
 
98
            content = branch.control_transport.get_bytes('branch.conf')
90
99
        except errors.NoSuchFile:
91
100
            content = ''
92
101
        return SuccessfulSmartServerResponse( ('ok', ), content)
93
102
 
94
103
 
 
104
class SmartServerBranchPutConfigFile(SmartServerBranchRequest):
 
105
    """Set the configuration data for a branch.
 
106
 
 
107
    New in 2.5.
 
108
    """
 
109
 
 
110
    def do_with_branch(self, branch, branch_token, repo_token):
 
111
        """Set the content of branch.conf.
 
112
 
 
113
        The body is not utf8 decoded - its the literal bytestream for disk.
 
114
        """
 
115
        self._branch = branch
 
116
        self._branch_token = branch_token
 
117
        self._repo_token = repo_token
 
118
        # Signal we want a body
 
119
        return None
 
120
 
 
121
    def do_body(self, body_bytes):
 
122
        self._branch.repository.lock_write(token=self._repo_token)
 
123
        try:
 
124
            self._branch.lock_write(token=self._branch_token)
 
125
            try:
 
126
                self._branch.control_transport.put_bytes(
 
127
                    'branch.conf', body_bytes)
 
128
            finally:
 
129
                self._branch.unlock()
 
130
        finally:
 
131
            self._branch.repository.unlock()
 
132
        return SuccessfulSmartServerResponse(('ok', ))
 
133
 
 
134
 
 
135
class SmartServerBranchGetParent(SmartServerBranchRequest):
 
136
 
 
137
    def do_with_branch(self, branch):
 
138
        """Return the parent of branch."""
 
139
        parent = branch._get_parent_location() or ''
 
140
        return SuccessfulSmartServerResponse((parent,))
 
141
 
 
142
 
 
143
class SmartServerBranchGetTagsBytes(SmartServerBranchRequest):
 
144
 
 
145
    def do_with_branch(self, branch):
 
146
        """Return the _get_tags_bytes for a branch."""
 
147
        bytes = branch._get_tags_bytes()
 
148
        return SuccessfulSmartServerResponse((bytes,))
 
149
 
 
150
 
 
151
class SmartServerBranchSetTagsBytes(SmartServerLockedBranchRequest):
 
152
 
 
153
    def __init__(self, backing_transport, root_client_path='/', jail_root=None):
 
154
        SmartServerLockedBranchRequest.__init__(
 
155
            self, backing_transport, root_client_path, jail_root)
 
156
        self.locked = False
 
157
        
 
158
    def do_with_locked_branch(self, branch):
 
159
        """Call _set_tags_bytes for a branch.
 
160
 
 
161
        New in 1.18.
 
162
        """
 
163
        # We need to keep this branch locked until we get a body with the tags
 
164
        # bytes.
 
165
        self.branch = branch
 
166
        self.branch.lock_write()
 
167
        self.locked = True
 
168
 
 
169
    def do_body(self, bytes):
 
170
        self.branch._set_tags_bytes(bytes)
 
171
        return SuccessfulSmartServerResponse(())
 
172
 
 
173
    def do_end(self):
 
174
        # TODO: this request shouldn't have to do this housekeeping manually.
 
175
        # Some of this logic probably belongs in a base class.
 
176
        if not self.locked:
 
177
            # We never acquired the branch successfully in the first place, so
 
178
            # there's nothing more to do.
 
179
            return
 
180
        try:
 
181
            return SmartServerLockedBranchRequest.do_end(self)
 
182
        finally:
 
183
            # Only try unlocking if we locked successfully in the first place
 
184
            self.branch.unlock()
 
185
 
 
186
 
 
187
class SmartServerBranchHeadsToFetch(SmartServerBranchRequest):
 
188
 
 
189
    def do_with_branch(self, branch):
 
190
        """Return the heads-to-fetch for a Branch as two bencoded lists.
 
191
        
 
192
        See Branch.heads_to_fetch.
 
193
 
 
194
        New in 2.4.
 
195
        """
 
196
        must_fetch, if_present_fetch = branch.heads_to_fetch()
 
197
        return SuccessfulSmartServerResponse(
 
198
            (list(must_fetch), list(if_present_fetch)))
 
199
 
 
200
 
95
201
class SmartServerBranchRequestGetStackedOnURL(SmartServerBranchRequest):
96
202
 
97
203
    def do_with_branch(self, branch):
107
213
        The revision list is returned as the body content,
108
214
        with each revision utf8 encoded and \x00 joined.
109
215
        """
 
216
        branch.lock_read()
 
217
        try:
 
218
            graph = branch.repository.get_graph()
 
219
            stop_revisions = (None, _mod_revision.NULL_REVISION)
 
220
            history = list(graph.iter_lefthand_ancestry(
 
221
                branch.last_revision(), stop_revisions))
 
222
        finally:
 
223
            branch.unlock()
110
224
        return SuccessfulSmartServerResponse(
111
 
            ('ok', ), ('\x00'.join(branch.revision_history())))
 
225
            ('ok', ), ('\x00'.join(reversed(history))))
112
226
 
113
227
 
114
228
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
115
 
    
 
229
 
116
230
    def do_with_branch(self, branch):
117
231
        """Return branch.last_revision_info().
118
 
        
 
232
 
119
233
        The revno is encoded in decimal, the revision_id is encoded as utf8.
120
234
        """
121
235
        revno, last_revision = branch.last_revision_info()
122
236
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
123
237
 
124
238
 
 
239
class SmartServerBranchRequestRevisionIdToRevno(SmartServerBranchRequest):
 
240
 
 
241
    def do_with_branch(self, branch, revid):
 
242
        """Return branch.revision_id_to_revno().
 
243
 
 
244
        New in 2.5.
 
245
 
 
246
        The revno is encoded in decimal, the revision_id is encoded as utf8.
 
247
        """
 
248
        try:
 
249
            dotted_revno = branch.revision_id_to_dotted_revno(revid)
 
250
        except errors.NoSuchRevision:
 
251
            return FailedSmartServerResponse(('NoSuchRevision', revid))
 
252
        return SuccessfulSmartServerResponse(
 
253
            ('ok', ) + tuple(map(str, dotted_revno)))
 
254
 
 
255
 
125
256
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
126
257
    """Base class for handling common branch request logic for requests that
127
258
    update the branch tip.
137
268
            return FailedSmartServerResponse(('TipChangeRejected', msg))
138
269
 
139
270
 
 
271
class SmartServerBranchRequestSetConfigOption(SmartServerLockedBranchRequest):
 
272
    """Set an option in the branch configuration."""
 
273
 
 
274
    def do_with_locked_branch(self, branch, value, name, section):
 
275
        if not section:
 
276
            section = None
 
277
        branch._get_config().set_option(value.decode('utf8'), name, section)
 
278
        return SuccessfulSmartServerResponse(())
 
279
 
 
280
 
 
281
class SmartServerBranchRequestSetConfigOptionDict(SmartServerLockedBranchRequest):
 
282
    """Set an option in the branch configuration.
 
283
    
 
284
    New in 2.2.
 
285
    """
 
286
 
 
287
    def do_with_locked_branch(self, branch, value_dict, name, section):
 
288
        utf8_dict = bencode.bdecode(value_dict)
 
289
        value_dict = {}
 
290
        for key, value in utf8_dict.items():
 
291
            value_dict[key.decode('utf8')] = value.decode('utf8')
 
292
        if not section:
 
293
            section = None
 
294
        branch._get_config().set_option(value_dict, name, section)
 
295
        return SuccessfulSmartServerResponse(())
 
296
 
 
297
 
140
298
class SmartServerBranchRequestSetLastRevision(SmartServerSetTipRequest):
141
 
    
 
299
 
142
300
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
143
301
        if new_last_revision_id == 'null:':
144
 
            branch.set_revision_history([])
 
302
            branch.set_last_revision_info(0, new_last_revision_id)
145
303
        else:
146
304
            if not branch.repository.has_revision(new_last_revision_id):
147
305
                return FailedSmartServerResponse(
148
306
                    ('NoSuchRevision', new_last_revision_id))
149
 
            branch.generate_revision_history(new_last_revision_id)
 
307
            branch.generate_revision_history(new_last_revision_id, None, None)
150
308
        return SuccessfulSmartServerResponse(('ok',))
151
309
 
152
310
 
153
311
class SmartServerBranchRequestSetLastRevisionEx(SmartServerSetTipRequest):
154
 
    
 
312
 
155
313
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id,
156
314
            allow_divergence, allow_overwrite_descendant):
157
315
        """Set the last revision of the branch.
158
316
 
159
317
        New in 1.6.
160
 
        
 
318
 
161
319
        :param new_last_revision_id: the revision ID to set as the last
162
320
            revision of the branch.
163
321
        :param allow_divergence: A flag.  If non-zero, change the revision ID
204
362
 
205
363
    New in bzrlib 1.4.
206
364
    """
207
 
    
 
365
 
208
366
    def do_tip_change_with_locked_branch(self, branch, new_revno,
209
367
            new_last_revision_id):
210
368
        try:
215
373
        return SuccessfulSmartServerResponse(('ok',))
216
374
 
217
375
 
 
376
class SmartServerBranchRequestSetParentLocation(SmartServerLockedBranchRequest):
 
377
    """Set the parent location for a branch.
 
378
    
 
379
    Takes a location to set, which must be utf8 encoded.
 
380
    """
 
381
 
 
382
    def do_with_locked_branch(self, branch, location):
 
383
        branch._set_parent_location(location)
 
384
        return SuccessfulSmartServerResponse(())
 
385
 
 
386
 
218
387
class SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
219
 
    
 
388
 
220
389
    def do_with_branch(self, branch, branch_token='', repo_token=''):
221
390
        if branch_token == '':
222
391
            branch_token = None
223
392
        if repo_token == '':
224
393
            repo_token = None
225
394
        try:
226
 
            repo_token = branch.repository.lock_write(token=repo_token)
 
395
            repo_token = branch.repository.lock_write(
 
396
                token=repo_token).repository_token
227
397
            try:
228
 
                branch_token = branch.lock_write(token=branch_token)
 
398
                branch_token = branch.lock_write(
 
399
                    token=branch_token).branch_token
229
400
            finally:
230
401
                # this leaves the repository with 1 lock
231
402
                branch.repository.unlock()
262
433
        branch.dont_leave_lock_in_place()
263
434
        branch.unlock()
264
435
        return SuccessfulSmartServerResponse(('ok',))
265
 
        
 
436
 
 
437
 
 
438
class SmartServerBranchRequestGetPhysicalLockStatus(SmartServerBranchRequest):
 
439
    """Get the physical lock status for a branch.
 
440
 
 
441
    New in 2.5.
 
442
    """
 
443
 
 
444
    def do_with_branch(self, branch):
 
445
        if branch.get_physical_lock_status():
 
446
            return SuccessfulSmartServerResponse(('yes',))
 
447
        else:
 
448
            return SuccessfulSmartServerResponse(('no',))