← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

Merge from bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
# TODO: At some point, handle upgrades by just passing the whole request
 
18
# across to run on the server.
 
19
 
 
20
from cStringIO import StringIO
 
21
 
 
22
from bzrlib import branch, errors, lockdir, repository
 
23
from bzrlib.branch import BranchReferenceFormat
 
24
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
25
from bzrlib.config import BranchConfig, TreeConfig
 
26
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
27
from bzrlib.errors import NoSuchRevision
 
28
from bzrlib.lockable_files import LockableFiles
 
29
from bzrlib.revision import NULL_REVISION
 
30
from bzrlib.smart import client, vfs
 
31
 
 
32
# Note: RemoteBzrDirFormat is in bzrdir.py
 
33
 
 
34
class RemoteBzrDir(BzrDir):
 
35
    """Control directory on a remote server, accessed via bzr:// or similar."""
 
36
 
 
37
    def __init__(self, transport, _client=None):
 
38
        """Construct a RemoteBzrDir.
 
39
 
 
40
        :param _client: Private parameter for testing. Disables probing and the
 
41
            use of a real bzrdir.
 
42
        """
 
43
        BzrDir.__init__(self, transport, RemoteBzrDirFormat())
 
44
        # this object holds a delegated bzrdir that uses file-level operations
 
45
        # to talk to the other side
 
46
        self._real_bzrdir = None
 
47
 
 
48
        if _client is None:
 
49
            self._medium = transport.get_smart_client()
 
50
            self._client = client._SmartClient(self._medium)
 
51
        else:
 
52
            self._client = _client
 
53
            self._medium = None
 
54
            return
 
55
 
 
56
        self._ensure_real()
 
57
        path = self._path_for_remote_call(self._client)
 
58
        response = self._client.call('BzrDir.open', path)
 
59
        if response not in [('yes',), ('no',)]:
 
60
            raise errors.UnexpectedSmartServerResponse(response)
 
61
        if response == ('no',):
 
62
            raise errors.NotBranchError(path=transport.base)
 
63
 
 
64
    def _ensure_real(self):
 
65
        """Ensure that there is a _real_bzrdir set.
 
66
 
 
67
        Used before calls to self._real_bzrdir.
 
68
        """
 
69
        if not self._real_bzrdir:
 
70
            self._real_bzrdir = BzrDir.open_from_transport(
 
71
                self.root_transport, _server_formats=False)
 
72
 
 
73
    def create_repository(self, shared=False):
 
74
        self._ensure_real()
 
75
        self._real_bzrdir.create_repository(shared=shared)
 
76
        return self.open_repository()
 
77
 
 
78
    def create_branch(self):
 
79
        self._ensure_real()
 
80
        real_branch = self._real_bzrdir.create_branch()
 
81
        return RemoteBranch(self, self.find_repository(), real_branch)
 
82
 
 
83
    def create_workingtree(self, revision_id=None):
 
84
        raise errors.NotLocalUrl(self.transport.base)
 
85
 
 
86
    def find_branch_format(self):
 
87
        """Find the branch 'format' for this bzrdir.
 
88
 
 
89
        This might be a synthetic object for e.g. RemoteBranch and SVN.
 
90
        """
 
91
        b = self.open_branch()
 
92
        return b._format
 
93
 
 
94
    def get_branch_reference(self):
 
95
        """See BzrDir.get_branch_reference()."""
 
96
        path = self._path_for_remote_call(self._client)
 
97
        response = self._client.call('BzrDir.open_branch', path)
 
98
        if response[0] == 'ok':
 
99
            if response[1] == '':
 
100
                # branch at this location.
 
101
                return None
 
102
            else:
 
103
                # a branch reference, use the existing BranchReference logic.
 
104
                return response[1]
 
105
        elif response == ('nobranch',):
 
106
            raise errors.NotBranchError(path=self.root_transport.base)
 
107
        else:
 
108
            assert False, 'unexpected response code %r' % (response,)
 
109
 
 
110
    def open_branch(self, _unsupported=False):
 
111
        assert _unsupported == False, 'unsupported flag support not implemented yet.'
 
112
        reference_url = self.get_branch_reference()
 
113
        if reference_url is None:
 
114
            # branch at this location.
 
115
            return RemoteBranch(self, self.find_repository())
 
116
        else:
 
117
            # a branch reference, use the existing BranchReference logic.
 
118
            format = BranchReferenceFormat()
 
119
            return format.open(self, _found=True, location=reference_url)
 
120
                
 
121
    def open_repository(self):
 
122
        path = self._path_for_remote_call(self._client)
 
123
        response = self._client.call('BzrDir.find_repository', path)
 
124
        assert response[0] in ('ok', 'norepository'), \
 
125
            'unexpected response code %s' % (response,)
 
126
        if response[0] == 'norepository':
 
127
            raise errors.NoRepositoryPresent(self)
 
128
        assert len(response) == 4, 'incorrect response length %s' % (response,)
 
129
        if response[1] == '':
 
130
            format = RemoteRepositoryFormat()
 
131
            format.rich_root_data = (response[2] == 'yes')
 
132
            format.supports_tree_reference = (response[3] == 'yes')
 
133
            return RemoteRepository(self, format)
 
