~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/bzrdir.py

Merge fix for overflow issues in pack_stat from 2.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
16
16
 
17
17
"""Server-side bzrdir related request implmentations."""
18
18
 
19
 
from __future__ import absolute_import
20
19
 
21
 
from bzrlib import (
22
 
    bencode,
23
 
    branch,
24
 
    errors,
25
 
    repository,
26
 
    urlutils,
27
 
    )
 
20
from bzrlib import branch, errors, repository, urlutils
28
21
from bzrlib.bzrdir import (
29
22
    BzrDir,
30
23
    BzrDirFormat,
 
24
    BzrDirMetaFormat1,
31
25
    BzrProber,
32
26
    )
33
27
from bzrlib.controldir import (
127
121
        return '/'.join(segments)
128
122
 
129
123
 
130
 
class SmartServerBzrDirRequestDestroyBranch(SmartServerRequestBzrDir):
131
 
 
132
 
    def do_bzrdir_request(self, name=None):
133
 
        """Destroy the branch with the specified name.
134
 
 
135
 
        New in 2.5.0.
136
 
        :return: On success, 'ok'.
137
 
        """
138
 
        try:
139
 
            self._bzrdir.destroy_branch(name)
140
 
        except errors.NotBranchError, e:
141
 
            return FailedSmartServerResponse(('nobranch',))
142
 
        return SuccessfulSmartServerResponse(('ok',))
143
 
 
144
 
 
145
 
class SmartServerBzrDirRequestHasWorkingTree(SmartServerRequestBzrDir):
146
 
 
147
 
    def do_bzrdir_request(self, name=None):
148
 
        """Check whether there is a working tree present.
149
 
 
150
 
        New in 2.5.0.
151
 
 
152
 
        :return: If there is a working tree present, 'yes'.
153
 
            Otherwise 'no'.
154
 
        """
155
 
        if self._bzrdir.has_workingtree():
156
 
            return SuccessfulSmartServerResponse(('yes', ))
157
 
        else:
158
 
            return SuccessfulSmartServerResponse(('no', ))
159
 
 
160
 
 
161
 
class SmartServerBzrDirRequestDestroyRepository(SmartServerRequestBzrDir):
162
 
 
163
 
    def do_bzrdir_request(self, name=None):
164
 
        """Destroy the repository.
165
 
 
166
 
        New in 2.5.0.
167
 
 
168
 
        :return: On success, 'ok'.
169
 
        """
170
 
        try:
171
 
            self._bzrdir.destroy_repository()
172
 
        except errors.NoRepositoryPresent, e:
173
 
            return FailedSmartServerResponse(('norepository',))
174
 
        return SuccessfulSmartServerResponse(('ok',))
175
 
 
176
 
 
177
124
class SmartServerBzrDirRequestCloningMetaDir(SmartServerRequestBzrDir):
178
125
 
179
126
    def do_bzrdir_request(self, require_stacking):
215
162
            branch_name))
216
163
 
217
164
 
218
 
class SmartServerBzrDirRequestCheckoutMetaDir(SmartServerRequestBzrDir):
219
 
    """Get the format to use for checkouts.
220
 
 
221
 
    New in 2.5.
222
 
 
223
 
    :return: on success, a 3-tuple of network names for (control,
224
 
        repository, branch) directories, where '' signifies "not present".
225
 
        If this BzrDir contains a branch reference then this will fail with
226
 
        BranchReference; clients should resolve branch references before
227
 
        calling this RPC (they should not try to create a checkout of a
228
 
        checkout).
229
 
    """
230
 
 
231
 
    def do_bzrdir_request(self):
232
 
        try:
233
 
            branch_ref = self._bzrdir.get_branch_reference()
234
 
        except errors.NotBranchError:
235
 
            branch_ref = None
236
 
        if branch_ref is not None:
237
 
            # The server shouldn't try to resolve references, and it quite
238
 
            # possibly can't reach them anyway.  The client needs to resolve
239
 
            # the branch reference to determine the cloning_metadir.
240
 
            return FailedSmartServerResponse(('BranchReference',))
241
 
        control_format = self._bzrdir.checkout_metadir()
242
 
        control_name = control_format.network_name()
243
 
        if not control_format.fixed_components:
244
 
            branch_name = control_format.get_branch_format().network_name()
245
 
            repo_name = control_format.repository_format.network_name()
246
 
        else:
247
 
            branch_name = ''
248
 
            repo_name = ''
249
 
        return SuccessfulSmartServerResponse(
250
 
            (control_name, repo_name, branch_name))
251
 
 
252
 
 
253
165
class SmartServerRequestCreateBranch(SmartServerRequestBzrDir):
254
166
 
255
167
    def do(self, path, network_name):
274
186
            self.transport_from_client_path(path))
275
187
        format = branch.network_format_registry.get(network_name)
276
188
        bzrdir.branch_format = format
277
 
        result = format.initialize(bzrdir, name="")
 
189
        result = format.initialize(bzrdir)
278
190
        rich_root, tree_ref, external_lookup = self._format_to_capabilities(
279
191
            result.repository._format)
280
192
        branch_format = result._format.network_name()
431
343
        return SuccessfulSmartServerResponse((), content)
432
344
 
433
345
 
434
 
class SmartServerBzrDirRequestGetBranches(SmartServerRequestBzrDir):
435
 
 
436
 
    def do_bzrdir_request(self):
437
 
        """Get the branches in a control directory.
438
 
        
439
 
        The body is a bencoded dictionary, with values similar to the return
440
 
        value of the open branch request.
441
 
        """
442
 
        branches = self._bzrdir.get_branches()
443
 
        ret = {}
444
 
        for name, b in branches.iteritems():
445
 
            if name is None:
446
 
                name = ""
447
 
            ret[name] = ("branch", b._format.network_name())
448
 
        return SuccessfulSmartServerResponse(
449
 
            ("success", ), bencode.bencode(ret))
450
 
 
451
 
 
452
346
class SmartServerRequestInitializeBzrDir(SmartServerRequest):
453
347
 
454
348
    def do(self, path):