← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/bzrdir.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-10 15:46:03 UTC
  • mfrom: (4985.3.21 update)
  • mto: This revision was merged to the branch mainline in revision 5021.
  • Revision ID: v.ladeuil+lp@free.fr-20100210154603-k4no1gvfuqpzrw7p
https://launchpad.net/bugs/113809
Update performs two merges in a more logical order but stop on conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/bzrdir.py
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 bzrdir related request implmentations."""
18
18
 
19
19
 
20
 
from bzrlib import errors
21
 
from bzrlib.bzrdir import BzrDir, BzrDirFormat
 
20
from bzrlib import branch, errors, repository, urlutils
 
21
from bzrlib.bzrdir import (
 
22
    BzrDir,
 
23
    BzrDirFormat,
 
24
    BzrDirMetaFormat1,
 
25
    network_format_registry,
 
26
    )
22
27
from bzrlib.smart.request import (
23
28
    FailedSmartServerResponse,
24
29
    SmartServerRequest,
29
34
class SmartServerRequestOpenBzrDir(SmartServerRequest):
30
35
 
31
36
    def do(self, path):
32
 
        from bzrlib.bzrdir import BzrDirFormat
33
37
        try:
34
38
            t = self.transport_from_client_path(path)
35
39
        except errors.PathNotChild:
51
55
        return SuccessfulSmartServerResponse((answer,))
52
56
 
53
57
 
54
 
class SmartServerRequestFindRepository(SmartServerRequest):
 
58
class SmartServerRequestOpenBzrDir_2_1(SmartServerRequest):
 
59
 
 
60
    def do(self, path):
 
61
        """Is there a BzrDir present, and if so does it have a working tree?
 
62
 
 
63
        New in 2.1.
 
64
        """
 
65
        try:
 
66
            t = self.transport_from_client_path(path)
 
67
        except errors.PathNotChild:
 
68
            # The client is trying to ask about a path that they have no access
 
69
            # to.
 
70
            return SuccessfulSmartServerResponse(('no',))
 
71
        try:
 
72
            bd = BzrDir.open_from_transport(t)
 
73
        except errors.NotBranchError:
 
74
            answer = ('no',)
 
75
        else:
 
76
            answer = ('yes',)
 
77
            if bd.has_workingtree():
 
78
                answer += ('yes',)
 
79
            else:
 
80
                answer += ('no',)
 
81
        return SuccessfulSmartServerResponse(answer)
 
82
 
 
83
 
 
84
class SmartServerRequestBzrDir(SmartServerRequest):
 
85
 
 
86
    def do(self, path, *args):
 
87
        """Open a BzrDir at path, and return self.do_bzrdir_request(*args)."""
 
88
        try:
 
89
            self._bzrdir = BzrDir.open_from_transport(
 
90
                self.transport_from_client_path(path))
 
91
        except errors.NotBranchError, e:
 
92
            return FailedSmartServerResponse(('nobranch',))
 
93
        return self.do_bzrdir_request(*args)
55
94
 
56
95
    def _boolean_to_yes_no(self, a_boolean):
57
96
        if a_boolean:
59
98
        else:
60
99
            return 'no'
61
100
 
62
 
    def _find(self, path):
63
 
        """try to find a repository from path upwards
64
 
        
65
 
        This operates precisely like 'bzrdir.find_repository'.
66
 
        
67
 
        :return: (relpath, rich_root, tree_ref, external_lookup) flags. All are
68
 
            strings, relpath is a / prefixed path, and the other three are
69
 
            either 'yes' or 'no'.
70
 
        :raises errors.NoRepositoryPresent: When there is no repository
71
 
            present.