134
        else:
 
135
            raise errors.NoRepositoryPresent(self)
 
136
 
 
137
    def open_workingtree(self, recommend_upgrade=True):
 
138
        raise errors.NotLocalUrl(self.root_transport)
 
139
 
 
140
    def _path_for_remote_call(self, client):
 
141
        """Return the path to be used for this bzrdir in a remote call."""
 
142
        return client.remote_path_from_transport(self.root_transport)
 
143
 
 
144
    def get_branch_transport(self, branch_format):
 
145
        self._ensure_real()
 
146
        return self._real_bzrdir.get_branch_transport(branch_format)
 
147
 
 
148
    def get_repository_transport(self, repository_format):
 
149
        self._ensure_real()
 
150
        return self._real_bzrdir.get_repository_transport(repository_format)
 
151
 
 
152
    def get_workingtree_transport(self, workingtree_format):
 
153
        self._ensure_real()
 
154
        return self._real_bzrdir.get_workingtree_transport(workingtree_format)
 
155
 
 
156
    def can_convert_format(self):
 
157
        """Upgrading of remote bzrdirs is not supported yet."""
 
158
        return False
 
159
 
 
160
    def needs_format_conversion(self, format=None):
 
161
        """Upgrading of remote bzrdirs is not supported yet."""
 
162
        return False
 
163
 
 
164
    def clone(self, url, revision_id=None, force_new_repo=False):
 
165
        self._ensure_real()
 
166
        return self._real_bzrdir.clone(url, revision_id=revision_id,
 
167
            force_new_repo=force_new_repo)
 
168
 
 
169
 
 
170
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
171
    """Format for repositories accessed over a _SmartClient.
 
172
 
 
173
    Instances of this repository are represented by RemoteRepository
 
174
    instances.
 
175
 
 
176
    The RemoteRepositoryFormat is parameterised during construction
 
177
    to reflect the capabilities of the real, remote format. Specifically
 
178
    the attributes rich_root_data and supports_tree_reference are set
 
179
    on a per instance basis, and are not set (and should not be) at
 
180
    the class level.
 
181
    """
 
182
 
 
183
    _matchingbzrdir = RemoteBzrDirFormat
 
184
 
 
185
    def initialize(self, a_bzrdir, shared=False):
 
186
        assert isinstance(a_bzrdir, RemoteBzrDir), \
 
187
            '%r is not a RemoteBzrDir' % (a_bzrdir,)
 
188
        return a_bzrdir.create_repository(shared=shared)
 
189
    
 
190
    def open(self, a_bzrdir):
 
191
        assert isinstance(a_bzrdir, RemoteBzrDir)
 
192
        return a_bzrdir.open_repository()
 
193
 
 
194
    def get_format_description(self):
 
195
        return 'bzr remote repository'
 
196
 
 
197
    def __eq__(self, other):
 
198
        return self.__class__ == other.__class__
 
199
 
 
200
    def check_conversion_target(self, target_format):
 
201
        if self.rich_root_data and not target_format.rich_root_data:
 
202
            raise errors.BadConversionTarget(
 
203
                'Does not support rich root data.', target_format)
 
204
        if (self.supports_tree_reference and
 
205
            not getattr(target_format, 'supports_tree_reference', False)):
 
206
            raise errors.BadConversionTarget(
 
207
                'Does not support nested trees', target_format)
 
208
 
 
209
 
 
210
class RemoteRepository(object):
 
211
    """Repository accessed over rpc.
 
212
 
 
213
    For the moment most operations are performed using local transport-backed
 
214
    Repository objects.
 
215
    """
 
216
 
 
217
    def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
 
218
        """Create a RemoteRepository instance.
 
219
        
 
220
        :param remote_bzrdir: The bzrdir hosting this repository.
 
221
        :param format: The RemoteFormat object to use.
 
222
        :param real_repository: If not None, a local implementation of the
 
223
            repository logic for the repository, usually accessing the data
 
224
            via the VFS.
 
225
        :param _client: Private testing parameter - override the smart client
 
226
            to be used by the repository.
 
227
        """
 
228
        if real_repository:
 
229
            self._real_repository = real_repository
 
230
        else:
 
231
            self._real_repository = None
 
232
        self.bzrdir = remote_bzrdir
 
233
        if _client is None:
 
234
            self._client = client._SmartClient(self.bzrdir._medium)
 
235
        else:
 
236
            self._client = _client
 
237
        self._format = format
 
238
        self._lock_mode = None
 
239
        self._lock_token = None
 
240
        self._lock_count = 0
 
241
        self._leave_lock = False
 
242
 
 
243
    def _ensure_real(self):
 
244
        """Ensure that there is a _real_repository set.
 
245
 
 
246
        Used before calls to self._real_repository.
 
247
        """
 
248
        if not self._real_repository:
 
249
            self.bzrdir._ensure_real()
 
250
            #self._real_repository = self.bzrdir._real_bzrdir.open_repository()
 
251
            self._set_real_repository(self.bzrdir._real_bzrdir.open_repository())
 
252
 
 
253
    def get_revision_graph(self, revision_id=None):
 
254
        """See Repository.get_revision_graph()."""
 
255
        if revision_id is None:
 
