← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/branch.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-10-02 17:28:44 UTC
  • mfrom: (3744.2.2 merge_reprocess)
  • Revision ID: pqm@pqm.ubuntu.com-20081002172844-d6df1l8dzpsqzyup
(jam) For 'bzr merge' enable '--reprocess' by default whenever
        '--show-base' is not set.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/branch.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006 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., 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
 
19
19
 
20
 
from bzrlib import (
21
 
    bencode,
22
 
    errors,
23
 
    )
 
20
from bzrlib import errors
24
21
from bzrlib.bzrdir import BzrDir
25
22
from bzrlib.smart.request import (
26
23
    FailedSmartServerResponse,
35
32
 
36
33
    def do(self, path, *args):
37
34
        """Execute a request for a branch at path.
38
 
 
 
35
    
39
36
        All Branch requests take a path to the branch as their first argument.
40
37
 
41
38
        If the branch is a branch reference, NotBranchError is raised.
48
45
        bzrdir = BzrDir.open_from_transport(transport)
49
46
        if bzrdir.get_branch_reference() is not None:
50
47
            raise errors.NotBranchError(transport.base)
51
 
        branch = bzrdir.open_branch(ignore_fallbacks=True)
 
48
        branch = bzrdir.open_branch()
52
49
        return self.do_with_branch(branch, *args)
53
50
 
54
51
 
77
74
 
78
75
 
79
76
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
80
 
 
 
77
    
81
78
    def do_with_branch(self, branch):
82
79
        """Return the content of branch.conf
83
 
 
 
80
        
84
81
        The body is not utf8 decoded - its the literal bytestream from disk.
85
82
        """
 
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.
86
88
        try:
87
89
            content = branch._transport.get_bytes('branch.conf')
88
90
        except errors.NoSuchFile:
90
92
        return SuccessfulSmartServerResponse( ('ok', ), content)
91
93
 
92
94
 
93
 
class SmartServerBranchGetParent(SmartServerBranchRequest):
94
 
 
95
 
    def do_with_branch(self, branch):
96
 
        """Return the parent of branch."""
97
 
        parent = branch._get_parent_location() or ''
98
 
        return SuccessfulSmartServerResponse((parent,))
99
 
 
100
 
 
101
 
class SmartServerBranchGetTagsBytes(SmartServerBranchRequest):
102
 
 
103
 
    def do_with_branch(self, branch):
104
 
        """Return the _get_tags_bytes for a branch."""
105
 
        bytes = branch._get_tags_bytes()
106
 
        return SuccessfulSmartServerResponse((bytes,))
107
 
 
108
 
 
109
 
class SmartServerBranchSetTagsBytes(SmartServerLockedBranchRequest):
110
 
 
111
 
    def __init__(self, backing_transport, root_client_path='/', jail_root=None):
112
 
        SmartServerLockedBranchRequest.__init__(
113
 
            self, backing_transport, root_client_path, jail_root)
114
 
        self.locked = False
115
 
        
116
 
    def do_with_locked_branch(self, branch):
117
 
        """Call _set_tags_bytes for a branch.
118
 
 
119
 
        New in 1.18.
120
 
        """
121
 
        # We need to keep this branch locked until we get a body with the tags
122
 
        # bytes.
123
 
        self.branch = branch
124
 
        self.branch.lock_write()
125
 
        self.locked = True
126
 
 
127
 
    def do_body(self, bytes):
128
 
        self.branch._set_tags_bytes(bytes)
129
 
        return SuccessfulSmartServerResponse(())
130
 
 
131
 
    def do_end(self):
132
 
        # TODO: this request shouldn't have to do this housekeeping manually.
133
 
        # Some of this logic probably belongs in a base class.
134
 
        if not self.locked:
135
 
            # We never acquired the branch successfully in the first place, so
136
 
            # there's nothing more to do.
137
 
            return
138
 
        try:
139
 
            return SmartServerLockedBranchRequest.do_end(self)
140
 
        finally:
141
 
            # Only try unlocking if we locked successfully in the first place
142
 
            self.branch.unlock()
143
 
 
144
 
 
145
 
class SmartServerBranchHeadsToFetch(SmartServerBranchRequest):
146
 
 
147
 
    def do_with_branch(self, branch):
148
 
        """Return the heads-to-fetch for a Branch as two bencoded lists.
149
 
        
150
 
        See Branch.heads_to_fetch.
151
 
 
152
 
        New in 2.4.
153
 
        """
154
 
        must_fetch, if_present_fetch = branch.heads_to_fetch()
155
 
        return SuccessfulSmartServerResponse(
156
 
            (list(must_fetch), list(if_present_fetch)))
157
 
 
158
 
 
159
95
class SmartServerBranchRequestGetStackedOnURL(SmartServerBranchRequest):
160
96
 
161
97
    def do_with_branch(self, branch):
176
112
 
177
113
 
178
114
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
179
 
 
 
115
    
180
116
    def do_with_branch(self, branch):
181
117
        """Return branch.last_revision_info().
182
 
 
 
118
        
183
119
        The revno is encoded in decimal, the revision_id is encoded as utf8.
184
120
        """
185
121
        revno, last_revision = branch.last_revision_info()
201
137
            return FailedSmartServerResponse(('TipChangeRejected', msg))
202
138
 
203
139
 
204
 
class SmartServerBranchRequestSetConfigOption(SmartServerLockedBranchRequest):
205
 
    """Set an option in the branch configuration."""
206
 
 
207
 
    def do_with_locked_branch(self, branch, value, name, section):
208
 
        if not section:
209
 
            section = None
210
 
        branch._get_config().set_option(value.decode('utf8'), name, section)
211
 
        return SuccessfulSmartServerResponse(())
212
 
 
213
 
 
214
 
class SmartServerBranchRequestSetConfigOptionDict(SmartServerLockedBranchRequest):
215
 
    """Set an option in the branch configuration.
216
 
    
217
 
    New in 2.2.
218
 
    """
219
 
 
220
 
    def do_with_locked_branch(self, branch, value_dict, name, section):
221
 
        utf8_dict = bencode.bdecode(value_dict)
222
 
        value_dict = {}
223
 
        for key, value in utf8_dict.items():
224
 
            value_dict[key.decode('utf8')] = value.decode('utf8')
225
 
        if not section:
226
 
            section = None
227
 
        branch._get_config().set_option(value_dict, name, section)
228
 
        return SuccessfulSmartServerResponse(())
229
 
 
230
 
 
231
140
class SmartServerBranchRequestSetLastRevision(SmartServerSetTipRequest):
232
 
 
 
141
    
233
142
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
234
143
        if new_last_revision_id == 'null:':
235
 
            branch._set_revision_history([])
 
144
            branch.set_revision_history([])
236
145
        else:
237
146
            if not branch.repository.has_revision(new_last_revision_id):
238
147
                return FailedSmartServerResponse(
239
148
                    ('NoSuchRevision', new_last_revision_id))
240
 
            branch._set_revision_history(branch._lefthand_history(
241
 
                new_last_revision_id, None, None))
 
149
            branch.generate_revision_history(new_last_revision_id)
242
150
        return SuccessfulSmartServerResponse(('ok',))
243
151
 
244
152
 
245
153
class SmartServerBranchRequestSetLastRevisionEx(SmartServerSetTipRequest):
246
 
 
 
154
    
247
155
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id,
248
156
            allow_divergence, allow_overwrite_descendant):
249
157
        """Set the last revision of the branch.
250
158
 
251
159
        New in 1.6.
252
 
 
 
160
        
253
161
        :param new_last_revision_id: the revision ID to set as the last
254
162
            revision of the branch.
255
163
        :param allow_divergence: A flag.  If non-zero, change the revision ID
296
204
 
297
205
    New in bzrlib 1.4.
298
206
    """
299
 
 
 
207
    
300
208
    def do_tip_change_with_locked_branch(self, branch, new_revno,
301
209
            new_last_revision_id):
302
210
        try:
307
215
        return SuccessfulSmartServerResponse(('ok',))
308
216
 
309
217
 
310
 
class SmartServerBranchRequestSetParentLocation(SmartServerLockedBranchRequest):
311
 
    """Set the parent location for a branch.
312
 
    
313
 
    Takes a location to set, which must be utf8 encoded.
314
 
    """
315
 
 
316
 
    def do_with_locked_branch(self, branch, location):
317
 
        branch._set_parent_location(location)
318
 
        return SuccessfulSmartServerResponse(())
319
 
 
320
 
 
321
218
class SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
322
 
 
 
219
    
323
220
    def do_with_branch(self, branch, branch_token='', repo_token=''):
324
221
        if branch_token == '':
325
222
            branch_token = None
326
223
        if repo_token == '':
327
224
            repo_token = None
328
225
        try:
329
 
            repo_token = branch.repository.lock_write(
330
 
                token=repo_token).repository_token
 
226
            repo_token = branch.repository.lock_write(token=repo_token)
331
227
            try:
332
 
                branch_token = branch.lock_write(
333
 
                    token=branch_token).branch_token
 
228
                branch_token = branch.lock_write(token=branch_token)
334
229
            finally:
335
230
                # this leaves the repository with 1 lock
336
231
                branch.repository.unlock()
367
262
        branch.dont_leave_lock_in_place()
368
263
        branch.unlock()
369
264
        return SuccessfulSmartServerResponse(('ok',))
370
 
 
 
265