72
 
        """
73
 
        bzrdir = BzrDir.open_from_transport(
74
 
            self.transport_from_client_path(path))
75
 
        repository = bzrdir.find_repository()
76
 
        # the relpath of the bzrdir in the found repository gives us the 
 
101
    def _format_to_capabilities(self, repo_format):
 
102
        rich_root = self._boolean_to_yes_no(repo_format.rich_root_data)
 
103
        tree_ref = self._boolean_to_yes_no(
 
104
            repo_format.supports_tree_reference)
 
105
        external_lookup = self._boolean_to_yes_no(
 
106
            repo_format.supports_external_lookups)
 
107
        return rich_root, tree_ref, external_lookup
 
108
 
 
109
    def _repo_relpath(self, current_transport, repository):
 
110
        """Get the relative path for repository from current_transport."""
 
111
        # the relpath of the bzrdir in the found repository gives us the
77
112
        # path segments to pop-out.
78
113
        relpath = repository.bzrdir.root_transport.relpath(
79
 
            bzrdir.root_transport.base)
 
114
            current_transport.base)
80
115
        if len(relpath):
81
116
            segments = ['..'] * len(relpath.split('/'))
82
117
        else:
83
118
            segments = []
84
 
        rich_root = self._boolean_to_yes_no(repository.supports_rich_root())
85
 
        tree_ref = self._boolean_to_yes_no(
86
 
            repository._format.supports_tree_reference)
87
 
        external_lookup = self._boolean_to_yes_no(
88
 
            repository._format.supports_external_lookups)
89
 
        return '/'.join(segments), rich_root, tree_ref, external_lookup
 
119
        return '/'.join(segments)
 
120
 
 
121
 
 
122
class SmartServerBzrDirRequestCloningMetaDir(SmartServerRequestBzrDir):
 
123
 
 
124
    def do_bzrdir_request(self, require_stacking):
 
125
        """Get the format that should be used when cloning from this dir.
 
126
 
 
127
        New in 1.13.
 
128
        
 
129
        :return: on success, a 3-tuple of network names for (control,
 
130
            repository, branch) directories, where '' signifies "not present".
 
131
            If this BzrDir contains a branch reference then this will fail with
 
132
            BranchReference; clients should resolve branch references before
 
133
            calling this RPC.
 
134
        """
 
135
        try:
 
136
            branch_ref = self._bzrdir.get_branch_reference()
 
137
        except errors.NotBranchError:
 
138
            branch_ref = None
 
139
        if branch_ref is not None:
 
140
            # The server shouldn't try to resolve references, and it quite
 
141
            # possibly can't reach them anyway.  The client needs to resolve
 
142
            # the branch reference to determine the cloning_metadir.
 
143
            return FailedSmartServerResponse(('BranchReference',))
 
144
        if require_stacking == "True":
 
145
            require_stacking = True
 
146
        else:
 
147
            require_stacking = False
 
148
        control_format = self._bzrdir.cloning_metadir(
 
149
            require_stacking=require_stacking)
 
150
        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):
 
154
            branch_name = ('branch',
 
155
                control_format.get_branch_format().network_name())
 
156
            repository_name = control_format.repository_format.network_name()
 
157
        else:
 
158
            # Only MetaDir has delegated formats today.
 
159
            branch_name = ('branch', '')
 
160
            repository_name = ''
 
161
        return SuccessfulSmartServerResponse((control_name, repository_name,
 
162
            branch_name))
 
163
 
 
164
 
 
165
class SmartServerRequestCreateBranch(SmartServerRequestBzrDir):
 
166
 
 
167
    def do(self, path, network_name):
 
168
        """Create a branch in the bzr dir at path.
 
169
 
 
170
        This operates precisely like 'bzrdir.create_branch'.
 
171
 
 
172
        If a bzrdir is not present, an exception is propogated
 
173
        rather than 'no branch' because these are different conditions (and
 
174
        this method should only be called after establishing that a bzr dir
 
175
        exists anyway).
 
176
 
 
177
        This is the initial version of this method introduced to the smart
 
178
        server for 1.13.
 
179
 
 
180
        :param path: The path to the bzrdir.
 
181
        :param network_name: The network name of the branch type to create.
 
182
        :return: (ok, network_name)
 