256
            revision_id = ''
 
257
        elif revision_id == NULL_REVISION:
 
258
            return {}
 
259
 
 
260
        path = self.bzrdir._path_for_remote_call(self._client)
 
261
        assert type(revision_id) is str
 
262
        response = self._client.call_expecting_body(
 
263
            'Repository.get_revision_graph', path, revision_id)
 
264
        if response[0][0] not in ['ok', 'nosuchrevision']:
 
265
            raise errors.UnexpectedSmartServerResponse(response[0])
 
266
        if response[0][0] == 'ok':
 
267
            coded = response[1].read_body_bytes()
 
268
            if coded == '':
 
269
                # no revisions in this repository!
 
270
                return {}
 
271
            lines = coded.split('\n')
 
272
            revision_graph = {}
 
273
            for line in lines:
 
274
                d = list(line.split())
 
275
                revision_graph[d[0]] = d[1:]
 
276
                
 
277
            return revision_graph
 
278
        else:
 
279
            response_body = response[1].read_body_bytes()
 
280
            assert response_body == ''
 
281
            raise NoSuchRevision(self, revision_id)
 
282
 
 
283
    def has_revision(self, revision_id):
 
284
        """See Repository.has_revision()."""
 
285
        if revision_id is None:
 
286
            # The null revision is always present.
 
287
            return True
 
288
        path = self.bzrdir._path_for_remote_call(self._client)
 
289
        response = self._client.call('Repository.has_revision', path, revision_id)
 
290
        assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
 
291
        return response[0] == 'yes'
 
292
 
 
293
    def gather_stats(self, revid=None, committers=None):
 
294
        """See Repository.gather_stats()."""
 
295
        path = self.bzrdir._path_for_remote_call(self._client)
 
296
        if revid in (None, NULL_REVISION):
 
297
            fmt_revid = ''
 
298
        else:
 
299
            fmt_revid = revid
 
300
        if committers is None or not committers:
 
301
            fmt_committers = 'no'
 
302
        else:
 
303
            fmt_committers = 'yes'
 
304
        response = self._client.call_expecting_body(
 
305
            'Repository.gather_stats', path, fmt_revid, fmt_committers)
 
306
        assert response[0][0] == 'ok', \
 
307
            'unexpected response code %s' % (response[0],)
 
308
 
 
309
        body = response[1].read_body_bytes()
 
310
        result = {}
 
311
        for line in body.split('\n'):
 
312
            if not line:
 
313
                continue
 
314
            key, val_text = line.split(':')
 
315
            if key in ('revisions', 'size', 'committers'):
 
316
                result[key] = int(val_text)
 
317
            elif key in ('firstrev', 'latestrev'):
 
318
                values = val_text.split(' ')[1:]
 
319
                result[key] = (float(values[0]), long(values[1]))
 
320
 
 
321
        return result
 
322
 
 
323
    def get_physical_lock_status(self):
 
324
        """See Repository.get_physical_lock_status()."""
 
325
        return False
 
326
 
 
327
    def is_shared(self):
 
328
        """See Repository.is_shared()."""
 
329
        path = self.bzrdir._path_for_remote_call(self._client)
 
330
        response = self._client.call('Repository.is_shared', path)
 
331
        assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
 
332
        return response[0] == 'yes'
 
333
 
 
334
    def lock_read(self):
 
335
        # wrong eventually - want a local lock cache context
 
336
        if not self._lock_mode:
 
337
            self._lock_mode = 'r'
 
338
            self._lock_count = 1
 
339
            if self._real_repository is not None:
 
340
                self._real_repository.lock_read()
 
341
        else:
 
342
            self._lock_count += 1
 
343
 
 
344
    def _remote_lock_write(self, token):
 
345
        path = self.bzrdir._path_for_remote_call(self._client)
 
346
        if token is None:
 
347
            token = ''
 
348
        response = self._client.call('Repository.lock_write', path, token)
 
349
        if response[0] == 'ok':
 
350
            ok, token = response
 
351
            return token
 
352
        elif response[0] == 'LockContention':
 
353
            raise errors.LockContention('(remote lock)')
 
354
        elif response[0] == 'UnlockableTransport':
 
355
            raise errors.UnlockableTransport(self.bzrdir.root_transport)
 
356
        else:
 
357
            assert False, 'unexpected response code %s' % (response,)
 
358
 
 
359
    def lock_write(self, token=None):
 
360
        if not self._lock_mode:
 
361
            self._lock_token = self._remote_lock_write(token)
 
362
            assert self._lock_token, 'Remote server did not return a token!'
 
363
            if self._real_repository is not None:
 
364
                self._real_repository.lock_write(token=self._lock_token)
 
365
            if token is not None:
 
366
                self._leave_lock = True
 
367
            else:
 
368
                self._leave_lock = False
 
369
            self._lock_mode = 'w'
 
370
            self._lock_count = 1
 
371
        elif self._lock_mode == 'r':
 
372
            raise errors.ReadOnlyError(self)
 
373
        else:
 
374
            self._lock_count += 1
 
375
        return self._lock_token
 
376
 
 
377
    def leave_lock_in_place(self):
 
378
        self._leave_lock = True
 
