/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/smart/bzrdir.py

  • Committer: Vincent Ladeuil
  • Date: 2012-01-18 14:09:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120118140919-rlvdrhpc0nq1lbwi
Change set/remove to require a lock for the branch config files.

This means that tests (or any plugin for that matter) do not requires an
explicit lock on the branch anymore to change a single option. This also
means the optimisation becomes "opt-in" and as such won't be as
spectacular as it may be and/or harder to get right (nothing fails
anymore).

This reduces the diff by ~300 lines.

Code/tests that were updating more than one config option is still taking
a lock to at least avoid some IOs and demonstrate the benefits through
the decreased number of hpss calls.

The duplication between BranchStack and BranchOnlyStack will be removed
once the same sharing is in place for local config files, at which point
the Stack class itself may be able to host the changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/bzrdir.py
16
16
 
17
17
"""Server-side bzrdir related request implmentations."""
18
18
 
 
19
from __future__ import absolute_import
19
20
 
20
21
from bzrlib import branch, errors, repository, urlutils
21
22
from bzrlib.bzrdir import (
22
23
    BzrDir,
23
24
    BzrDirFormat,
24
 
    BzrDirMetaFormat1,
 
25
    BzrProber,
 
26
    )
 
27
from bzrlib.controldir import (
25
28
    network_format_registry,
26
29
    )
27
30
from bzrlib.smart.request import (
44
47
            # clients that don't anticipate errors from this method.
45
48
            answer = 'no'
46
49
        else:
47
 
            default_format = BzrDirFormat.get_default_format()
48
 
            real_bzrdir = default_format.open(t, _found=True)
 
50
            bzr_prober = BzrProber()
49
51
            try:
50
 
                real_bzrdir._format.probe_transport(t)
 
52
                bzr_prober.probe_transport(t)
51
53
            except (errors.NotBranchError, errors.UnknownFormatError):
52
54
                answer = 'no'
53
55
            else:
84
86
class SmartServerRequestBzrDir(SmartServerRequest):
85
87
 
86
88
    def do(self, path, *args):
87
 
        """Open a BzrDir at path, and return self.do_bzrdir_request(*args)."""
 
89
        """Open a BzrDir at path, and return `self.do_bzrdir_request(*args)`."""
88
90
        try:
89
91
            self._bzrdir = BzrDir.open_from_transport(
90
92
                self.transport_from_client_path(path))
119
121
        return '/'.join(segments)
120
122
 
121
123
 
 
124
class SmartServerBzrDirRequestDestroyBranch(SmartServerRequestBzrDir):
 
125
 
 
126
    def do_bzrdir_request(self, name=None):
 
127
        """Destroy the branch with the specified name.
 
128
 
 
129
        New in 2.5.0.
 
130
        :return: On success, 'ok'.
 
131
        """
 
132
        try:
 
133
            self._bzrdir.destroy_branch(name)
 
134
        except errors.NotBranchError, e:
 
135
            return FailedSmartServerResponse(('nobranch',))
 
136
        return SuccessfulSmartServerResponse(('ok',))
 
137
 
 
138
 
 
139
class SmartServerBzrDirRequestHasWorkingTree(SmartServerRequestBzrDir):
 
140
 
 
141
    def do_bzrdir_request(self, name=None):
 
142
        """Check whether there is a working tree present.
 
143
 
 
144
        New in 2.5.0.
 
145
 
 
146
        :return: If there is a working tree present, 'yes'.
 
147
            Otherwise 'no'.
 
148
        """
 
149
        if self._bzrdir.has_workingtree():
 
150
            return SuccessfulSmartServerResponse(('yes', ))
 
151
        else:
 
152
            return SuccessfulSmartServerResponse(('no', ))
 
153
 
 
154
 
 
155
class SmartServerBzrDirRequestDestroyRepository(SmartServerRequestBzrDir):
 
156
 
 
157
    def do_bzrdir_request(self, name=None):
 
158
        """Destroy the repository.
 
159
 
 
160
        New in 2.5.0.
 
161
 
 
162
        :return: On success, 'ok'.
 
163
        """
 
164
        try:
 
165
            self._bzrdir.destroy_repository()
 
166
        except errors.NoRepositoryPresent, e:
 
167
            return FailedSmartServerResponse(('norepository',))
 
168
        return SuccessfulSmartServerResponse(('ok',))
 
169
 
 
170
 
122
171
class SmartServerBzrDirRequestCloningMetaDir(SmartServerRequestBzrDir):
123
172
 
124
173
    def do_bzrdir_request(self, require_stacking):
148
197
        control_format = self._bzrdir.cloning_metadir(
149
198
            require_stacking=require_stacking)
150
199
        control_name = control_format.network_name()
151
 
        # XXX: There should be a method that tells us that the format does/does
152
 
        # not have subformats.
153
 
        if isinstance(control_format, BzrDirMetaFormat1):
 
200
        if not control_format.fixed_components:
154
201
            branch_name = ('branch',
155
202
                control_format.get_branch_format().network_name())
156
203
            repository_name = control_format.repository_format.network_name()
162
209
            branch_name))
163
210
 
164
211
 
 
212
class SmartServerBzrDirRequestCheckoutMetaDir(SmartServerRequestBzrDir):
 
213
    """Get the format to use for checkouts.
 
214
 
 
215
    New in 2.5.
 
216
 
 
217
    :return: on success, a 3-tuple of network names for (control,
 
218
        repository, branch) directories, where '' signifies "not present".
 
219
        If this BzrDir contains a branch reference then this will fail with
 
220
        BranchReference; clients should resolve branch references before
 
221
        calling this RPC (they should not try to create a checkout of a
 
222
        checkout).
 
223
    """
 
224
 
 
225
    def do_bzrdir_request(self):
 
226
        try:
 
227
            branch_ref = self._bzrdir.get_branch_reference()
 
228
        except errors.NotBranchError:
 
229
            branch_ref = None
 
230
        if branch_ref is not None:
 
231
            # The server shouldn't try to resolve references, and it quite
 
232
            # possibly can't reach them anyway.  The client needs to resolve
 
233
            # the branch reference to determine the cloning_metadir.
 
234
            return FailedSmartServerResponse(('BranchReference',))
 
235
        control_format = self._bzrdir.checkout_metadir()
 
236
        control_name = control_format.network_name()
 
237
        if not control_format.fixed_components:
 
238
            branch_name = control_format.get_branch_format().network_name()
 
239
            repo_name = control_format.repository_format.network_name()
 
240
        else:
 
241
            branch_name = ''
 
242
            repo_name = ''
 
243
        return SuccessfulSmartServerResponse(
 
244
            (control_name, repo_name, branch_name))
 
245
 
 
246
 
165
247
class SmartServerRequestCreateBranch(SmartServerRequestBzrDir):
166
248
 
167
249
    def do(self, path, network_name):
179
261
 
180
262
        :param path: The path to the bzrdir.
181
263
        :param network_name: The network name of the branch type to create.
182
 
        :return: (ok, network_name)
 
264
        :return: ('ok', branch_format, repo_path, rich_root, tree_ref,
 
265
            external_lookup, repo_format)
183
266
        """
184
267
        bzrdir = BzrDir.open_from_transport(
185
268
            self.transport_from_client_path(path))
429
512
            # It is returned locked, but we need to do the lock to get the lock
430
513
            # token.
431
514
            repo.unlock()
432
 
            repo_lock_token = repo.lock_write() or ''
 
515
            repo_lock_token = repo.lock_write().repository_token or ''
433
516
            if repo_lock_token:
434
517
                repo.leave_lock_in_place()
435
518
            repo.unlock()