183
        """
 
184
        bzrdir = BzrDir.open_from_transport(
 
185
            self.transport_from_client_path(path))
 
186
        format = branch.network_format_registry.get(network_name)
 
187
        bzrdir.branch_format = format
 
188
        result = format.initialize(bzrdir)
 
189
        rich_root, tree_ref, external_lookup = self._format_to_capabilities(
 
190
            result.repository._format)
 
191
        branch_format = result._format.network_name()
 
192
        repo_format = result.repository._format.network_name()
 
193
        repo_path = self._repo_relpath(bzrdir.root_transport,
 
194
            result.repository)
 
195
        # branch format, repo relpath, rich_root, tree_ref, external_lookup,
 
196
        # repo_network_name
 
197
        return SuccessfulSmartServerResponse(('ok', branch_format, repo_path,
 
198
            rich_root, tree_ref, external_lookup, repo_format))
 
199
 
 
200
 
 
201
class SmartServerRequestCreateRepository(SmartServerRequestBzrDir):
 
202
 
 
203
    def do(self, path, network_name, shared):
 
204
        """Create a repository in the bzr dir at path.
 
205
 
 
206
        This operates precisely like 'bzrdir.create_repository'.
 
207
 
 
208
        If a bzrdir is not present, an exception is propagated
 
209
        rather than 'no branch' because these are different conditions (and
 
210
        this method should only be called after establishing that a bzr dir
 
211
        exists anyway).
 
212
 
 
213
        This is the initial version of this method introduced to the smart
 
214
        server for 1.13.
 
215
 
 
216
        :param path: The path to the bzrdir.
 
217
        :param network_name: The network name of the repository type to create.
 
218
        :param shared: The value to pass create_repository for the shared
 
219
            parameter.
 
220
        :return: (ok, rich_root, tree_ref, external_lookup, network_name)
 
221
        """
 
222
        bzrdir = BzrDir.open_from_transport(
 
223
            self.transport_from_client_path(path))
 
224
        shared = shared == 'True'
 
225
        format = repository.network_format_registry.get(network_name)
 
226
        bzrdir.repository_format = format
 
227
        result = format.initialize(bzrdir, shared=shared)
 
228
        rich_root, tree_ref, external_lookup = self._format_to_capabilities(
 
229
            result._format)
 
230
        return SuccessfulSmartServerResponse(('ok', rich_root, tree_ref,
 
231
            external_lookup, result._format.network_name()))
 
232
 
 
233
 
 
234
class SmartServerRequestFindRepository(SmartServerRequestBzrDir):
 
235
 
 
236
    def _find(self, path):
 
237
        """try to find a repository from path upwards
 
238
 
 
239
        This operates precisely like 'bzrdir.find_repository'.
 
240
 
 
241
        :return: (relpath, rich_root, tree_ref, external_lookup, network_name).
 
242
            All are strings, relpath is a / prefixed path, the next three are
 
243
            either 'yes' or 'no', and the last is a repository format network
 
244
            name.
 
245
        :raises errors.NoRepositoryPresent: When there is no repository
 
246
            present.
 
247
        """
 
248
        bzrdir = BzrDir.open_from_transport(
 
249
            self.transport_from_client_path(path))
 
250
        repository = bzrdir.find_repository()
 
251
        path = self._repo_relpath(bzrdir.root_transport, repository)
 
252
        rich_root, tree_ref, external_lookup = self._format_to_capabilities(
 
253
            repository._format)
 
254
        network_name = repository._format.network_name()
 
255
        return path, rich_root, tree_ref, external_lookup, network_name
90
256
 
91
257
 
92
258
class SmartServerRequestFindRepositoryV1(SmartServerRequestFindRepository):
93
259
 
94
260
    def do(self, path):
95
261
        """try to find a repository from path upwards
96
 
        
 
262
 
97
263
        This operates precisely like 'bzrdir.find_repository'.
98
 
        
99
 
        If a bzrdir is not present, an exception is propogated
 
264
 
 
265
        If a bzrdir is not present, an exception is propagated
100
266
        rather than 'no branch' because these are different conditions.
101
267
 
102
268
        This is the initial version of this method introduced with the smart