379
 
 
380
    def dont_leave_lock_in_place(self):
 
381
        self._leave_lock = False
 
382
 
 
383
    def _set_real_repository(self, repository):
 
384
        """Set the _real_repository for this repository.
 
385
 
 
386
        :param repository: The repository to fallback to for non-hpss
 
387
            implemented operations.
 
388
        """
 
389
        assert not isinstance(repository, RemoteRepository)
 
390
        self._real_repository = repository
 
391
        if self._lock_mode == 'w':
 
392
            # if we are already locked, the real repository must be able to
 
393
            # acquire the lock with our token.
 
394
            self._real_repository.lock_write(self._lock_token)
 
395
        elif self._lock_mode == 'r':
 
396
            self._real_repository.lock_read()
 
397
 
 
398
    def _unlock(self, token):
 
399
        path = self.bzrdir._path_for_remote_call(self._client)
 
400
        response = self._client.call('Repository.unlock', path, token)
 
401
        if response == ('ok',):
 
402
            return
 
403
        elif response[0] == 'TokenMismatch':
 
404
            raise errors.TokenMismatch(token, '(remote token)')
 
405
        else:
 
406
            assert False, 'unexpected response code %s' % (response,)
 
407
 
 
408
    def unlock(self):
 
409
        self._lock_count -= 1
 
410
        if not self._lock_count:
 
411
            mode = self._lock_mode
 
412
            self._lock_mode = None
 
413
            if self._real_repository is not None:
 
414
                self._real_repository.unlock()
 
415
            if mode != 'w':
 
416
                # Only write-locked repositories need to make a remote method
 
417
                # call to perfom the unlock.
 
418
                return
 
419
            assert self._lock_token, 'Locked, but no token!'
 
420
            token = self._lock_token
 
421
            self._lock_token = None
 
422
            if not self._leave_lock:
 
423
                self._unlock(token)
 
424
 
 
425
    def break_lock(self):
 
426
        # should hand off to the network
 
427
        self._ensure_real()
 
428
        return self._real_repository.break_lock()
 
429
 
 
430
    ### These methods are just thin shims to the VFS object for now.
 
431
 
 
432
    def revision_tree(self, revision_id):
 
433
        self._ensure_real()
 
434
        return self._real_repository.revision_tree(revision_id)
 
435
 
 
436
    def get_commit_builder(self, branch, parents, config, timestamp=None,
 
437
                           timezone=None, committer=None, revprops=None,
 
438
                           revision_id=None):
 
439
        # FIXME: It ought to be possible to call this without immediately
 
440
        # triggering _ensure_real.  For now it's the easiest thing to do.
 
441
        self._ensure_real()
 
442
        builder = self._real_repository.get_commit_builder(branch, parents,
 
443
                config, timestamp=timestamp, timezone=timezone,
 
444
                committer=committer, revprops=revprops, revision_id=revision_id)
 
445
        # Make the builder use this RemoteRepository rather than the real one.
 
446
        builder.repository = self
 
447
        return builder
 
448
 
 
449
    @needs_write_lock
 
450
    def add_inventory(self, revid, inv, parents):
 
451
        self._ensure_real()
 
452
        return self._real_repository.add_inventory(revid, inv, parents)
 
453
 
 
454
    @needs_write_lock
 
455
    def add_revision(self, rev_id, rev, inv=None, config=None):
 
456
        self._ensure_real()
 
457
        return self._real_repository.add_revision(
 
458
            rev_id, rev, inv=inv, config=config)
 
459
 
 
460
    @needs_read_lock
 
461
    def get_inventory(self, revision_id):
 
462
        self._ensure_real()
 
463
        return self._real_repository.get_inventory(revision_id)
 
464
 
 
465
    @needs_read_lock
 
466
    def get_revision(self, revision_id):
 
467
        self._ensure_real()
 
468
        return self._real_repository.get_revision(revision_id)
 
469
 
 
470
    @property
 
471
    def weave_store(self):
 
472
        self._ensure_real()
 
473
        return self._real_repository.weave_store
 
474
 
 
475
    def get_transaction(self):
 
476
        self._ensure_real()
 
477
        return self._real_repository.get_transaction()
 
478
 
 
479
    @needs_read_lock
 
480
    def clone(self, a_bzrdir, revision_id=None):
 
481
        self._ensure_real()
 
482
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
483
 
 
484
    def make_working_trees(self):
 
485
        """RemoteRepositories never create working trees by default."""
 
486
        return False
 
487
 
 
488
    def fetch(self, source, revision_id=None, pb=None):
 
489
        self._ensure_real()
 
490
        return self._real_repository.fetch(
 
491
            source, revision_id=revision_id, pb=pb)
 
492
 
 
493
    @property
 
494
    def control_weaves(self):
 
495
        self._ensure_real()
 
496
        return self._real_repository.control_weaves
 
497
 
 
498
    @needs_read_lock
 
499
    def get_ancestry(self, revision_id):
 
500
        self._ensure_real()
 
501
        return self._real_repository.get_ancestry(revision_id)
 
502
 
 
503
    @needs_read_lock
 
504
    def get_inventory_weave(self):
 
505
        self._ensure_real()
 
506
        return self._real_repository.get_inventory_weave()
 
