← 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
 
 
201
class SmartServerBranchRequestGetStackedOnURL(SmartServerBranchRequest):
 
202
 
 
203
    def do_with_branch(self, branch):
 
204
        stacked_on_url = branch.get_stacked_on_url()
 
205
        return SuccessfulSmartServerResponse(('ok', stacked_on_url))
 
206
 
 
207
 
95
208
class SmartServerRequestRevisionHistory(SmartServerBranchRequest):
96
209
 
97
210
    def do_with_branch(self, branch):
100
213
        The revision list is returned as the body content,
101
214
        with each revision utf8 encoded and \x00 joined.
102
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()
103
224
        return SuccessfulSmartServerResponse(
104
 
            ('ok', ), ('\x00'.join(branch.revision_history())))
 
225
            ('ok', ), ('\x00'.join(reversed(history))))
105
226
 
106
227
 
107
228
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
108
 
    
 
229
 
109
230
    def do_with_branch(self, branch):
110
231
        """Return branch.last_revision_info().
111
 
        
 
232
 
112
233
        The revno is encoded in decimal, the revision_id is encoded as utf8.
113
234
        """
114
235
        revno, last_revision = branch.last_revision_info()
115
236
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
116
237
 
117
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
 
118
256
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
119
257
    """Base class for handling common branch request logic for requests that
120
258
    update the branch tip.
130
268
            return FailedSmartServerResponse(('TipChangeRejected', msg))
131
269
 
132
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
 
133
298
class SmartServerBranchRequestSetLastRevision(SmartServerSetTipRequest):
134
 
    
 
299
 
135
300
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
136
301
        if new_last_revision_id == 'null:':
137
 
            branch.set_revision_history([])
 
302
            branch.set_last_revision_info(0, new_last_revision_id)
138
303
        else:
139
304
            if not branch.repository.has_revision(new_last_revision_id):
140
305
                return FailedSmartServerResponse(
141
306
                    ('NoSuchRevision', new_last_revision_id))
142
 
            branch.generate_revision_history(new_last_revision_id)
 
307
            branch.generate_revision_history(new_last_revision_id, None, None)
143
308
        return SuccessfulSmartServerResponse(('ok',))
144
309
 
145
310
 
146
311
class SmartServerBranchRequestSetLastRevisionEx(SmartServerSetTipRequest):
147
 
    
 
312
 
148
313
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id,
149
314
            allow_divergence, allow_overwrite_descendant):
150
315
        """Set the last revision of the branch.
151
316
 
152
317
        New in 1.6.
153
 
        
 
318
 
154
319
        :param new_last_revision_id: the revision ID to set as the last
155
320
            revision of the branch.
156
321
        :param allow_divergence: A flag.  If non-zero, change the revision ID
197
362
 
198
363
    New in bzrlib 1.4.
199
364
    """
200
 
    
 
365
 
201
366
    def do_tip_change_with_locked_branch(self, branch, new_revno,
202
367
            new_last_revision_id):
203
368
        try:
208
373
        return SuccessfulSmartServerResponse(('ok',))
209
374
 
210
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
 
211
387
class SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
212
 
    
 
388
 
213
389
    def do_with_branch(self, branch, branch_token='', repo_token=''):
214
390
        if branch_token == '':
215
391
            branch_token = None
216
392
        if repo_token == '':
217
393
            repo_token = None
218
394
        try:
219
 
            repo_token = branch.repository.lock_write(token=repo_token)
 
395
            repo_token = branch.repository.lock_write(
 
396
                token=repo_token).repository_token
220
397
            try:
221
 
                branch_token = branch.lock_write(token=branch_token)
 
398
                branch_token = branch.lock_write(
 
399
                    token=branch_token).branch_token
222
400
            finally:
223
401
                # this leaves the repository with 1 lock
224
402
                branch.repository.unlock()
255
433
        branch.dont_leave_lock_in_place()
256
434
        branch.unlock()
257
435
        return SuccessfulSmartServerResponse(('ok',))
258
 
        
 
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',))