106
272
        :return: norepository or ok, relpath.
107
273
        """
108
274
        try:
109
 
            path, rich_root, tree_ref, external_lookup = self._find(path)
 
275
            path, rich_root, tree_ref, external_lookup, name = self._find(path)
110
276
            return SuccessfulSmartServerResponse(('ok', path, rich_root, tree_ref))
111
277
        except errors.NoRepositoryPresent:
112
278
            return FailedSmartServerResponse(('norepository', ))
116
282
 
117
283
    def do(self, path):
118
284
        """try to find a repository from path upwards
119
 
        
 
285
 
120
286
        This operates precisely like 'bzrdir.find_repository'.
121
 
        
122
 
        If a bzrdir is not present, an exception is propogated
 
287
 
 
288
        If a bzrdir is not present, an exception is propagated
123
289
        rather than 'no branch' because these are different conditions.
124
290
 
125
291
        This is the second edition of this method introduced in bzr 1.3, which
126
292
        returns information about the supports_external_lookups format
127
293
        attribute too.
128
294
 
129
 
        :return: norepository or ok, relpath.
 
295
        :return: norepository or ok, relpath, rich_root, tree_ref,
 
296
            external_lookup.
130
297
        """
131
298
        try:
132
 
            path, rich_root, tree_ref, external_lookup = self._find(path)
 
299
            path, rich_root, tree_ref, external_lookup, name = self._find(path)
133
300
            return SuccessfulSmartServerResponse(
134
301
                ('ok', path, rich_root, tree_ref, external_lookup))
135
302
        except errors.NoRepositoryPresent:
136
303
            return FailedSmartServerResponse(('norepository', ))
137
304
 
138
305
 
 
306
class SmartServerRequestFindRepositoryV3(SmartServerRequestFindRepository):
 
307
 
 
308
    def do(self, path):
 
309
        """try to find a repository from path upwards
 
310
 
 
311
        This operates precisely like 'bzrdir.find_repository'.
 
312
 
 
313
        If a bzrdir is not present, an exception is propogated
 
314
        rather than 'no branch' because these are different conditions.
 
315
 
 
316
        This is the third edition of this method introduced in bzr 1.13, which
 
317
        returns information about the network name of the repository format.
 
318
 
 
319
        :return: norepository or ok, relpath, rich_root, tree_ref,
 
320
            external_lookup, network_name.
 
321
        """
 
322
        try:
 
323
            path, rich_root, tree_ref, external_lookup, name = self._find(path)
 
324
            return SuccessfulSmartServerResponse(
 
325
                ('ok', path, rich_root, tree_ref, external_lookup, name))
 
326
        except errors.NoRepositoryPresent:
 
327
            return FailedSmartServerResponse(('norepository', ))
 
328
 
 
329
 
 
330
class SmartServerBzrDirRequestConfigFile(SmartServerRequestBzrDir):
 
331
 
 
332
    def do_bzrdir_request(self):
 
333
        """Get the configuration bytes for a config file in bzrdir.
 
334
        
 
335
        The body is not utf8 decoded - it is the literal bytestream from disk.
 
336
        """
 
337
        config = self._bzrdir._get_config()
 
338
        if config is None:
 
339
            content = ''
 
340
        else:
 
341
            content = config._get_config_file().read()
 
342
        return SuccessfulSmartServerResponse((), content)
 
343
 
 
344
 
139
345
class SmartServerRequestInitializeBzrDir(SmartServerRequest):
140
346
 
141
347
    def do(self, path):
149
355
        return SuccessfulSmartServerResponse(('ok', ))
150
356
 
151
357
 
152
 
class SmartServerRequestOpenBranch(SmartServerRequest):
153
 
 
154
 
    def do(self, path):
155
 
        """try to open a branch at path and return ok/nobranch.
156
 
        
157
 
        If a bzrdir is not present, an exception is propogated
158
 
        rather than 'no branch' because these are different conditions.
 
358
class SmartServerRequestBzrDirInitializeEx(SmartServerRequestBzrDir):
 