507
 
 
508
    def fileids_altered_by_revision_ids(self, revision_ids):
 
509
        self._ensure_real()
 
510
        return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
 
511
 
 
512
    @needs_read_lock
 
513
    def get_signature_text(self, revision_id):
 
514
        self._ensure_real()
 
515
        return self._real_repository.get_signature_text(revision_id)
 
516
 
 
517
    @needs_read_lock
 
518
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
519
        self._ensure_real()
 
520
        return self._real_repository.get_revision_graph_with_ghosts(
 
521
            revision_ids=revision_ids)
 
522
 
 
523
    @needs_read_lock
 
524
    def get_inventory_xml(self, revision_id):
 
525
        self._ensure_real()
 
526
        return self._real_repository.get_inventory_xml(revision_id)
 
527
 
 
528
    def deserialise_inventory(self, revision_id, xml):
 
529
        self._ensure_real()
 
530
        return self._real_repository.deserialise_inventory(revision_id, xml)
 
531
 
 
532
    def reconcile(self, other=None, thorough=False):
 
533
        self._ensure_real()
 
534
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
535
        
 
536
    def all_revision_ids(self):
 
537
        self._ensure_real()
 
538
        return self._real_repository.all_revision_ids()
 
539
    
 
540
    @needs_read_lock
 
541
    def get_deltas_for_revisions(self, revisions):
 
542
        self._ensure_real()
 
543
        return self._real_repository.get_deltas_for_revisions(revisions)
 
544
 
 
545
    @needs_read_lock
 
546
    def get_revision_delta(self, revision_id):
 
547
        self._ensure_real()
 
548
        return self._real_repository.get_revision_delta(revision_id)
 
549
 
 
550
    @needs_read_lock
 
551
    def revision_trees(self, revision_ids):
 
552
        self._ensure_real()
 
553
        return self._real_repository.revision_trees(revision_ids)
 
554
 
 
555
    @needs_read_lock
 
556
    def get_revision_reconcile(self, revision_id):
 
557
        self._ensure_real()
 
558
        return self._real_repository.get_revision_reconcile(revision_id)
 
559
 
 
560
    @needs_read_lock
 
561
    def check(self, revision_ids):
 
562
        self._ensure_real()
 
563
        return self._real_repository.check(revision_ids)
 
564
 
 
565
    def copy_content_into(self, destination, revision_id=None):
 
566
        self._ensure_real()
 
567
        return self._real_repository.copy_content_into(
 
568
            destination, revision_id=revision_id)
 
569
 
 
570
    def set_make_working_trees(self, new_value):
 
571
        raise NotImplementedError(self.set_make_working_trees)
 
572
 
 
573
    @needs_write_lock
 
574
    def sign_revision(self, revision_id, gpg_strategy):
 
575
        self._ensure_real()
 
576
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
577
 
 
578
    @needs_read_lock
 
579
    def get_revisions(self, revision_ids):
 
580
        self._ensure_real()
 
581
        return self._real_repository.get_revisions(revision_ids)
 
582
 
 
583
    def supports_rich_root(self):
 
584
        self._ensure_real()
 
585
        return self._real_repository.supports_rich_root()
 
586
 
 
587
    def iter_reverse_revision_history(self, revision_id):
 
588
        self._ensure_real()
 
589
        return self._real_repository.iter_reverse_revision_history(revision_id)
 
590
 
 
591
    @property
 
592
    def _serializer(self):
 
593
        self._ensure_real()
 
594
        return self._real_repository._serializer
 
595
 
 
596
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
597
        self._ensure_real()
 
598
        return self._real_repository.store_revision_signature(
 
599
            gpg_strategy, plaintext, revision_id)
 
600
 
 
601
    def has_signature_for_revision_id(self, revision_id):
 
602
        self._ensure_real()
 
603
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
604
 
 
605
 
 
606
class RemoteBranchLockableFiles(LockableFiles):
 
607
    """A 'LockableFiles' implementation that talks to a smart server.
 
608
    
 
609
    This is not a public interface class.
 
610
    """
 
611
 
 
612
    def __init__(self, bzrdir, _client):
 
613
        self.bzrdir = bzrdir
 
614
        self._client = _client
 
615
        self._need_find_modes = True
 
616
        LockableFiles.__init__(
 
617
            self, bzrdir.get_branch_transport(None),
 
618
            'lock', lockdir.LockDir)
 
619
 
 
620
    def _find_modes(self):
 
621
        # RemoteBranches don't let the client set the mode of control files.
 
622
        self._dir_mode = None
 
623
        self._file_mode = None
 
624
 
 
625
    def get(self, path):
 
626
        """'get' a remote path as per the LockableFiles interface.
 
627
 
 
628
        :param path: the file to 'get'. If this is 'branch.conf', we do not
 
629
             just retrieve a file, instead we ask the smart server to generate
 
630
             a configuration for us - which is retrieved as an INI file.
 
631
        """
 
632
        if path == 'branch.conf':
 
633
            path = self.bzrdir._path_for_remote_call(self._client)
 
634
            response = self._client.call_expecting_body(
 
635
                'Branch.get_config_file', path)
 
636
            assert response[0][0] == 'ok', \
 
