← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/branch.py

  • Committer: Alexander Belchenko
  • Date: 2012-03-29 08:34:13 UTC
  • mto: (6015.44.14 2.4)
  • mto: This revision was merged to the branch mainline in revision 6513.
  • Revision ID: bialix@ukr.net-20120329083413-d4bqqdtfn2yrxp4f
change st_dev, st_ino, st_uid, st_gid from int members to properties.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/branch.py
16
16
 
17
17
"""Server-side branch related request implmentations."""
18
18
 
19
 
from __future__ import absolute_import
20
19
 
21
20
from bzrlib import (
22
21
    bencode,
23
22
    errors,
24
 
    revision as _mod_revision,
25
23
    )
26
 
from bzrlib.controldir import ControlDir
 
24
from bzrlib.bzrdir import BzrDir
27
25
from bzrlib.smart.request import (
28
26
    FailedSmartServerResponse,
29
27
    SmartServerRequest,
47
45
        :return: A SmartServerResponse from self.do_with_branch().
48
46
        """
49
47
        transport = self.transport_from_client_path(path)
50
 
        controldir = ControlDir.open_from_transport(transport)
51
 
        if controldir.get_branch_reference() is not None:
 
48
        bzrdir = BzrDir.open_from_transport(transport)
 
49
        if bzrdir.get_branch_reference() is not None:
52
50
            raise errors.NotBranchError(transport.base)
53
 
        branch = controldir.open_branch(ignore_fallbacks=True)
 
51
        branch = bzrdir.open_branch(ignore_fallbacks=True)
54
52
        return self.do_with_branch(branch, *args)
55
53
 
56
54
 
78
76
            branch.repository.unlock()
79
77
 
80
78
 
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
 
 
90
79
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
91
80
 
92
81
    def do_with_branch(self, branch):
95
84
        The body is not utf8 decoded - its the literal bytestream from disk.
96
85
        """
97
86
        try:
98
 
            content = branch.control_transport.get_bytes('branch.conf')
 
87
            content = branch._transport.get_bytes('branch.conf')
99
88
        except errors.NoSuchFile:
100
89
            content = ''
101
90
        return SuccessfulSmartServerResponse( ('ok', ), content)
102
91
 
103
92
 
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
93
class SmartServerBranchGetParent(SmartServerBranchRequest):
136
94
 
137
95
    def do_with_branch(self, branch):
213
171
        The revision list is returned as the body content,
214
172
        with each revision utf8 encoded and \x00 joined.
215
173
        """
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()
224
174
        return SuccessfulSmartServerResponse(
225
 
            ('ok', ), ('\x00'.join(reversed(history))))
 
175
            ('ok', ), ('\x00'.join(branch.revision_history())))
226
176
 
227
177
 
228
178
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
236
186
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
237
187
 
238
188
 
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
 
 
256
189
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
257
190
    """Base class for handling common branch request logic for requests that
258
191
    update the branch tip.
299
232
 
300
233
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
301
234
        if new_last_revision_id == 'null:':
302
 
            branch.set_last_revision_info(0, new_last_revision_id)
 
235
            branch._set_revision_history([])
303
236
        else:
304
237
            if not branch.repository.has_revision(new_last_revision_id):
305
238
                return FailedSmartServerResponse(
306
239
                    ('NoSuchRevision', new_last_revision_id))
307
 
            branch.generate_revision_history(new_last_revision_id, None, None)
 
240
            branch._set_revision_history(branch._lefthand_history(
 
241
                new_last_revision_id, None, None))
308
242
        return SuccessfulSmartServerResponse(('ok',))
309
243
 
310
244
 
434
368
        branch.unlock()
435
369
        return SuccessfulSmartServerResponse(('ok',))
436
370
 
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',))