359
 
 
360
    def parse_NoneTrueFalse(self, arg):
 
361
        if not arg:
 
362
            return None
 
363
        if arg == 'False':
 
364
            return False
 
365
        if arg == 'True':
 
366
            return True
 
367
        raise AssertionError("invalid arg %r" % arg)
 
368
 
 
369
    def parse_NoneString(self, arg):
 
370
        return arg or None
 
371
 
 
372
    def _serialize_NoneTrueFalse(self, arg):
 
373
        if arg is False:
 
374
            return 'False'
 
375
        if not arg:
 
376
            return ''
 
377
        return 'True'
 
378
 
 
379
    def do(self, bzrdir_network_name, path, use_existing_dir, create_prefix,
 
380
        force_new_repo, stacked_on, stack_on_pwd, repo_format_name,
 
381
        make_working_trees, shared_repo):
 
382
        """Initialize a bzrdir at path as per
 
383
        BzrDirFormat.initialize_on_transport_ex.
 
384
 
 
385
        New in 1.16.  (Replaces BzrDirFormat.initialize_ex verb from 1.15).
 
386
 
 
387
        :return: return SuccessfulSmartServerResponse((repo_path, rich_root,
 
388
            tree_ref, external_lookup, repo_network_name,
 
389
            repo_bzrdir_network_name, bzrdir_format_network_name,
 
390
            NoneTrueFalse(stacking), final_stack, final_stack_pwd,
 
391
            repo_lock_token))
159
392
        """
160
 
        bzrdir = BzrDir.open_from_transport(
161
 
            self.transport_from_client_path(path))
 
393
        target_transport = self.transport_from_client_path(path)
 
394
        format = network_format_registry.get(bzrdir_network_name)
 
395
        use_existing_dir = self.parse_NoneTrueFalse(use_existing_dir)
 
396
        create_prefix = self.parse_NoneTrueFalse(create_prefix)
 
397
        force_new_repo = self.parse_NoneTrueFalse(force_new_repo)
 
398
        stacked_on = self.parse_NoneString(stacked_on)
 
399
        stack_on_pwd = self.parse_NoneString(stack_on_pwd)
 
400
        make_working_trees = self.parse_NoneTrueFalse(make_working_trees)
 
401
        shared_repo = self.parse_NoneTrueFalse(shared_repo)
 
402
        if stack_on_pwd == '.':
 
403
            stack_on_pwd = target_transport.base
 
404
        repo_format_name = self.parse_NoneString(repo_format_name)
 
405
        repo, bzrdir, stacking, repository_policy = \
 
406
            format.initialize_on_transport_ex(target_transport,
 
407
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
408
            force_new_repo=force_new_repo, stacked_on=stacked_on,
 
409
            stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
410
            make_working_trees=make_working_trees, shared_repo=shared_repo)
 
411
        if repo is None:
 
412
            repo_path = ''
 
413
            repo_name = ''
 
414
            rich_root = tree_ref = external_lookup = ''
 
415
            repo_bzrdir_name = ''
 
416
            final_stack = None
 
417
            final_stack_pwd = None
 
418
            repo_lock_token = ''
 
419
        else:
 
420
            repo_path = self._repo_relpath(bzrdir.root_transport, repo)
 
421
            if repo_path == '':
 
422
                repo_path = '.'
 
423
            rich_root, tree_ref, external_lookup = self._format_to_capabilities(
 
424
                repo._format)
 
425
            repo_name = repo._format.network_name()
 
426
            repo_bzrdir_name = repo.bzrdir._format.network_name()
 
427
            final_stack = repository_policy._stack_on
 
428
            final_stack_pwd = repository_policy._stack_on_pwd
 
429
            # It is returned locked, but we need to do the lock to get the lock
 
430
            # token.
 
431
            repo.unlock()
 
432
            repo_lock_token = repo.lock_write() or ''
 
433
            if repo_lock_token:
 
434
                repo.leave_lock_in_place()
 
435
            repo.unlock()
 
436
        final_stack = final_stack or ''
 