637
                'unexpected response code %s' % (response[0],)
 
638
            return StringIO(response[1].read_body_bytes())
 
639
        else:
 
640
            # VFS fallback.
 
641
            return LockableFiles.get(self, path)
 
642
 
 
643
 
 
644
class RemoteBranchFormat(branch.BranchFormat):
 
645
 
 
646
    def __eq__(self, other):
 
647
        return (isinstance(other, RemoteBranchFormat) and 
 
648
            self.__dict__ == other.__dict__)
 
649
 
 
650
    def get_format_description(self):
 
651
        return 'Remote BZR Branch'
 
652
 
 
653
    def get_format_string(self):
 
654
        return 'Remote BZR Branch'
 
655
 
 
656
    def open(self, a_bzrdir):
 
657
        assert isinstance(a_bzrdir, RemoteBzrDir)
 
658
        return a_bzrdir.open_branch()
 
659
 
 
660
    def initialize(self, a_bzrdir):
 
661
        assert isinstance(a_bzrdir, RemoteBzrDir)
 
662
        return a_bzrdir.create_branch()
 
663
 
 
664
 
 
665
class RemoteBranch(branch.Branch):
 
666
    """Branch stored on a server accessed by HPSS RPC.
 
667
 
 
668
    At the moment most operations are mapped down to simple file operations.
 
669
    """
 
670
 
 
671
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
 
672
        _client=None):
 
673
        """Create a RemoteBranch instance.
 
674
 
 
675
        :param real_branch: An optional local implementation of the branch
 
676
            format, usually accessing the data via the VFS.
 
677
        :param _client: Private parameter for testing.
 
678
        """
 
679
        # We intentionally don't call the parent class's __init__, because it
 
680
        # will try to assign to self.tags, which is a property in this subclass.
 
681
        # And the parent's __init__ doesn't do much anyway.
 
682
        self._revision_history_cache = None
 
683
        self.bzrdir = remote_bzrdir
 
684
        if _client is not None:
 
685
            self._client = _client
 
686
        else:
 
687
            self._client = client._SmartClient(self.bzrdir._medium)
 
688
        self.repository = remote_repository
 
689
        if real_branch is not None:
 
690
            self._real_branch = real_branch
 
691
            # Give the remote repository the matching real repo.
 
692
            real_repo = self._real_branch.repository
 
693
            if isinstance(real_repo, RemoteRepository):
 
694
                real_repo._ensure_real()
 
695
                real_repo = real_repo._real_repository
 
696
            self.repository._set_real_repository(real_repo)
 
697
            # Give the branch the remote repository to let fast-pathing happen.
 
698
            self._real_branch.repository = self.repository
 
699
        else:
 
700
            self._real_branch = None
 
701
        # Fill out expected attributes of branch for bzrlib api users.
 
702
        self._format = RemoteBranchFormat()
 
703
        self.base = self.bzrdir.root_transport.base
 
704
        self._control_files = None
 
705
        self._lock_mode = None
 
706
        self._lock_token = None
 
707
        self._lock_count = 0
 
708
        self._leave_lock = False
 
709
 
 
710
    def _ensure_real(self):
 
711
        """Ensure that there is a _real_branch set.
 
712
 
 
713
        Used before calls to self._real_branch.
 
714
        """
 
715
        if not self._real_branch:
 
716
            assert vfs.vfs_enabled()
 
717
            self.bzrdir._ensure_real()
 
718
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
 
719
            # Give the remote repository the matching real repo.
 
720
            real_repo = self._real_branch.repository
 
721
            if isinstance(real_repo, RemoteRepository):
 
722
                real_repo._ensure_real()
 
723
                real_repo = real_repo._real_repository
 
724
            self.repository._set_real_repository(real_repo)
 
725
            # Give the branch the remote repository to let fast-pathing happen.
 
726
            self._real_branch.repository = self.repository
 
727
            # XXX: deal with _lock_mode == 'w'
 
728
            if self._lock_mode == 'r':
 
729
                self._real_branch.lock_read()
 
730
 
 
731
    @property
 
732
    def control_files(self):
 
733
        # Defer actually creating RemoteBranchLockableFiles until its needed,
 
734
        # because it triggers an _ensure_real that we otherwise might not need.
 
735
        if self._control_files is None:
 
736
            self._control_files = RemoteBranchLockableFiles(
 
737
                self.bzrdir, self._client)
 
738
        return self._control_files
 
739
 
 
740
    def _get_checkout_format(self):
 
741
        self._ensure_real()
 
742
        return self._real_branch._get_checkout_format()
 
743
 
 
744
    def get_physical_lock_status(self):
 
745
        """See Branch.get_physical_lock_status()."""
 
746
        # should be an API call to the server, as branches must be lockable.
 
747
        self._ensure_real()
 
748
        return self._real_branch.get_physical_lock_status()
 
749
 
 
750
    def lock_read(self):
 
751
        if not self._lock_mode:
 
752
            self._lock_mode = 'r'
 
753
            self._lock_count = 1
 
754
            if self._real_branch is not None:
 
755
                self._real_branch.lock_read()
 
756
        else:
 
757
            self._lock_count += 1
 
758
 
 
759
    def _remote_lock_write(self, token):
 
760
        if token is None:
 
761
            branch_token = repo_token = ''
 
762
        else:
 
763
            branch_token = token
 
764
            repo_token = self.repository.lock_write()
 
765
            self.repository.unlock()
 
766
        path = self.bzrdir._path_for_remote_call(self._client)
 
767
        response = self._client.call('Branch.lock_write', path, branch_token,
 
768
                                     repo_token)
 
769
        if response[0] == 'ok':
 
770
            ok, branch_token, repo_token = response
 
771
            return branch_token, repo_token
 
772
        elif response[0] == 'LockContention':
 
773
            raise errors.LockContention('(remote lock)')
 
774
        elif response[0] == 'TokenMismatch':
 
775
            raise errors.TokenMismatch(token, '(remote token)')
 
776
        elif response[0] == 'UnlockableTransport':
 
777
            raise errors.UnlockableTransport(self.bzrdir.root_transport)
 
778
        elif response[0] == 'ReadOnlyError':
 
779
            raise errors.ReadOnlyError(self)
 
780
        else:
 
781
            assert False, 'unexpected response code %r' % (response,)
 
782
            
 
783
    def lock_write(self, token=None):
 
784
        if not self._lock_mode:
 
785
            remote_tokens = self._remote_lock_write(token)
 
786
            self._lock_token, self._repo_lock_token = remote_tokens
 
787
            assert self._lock_token, 'Remote server did not return a token!'
 
788
            # TODO: We really, really, really don't want to call _ensure_real
 
789
            # here, but it's the easiest way to ensure coherency between the
 
790
            # state of the RemoteBranch and RemoteRepository objects and the
 
791
            # physical locks.  If we don't materialise the real objects here,
 
792
            # then getting everything in the right state later is complex, so
 
793
            # for now we just do it the lazy way.
 
794
            #   -- Andrew Bennetts, 2007-02-22.
 
795
            self._ensure_real()
 
796
            if self._real_branch is not None:
 
797
                self._real_branch.repository.lock_write(
 
798
                    token=self._repo_lock_token)
 
799
                try:
 
800
                    self._real_branch.lock_write(token=self._lock_token)
 
801
                finally:
 
802
                    self._real_branch.repository.unlock()
 
803
            if token is not None:
 
804
                self._leave_lock = True
 
805
            else:
 
806
                # XXX: this case seems to be unreachable; token cannot be None.
 
807
                self._leave_lock = False
 
808
            self._lock_mode = 'w'
 
809
            self._lock_count = 1
 
810
        elif self._lock_mode == 'r':
 
811
            raise errors.ReadOnlyTransaction
 
812
        else:
 
813
            if token is not None:
 
814
                # A token was given to lock_write, and we're relocking, so check
 
815
                # that the given token actually matches the one we already have.
 
816
                if token != self._lock_token:
 
817
                    raise errors.TokenMismatch(token, self._lock_token)
 
818
            self._lock_count += 1
 
819
        return self._lock_token
 
820
 
 
821
    def _unlock(self, branch_token, repo_token):
 
822
        path = self.bzrdir._path_for_remote_call(self._client)
 
823
        response = self._client.call('Branch.unlock', path, branch_token,
 
824
                                     repo_token)
 
825
        if response == ('ok',):
 
826
            return
 
827
        elif response[0] == 'TokenMismatch':
 
828
            raise errors.TokenMismatch(
 
829
                str((branch_token, repo_token)), '(remote tokens)')
 
830
        else:
 
831
            assert False, 'unexpected response code %s' % (response,)
 
832
 
 
833
    def unlock(self):
 
834
        self._lock_count -= 1
 
835
        if not self._lock_count:
 
836
            self._clear_cached_state()
 
837
            mode = self._lock_mode
 
838
            self._lock_mode = None
 
839
            if self._real_branch is not None:
 
840
                if not self._leave_lock:
 
841
                    # If this RemoteBranch will remove the physical lock for the
 
842
                    # repository, make sure the _real_branch doesn't do it
 
843
                    # first.  (Because the _real_branch's repository is set to
 
844
                    # be the RemoteRepository.)
 
845
                    self._real_branch.repository.leave_lock_in_place()
 
846
                self._real_branch.unlock()
 
847
            if mode != 'w':
 
848
                # Only write-locked branched need to make a remote method call
 
849
                # to perfom the unlock.
 
850
                return
 
851
            assert self._lock_token, 'Locked, but no token!'
 
852
            branch_token = self._lock_token
 
853
            repo_token = self._repo_lock_token
 
854
            self._lock_token = None
 
855
            self._repo_lock_token = None
 
856
            if not self._leave_lock:
 
857
                self._unlock(branch_token, repo_token)
 
858
 
 
859
    def break_lock(self):
 
860
        self._ensure_real()
 
861
        return self._real_branch.break_lock()
 
862
 
 
863
    def leave_lock_in_place(self):
 
864
        self._leave_lock = True
 
865
 
 
866
    def dont_leave_lock_in_place(self):
 
867
        self._leave_lock = False
 
868
 
 
869
    def last_revision_info(self):
 
870
        """See Branch.last_revision_info()."""
 