437
        final_stack_pwd = final_stack_pwd or ''
 
438
 
 
439
        # We want this to be relative to the bzrdir.
 
440
        if final_stack_pwd:
 
441
            final_stack_pwd = urlutils.relative_url(
 
442
                target_transport.base, final_stack_pwd)
 
443
 
 
444
        # Can't meaningfully return a root path.
 
445
        if final_stack.startswith('/'):
 
446
            client_path = self._root_client_path + final_stack[1:]
 
447
            final_stack = urlutils.relative_url(
 
448
                self._root_client_path, client_path)
 
449
            final_stack_pwd = '.'
 
450
 
 
451
        return SuccessfulSmartServerResponse((repo_path, rich_root, tree_ref,
 
452
            external_lookup, repo_name, repo_bzrdir_name,
 
453
            bzrdir._format.network_name(),
 
454
            self._serialize_NoneTrueFalse(stacking), final_stack,
 
455
            final_stack_pwd, repo_lock_token))
 
456
 
 
457
 
 
458
class SmartServerRequestOpenBranch(SmartServerRequestBzrDir):
 
459
 
 
460
    def do_bzrdir_request(self):
 
461
        """open a branch at path and return the branch reference or branch."""
162
462
        try:
163
 
            reference_url = bzrdir.get_branch_reference()
 
463
            reference_url = self._bzrdir.get_branch_reference()
164
464
            if reference_url is None:
165
465
                return SuccessfulSmartServerResponse(('ok', ''))
166
466
            else:
167
467
                return SuccessfulSmartServerResponse(('ok', reference_url))
168
 
        except errors.NotBranchError:
169
 
            return FailedSmartServerResponse(('nobranch', ))
 
468
        except errors.NotBranchError, e:
 
469
            return FailedSmartServerResponse(('nobranch',))
 
470
 
 
471
 
 
472
class SmartServerRequestOpenBranchV2(SmartServerRequestBzrDir):
 
473
 
 
474
    def do_bzrdir_request(self):
 
475
        """open a branch at path and return the reference or format."""
 
476
        try:
 
477
            reference_url = self._bzrdir.get_branch_reference()
 
478
            if reference_url is None:
 
479
                br = self._bzrdir.open_branch(ignore_fallbacks=True)
 
480
                format = br._format.network_name()
 
481
                return SuccessfulSmartServerResponse(('branch', format))
 
482
            else:
 
483
                return SuccessfulSmartServerResponse(('ref', reference_url))
 
484
        except errors.NotBranchError, e:
 
485
            return FailedSmartServerResponse(('nobranch',))
 
486
 
 
487
 
 
488
class SmartServerRequestOpenBranchV3(SmartServerRequestBzrDir):
 
489
 
 
490
    def do_bzrdir_request(self):
 
491
        """Open a branch at path and return the reference or format.
 
492
        
 
493
        This version introduced in 2.1.
 
494
 
 
495
        Differences to SmartServerRequestOpenBranchV2:
 
496
          * can return 2-element ('nobranch', extra), where 'extra' is a string
 
497
            with an explanation like 'location is a repository'.  Previously
 
498
            a 'nobranch' response would never have more than one element.
 
499
        """
 
500
        try:
 
501
            reference_url = self._bzrdir.get_branch_reference()
 
502
            if reference_url is None:
 
503
                br = self._bzrdir.open_branch(ignore_fallbacks=True)
 
504
                format = br._format.network_name()
 
505
                return SuccessfulSmartServerResponse(('branch', format))
 
506
            else:
 
507
                return SuccessfulSmartServerResponse(('ref', reference_url))
 
508
        except errors.NotBranchError, e:
 
509
            # Stringify the exception so that its .detail attribute will be
 
510
            # filled out.
 
511
            str(e)
 
512
            resp = ('nobranch',)
 
513
            detail = e.detail
 
514
            if detail:
 
515
                if detail.startswith(': '):
 
516
                    detail = detail[2:]
 
517
                resp += (detail,)
 
518
            return FailedSmartServerResponse(resp)
 
519