871
        path = self.bzrdir._path_for_remote_call(self._client)
 
872
        response = self._client.call('Branch.last_revision_info', path)
 
873
        assert response[0] == 'ok', 'unexpected response code %s' % (response,)
 
874
        revno = int(response[1])
 
875
        last_revision = response[2]
 
876
        return (revno, last_revision)
 
877
 
 
878
    def _gen_revision_history(self):
 
879
        """See Branch._gen_revision_history()."""
 
880
        path = self.bzrdir._path_for_remote_call(self._client)
 
881
        response = self._client.call_expecting_body(
 
882
            'Branch.revision_history', path)
 
883
        assert response[0][0] == 'ok', ('unexpected response code %s'
 
884
                                        % (response[0],))
 
885
        result = response[1].read_body_bytes().split('\x00')
 
886
        if result == ['']:
 
887
            return []
 
888
        return result
 
889
 
 
890
    @needs_write_lock
 
891
    def set_revision_history(self, rev_history):
 
892
        # Send just the tip revision of the history; the server will generate
 
893
        # the full history from that.  If the revision doesn't exist in this
 
894
        # branch, NoSuchRevision will be raised.
 
895
        path = self.bzrdir._path_for_remote_call(self._client)
 
896
        if rev_history == []:
 
897
            rev_id = 'null:'
 
898
        else:
 
899
            rev_id = rev_history[-1]
 
900
        response = self._client.call('Branch.set_last_revision',
 
901
            path, self._lock_token, self._repo_lock_token, rev_id)
 
902
        if response[0] == 'NoSuchRevision':
 
903
            raise NoSuchRevision(self, rev_id)
 
904
        else:
 
905
            assert response == ('ok',), (
 
906
                'unexpected response code %r' % (response,))
 
907
        self._cache_revision_history(rev_history)
 
908
 
 
909
    def get_parent(self):
 
910
        self._ensure_real()
 
911
        return self._real_branch.get_parent()
 
912
        
 
913
    def set_parent(self, url):
 
914
        self._ensure_real()
 
915
        return self._real_branch.set_parent(url)
 
916
        
 
917
    def get_config(self):
 
918
        return RemoteBranchConfig(self)
 
919
 
 
920
    def sprout(self, to_bzrdir, revision_id=None):
 
921
        # Like Branch.sprout, except that it sprouts a branch in the default
 
922
        # format, because RemoteBranches can't be created at arbitrary URLs.
 
923
        # XXX: if to_bzrdir is a RemoteBranch, this should perhaps do
 
924
        # to_bzrdir.create_branch...
 
925
        self._ensure_real()
 
926
        result = branch.BranchFormat.get_default_format().initialize(to_bzrdir)
 
927
        self._real_branch.copy_content_into(result, revision_id=revision_id)
 
928
        result.set_parent(self.bzrdir.root_transport.base)
 
929
        return result
 
930
 
 
931
    @needs_write_lock
 
932
    def append_revision(self, *revision_ids):
 
933
        self._ensure_real()
 
934
        return self._real_branch.append_revision(*revision_ids)
 
935
 
 
936
    @needs_write_lock
 
937
    def pull(self, source, overwrite=False, stop_revision=None):
 
938
        self._ensure_real()
 
939
        self._real_branch.pull(
 
940
            source, overwrite=overwrite, stop_revision=stop_revision)
 
941
 
 
942
    @needs_read_lock
 
943
    def push(self, target, overwrite=False, stop_revision=None):
 
944
        self._ensure_real()
 
945
        return self._real_branch.push(
 
946
            target, overwrite=overwrite, stop_revision=stop_revision)
 
947
 
 
948
    def is_locked(self):
 
949
        return self._lock_count >= 1
 
950
 
 
951
    def set_last_revision_info(self, revno, revision_id):
 
952
        self._ensure_real()
 
953
        self._clear_cached_state()
 
954
        return self._real_branch.set_last_revision_info(revno, revision_id)
 
955
 
 
956
    def generate_revision_history(self, revision_id, last_rev=None,
 
957
                                  other_branch=None):
 
958
        self._ensure_real()
 
959
        return self._real_branch.generate_revision_history(
 
960
            revision_id, last_rev=last_rev, other_branch=other_branch)
 
961
 
 
962
    @property
 
963
    def tags(self):
 
964
        self._ensure_real()
 
965
        return self._real_branch.tags
 
966
 
 
967
    def set_push_location(self, location):
 
968
        self._ensure_real()
 
969
        return self._real_branch.set_push_location(location)
 
970
 
 
971
    def update_revisions(self, other, stop_revision=None):
 
972
        self._ensure_real()
 
973
        return self._real_branch.update_revisions(
 
974
            other, stop_revision=stop_revision)
 
975
 
 
976
 
 
977
class RemoteBranchConfig(BranchConfig):
 
978
 
 
979
    def username(self):
 
980
        self.branch._ensure_real()
 
981
        return self.branch._real_branch.get_config().username()
 
982
 
 
983
    def _get_branch_data_config(self):
 
984
        self.branch._ensure_real()
 
985
        if self._branch_data_config is None:
 
986
            self._branch_data_config = TreeConfig(self.branch._real_branch)
 
987
        return self._branch_data_config
 
988